Engine.PlayerController

//=============================================================================
// PlayerController
//
// PlayerControllers are used by human players to control pawns.
//
// This is a built-in Unreal class and it shouldn't be modified.
// CHANGENOTE: All Changes since v739 in this class are related to the Weapon code update, except
// for the change in Possess().
//=============================================================================
//NEW (mdf) support Licensee extensions
class PlayerController extends LicenseeController
	config(user)
	native
	nativereplication;

//NEW (mdf) State names
const BaseSpectatingState		= 'BaseSpectating';
const SpectatingState			= 'Spectating';
const PlayerClimbingState		= 'PlayerClimbing';
const PlayerFlyingState			= 'PlayerFlying';
const PlayerHelicopteringState	= 'PlayerHelicoptering';
const PlayerSpideringState		= 'PlayerSpidering';
const PlayerSwimmingState		= 'PlayerSwimming';
const PlayerWaitingState		= 'PlayerWaiting';
const PlayerWalkingState		= 'PlayerWalking';
const WaitingForPawnState		= 'WaitingForPawn';
//OLD

// Player info.
var const player Player;

// player input control
var globalconfig	bool 	bLookUpStairs;	// look up/down stairs (player)
var globalconfig	bool	bSnapToLevel;	// Snap to level eyeheight when not mouselooking
var globalconfig	bool	bAlwaysMouseLook;
var globalconfig	bool	bKeyboardLook;	// no snapping when true
var bool					bCenterView;

var const PlayerController nextPlayerController;	//NEW (mdf) chained PlayerControllerList

// Player control flags
var bool		bBehindView;    // Outside-the-player view.
var bool		bFrozen;		// set when game ends or player dies to temporarily prevent player from restarting (until cleared by timer)
var bool		bPressedJump;
var bool		bUpdatePosition;
var bool		bIsTyping;
var bool		bFixedCamera;	// used to fix camera in position (to view animations)
//NEW MJL
var bool		bJumped;
/*OLD
var bool		bJumpStatus;	// used in net games
*/
var	bool		bUpdating;
var globalconfig bool	bNeverSwitchOnPickup;	// if true, don't automatically switch to picked up weapon

//NEW (mdf) - icky \hack moved here so can be accessed in native weapon code (U2PlayerController not native)
var vector LeanOffset; // actual additional camera offset due to leaning (DesiredLeanOffset smoothed in over time)
//OLD

//NEW (mwp) replace the PlayerController.WeaponPriority support that was removed from Warfare
var globalconfig name WeaponPriority[50]; // weapon class priorities higher is better
//OLD

var bool		bZooming;
var	bool		bOnlySpectator;	// This controller is not allowed to possess pawns

var globalconfig bool bCheatsEnabled; //NEW (mdf)

var globalconfig bool bAlwaysLevel;
var bool		bSetTurnRot;
var bool		bCheatFlying;	// instantly stop in flying mode
var bool		bFreeCamera;	// free camera when in behindview mode (for checking out player models and animations)
var	bool		bZeroRoll;

var float AimingHelp;
var float WaitDelay;			// Delay time until can restart

var input float
	aBaseX, aBaseY, aBaseZ,	aMouseX, aMouseY,
	aForward, aTurn, aStrafe, aUp, aLookUp;

var input byte
	bStrafe, bSnapLevel, bLook, bFreeLook, bTurn180, bTurnToNearest;

var EDoubleClickDir DoubleClickDir;		// direction of movement key double click (for special moves)

// Camera info.
var int ShowFlags;
var int Misc1,Misc2;
var int RendMap;
var float        OrthoZoom;     // Orthogonal/map view zoom factor.
var const actor ViewTarget;
var float CameraDist;		// multiplier for behindview camera dist

var globalconfig float DesiredFOV;
var globalconfig float DefaultFOV;
var float		ZoomLevel;

// Screen flashes
var vector FlashScale, FlashFog;
var float DesiredFlashScale, ConstantGlowScale, InstantFlash;
var vector DesiredFlashFog, ConstantGlowFog, InstantFog;

// Distance fog fading.
var color	LastDistanceFogColor;
var float	LastDistanceFogStart;
var float	LastDistanceFogEnd;
var float	CurrentDistanceFogEnd;
var float	TimeSinceLastFogChange;
var int		LastZone;

// Remote Pawn ViewTargets
var rotator		TargetViewRotation; 
var float		TargetEyeHeight;
var vector		TargetWeaponViewOffset;

var HUD	myHUD;	// heads up display info

var float LastPlaySound;
var globalconfig int AnnouncerVolume;

// Music info.
var string				Song;
var EMusicTransition	Transition;

// Move buffering for network games.  Clients save their un-acknowledged moves in order to replay them
// when they get position updates from the server.
var SavedMove SavedMoves;	// buffered moves pending position updates
var SavedMove FreeMoves;	// freed moves, available for buffering
var SavedMove PendingMove;	
var float CurrentTimeStamp,LastUpdateTime,ServerTimeStamp,TimeMargin, ClientUpdateTime;
var globalconfig float MaxTimeMargin;
var Weapon OldClientWeapon;
var int WeaponUpdate;

// Progess Indicator - used by the engine to provide status messages (HUD is responsible for displaying these).
var string	ProgressMessage[4];
var color	ProgressColor[4];
var float	ProgressTimeOut;

// Localized strings
var localized string QuickSaveString;
var localized string NoPauseMessage;
var localized string ViewingFrom;
var localized string OwnCamera;

// ReplicationInfo
var GameReplicationInfo GameReplicationInfo;

// ngWorldStats Logging
var globalconfig private string ngWorldSecret;
var globalconfig bool ngSecretSet;
var bool ReceivedSecretChecksum;

var class<LocalMessage> LocalMessageClass;

var				globalconfig float Bob;
var				float				LandBob, AppliedBob;
var				float bobtime;
var				vector			WalkBob;

// view shaking (affects roll, and offsets camera position)
//NEW
var       float ShakeDuration,ShakeTime;
var       float ShakeMagX,ShakeMagY;
var const float ShakePeriodX,ShakePeriodY;
var vector ShakeOffset; //current magnitude to offset camera from shake
/*OLD
var float	MaxShakeRoll; // max magnitude to roll camera
var vector	MaxShakeOffset; // max magnitude to offset camera position
var float	ShakeRollRate;	// rate to change roll
var vector	ShakeOffsetRate;
var vector	ShakeOffset; //current magnitude to offset camera from shake
var float	ShakeRollTime; // how long to roll.  if value is < 1.0, then MaxShakeOffset gets damped by this, else if > 1 then its the number of times to repeat undamped
var vector	ShakeOffsetTime;
*/

var Pawn		TurnTarget;
var config int	EnemyTurnSpeed;
var int			GroundPitch;
var rotator		TurnRot180;

var vector OldFloor;		// used by PlayerSpider mode - floor for which old rotation was based;

// Components ( inner classes )
//NEW
/*OLD
var CheatManager			CheatManager;	// Object within playercontroller that manages "cheat" commands
var class<CheatManager>		CheatClass;		// class of my CheatManager
*/
var transient PlayerInput	PlayerInput;	// Object within playercontroller that manages player input.
var class<PlayerInput>		InputClass;		// class of my PlayerInput

//NEW MJL: needs to be here so the native code can run through the ExecManagers
var array<Object> ExecManagers;					// Array of execmanagers (cheatmanager is not used anymore)
var array< class<Object> > ExecManagerClasses;	// Array of default execmanager classes, set in the ini
//OLD

//NEW (mdf)
var bool bForwardPressed; 							// mantling support (!!MJL tbr -- remove if definitely won't be used)
var bool bUpPressed;								// mantling support
var globalconfig float SpectatingAccelerationScale; // default to faster movement when spectating and make the speed configurable		
var float CheatFlyingSpeed;							// ghost can specify speed
//OLD

//NEW (mdf) matinee fixes
var bool bMatineePossess;							// set to true for duration of PossessMatinee/UnPossessMatinee
//OLD

// Demo recording view rotation
var int DemoViewPitch;
var int DemoViewYaw;

var globalconfig bool ShowSubtitles; //NEW

replication
{
	// Functions server can call.
	reliable if( Role==ROLE_Authority )
		ClientSetHUD,ClientReliablePlaySound, FOV, StartZoom, 
//NEW MJL
		ToggleZoom, StopZoom, EndZoom, ClientSetMusic, SetMasterVolume,
/*OLD
		ToggleZoom, StopZoom, EndZoom, ClientSetMusic, ClientRestart,
*/
		ClientReplicateSkins, ClientAdjustGlow, 
		ClientSetBehindView, ClientSetFixedCamera, ClearProgressMessages, 
		SetProgressMessage, SetProgressTime,
//NEW MJL
		ClientGotoState; 
/*OLD
		GivePawn, ClientGotoState; 
*/
	reliable if ( (Role == ROLE_Authority) && (!bDemoRecording || (bClientDemoRecording && bClientDemoNetFunc)) )
		ClientMessage, TeamMessage, ReceiveLocalizedMessage;
	unreliable if( Role==ROLE_Authority && !bDemoRecording )
		ClientPlaySound;
	reliable if( Role==ROLE_Authority && !bDemoRecording )
		ClientTravel;
	unreliable if( Role==ROLE_Authority )
		SetFOVAngle, ClientShake, ClientFlash, ClientInstantFlash, 
		ClientAdjustPosition, ShortClientAdjustPosition, VeryShortClientAdjustPosition, LongClientAdjustPosition;
	unreliable if( (!bDemoRecording || bClientDemoRecording && bClientDemoNetFunc) && Role==ROLE_Authority )
		ClientHearSound;
//NEW MJL: revised interface to send UI events
	reliable if( Role==ROLE_Authority )
		ClientSendEvent;
//OLD

	// Functions client can call.
	unreliable if( Role<ROLE_Authority )
		ShortServerMove, ServerMove, Say, TeamSay, ServerSetHandedness;
	reliable if( Role<ROLE_Authority )
//NEW
		Speech, Pause, SetPause, Admin,
		PrevItem, ActivateItem, ServerReStartGame,
		ChangeName, ChangeTeam, Suicide,
		ActivateInventoryItem, ServerThrowWeapon, // new functions
		BehindView, Typing;
/*OLD
		Speech, Pause, SetPause,
		PrevItem, ActivateItem, ServerReStartGame, AskForPawn,
		ChangeName, ChangeTeam, Suicide,
		ThrowWeapon, BehindView, Typing;
*/
}

event Replication()
{
	Super.Replication();

	//controllers are only relevant to the player they correspond to, so bNetOwner checks are not necessary

	if( !bNetInitial )
	{
		DOREP('bCollideWorld');
		DOREP('CollisionRadius');
		DOREP('CollisionHeight');
	}
	if( bNetInitial )
	{
		//needed so the initial replication reaches the client, and we can join the game in the first place
		DOREP('bNetOwner');

		DOREP('GameReplicationInfo');
	}
	
	DOREP('bBehindView');
	DOREP('ViewTarget');
	if ( (ViewTarget != Pawn) && Pawn(ViewTarget) != None )
	{
		DOREP('TargetViewRotation');
		DOREP('TargetEyeHeight');
		DOREP('TargetWeaponViewOffset');
	}

/*NEW MJL: for our pawn viewtargets ...
viewrotation is sent as part of the u2pawn's currentstatus.
weaponviewoffset could be calculated clientside.
eyeheight ... it changes? :)
*/
	/* mjl-tbd: demos
	if( bDemoRecording )
	{
		DOREP('DemoViewPitch');
		DOREP('DemoViewYaw');
	}
	*/
}

function SetAutoSaveIndex( int i );		// Autosave interface.

function bool OKToCheat( optional bool bQuiet ) { return true; } //NEW (Mdf)

//NEW MJL: for easier debugging
exec function Mark()
{
	log("Mark at Time = "$Level.TimeSeconds);
}

//NEW MJL: to allow easy overriding of the movement code
protected function HandleMove
(
	float DeltaTime, 
	vector NewAccel, 
	eDoubleClickDir DoubleClickMove, 
	rotator DeltaRot
) {
		if ( Role < ROLE_Authority ) // then save this move and replicate it
			ReplicateMove(DeltaTime, NewAccel, DoubleClickMove, DeltaRot);
		else
			ProcessMove(DeltaTime, NewAccel, DoubleClickMove, DeltaRot);
}
//OLD

//NEW MJL: revised interface to send UI events
native final function SendEvent( string Event );
final function ClientSendEvent( string Event )
{
	SendEvent( Event );
}
//OLD

native final function string GetPlayerNetworkAddress();
native function string ConsoleCommand( string Command );
native final function LevelInfo GetEntryLevel();
native(544) final function ResetKeyboard();
native /*final*/ function SetViewTarget(Actor NewViewTarget);	//NEW (mdf) Allow overriding in subclasses.
native event ClientTravel( string URL, ETravelType TravelType, bool bItems );
native(546) final function UpdateURL(string NewOption, string NewValue, bool bSaveDefault);
native final function string GetDefaultURL(string Option);
// Execute a console command in the context of this player, then forward to Actor.ConsoleCommand.
native function CopyToClipboard( string Text );
native function string PasteFromClipboard();

/* FindStairRotation()
returns an integer to use as a pitch to orient player view along current ground (flat, up, or down)
*/
native(524) final function int FindStairRotation(float DeltaTime);

native event ClientHearSound ( 
	actor Actor, 
	int Id, 
	sound S, 
	vector SoundLocation, 
	vector Parameters,
	bool Attenuate
);

//NEW MJL
exec function Admin( string CommandLine )
{
	local string Result;
	if( PlayerReplicationInfo.bAdmin || Level.NetMode == NM_Standalone )
	{
		Result = ConsoleCommand( CommandLine );
		if( Result!="" )
			ClientMessage( Result );
	}
}
//OLD

event PostBeginPlay()
{
	local int i; //NEW MJL: for the code below

	Super.PostBeginPlay();
	SpawnDefaultHUD();
	if (Level.LevelEnterText != "" )
		ClientMessage(Level.LevelEnterText);

	DesiredFOV = DefaultFOV;
	SetViewTarget(self);  // MUST have a view target!
//NEW MJL: improved execmanager support
	if (Role==ROLE_Authority)
	{
		for (i=0; i<ExecManagerClasses.Length; i++)
		{
			ExecManagers[i] = new(self) ExecManagerClasses[i];
		}
	}
/*OLD
	if ( Level.NetMode == NM_Standalone )
		CheatManager = new CheatClass;
*/
}

/* SpawnDefaultHUD()
Spawn a HUD (make sure that PlayerController always has valid HUD, even if \
ClientSetHUD() hasn't been called\
*/
function SpawnDefaultHUD()
{
	myHUD = spawn(class'HUD',self);
}
	
/* Reset() 
reset actor to initial state - used when restarting level without reloading.
*/
function Reset()
{
	PawnDied();
	Super.Reset();
	SetViewTarget(self);
	bBehindView = false;
	WaitDelay = Level.TimeSeconds + 2;
	GotoState('PlayerWaiting');
}

/* InitInputSystem()
Spawn the appropriate class of PlayerInput
Only called for playercontrollers that belong to local players
*/
event InitInputSystem()
{
	PlayerInput = new InputClass;
}

/* ClientGotoState()
server uses this to force client into NewState
*/
function ClientGotoState(name NewState, name NewLabel)
{
	GotoState(NewState,NewLabel);
}

//NEW MJL
/*OLD
function AskForPawn()
{
	if ( Pawn != None )
		GivePawn(Pawn);
	else if ( IsInState('GameEnded') )
		ClientGotoState('GameEnded', 'Begin');
	else if ( IsInState('Dead') )
	{
		bFrozen = false;
		ServerRestartPlayer();
	}		
}	

function GivePawn(Pawn NewPawn)
{
	if ( NewPawn == None )
		return;
	Pawn = NewPawn;
	NewPawn.Controller = self;
	ClientRestart();
}	
*/

/* GetFacingDirection()
returns direction faced relative to movement dir
0 = forward
16384 = right
32768 = back
49152 = left
*/
function int GetFacingDirection()
{
	local vector X,Y,Z, Dir;

	GetAxes(Pawn.Rotation, X,Y,Z);
	Dir = Normal(Pawn.Acceleration);
	if ( Y Dot Dir > 0 )
		return ( 49152 + 16384 * (X Dot Dir) );
	else
		return ( 16384 - 16384 * (X Dot Dir) );
}

// Possess a pawn
function Possess( Pawn aPawn )
{
	if ( bOnlySpectator )
		return;
		
//NEW MJL:
	//would be nice if we could do this on the server as well,
	//  but various places set Pawn before code execution gets here
	//  so this logic applies only on the server
	if( Level.NetMode == NM_Client )
	{
		if( Pawn == aPawn )
			return;
		if( Pawn != None )
			UnPossess();
	}
//OLD

	SetRotation(aPawn.Rotation);
//NEW MJL:
	Pawn = aPawn;
	Pawn.PossessedBy(self);
/*OLD
	aPawn.PossessedBy(self);
	Pawn = aPawn;
*/
	
	Pawn.bStasis = false;
	PlayerReplicationInfo.bIsFemale = Pawn.bIsFemale;
	ServerSetHandedness(Handedness);
	Restart();
}

// unpossessed a pawn (not because pawn was killed)
function UnPossess()
{
	if ( Pawn != None )
	{
		SetLocation(Pawn.Location);
//NEW MJL
		Pawn.UnPossessed();
		Pawn.RemoteRole = ROLE_SimulatedProxy;
/*OLD
		Pawn.RemoteRole = ROLE_SimulatedProxy;
		Pawn.UnPossessed();
*/
		if ( Viewtarget == Pawn )
			SetViewTarget(self);
	}
	Pawn = None;

//NEW
	GotoState( SpectatingState );
/*OLD
	GotoState('Spectating');
*/
}

//NEW (mdf) matinee fixes
function PossessMatinee( Pawn P )
{
	bMatineePossess = true;
	Possess( P );
	bMatineePossess = false;
}

function UnPossessMatinee()
{
	// basically a hack so we don't have to refactor 100's of lines of code
	bMatineePossess = true;
	UnPossess();
	bMatineePossess = false;
}
//OLD

// unpossessed a pawn (because pawn was killed)
function PawnDied()
{
	StopZoom();
	if ( Pawn != None )
		Pawn.RemoteRole = ROLE_SimulatedProxy;
	if ( ViewTarget == Pawn )
		bBehindView = true;

	Super.PawnDied();
}

function ClientSetHUD(class<HUD> newHUDType, class<Scoreboard> newScoringType)
{
	local HUD NewHUD;

	if ( (myHUD == None) || ((newHUDType != None) && (newHUDType != myHUD.Class)) )
	{
		NewHUD = spawn(newHUDType, self); 
		if ( NewHUD != None )
		{
			if ( myHUD != None )
				myHUD.Destroy();
			myHUD = NewHUD;
		}
	}
	if ( (myHUD != None) && (newScoringType != None) )
		MyHUD.SpawnScoreBoard(newScoringType);
}

function HandlePickup(Pickup pick)
{
	ReceiveLocalizedMessage( pick.MessageClass, 0, None, None, pick.Class );
}
	
function ViewFlash(float DeltaTime)
{
	local vector goalFog;
	local float goalscale, delta;

	delta = FMin(0.1, DeltaTime);
	goalScale = 1 + DesiredFlashScale + ConstantGlowScale;
	goalFog = DesiredFlashFog + ConstantGlowFog;

	if ( Pawn != None )
	{
		goalScale += Pawn.HeadVolume.ViewFlash.X; 
		goalFog += Pawn.HeadVolume.ViewFog;
	}

	DesiredFlashScale -= DesiredFlashScale * 2 * delta;  
	DesiredFlashFog -= DesiredFlashFog * 2 * delta;
	FlashScale.X += (goalScale - FlashScale.X + InstantFlash) * 10 * delta;
	FlashFog += (goalFog - FlashFog + InstantFog) * 10 * delta;
	InstantFlash = 0;
	InstantFog = vect(0,0,0);

	if ( FlashScale.X > 0.981 )
		FlashScale.X = 1;
	FlashScale = FlashScale.X * vect(1,1,1);

	if ( FlashFog.X < 0.019 )
		FlashFog.X = 0;
	if ( FlashFog.Y < 0.019 )
		FlashFog.Y = 0;
	if ( FlashFog.Z < 0.019 )
		FlashFog.Z = 0;
}

event ReceiveLocalizedMessage( class<LocalMessage> Message, optional int Switch, optional PlayerReplicationInfo RelatedPRI_1, optional PlayerReplicationInfo RelatedPRI_2, optional Object OptionalObject )
{
	Message.Static.ClientReceive( Self, Switch, RelatedPRI_1, RelatedPRI_2, OptionalObject );
}

event ClientMessage( coerce string S, optional Name Type )
{
	if (Type == '')
		Type = 'Event';
	TeamMessage(PlayerReplicationInfo, S, Type);
}

event TeamMessage( PlayerReplicationInfo PRI, coerce string S, name Type  )
{
	local string ConsoleString;

	//log("Teammessage with PRI "$PRI$" hud "$myHud$" Player "$Player$" console "$Player.console$" string "$S);
	ConsoleString = S;
//NEW (mdf) -- temp warning fix until PRI stuff nailed down
	if ( PRI != None && ((Type == 'Say') || (Type == 'TeamSay')) )
/*OLD
	if ( (Type == 'Say') || (Type == 'TeamSay') )
*/
		ConsoleString = PRI.PlayerName$": "$ConsoleString;

//NEW (mdf) -- temp warning fix until PRI stuff nailed down
	if( Player != None && Player.Console != None )
		Player.Console.Message( ConsoleString, 6.0 );
/*OLD
	Player.Console.Message( ConsoleString, 6.0 );
*/

	myHUD.Message( PRI, S, Type );
}

simulated function PlayBeepSound();

//Play a sound client side (so only client will hear it
simulated function ClientPlaySound(sound ASound, optional bool bVolumeControl )
{	
	local int i;

	ViewTarget.PlaySound(ASound, SLOT_None, 1);

	LastPlaySound = Level.TimeSeconds;	// so voice messages won't overlap
}

simulated function ClientReliablePlaySound(sound ASound, optional bool bVolumeControl )
{
	ClientPlaySound(ASound, bVolumeControl);
}

simulated event Destroyed()
{
	local SavedMove Next;
	local int i; //NEW (mdf)
	
//NEW (mdf)
	if( Role == ROLE_Authority )
	{
		for( i=0; i<ExecManagerClasses.Length; i++ )
		{
			if( ExecManagers[ i ] != None )
				ExecManagers[ i ].Delete();
		}
		
		ExecManagers.Length = 0;
	}
//OLD
	
	if ( Pawn != None )
	{
		Pawn.Health = 0;
		Pawn.Died( self, class'Suicided', Pawn.Location, vect(0,0,0) );
	}
	Super.Destroyed();
	myHud.Destroy();

	while ( FreeMoves != None )
	{
		Next = FreeMoves.NextMove;
		FreeMoves.Destroy();
		FreeMoves = Next;
	}
	while ( SavedMoves != None )
	{
		Next = SavedMoves.NextMove;
		SavedMoves.Destroy();
		SavedMoves = Next;
	}
}

function ClientSetMusic( string NewSong, EMusicTransition NewTransition )
{
	StopAllMusic( 0.0 );
	PlayMusic( NewSong, 3.0 );
	Song        = NewSong;
	Transition  = NewTransition;
}
	
// Volume is in decibels (-100db to +10db).
exec function SetMasterVolume( int Volume )
{
    class'MusicScriptEvent'.static.SetMasterVolume( Volume );
}

// ------------------------------------------------------------------------
// Zooming/FOV change functions

function ToggleZoom()
{
	if ( DefaultFOV != DesiredFOV )
		EndZoom();
	else
		StartZoom();
}
	
function StartZoom()
{
	ZoomLevel = 0.0;
	bZooming = true;
}

function StopZoom()
{
	bZooming = false;
}

function EndZoom()
{
	bZooming = false;
	DesiredFOV = DefaultFOV;
}

//NEW
/*OLD (mdf) interferes with our exec -- is this needed?
function SetFOV(float NewFOV)
{
	DesiredFOV = NewFOV;
	FOVAngle = NewFOV;
}
*/

function FixFOV()
{
	FOVAngle = Default.DefaultFOV;
	DesiredFOV = Default.DefaultFOV;
	DefaultFOV = Default.DefaultFOV;
}

function ResetFOV()
{
	DesiredFOV = DefaultFOV;
	FOVAngle = DefaultFOV;
}

exec function FOV(float F)
{
	if( (F >= 80.0) || (Level.Netmode==NM_Standalone) )
	{
		DefaultFOV = FClamp(F, 1, 170);
		DesiredFOV = DefaultFOV;
		SaveConfig();
	}
}


// ------------------------------------------------------------------------
// Messaging functions

// Send a message to all players.
exec function Say( string Msg )
{
	Level.Game.Broadcast(self, Msg, 'Say');
}

exec function TeamSay( string Msg )
{
	Level.Game.BroadcastTeam(self, Msg, 'Say');
}

//NEW
exec function Use();
exec function Unuse();
//OLD

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

function ServerSetHandedness( float hand)
{
	Handedness = hand;
	if ( Pawn.Weapon != None )
		Pawn.Weapon.SetHand(Handedness);
}

function SetHand()
{
	Pawn.Weapon.SetHand(Handedness);
	ServerSetHandedness(Handedness);
}

function ChangeSetHand( string S )
{
	if ( S ~= "Left" )
		Handedness = -1;
	else if ( S~= "Right" )
		Handedness = 1;
	else if ( S ~= "Center" )
		Handedness = 0;
	else if ( S ~= "Hidden" )
		Handedness = 2;
	SetHand();
}

event PreClientTravel()
{
}

function ClientSetFixedCamera(bool B)
{
	bFixedCamera = B;
}

function ClientSetBehindView(bool B)
{
	bBehindView = B;
}

function ClientReplicateSkins(Material Skin1, optional Material Skin2, optional Material Skin3, optional Material Skin4)
{
	// do nothing (just loading other player skins onto client)
	log("Getting "$Skin1$", "$Skin2$", "$Skin3$", "$Skin4);
	return;
}

function CheckBob(float DeltaTime, float Speed2D, vector Y)
{
	if ( Speed2D < 10 )
		BobTime += 0.2 * DeltaTime;
	else
		BobTime += DeltaTime * (0.3 + 0.7 * Speed2D/Pawn.GroundSpeed);
	WalkBob = Y * 0.4 * Bob * Speed2D * sin(8 * BobTime);
	AppliedBob = AppliedBob * (1 - FMin(1, 16 * deltatime));
	if ( Speed2D < 10 )
		WalkBob.Z = AppliedBob;
	else
		WalkBob.Z = AppliedBob + 0.3 * Bob * Speed2D * sin(16 * BobTime);
	if ( LandBob > 0.01 )
	{
		AppliedBob += FMin(1, 16 * deltatime) * LandBob;
		LandBob *= (1 - 8*Deltatime);
	}
}

function vector WeaponBob(float BobDamping)
{
	Local Vector WBob;

	WBob = BobDamping * WalkBob;
	WBob.Z = (0.45 + 0.55 * BobDamping) * WalkBob.Z;

	return (WBob + 0.9 * ShakeOffset);
}

function ClientVoiceMessage(PlayerReplicationInfo Sender, PlayerReplicationInfo Recipient, name messagetype, byte messageID)
{
	local VoicePack V;

	if ( (Sender == None) || (Sender.voicetype == None) || (Player.Console == None) )
		return;
		
	V = Spawn(Sender.voicetype, self);
	if ( V != None )
		V.ClientInitialize(Sender, Recipient, messagetype, messageID);
}

/* ForceDeathUpdate()
Make sure ClientAdjustPosition immediately informs client of pawn's death
*/
function ForceDeathUpdate()
{
	LastUpdateTime = Level.TimeSeconds - 10;
}

/* ShortServerMove()
compressed version of server move for bandwidth saving
*/
function ShortServerMove
(
	float TimeStamp, 
	vector ClientLoc,
	bool NewbRun,
	bool NewbDuck,
	bool NewbJumpStatus, 
	byte ClientRoll, 
	int View
)
{
	ServerMove(TimeStamp,vect(0,0,0),ClientLoc,NewbRun,NewbDuck,NewbJumpStatus,DCLICK_None,ClientRoll,View);
}

/* ServerMove() 
- replicated function sent by client to server - contains client movement and firing info
Passes acceleration in components so it doesn't get rounded.
*/
function ServerMove
(
	float TimeStamp, 
	vector InAccel, 
	vector ClientLoc,
	bool NewbRun,
	bool NewbDuck,
//NEW
	bool bJumped, 
/*OLD
	bool NewbJumpStatus, 
*/
	eDoubleClickDir DoubleClickMove, 
	byte ClientRoll, 
	int View,
	optional byte OldTimeDelta,
	optional int OldAccel
)
{
	local float DeltaTime, clientErr, OldTimeStamp;
	local rotator DeltaRot, Rot, ViewRot;
	local vector Accel, LocDiff, ClientVel, ClientFloor;
	local int maxPitch, ViewPitch, ViewYaw;
	local bool NewbPressedJump, OldbRun, OldbDuck;
	local eDoubleClickDir OldDoubleClickMove;
	local actor ClientBase;
	local ePhysics ClientPhysics;

	// If this move is outdated, discard it.
	if ( CurrentTimeStamp >= TimeStamp )
		return;

	// if OldTimeDelta corresponds to a lost packet, process it first
	if (  OldTimeDelta != 0 )
	{
		OldTimeStamp = TimeStamp - float(OldTimeDelta)/500 - 0.001;
		if ( CurrentTimeStamp < OldTimeStamp - 0.001 )
		{
			// split out components of lost move (approx)
			Accel.X = OldAccel >>> 23;
			if ( Accel.X > 127 )
				Accel.X = -1 * (Accel.X - 128);
			Accel.Y = (OldAccel >>> 15) & 255;
			if ( Accel.Y > 127 )
				Accel.Y = -1 * (Accel.Y - 128);
			Accel.Z = (OldAccel >>> 7) & 255;
			if ( Accel.Z > 127 )
				Accel.Z = -1 * (Accel.Z - 128);
			Accel *= 20;
			
			OldbRun = ( (OldAccel & 64) != 0 );
			OldbDuck = ( (OldAccel & 32) != 0 );
//NEW MJL: jump (ugly copied code from below...to make ServerMove work, even though we have ServerMoveEx)
			NewbPressedJump = false;
			if ( (OldAccel & 16) != 0 )
			{
				if ( bJump == 0 )
					NewbPressedJump = true;
				bJump = 1;
			}
			else
			{
				bJump = 0;
			}
/*OLD
			NewbPressedJump = ( (OldAccel & 16) != 0 );
			if ( NewbPressedJump )
				bJumpStatus = NewbJumpStatus;
*/

			switch (OldAccel & 7)
			{
				case 0:
					OldDoubleClickMove = DCLICK_None;
					break;
				case 1:
					OldDoubleClickMove = DCLICK_Left;
					break;
				case 2:
					OldDoubleClickMove = DCLICK_Right;
					break;
				case 3:
					OldDoubleClickMove = DCLICK_Forward;
					break;
				case 4:
					OldDoubleClickMove = DCLICK_Back;
					break;
			}
			//log("Recovered move from "$OldTimeStamp$" acceleration "$Accel$" from "$OldAccel);
			MoveAutonomous(OldTimeStamp - CurrentTimeStamp, OldbRun, OldbDuck, NewbPressedJump, OldDoubleClickMove, Accel, rot(0,0,0));
			CurrentTimeStamp = OldTimeStamp;
		}
	}		

	// View components
	ViewPitch = View/32768;
	ViewYaw = 2 * (View - 32768 * ViewPitch);
	ViewPitch *= 2;
	// Make acceleration.
	Accel = InAccel/10;

//NEW MJL: jump
	NewbPressedJump = false;
	if ( bJumped )
	{
		if ( bJump == 0 )
			NewbPressedJump = true;
		bJump = 1;
	}
	else
	{
		bJump = 0;
	}
/*OLD
	NewbPressedJump = (bJumpStatus != NewbJumpStatus);
	bJumpStatus = NewbJumpStatus;
*/

/*uw829 has weapons handle their firing. we are retaining the old way...in U2PlayerNetTestController
	// handle firing and alt-firing
	if ( bFired )
	{
//NEW MJL: no ForceFire
		if ( bFire == 0 )
		{
			bFire = 1;
			Fire();
		}
/*OLD
		if ( bForceFire && (Pawn != None) && (Pawn.Weapon != None) )
			Pawn.Weapon.ForceFire();
		else if ( bFire == 0 )
			Fire(0);
		bFire = 1;
*/
	}
	else
		bFire = 0;


	if ( bAltFired )
	{
//NEW MJL: no ForceAltFire
		if ( bAltFire == 0 )
		{
			bAltFire = 1;
			AltFire();
		}
/*OLD
		if ( bForceAltFire && (Pawn != None) && (Pawn.Weapon != None) )
			Pawn.Weapon.ForceAltFire();
		else if ( bAltFire == 0 )
			AltFire(0);
		bAltFire = 1;
*/
	}
	else
		bAltFire = 0;
*/
	// Save move parameters.
	DeltaTime = TimeStamp - CurrentTimeStamp;
	if ( ServerTimeStamp > 0 )
	{
		// allow 1% error
		TimeMargin += DeltaTime - 1.01 * (Level.TimeSeconds - ServerTimeStamp);
		if ( TimeMargin > MaxTimeMargin )
		{
			// player is too far ahead
			TimeMargin -= DeltaTime;
			if ( TimeMargin < 0.5 )
				MaxTimeMargin = Default.MaxTimeMargin;
			else
				MaxTimeMargin = 0.5;
			DeltaTime = 0;
		}
	}

	CurrentTimeStamp = TimeStamp;
	ServerTimeStamp = Level.TimeSeconds;
	ViewRot.Pitch = ViewPitch;
	ViewRot.Yaw = ViewYaw;
	ViewRot.Roll = 0;
	SetRotation(ViewRot);

	if ( Pawn != None )
	{
		Rot.Roll = 256 * ClientRoll;
		Rot.Yaw = ViewYaw;
		if ( (Pawn.Physics == PHYS_Swimming) || (Pawn.Physics == PHYS_Flying) )
			maxPitch = 2;
		else
			maxPitch = 1;
		If ( (ViewPitch > maxPitch * RotationRate.Pitch) && (ViewPitch < 65536 - maxPitch * RotationRate.Pitch) )
		{
			If (ViewPitch < 32768) 
				Rot.Pitch = maxPitch * RotationRate.Pitch;
			else
				Rot.Pitch = 65536 - maxPitch * RotationRate.Pitch;
		}
		else
			Rot.Pitch = ViewPitch;

//NEW MJL: Should use Pawn's Rotation, not Controller's
		DeltaRot = (Pawn.Rotation - Rot);
/*OLD
		DeltaRot = (Rotation - Rot);
*/
		Pawn.SetRotation(Rot);
	}

	// Perform actual movement.
	if ( (Level.Pauser == None) && (DeltaTime > 0) )
		MoveAutonomous(DeltaTime, NewbRun, NewbDuck, NewbPressedJump, DoubleClickMove, Accel, DeltaRot);

	// Accumulate movement error.
	if ( Level.TimeSeconds - LastUpdateTime > 0.3 )
		ClientErr = 10000;
	else if ( Level.TimeSeconds - LastUpdateTime > 180.0/Player.CurrentNetSpeed )
	{
		if ( Pawn == None )
			LocDiff = Location - ClientLoc;
		else
			LocDiff = Pawn.Location - ClientLoc;
		ClientErr = LocDiff Dot LocDiff;
	}

	// If client has accumulated a noticeable positional error, correct him.
	if ( ClientErr > 3 )
	{
		if ( Pawn == None )
		{
			ClientPhysics = Physics;
			ClientLoc = Location;
			ClientVel = Velocity;
		}
		else
		{
			ClientPhysics = Pawn.Physics;
			ClientVel = Pawn.Velocity;
			ClientBase = Pawn.Base;
			if ( Mover(Pawn.Base) != None )
				ClientLoc = Pawn.Location - Pawn.Base.Location;
			else
				ClientLoc = Pawn.Location;
			ClientFloor = Pawn.Floor;
		}
		//log("Client Error at "$TimeStamp$" is "$ClientErr$" with acceleration "$Accel$" LocDiff "$LocDiff$" Physics "$Pawn.Physics);
		LastUpdateTime = Level.TimeSeconds;

		if ( (Pawn == None) || (Pawn.Physics != PHYS_Spider) )
		{
			if ( ClientVel == vect(0,0,0) )
			{
				if ( IsInState('PlayerWalking') && (Pawn != None) && (Pawn.Physics == PHYS_Walking) )
				{
					VeryShortClientAdjustPosition
					(
						TimeStamp,
						ClientLoc.X,
						ClientLoc.Y,
						ClientLoc.Z,
						ClientBase
					);
				}
				else
					ShortClientAdjustPosition
					(
						TimeStamp, 
						GetStateName(), 
						ClientPhysics, 
						ClientLoc.X, 
						ClientLoc.Y, 
						ClientLoc.Z, 
						ClientBase
					);
			}
			else
				ClientAdjustPosition
				(
					TimeStamp, 
					GetStateName(), 
					ClientPhysics, 
					ClientLoc.X, 
					ClientLoc.Y, 
					ClientLoc.Z, 
					ClientVel.X, 
					ClientVel.Y, 
					ClientVel.Z,
					ClientBase
				);
		}
		else
			LongClientAdjustPosition
			(
				TimeStamp, 
				GetStateName(), 
				ClientPhysics, 
				ClientLoc.X, 
				ClientLoc.Y, 
				ClientLoc.Z, 
				ClientVel.X, 
				ClientVel.Y, 
				ClientVel.Z,
				ClientBase,
				ClientFloor.X,
				ClientFloor.Y,
				ClientFloor.Z
			);
	}
	//log("Server moved stamp "$TimeStamp$" location "$Pawn.Location$" Acceleration "$Pawn.Acceleration$" Velocity "$Pawn.Velocity);
}	

function ProcessMove ( float DeltaTime, vector newAccel, eDoubleClickDir DoubleClickMove, rotator DeltaRot)
{
	if ( Pawn != None )
		Pawn.Acceleration = newAccel;
}

final function MoveAutonomous
(	
	float DeltaTime, 	
	bool NewbRun,
	bool NewbDuck,
	bool NewbPressedJump, 
	eDoubleClickDir DoubleClickMove, 
	vector newAccel, 
	rotator DeltaRot
)
{
//NEW (mdf)
	if ( NewbRun )
		SetRunFlag( 1 );
	else
		SetRunFlag( 0 );

	if ( NewbDuck )
		SetDuckFlag( 1 );
	else
		SetDuckFlag( 0 );
/*OLD
	if ( NewbRun )
		bRun = 1;
	else
		bRun = 0;

	if ( NewbDuck )
		bDuck = 1;
	else
		bDuck = 0;
*/		
	bPressedJump = NewbPressedJump;

	HandleWalking();
	ProcessMove(DeltaTime, newAccel, DoubleClickMove, DeltaRot);
	if ( Pawn != None )	
		Pawn.AutonomousPhysics(DeltaTime);
	else
		AutonomousPhysics(DeltaTime);
	//log("Role "$Role$" moveauto time "$100 * DeltaTime$" ("$Level.TimeDilation$")");
}

/* VeryShortClientAdjustPosition
bandwidth saving version, when velocity is zeroed, and pawn is walking
*/
function VeryShortClientAdjustPosition
(
	float TimeStamp, 
	float NewLocX, 
	float NewLocY, 
	float NewLocZ, 
	Actor NewBase
)
{
	local vector Floor;

	if ( Pawn != None )
		Floor = Pawn.Floor;
	LongClientAdjustPosition(TimeStamp,'PlayerWalking',PHYS_Walking,NewLocX,NewLocY,NewLocZ,0,0,0,NewBase,Floor.X,Floor.Y,Floor.Z);
}

/* ShortClientAdjustPosition
bandwidth saving version, when velocity is zeroed
*/
function ShortClientAdjustPosition
(
	float TimeStamp, 
	name newState, 
	EPhysics newPhysics,
	float NewLocX, 
	float NewLocY, 
	float NewLocZ, 
	Actor NewBase
)
{
	local vector Floor;

	if ( Pawn != None )
		Floor = Pawn.Floor;
	LongClientAdjustPosition(TimeStamp,newState,newPhysics,NewLocX,NewLocY,NewLocZ,0,0,0,NewBase,Floor.X,Floor.Y,Floor.Z);
}

/* ClientAdjustPosition
- pass newloc and newvel in components so they don't get rounded
*/
function ClientAdjustPosition
(
	float TimeStamp, 
	name newState, 
	EPhysics newPhysics,
	float NewLocX, 
	float NewLocY, 
	float NewLocZ, 
	float NewVelX, 
	float NewVelY, 
	float NewVelZ,
	Actor NewBase
)
{
	local vector Floor;

	if ( Pawn != None )
		Floor = Pawn.Floor;
	LongClientAdjustPosition(TimeStamp,newState,newPhysics,NewLocX,NewLocY,NewLocZ,NewVelX,NewVelY,NewVelZ,NewBase,Floor.X,Floor.Y,Floor.Z);
}

/* LongClientAdjustPosition 
long version, when care about pawn's floor normal
*/
function LongClientAdjustPosition
(
	float TimeStamp, 
	name newState, 
	EPhysics newPhysics,
	float NewLocX, 
	float NewLocY, 
	float NewLocZ, 
	float NewVelX, 
	float NewVelY, 
	float NewVelZ,
	Actor NewBase,
	float NewFloorX,
	float NewFloorY,
	float NewFloorZ
)
{
	local vector NewLocation, NewFloor;
	local Actor MoveActor;

	if ( Pawn != None )
	{
		if ( Pawn.bTearOff )
		{
			Pawn = None;
			GotoState('Dead');
			return;
		}
		MoveActor = Pawn;
	}
	else 
		MoveActor = self;

	if ( CurrentTimeStamp > TimeStamp )
		return;
	CurrentTimeStamp = TimeStamp;

	NewLocation.X = NewLocX;
	NewLocation.Y = NewLocY;
	NewLocation.Z = NewLocZ;
	MoveActor.Velocity.X = NewVelX;
	MoveActor.Velocity.Y = NewVelY;
	MoveActor.Velocity.Z = NewVelZ;

	NewFloor.X = NewFloorX;
	NewFloor.Y = NewFloorY;
	NewFloor.Z = NewFloorZ;
	MoveActor.SetBase(NewBase, NewFloor);
	if ( Mover(NewBase) != None )
		NewLocation += NewBase.Location;

	//log("Client "$Role$" adjust "$self$" stamp "$TimeStamp$" location "$MoveActor.Location);
	MoveActor.bCanTeleport = false;
	MoveActor.SetLocation(NewLocation);
	MoveActor.bCanTeleport = true;
	MoveActor.SetPhysics(newPhysics);

	if( GetStateName() != newstate )
		GotoState(newstate);

	bUpdatePosition = true;
}

function ClientUpdatePosition()
{
	local SavedMove CurrentMove;
	local int realbRun, realbDuck;
	local bool bRealJump;
	local float TotalTime;

	bUpdatePosition = false;
//NEW (mdf)	
	realbRun = GetbRun();
	realbDuck = GetbDuck();
/*OLD	
	realbRun = bRun;
	realbDuck = bDuck;
*/	
	bRealJump = bPressedJump;
	CurrentMove = SavedMoves;
	bUpdating = true;
	while ( CurrentMove != None )
	{
		if ( CurrentMove.TimeStamp <= CurrentTimeStamp )
		{
			SavedMoves = CurrentMove.NextMove;
			CurrentMove.NextMove = FreeMoves;
			FreeMoves = CurrentMove;
			FreeMoves.Clear();
			CurrentMove = SavedMoves;
		}
		else
		{
			if ( (TotalTime > 0) && (Pawn != None) )
				AdjustRadius(CurrentMove.Delta * Pawn.GroundSpeed);
			TotalTime += CurrentMove.Delta;
			MoveAutonomous(CurrentMove.Delta, CurrentMove.bRun, CurrentMove.bDuck, CurrentMove.bPressedJump, CurrentMove.DoubleClickMove, CurrentMove.Acceleration, rot(0,0,0));
			CurrentMove = CurrentMove.NextMove;
		}
	}
	//log("Client updated position to "$Pawn.Location);
	bUpdating = false;
//NEW (mdf)	
	SetDuckFlag( realbDuck );
	SetRunFlag( realbRun );
/*OLD
	bDuck = realbDuck;
	bRun = realbRun;
*/	
	bPressedJump = bRealJump;
}

function AdjustRadius(float MaxMove)
{
	local Pawn P;
	local vector Dir;

	// if other pawn moving away from player, push it away if its close
	// since the client-side position is behind the server side position
	ForEach DynamicActors(class'Pawn', P)
		if ( (P != Pawn) && (P.Velocity != vect(0,0,0)) && P.bBlockPlayers )
		{
			Dir = Normal(P.Location - Pawn.Location);
			if ( (Pawn.Velocity Dot Dir > 0) && (P.Velocity Dot Dir > 0) )
			{
				if ( VSize(P.Location - Pawn.Location) < P.CollisionRadius + Pawn.CollisionRadius + MaxMove )
//NEW MJL: should be 1 * ping, not .5 * ping, since our view is one full ping out of sync with our local gamestate
					P.MoveSmooth(P.Velocity * PlayerReplicationInfo.Ping / 1000.0 );
/*OLD
					P.MoveSmooth(P.Velocity * 0.5 * PlayerReplicationInfo.Ping);
*/
			}
		} 
}

final function SavedMove GetFreeMove()
{
	local SavedMove s, first;
	local int i;

	if ( FreeMoves == None )
	{
		// don't allow more than 30 saved moves
		For ( s=SavedMoves; s!=None; s=s.NextMove )
		{
			i++;
			if ( i > 30 )
			{
				first = SavedMoves;
				SavedMoves = SavedMoves.NextMove;
				first.Clear();
				first.NextMove = None;
				// clear out all the moves
				While ( SavedMoves != None )
				{
					s = SavedMoves;
					SavedMoves = SavedMoves.NextMove;
					s.Clear();
					s.NextMove = FreeMoves;
					FreeMoves = s;
				}
				return first;
			}
		}
		return Spawn(class'SavedMove');
	}
	else
	{
		s = FreeMoves;
		FreeMoves = FreeMoves.NextMove;
		s.NextMove = None;
		return s;
	}	
}

function int CompressAccel(int C)
{
	if ( C >= 0 )
		C = Min(C, 127);
	else
		C = Min(abs(C), 127) + 128;
	return C;
}
/* 
========================================================================
Here's how player movement prediction, replication and correction works in network games:

Every tick, the PlayerTick() event is called.  It calls the PlayerMove() function (which is implemented 
in various states).  PlayerMove() figures out the acceleration and rotation, and then calls ProcessMove() 
(for single player or listen servers), or ReplicateMove() (if its a network client).

ReplicateMove() saves the move (in the PendingMove list), calls ProcessMove(), and then replicates the move 
to the server by calling the replicated function ServerMove() - passing the movement parameters, the client's 
resultant position, and a timestamp.

ServerMove() is executed on the server.  It decodes the movement parameters and causes the appropriate movement 
to occur.  It then looks at the resulting position and if enough time has passed since the last response, or the 
position error is significant enough, the server calls ClientAdjustPosition(), a replicated function.

ClientAdjustPosition() is executed on the client.  The client sets its position to the servers version of position, 
and sets the bUpdatePosition flag to true.  

When PlayerTick() is called on the client again, if bUpdatePosition is true, the client will call 
ClientUpdatePosition() before calling PlayerMove().  ClientUpdatePosition() replays all the moves in the pending 
move list which occured after the timestamp of the move the server was adjusting.
*/

//
// Replicate this client's desired movement to the server.
//
function ReplicateMove
(
	float DeltaTime, 
	vector NewAccel, 
	eDoubleClickDir DoubleClickMove, 
	rotator DeltaRot
)
{
	local SavedMove NewMove, OldMove, LastMove;
	local byte ClientRoll;
	local float OldTimeDelta, NetMoveDelta;
	local int i, OldAccel;
	local vector BuildAccel, AccelNorm, MoveLoc;

	// Get a SavedMove actor to store the movement in.
	if ( PendingMove != None )
		PendingMove.SetMoveFor(self, DeltaTime, NewAccel, DoubleClickMove);

	if ( SavedMoves != None )
	{
		NewMove = SavedMoves;
		AccelNorm = Normal(NewAccel);
		while ( NewMove.NextMove != None )
		{
			// find most recent interesting move to send redundantly
			if ( NewMove.bPressedJump || ((NewMove.DoubleClickMove != DCLICK_NONE) && (NewMove.DoubleClickMove < 5))
				|| ((NewMove.Acceleration != NewAccel) && ((normal(NewMove.Acceleration) Dot AccelNorm) < 0.95)) )
				OldMove = NewMove;
			NewMove = NewMove.NextMove;
		}
		if ( NewMove.bPressedJump || ((NewMove.DoubleClickMove != DCLICK_NONE) && (NewMove.DoubleClickMove < 5))
			|| ((NewMove.Acceleration != NewAccel) && ((normal(NewMove.Acceleration) Dot AccelNorm) < 0.95)) )
			OldMove = NewMove;
	}

	LastMove = NewMove;
	NewMove = GetFreeMove();
	if ( NewMove == None )
		return;
	NewMove.SetMoveFor(self, DeltaTime, NewAccel, DoubleClickMove);
	
	// adjust radius of nearby players with uncertain location
	if ( Pawn != None )
		AdjustRadius(NewMove.Delta * Pawn.GroundSpeed);

	// Simulate the movement locally.
	ProcessMove(NewMove.Delta, NewMove.Acceleration, NewMove.DoubleClickMove, DeltaRot);
	if ( Pawn != None )
		Pawn.AutonomousPhysics(NewMove.Delta);
	else
		AutonomousPhysics(DeltaTime);

	//log("Role "$Role$" repmove at "$Level.TimeSeconds$" Move time "$100 * DeltaTime$" ("$Level.TimeDilation$")");

	// Decide whether to hold off on move
	// send if double click move, jump, or fire unless really too soon, or if newmove.delta big enough
	// on client side, save extra buffered time in LastUpdateTime
	if ( PendingMove == None )
		PendingMove = NewMove;
	else
	{
		NewMove.NextMove = FreeMoves;
		FreeMoves = NewMove;
		FreeMoves.Clear();
		NewMove = PendingMove;
	}
	NetMoveDelta = FMax(64.0/Player.CurrentNetSpeed, 0.011);
	
	if ( !PendingMove.bPressedJump && (PendingMove.Delta < NetMoveDelta - ClientUpdateTime) )
	{
		// save as pending move
		return;
	}
	else if ( (ClientUpdateTime < 0) && (PendingMove.Delta < NetMoveDelta - ClientUpdateTime) )
		return;
	else
	{
		ClientUpdateTime = PendingMove.Delta - NetMoveDelta;
		if ( SavedMoves == None )
			SavedMoves = PendingMove;
		else
			LastMove.NextMove = PendingMove;
		PendingMove = None;
	}

	// check if need to redundantly send previous move
	if ( OldMove != None )
	{
		// log("Redundant send timestamp "$OldMove.TimeStamp$" accel "$OldMove.Acceleration$" at "$Level.Timeseconds$" New accel "$NewAccel);
		// old move important to replicate redundantly
		OldTimeDelta = FMin(255, (Level.TimeSeconds - OldMove.TimeStamp) * 500);
		BuildAccel = 0.05 * OldMove.Acceleration + vect(0.5, 0.5, 0.5);
		OldAccel = (CompressAccel(BuildAccel.X) << 23) 
					+ (CompressAccel(BuildAccel.Y) << 15) 
					+ (CompressAccel(BuildAccel.Z) << 7);
		if ( OldMove.bRun )
			OldAccel += 64;
		if ( OldMove.bDuck )
			OldAccel += 32;
		if ( OldMove.bPressedJump )
			OldAccel += 16;
		OldAccel += OldMove.DoubleClickMove;
	}
	//else
	//	log("No redundant timestamp at "$Level.TimeSeconds$" with accel "$NewAccel);
	//log("Replicate move at "$NewMove.TimeStamp$" location "$Pawn.Location);
	// Send to the server
	ClientRoll = (Rotation.Roll >> 8) & 255;
//NEW
/*OLD
	if ( NewMove.bPressedJump )
		bJumpStatus = !bJumpStatus;
*/
	if ( Pawn == None )
		MoveLoc = Location;
	else
		MoveLoc = Pawn.Location;

	if ( (NewMove.Acceleration == vect(0,0,0)) && (NewMove.DoubleClickMove == DCLICK_None) )
		ShortServerMove
		(
			NewMove.TimeStamp, 
			MoveLoc, 
			NewMove.bRun,
			NewMove.bDuck,
//NEW
			NewMove.bPressedJump,
/*OLD
			bJumpStatus, 
*/
			ClientRoll,
			(32767 & (Rotation.Pitch/2)) * 32768 + (32767 & (Rotation.Yaw/2))
		);
	else
		ServerMove
		(
			NewMove.TimeStamp, 
			NewMove.Acceleration * 10, 
			MoveLoc, 
			NewMove.bRun,
			NewMove.bDuck,
//NEW
			NewMove.bPressedJump,
/*OLD
			bJumpStatus,
*/
			NewMove.DoubleClickMove, 
			ClientRoll,
			(32767 & (Rotation.Pitch/2)) * 32768 + (32767 & (Rotation.Yaw/2)),
			OldTimeDelta,
			OldAccel 
		);
}

function HandleWalking()
{
//NEW (mdf) note: totally overridden for U2
	Pawn.SetWalking( ((GetRunFlag() > 0) || (GetDuckFlag() > 0)) && !Region.Zone.IsA('WarpZoneInfo') );
/*OLD	
	Pawn.SetWalking(((bRun != 0) || (bDuck != 0)) && !Region.Zone.IsA('WarpZoneInfo')); 
*/
}

function ServerRestartGame()
{
}

function SetFOVAngle(float newFOV)
{
	FOVAngle = newFOV;
}
	 
function ClientFlash( float scale, vector fog )
{
	DesiredFlashScale = scale;
	DesiredFlashFog = 0.001 * fog;
}

function ClientInstantFlash( float scale, vector fog )
{
	InstantFlash = scale;
	InstantFog = 0.001 * fog;
}
   
function ClientAdjustGlow( float scale, vector fog )
{
	ConstantGlowScale += scale;
	ConstantGlowFog += 0.001 * fog;
}

/* ClientShake()
Function called on client to shake view.
Only ShakeView() should call ClientShake()
*/
/*OLD
private function ClientShake(vector ShakeRoll, vector OffsetMag, vector ShakeRate, float OffsetTime)
{
	if ( (MaxShakeRoll < ShakeRoll.X) || (ShakeRollTime < 0.01 * ShakeRoll.Y) )
	{
		MaxShakeRoll = ShakeRoll.X;
		ShakeRollTime = 0.01 * ShakeRoll.Y;	
		ShakeRollRate = 0.01 * ShakeRoll.Z;
	}
	if ( VSize(OffsetMag) > VSize(MaxShakeOffset) )
	{
		ShakeOffsetTime = OffsetTime * vect(1,1,1);
		MaxShakeOffset = OffsetMag;
		ShakeOffsetRate = ShakeRate;
	}
}
*/

/* ShakeView()
Call this function to shake the player's view
shaketime = how long to roll view
RollMag = how far to roll view as it shakes
OffsetMag = max view offset
RollRate = how fast to roll view
OffsetRate = how fast to offset view
OffsetTime = how long to offset view (number of shakes)
*/
/*OLD
function ShakeView( float shaketime, float RollMag, vector OffsetMag, float RollRate, vector OffsetRate, float OffsetTime)
{
	local vector ShakeRoll;

	ShakeRoll.X = RollMag;
	ShakeRoll.Y = 100 * shaketime;
	ShakeRoll.Z = 100 * rollrate;
	ClientShake(ShakeRoll, OffsetMag, OffsetRate, OffsetTime);
}
*/

//NEW (mdf) -- of no use for players in U2
/*
function DamageAttitudeTo(pawn Other, float Damage)
{
	if ( (Other != None) && (Other != Pawn) && (Damage > 0) )
		Enemy = Other;
}
*/

function Typing( bool bTyping )
{
	bIsTyping = bTyping;
//NEW
/*OLD (mdf) not used for U2
	if ( bTyping && (Pawn != None) && !Pawn.bTearOff )
		Pawn.ChangeAnimation();
*/
	if (Level.Game.StatLog != None)
		Level.Game.StatLog.LogTypingEvent(bTyping, Self);
}

// ------------------------------------------------------------------------
// Normal gameplay execs
// Type the name of the exec function at the console to execute it

exec function Jump( optional float F )
{
	if ( Level.Pauser == PlayerReplicationInfo )
		SetPause(False);
	else
		bPressedJump = true;
}

// Send a voice message of a certain type to a certain player.
exec function Speech( int Type, int Index, int Callsign )
{
	local VoicePack V;

	V = Spawn( PlayerReplicationInfo.VoiceType, Self );
	if (V != None)
		V.PlayerSpeech( Type, Index, Callsign );
}

exec function RestartLevel()
{
	if( Level.Netmode==NM_Standalone )
		ClientTravel( "?restart", TRAVEL_Relative, false );
}

exec function LocalTravel( string URL )
{
	if( Level.Netmode==NM_Standalone )
		ClientTravel( URL, TRAVEL_Relative, false );
}

// ------------------------------------------------------------------------
// Loading and saving

/* QuickSave()
Save game to slot 9
*/
exec function QuickSave()
{
	if ( (Pawn.Health > 0) 
		&& (Level.NetMode == NM_Standalone) )
	{
		ClientMessage(QuickSaveString);
		ConsoleCommand("SaveGame 9");
	}
}

/* QuickLoad()
Load game from slot 9
*/
exec function QuickLoad()
{
	if ( Level.NetMode == NM_Standalone )
		ClientTravel( "?load=9", TRAVEL_Absolute, false);
}

/* SetPause()
 Try to pause game; returns success indicator.
 Replicated to server in network games.
 */
function bool SetPause( BOOL bPause, optional int Key )
{
	return Level.Game.SetPause(bPause, self, Key);
}

/* Pause()
Command to try to pause the game.
*/
exec function Pause()
{
	if( !SetPause(Level.Pauser==None) )
		ClientMessage(NoPauseMessage);
}

// Activate specific inventory item
exec function ActivateInventoryItem( class InvItem )
{
	local Powerups Inv;

	Inv = Powerups(Pawn.FindInventoryType(InvItem));
	if ( Inv != None )
		Inv.Activate();
}

// ------------------------------------------------------------------------
// Weapon changing functions

/* ThrowWeapon()
Throw out current weapon, and switch to a new weapon
*/
//NEW MJL
function ServerThrowWeapon()
{
	Pawn.Weapon.bTossedOut = true;
	Pawn.TossWeapon(Vector(Rotation) * 500 + vect(0,0,220));
	SwitchToBestWeapon();
}

exec function ThrowWeapon()
{
	if( Pawn == None || Pawn.Weapon==None || !Pawn.Weapon.bCanThrow )
		return;
	ServerThrowWeapon();
	//if we are on the server, then ServerThrowWeapon handles SwitchToBestWeapon
	//    and Pawn.TossWeapon handles Pawn.DeleteInventory
	if ( Level.NetMode == NM_Client )
	{
		//we have to do this here in order to stay 'in sync' with the server.
		//   otherwise bad things will happen
		Pawn.Weapon.ClearWeaponEffects();
		Pawn.DeleteInventory(Pawn.Weapon);
		SwitchToBestWeapon();
	}
}
/*OLD
exec function ThrowWeapon()
{
	if( Level.NetMode == NM_Client )
		return;
	if( Pawn.Weapon==None || !Pawn.Weapon.bCanThrow )
		return;
	Pawn.Weapon.bTossedOut = true;
	Pawn.TossWeapon(Vector(Rotation) * 500 + vect(0,0,220));
	if ( Pawn.Weapon == None )
		SwitchToBestWeapon();
}
*/

/* PrevWeapon()
- switch to previous inventory group weapon
*/
exec function PrevWeapon()
{
	if( Level.Pauser!=None )
		return;
	if ( Pawn.Weapon == None )
	{
		SwitchToBestWeapon();
		return;
	}
	if ( Pawn.PendingWeapon != None )
		Pawn.PendingWeapon = Pawn.Inventory.PrevWeapon(None, Pawn.PendingWeapon);
	else
		Pawn.PendingWeapon = Pawn.Inventory.PrevWeapon(None, Pawn.Weapon);

	if ( Pawn.PendingWeapon != None )
		Pawn.Weapon.PutDown();
}

/* NextWeapon()
- switch to next inventory group weapon
*/
exec function NextWeapon()
{
	if( Level.Pauser!=None )
		return;
		
	//2002.12.19 (mdf) warning fix
	if( Pawn == None )
		return;
		
	if ( Pawn.Weapon == None )
	{
		SwitchToBestWeapon();
		return;
	}
	if ( Pawn.PendingWeapon != None )
		Pawn.PendingWeapon = Pawn.Inventory.NextWeapon(None, Pawn.PendingWeapon);
	else
		Pawn.PendingWeapon = Pawn.Inventory.NextWeapon(None, Pawn.Weapon);

	if ( Pawn.PendingWeapon != None )
		Pawn.Weapon.PutDown();
}

// The player wants to switch to weapon group number F.
exec function SwitchWeapon (byte F )
{
	local weapon newWeapon;

//NEW MIB changed WeaponChange call, cleaned up
	if ( (Level.Pauser!=None) || (Pawn == None) || (Pawn.Inventory == None) )
		return;

	newWeapon = Pawn.Inventory.WeaponChange(F,None);

	if ( newWeapon != None )
	{
		if ( Pawn.Weapon == None )
		{
			Pawn.PendingWeapon = newWeapon;
			Pawn.ChangedWeapon();
		}
		else if ( Pawn.Weapon != newWeapon ||
				  (Pawn.PendingWeapon != None && newWeapon != Pawn.PendingWeapon) )
		{
			Pawn.PendingWeapon = newWeapon;
			if ( !Pawn.Weapon.PutDown() )
				Pawn.PendingWeapon = None;
		}
	}

/*OLD
	if ( (Level.Pauser!=None) || (Pawn == None) || (Pawn.Inventory == None) )
		return;
	if ( (Pawn.Weapon != None) && (Pawn.Weapon.Inventory != None) )
		newWeapon = Pawn.Weapon.Inventory.WeaponChange(F);
	else
		newWeapon = None;	
	if ( newWeapon == None )
		newWeapon = Pawn.Inventory.WeaponChange(F);

	if ( newWeapon == None )
		return;

	if ( Pawn.Weapon == None )
	{
		Pawn.PendingWeapon = newWeapon;
		Pawn.ChangedWeapon();
	}
	else if ( Pawn.Weapon != newWeapon )
	{
		Pawn.PendingWeapon = newWeapon;
		if ( !Pawn.Weapon.PutDown() )
			Pawn.PendingWeapon = None;
	}
*/
}

exec function GetWeapon(class<Weapon> NewWeaponClass )
{
	local Inventory Inv;

	if ( (Pawn.Inventory == None) || (NewWeaponClass == None)
		|| ((Pawn.Weapon != None) && (Pawn.Weapon.Class == NewWeaponClass)) )
		return;

	for ( Inv=Pawn.Inventory; Inv!=None; Inv=Inv.Inventory )
		if ( Inv.Class == NewWeaponClass )
		{
			Pawn.PendingWeapon = Weapon(Inv);
			if ( !Pawn.PendingWeapon.HasAmmo() )
			{
				ClientMessage( Pawn.PendingWeapon.ItemName$Pawn.PendingWeapon.MessageNoAmmo );
				Pawn.PendingWeapon = None;
				return;
			}
			Pawn.Weapon.PutDown();
			return;
		}
}
	
// The player wants to select previous item
exec function PrevItem()
{
	local Inventory Inv;
	local Powerups LastItem;

	if ( Level.Pauser!=None )
		return;
	if (Pawn.SelectedItem==None) 
	{
//NEW (mdf) P/C fix -- EPIC PLEASE FIX ALSO!
		Pawn.SelectedItem = Pawn.Inventory.SelectNext();
/*OLD
		Pawn.SelectedItem = Inventory.SelectNext();
*/
		Return;
	}
	if (Pawn.SelectedItem.Inventory!=None) 
		for( Inv=Pawn.SelectedItem.Inventory; Inv!=None; Inv=Inv.Inventory ) 
		{
			if (Inv==None) Break;
			if ( Inv.IsA('Powerups') && Powerups(Inv).bActivatable) LastItem=Powerups(Inv);
		}
	for( Inv=Pawn.Inventory; Inv!=Pawn.SelectedItem; Inv=Inv.Inventory ) 
	{
		if (Inv==None) Break;
		if ( Inv.IsA('Powerups') && Powerups(Inv).bActivatable) LastItem=Powerups(Inv);
	}
	if (LastItem!=None) 
		Pawn.SelectedItem = LastItem;
}

// The player wants to active selected item
exec function ActivateItem()
{
	if( Level.Pauser!=None )
		return;
	if ( (Pawn != None) && (Pawn.SelectedItem!=None) ) 
		Pawn.SelectedItem.Activate();
}

// The player wants to fire.
//NEW (mdf) weapon interface cleanup
exec function Fire()
/*OLD
exec function Fire( optional float F )
*/
{
//NEW
/*OLD MJL: overridden in U2PlayerController
	if ( Level.Pauser == PlayerReplicationInfo )
	{
		SetPause(false);
		return;
	}
	if( Pawn.Weapon!=None )
		Pawn.Weapon.Fire(F);
*/
}

// The player wants to alternate-fire.
//NEW (mdf) weapon interface cleanup
exec function AltFire()
/*OLD
exec function AltFire( optional float F )
*/
{
//NEW
/*OLD MJL: overridden in U2PlayerController
	if ( Level.Pauser == PlayerReplicationInfo )
	{
		SetPause(false);
		return;
	}
	if( Pawn.Weapon!=None )
		Pawn.Weapon.AltFire(F);
*/
}

//NEW
/*OLD MIB
// The player wants to use something in the level.
exec function Use()
{
	local Actor A;

	if ( Level.Pauser == PlayerReplicationInfo )
	{
		SetPause(false);
		return;
	}

	// Send the 'DoUse' event to each actor player is touching.
	ForEach Pawn.TouchingActors(class'Actor', A)
	{
		A.UsedBy(Pawn);
	}
}
*/

exec function Suicide()
{
	Pawn.KilledBy( None );
}

exec function Name( coerce string S )
{
	ChangeName(S);
	UpdateURL("Name", S, true);
	SaveConfig();
}

function ChangeName( coerce string S )
{
	if ( Len(S) > 28 )
		S = left(S,28);
	ReplaceText(S, " ", "_");
	Level.Game.ChangeName( self, S, false );
}

exec function SwitchTeam()
{
	if ( (PlayerReplicationInfo.Team == None) || (PlayerReplicationInfo.Team.TeamIndex == 1) )
		ChangeTeam(0);
	else
		ChangeTeam(1);
}

function ChangeTeam( int N )
{
	local TeamInfo OldTeam;

	OldTeam = PlayerReplicationInfo.Team;
	Level.Game.ChangeTeam(self, N);
	if ( Level.Game.bTeamGame && (PlayerReplicationInfo.Team != OldTeam) )
		Pawn.Died( None, class'DamageType', Pawn.Location, vect(0,0,0) );
}


exec function SwitchLevel( string URL )
{
	if( Level.NetMode==NM_Standalone || Level.netMode==NM_ListenServer )
		Level.ServerTravel( URL, false );
}

exec function ClearProgressMessages()
{
	local int i;

	for (i=0; i<ArrayCount(ProgressMessage); i++)
	{
		ProgressMessage[i] = "";
		ProgressColor[i] = class'Canvas'.Static.MakeColor(255,255,255);
	}
}

exec event SetProgressMessage( int Index, string S, color C )
{
	if ( Index < ArrayCount(ProgressMessage) )
	{
		ProgressMessage[Index] = S;
		ProgressColor[Index] = C;
	}
}

exec event SetProgressTime( float T )
{
	ProgressTimeOut = T + Level.TimeSeconds;
}

function Restart()
{
	ServerTimeStamp = 0;
	TimeMargin = 0;
	//NEW (mdf)
	#debug   SetControllerEnemy( None, GetContext() );
	#release SetControllerEnemy( None );
	/*OLD
	Enemy = None;
	*/
	EnterStartState();
	SetViewTarget(Pawn);
	bBehindView = Pawn.PointOfView();
//NEW MJL
	Pawn.ClientRestart();
/*OLD
	ClientRestart();
*/
}

function EnterStartState()
{
	local name NewState;

//NEW (mdf)
	if( bMatineePossess && Pawn.Physics == PHYS_Flying )
		NewState = PlayerFlyingState;
	else
//OLD	
	if ( Pawn.PhysicsVolume.bWaterVolume )
	{
		if ( Pawn.HeadVolume.bWaterVolume )
			Pawn.BreathTime = Pawn.UnderWaterTime;
		NewState = Pawn.WaterMovementState;
	}
	else  
		NewState = Pawn.LandMovementState;

	if ( IsInState(NewState) )
		BeginState();
	else
		GotoState(NewState);
}

//NEW MJL
/*OLD
function ClientRestart()
{
	if ( Pawn == None )
	{
		GotoState('WaitingForPawn');
		return;
	}
	Pawn.ClientRestart();
	SetViewTarget(Pawn);
	bBehindView = Pawn.PointOfView();
	EnterStartState();	
}
*/

exec function BehindView( Bool B )
{
	bBehindView = B;
	ClientSetBehindView(bBehindView);
}

function UpdateBob(float F)
{
	Bob = FClamp(F,0,0.032);
}

	
//=============================================================================
// functions.

// Just changed to pendingWeapon
function ChangedWeapon()
{
	if ( Pawn.PendingWeapon != None )
		Pawn.PendingWeapon.SetHand(Handedness);
}

event TravelPostAccept()
{
	if ( Pawn.Health <= 0 )
		Pawn.Health = Pawn.Default.Health;
}

event PlayerTick( float DeltaTime )
{
	PlayerInput.PlayerInput(DeltaTime);
	if ( bUpdatePosition )
		ClientUpdatePosition();

//NEW (mdf) -- mantling support
//	bForwardPressed = (aForward > 0.0);
	bUpPressed = (aUp > 0.0);
//OLD

	PlayerMove(DeltaTime);
}

function PlayerMove(float DeltaTime);

//NEW (mdf) 777 version (reverted SteveP's changes)
//
/* AdjustAim()

Used for
	warning potential targets (if any)
	player aiming help (mainly if AimingHelp != 0, but always some help!)
*/
function bool AdjustAim( class<Projectile> ProjectileClass, float ProjSpeed, vector ProjStart, float WeaponFireSpread, bool bLeadTarget, bool bWarnTarget, bool bTossed, bool bTrySplash )
{
	local vector FireDir, AimSpot, HitNormal, HitLocation, OldAim, AimOffset;
	local Actor BestTarget;
	local float BestAim, BestDist;
	local Actor HitActor;
	local bool bNoZAdjust, bLeading;
	local bool bFastHit; // set if instant hit or high speed projectile
	local vector CameraLoc;

	/*
#debugbegin
	if( DebugAIAttacks() )
	{
		DMTNS( "AdjustAim (player)" );
		DMTNS( " Target:           "	$ Target );
		DMTNS( " ProjClass:        "	$ ProjectileClass );
		DMTNS( " ProjSpeed:        "	$ ProjSpeed );
		DMTNS( " ProjStart:        "	$ class'Util'.static.GetVectorString(ProjStart) );
		DMTNS( " WeaponFireSpread: "	$ WeaponFireSpread );
		DMTNS( " bLeadTarget:      "	$ bLeadTarget );
		DMTNS( " bWarnTarget:      "	$ bWarnTarget );
		DMTNS( " bTossed:          "	$ bTossed );
		DMTNS( " bTrySplash:       "	$ bTrySplash );

		AddActor( Pawn, ColorCyan() );
		AddCylinder( ProjStart, 16, 16, ColorMagenta() );
		if( Target != None )
		{
			AddCylinder( Target.Location, 16, 16, ColorYellow() );
			AddArrow( ProjStart, Target.Location, ColorGreen() );
		}
	}
#debugend
	*/

	FireDir = vector(Rotation);
	bFastHit = ( ProjSpeed <= 0 || ProjSpeed > 10000 );

	// ==> warn target?

	if( bFastHit )
		HitActor = Trace( HitLocation, HitNormal, ProjStart + 10000 * FireDir, ProjStart, true );
	else 
		HitActor = Trace( HitLocation, HitNormal, ProjStart + 4000 * FireDir, ProjStart, true );

	if( HitActor != None && HitActor.bProjTarget )
	{
		if( bWarnTarget && Pawn(HitActor) != None && Pawn(HitActor).Controller != None )
			Pawn(HitActor).Controller.ShotFiredNotification( Pawn, FireDir, ProjectileClass, ProjSpeed );

		BestTarget = HitActor;
		bNoZAdjust = true;
		OldAim = HitLocation;
		BestDist = VSize( BestTarget.Location - Pawn.Location );
	}
	else
	{
		// adjust aim based on FOV
		BestAim = 0.95;
		if( AimingHelp == 1 )
		{
			BestAim = 0.93;
			if( bFastHit )
				BestAim = 0.97; 
			if( FOVAngle < DefaultFOV - 8 )
				BestAim = 0.99;
		}
		else
		{
			if( bFastHit )
				BestAim = 0.98; 
			if( FOVAngle != DefaultFOV )
				BestAim = 0.995;
		}

		BestTarget = PickTarget( BestAim, BestDist, FireDir, ProjStart );
		if( BestTarget != None )
		{
			if( bWarnTarget && Pawn(BestTarget) != None && Pawn(BestTarget).Controller != None )
				Pawn(BestTarget).Controller.ShotFiredNotification( Pawn, FireDir, ProjectileClass, ProjSpeed );

			OldAim = ProjStart + FireDir * BestDist;
		}
	}

	if( BestTarget == None || AimingHelp == 0 )
	{
//NEW (mdf)
/*
#debugbegin
		HitActor = Trace( HitLocation, HitNormal, ProjStart + 8192.0*vector(Rotation), ProjStart, true ); 
		if( Pawn(HitActor) != None )
			AddArrow( ProjStart, HitLocation, ColorGreen() );
		else
			AddArrow( ProjStart, HitLocation, ColorRed() );
#debugend
*/
//OLD
//NEW (arl)
		CameraLoc = Pawn.Location;
		CameraLoc.Z += Pawn.BaseEyeHeight;
		HitActor = Trace( HitLocation, HitNormal, CameraLoc + 10000 * FireDir, CameraLoc, false );
		if (!HitActor)
			AimRotation = Rotation;
		else
			AimRotation = rotator(HitLocation-ProjStart);
			
		return true;
/*OLD
		return Rotation;
*/
	}
	
	// ==> extra aiming help - help with leading also
	if( !bFastHit )
	{
		BestDist = VSize( BestTarget.Location + BestTarget.Velocity * FMin(2, 0.02 + BestDist/ProjSpeed) - ProjStart ); 
		bLeading = true;
		FireDir = BestTarget.Location + BestTarget.Velocity * FMin(2, 0.02 + BestDist/ProjSpeed) - ProjStart;
		AimSpot = ProjStart + BestDist * Normal(FireDir);
		// if splash damage weapon, try aiming at feet - trace down to find floor
		if( bTrySplash && (BestTarget.Velocity != vect(0,0,0) || BestDist > 1500) )
		{
			HitActor = Trace( HitLocation, HitNormal, AimSpot - BestTarget.CollisionHeight * vect(0,0,2), AimSpot, false );
			if( HitActor != None && FastTrace(HitLocation + vect(0,0,4),ProjStart) )
			{
				AimRotation = rotator(HitLocation + vect(0,0,6) - ProjStart);
				return true;
			}
		}
	}
	else
	{
		FireDir = BestTarget.Location - ProjStart;
		AimSpot = ProjStart + BestDist * Normal(FireDir);
	}
	AimOffset = AimSpot - OldAim;

	// adjust Z of shooter if necessary
	if ( bNoZAdjust || (bLeading && Abs(AimOffset.Z) < BestTarget.CollisionHeight) )
		AimSpot.Z = OldAim.Z;
	else if ( AimOffset.Z < 0 )
		AimSpot.Z = BestTarget.Location.Z + 0.4 * BestTarget.CollisionHeight;
	else
		AimSpot.Z = BestTarget.Location.Z - 0.7 * BestTarget.CollisionHeight;

	if ( !bLeading )
	{
		// if not leading, add slight random error ( significant at long distances )
		if ( !bNoZAdjust )
		{
			AimRotation = rotator(AimSpot - ProjStart);
			if ( FOVAngle < DefaultFOV - 8 )
				AimRotation.Yaw = AimRotation.Yaw + 200 - Rand(400);
			else
				AimRotation.Yaw = AimRotation.Yaw + 375 - Rand(750);
			return true;
		}	
	}
	else if ( !FastTrace(ProjStart + 0.9 * BestDist * Normal(FireDir), ProjStart) )
	{
		FireDir = BestTarget.Location - ProjStart;
		AimSpot = ProjStart + BestDist * Normal(FireDir);
	}
		
	AimRotation =  rotator(AimSpot - ProjStart);
		
	return true;
}

//OLD: 829 version with SteveP's changes.

//
/* AdjustAim()
Calls this version for player aiming help.
Aimerror not used in this version.
Only adjusts aiming at pawns
*/
/*
function rotator AdjustAim(Ammunition FiredAmmunition, vector ProjStart, int aimerror)
{
	local vector FireDir, AimSpot, HitNormal, HitLocation, OldAim, AimOffset;
	local actor BestTarget;
	local float BestAim, BestDist, ProjSpeed;
	local actor HitActor;
	local bool bNoZAdjust, bLeading;
	local rotator AimRot;

	FireDir = vector(Rotation);
	if ( FiredAmmunition.bInstantHit )
		HitActor = Trace(HitLocation, HitNormal, ProjStart + 10000 * FireDir, ProjStart, true);
	else 
		HitActor = Trace(HitLocation, HitNormal, ProjStart + 4000 * FireDir, ProjStart, true);
	if ( (HitActor != None) && HitActor.bProjTarget )
	{
		FiredAmmunition.WarnTarget(Target,Pawn,FireDir);
		BestTarget = HitActor;
		bNoZAdjust = true;
		OldAim = HitLocation;
		BestDist = VSize(BestTarget.Location - Pawn.Location);
	}
	else
	{
		// adjust aim based on FOV
		BestAim = 0.95;
		if ( AimingHelp == 1 )
		{
			BestAim = 0.93;
			if ( FiredAmmunition.bInstantHit )
				BestAim = 0.97; 
			if ( FOVAngle < DefaultFOV - 8 )
				BestAim = 0.99;
		}
		else
		{
			if ( FiredAmmunition.bInstantHit )
				BestAim = 0.98; 
			if ( FOVAngle != DefaultFOV )
				BestAim = 0.995;
		}
		BestTarget = PickTarget(BestAim, BestDist, FireDir, ProjStart);
		if ( BestTarget == None )
			return Rotation;
		FiredAmmunition.WarnTarget(Target,Pawn,FireDir);
		OldAim = ProjStart + FireDir * BestDist;
	}
	if ( AimingHelp == 0 )
		return Rotation;

	// aim at target - help with leading also
	if ( !FiredAmmunition.bInstantHit )
	{
		ProjSpeed = FiredAmmunition.ProjectileClass.default.speed;
		BestDist = vsize(BestTarget.Location + BestTarget.Velocity * FMin(2, 0.02 + BestDist/ProjSpeed) - ProjStart); 
		bLeading = true;
		FireDir = BestTarget.Location + BestTarget.Velocity * FMin(2, 0.02 + BestDist/ProjSpeed) - ProjStart;
		AimSpot = ProjStart + BestDist * Normal(FireDir);
		// if splash damage weapon, try aiming at feet - trace down to find floor
		if ( FiredAmmunition.bTrySplash 
			&& ((BestTarget.Velocity != vect(0,0,0)) || (BestDist > 1500)) )
		{
			HitActor = Trace(HitLocation, HitNormal, AimSpot - BestTarget.CollisionHeight * vect(0,0,2), AimSpot, false);
			if ( (HitActor != None)
				&& FastTrace(HitLocation + vect(0,0,4),ProjStart) )
				return rotator(HitLocation + vect(0,0,6) - ProjStart);
		}
	}
	else
	{
		FireDir = BestTarget.Location - ProjStart;
		AimSpot = ProjStart + BestDist * Normal(FireDir);
	}
	AimOffset = AimSpot - OldAim;

	// adjust Z of shooter if necessary
	if ( bNoZAdjust || (bLeading && (Abs(AimOffset.Z) < BestTarget.CollisionHeight)) )
		AimSpot.Z = OldAim.Z;
	else if ( AimOffset.Z < 0 )
		AimSpot.Z = BestTarget.Location.Z + 0.4 * BestTarget.CollisionHeight;
	else
		AimSpot.Z = BestTarget.Location.Z - 0.7 * BestTarget.CollisionHeight;

	if ( !bLeading )
	{
		// if not leading, add slight random error ( significant at long distances )
		if ( !bNoZAdjust )
		{
			AimRot = rotator(AimSpot - ProjStart);
			if ( FOVAngle < DefaultFOV - 8 )
				AimRot.Yaw = AimRot.Yaw + 200 - Rand(400);
			else
				AimRot.Yaw = AimRot.Yaw + 375 - Rand(750);
			return AimRot;
		}	
	}
	else if ( !FastTrace(ProjStart + 0.9 * BestDist * Normal(FireDir), ProjStart) )
	{
		FireDir = BestTarget.Location - ProjStart;
		AimSpot = ProjStart + BestDist * Normal(FireDir);
	}
		
	return rotator(AimSpot - ProjStart);
}
*/

event bool NotifyLanded(vector HitNormal)
{
	if ( bUpdating )
		return true;
	LandBob = FMin(50, 0.055 * Pawn.Velocity.Z); 
	return false;
}
	
//NEW (mdf)
function NotifyStanceChange( byte NewStance, float HeightAdjust )
{
	bPressedJump = false;
}
//OLD

//NEW
/*OLD (mdf) -- U2 doesn't use this currently
function eAttitude AttitudeTo(Pawn Other)
{
	if ( Other.Controller == None )
		return ATTITUDE_Ignore;	
	if ( Other.IsPlayerPawn() )
		return AttitudeToPlayer;
	return Other.Controller.AttitudeToPlayer;
}
*/

//=============================================================================
// Player Control

// Player view.
// Compute the rendering viewpoint for the player.
//

function AdjustView(float DeltaTime )
{
	// teleporters affect your FOV, so adjust it back down
	if ( FOVAngle != DesiredFOV )
	{
//NEW
		if ( FOVAngle > DesiredFOV )
		{
			FOVAngle = FOVAngle - FMax(7, 0.9 * DeltaTime * (FOVAngle - DesiredFOV)); 
			if ( Abs(FOVAngle - DesiredFOV) <= 10 )
				FOVAngle = DesiredFOV;
		}
		else
			FOVAngle = DesiredFOV;
/*OLD
		if ( FOVAngle > DesiredFOV )
			FOVAngle = FOVAngle - FMax(7, 0.9 * DeltaTime * (FOVAngle - DesiredFOV)); 
		else 
			FOVAngle = FOVAngle - FMin(-7, 0.9 * DeltaTime * (FOVAngle - DesiredFOV)); 
		if ( Abs(FOVAngle - DesiredFOV) <= 10 )
			FOVAngle = DesiredFOV;
*/
	}

//NEW: Removed (MWP)
/*
	// adjust FOV for weapon zooming
	if ( bZooming )
	{	
		ZoomLevel += DeltaTime * 1.0;
		if (ZoomLevel > 0.9)
			ZoomLevel = 0.9;
		DesiredFOV = FClamp(90.0 - (ZoomLevel * 88.0), 1, 170);
	} 
*/
}

function CalcBehindView(out vector CameraLocation, out rotator CameraRotation, float Dist)
{
	local vector View,HitLocation,HitNormal;
	local float ViewDist;

	CameraRotation = Rotation;
	View = vect(1,0,0) >> CameraRotation;
	if( Trace( HitLocation, HitNormal, CameraLocation - (Dist + 30) * vector(CameraRotation), CameraLocation ) != None )
		ViewDist = FMin( (CameraLocation - HitLocation) Dot View, Dist );
	else
		ViewDist = Dist;
	CameraLocation -= (ViewDist - 30) * View; 
}

function CalcFirstPersonView( out vector CameraLocation, out rotator CameraRotation )
{
	// First-person view.
	CameraRotation = Rotation;
	CameraLocation = CameraLocation + Pawn.EyePosition() + WalkBob + ShakeOffset;
}

event PlayerCalcView(out actor ViewActor, out vector CameraLocation, out rotator CameraRotation )
{
	local Pawn PTarget;

	if ( (ViewTarget == None) || ViewTarget.bDeleteMe )
	{
		if ( (Pawn != None) && !Pawn.bDeleteMe )
			SetViewTarget(Pawn);
		else
			SetViewTarget(self);
	}

	ViewActor = ViewTarget;
	CameraLocation = ViewTarget.Location;

	if ( ViewTarget == Pawn )
	{
		if( bBehindView ) //up and behind
			CalcBehindView(CameraLocation, CameraRotation, CameraDist * Pawn.Default.CollisionRadius);
		else
			CalcFirstPersonView( CameraLocation, CameraRotation );
		return;
	}
	if ( ViewTarget == self )
	{
		CameraRotation = Rotation;
		return;
	}
	CameraRotation = ViewTarget.Rotation;
	PTarget = Pawn(ViewTarget);
	if ( PTarget != None )
	{
		if ( Level.NetMode == NM_Client )
		{
			if ( PTarget.IsPlayerPawn() )
			{
				PTarget.SetViewRotation(TargetViewRotation);
				CameraRotation = TargetViewRotation;
			}
			PTarget.EyeHeight = TargetEyeHeight;
			if ( PTarget.Weapon != None )
				PTarget.Weapon.PlayerViewOffset = TargetWeaponViewOffset;
		}
		else if ( PTarget.IsPlayerPawn() )
			CameraRotation = PTarget.GetViewRotation();
		if ( !bBehindView )
//NEW (mdf) hack fix move camera location away from center along Pawn's rotation to fix viewclass showing inside of golem meshes
			CameraLocation += PTarget.EyePosition() + 0.25 * PTarget.CollisionRadius * vector( PTarget.Rotation );
/*OLD
			CameraLocation += PTarget.EyePosition();
*/			
	}
	if ( bBehindView )
	{
		CameraLocation = CameraLocation + (ViewTarget.Default.CollisionHeight - ViewTarget.CollisionHeight) * vect(0,0,1);
		CalcBehindView(CameraLocation, CameraRotation, CameraDist * ViewTarget.Default.CollisionRadius);
	}
}

//NEW
exec function TestShake(float Magnitude,optional float Duration){ ShakeView(Magnitude,Duration); }
// Replication note: only call when Level.NetMode != NM_DedicatedServer, or from a non-simulated function (otherwise you'll get duplicate calls).
simulated function ShakeView(float Magnitude,optional float Duration){ ClientShake(Magnitude,Duration); }
simulated private function ClientShake(float Magnitude,optional float Duration)
{
	if(Duration==0)
		Duration=0.5;

	ShakeMagX = Magnitude;
	ShakeMagY = Magnitude;

	if( FRand()>0.5 )
		ShakeMagX = -ShakeMagX;

	if( FRand()>0.5 )
		ShakeMagY = -ShakeMagY;

	ShakeTime = Duration;
	ShakeDuration = Duration;
}
function ViewShake(float DeltaTime)
{
	local float Pct;

	ShakeOffset=vect(0,0,0);

	ShakeTime -= DeltaTime;
	if( ShakeTime<=0 )
		return;

	Pct = ShakeTime / ShakeDuration;

	ShakeOffset.Y = Pct * ShakeMagX * sin( ShakeTime * ShakePeriodX * PI );
	ShakeOffset.Z = Pct * ShakeMagY * sin( ShakeTime * ShakePeriodY * PI );
	
	ShakeOffset.Y = FClamp( ShakeOffset.Y, -32.0, 32.0 );
	ShakeOffset.Z = FClamp( ShakeOffset.Z, -32.0, 32.0 );

	ShakeOffset = ShakeOffset >> Rotation;
/*
	ShakeOffset.X = Pct * ShakeMagX * sin( ShakeTime * ShakePeriodX * PI );
	ShakeOffset.Y = Pct * ShakeMagY * sin( ShakeTime * ShakePeriodY * PI );
	ShakeOffset.Z = Pct * ShakeMagZ * sin( ShakeTime * ShakePeriodZ * PI );
*/
}
/*OLD
function CheckShake(out float MaxOffset, out float Offset, out float Rate, out float Time)
{
	if ( abs(Offset) < abs(MaxOffset) )
		return;

	Offset = MaxOffset;
	if ( Time > 1 )
	{
		if ( Time * abs(MaxOffset/Rate) <= 1 )
			MaxOffset = MaxOffset * (1/Time - 1);
		else
			MaxOffset *= -1;
		Time -= 1;
		Rate *= -1;
	}
	else
	{
		MaxOffset = 0;
		Offset = 0;
		Rate = 0;
	}
}

function ViewShake(float DeltaTime)
{
	local Rotator ViewRotation;
	local float FRoll;

	if ( ShakeOffsetRate != vect(0,0,0) )
	{
		// modify shake offset
		ShakeOffset.X += DeltaTime * ShakeOffsetRate.X;
		CheckShake(MaxShakeOffset.X, ShakeOffset.X, ShakeOffsetRate.X, ShakeOffsetTime.X);
		
		ShakeOffset.Y += DeltaTime * ShakeOffsetRate.Y;
		CheckShake(MaxShakeOffset.Y, ShakeOffset.Y, ShakeOffsetRate.Y, ShakeOffsetTime.Y);
		
		ShakeOffset.Z += DeltaTime * ShakeOffsetRate.Z;
		CheckShake(MaxShakeOffset.Z, ShakeOffset.Z, ShakeOffsetRate.Z, ShakeOffsetTime.Z);
	}				

	ViewRotation = Rotation;

	if ( ShakeRollRate != 0 )
	{
		ViewRotation.Roll = ((ViewRotation.Roll & 65535) + ShakeRollRate * DeltaTime) & 65535;
		if ( ViewRotation.Roll > 32768 )
			ViewRotation.Roll -= 65536;
		FRoll = ViewRotation.Roll;
		CheckShake(MaxShakeRoll, FRoll, ShakeRollRate, ShakeRollTime);
		ViewRotation.Roll = FRoll;
	}
	else if ( bZeroRoll )
		ViewRotation.Roll = 0;
	SetRotation(ViewRotation);
}
*/

function bool TurnTowardNearestEnemy();

function TurnAround()
{
	if ( !bSetTurnRot )
	{
		TurnRot180 = Rotation;
		TurnRot180.Yaw += 32768;
		bSetTurnRot = true;
	}
	
	DesiredRotation = TurnRot180;
	bRotateToDesired = ( DesiredRotation.Yaw != Rotation.Yaw );
}
					
function UpdateRotation(float DeltaTime, float maxPitch)
{
	local rotator newRotation, ViewRotation;

	if ( bInterpolating || ((Pawn != None) && Pawn.bInterpolating) )
	{
		ViewShake(deltaTime);
		return;
	}
	ViewRotation = Rotation;
	DesiredRotation = ViewRotation; //save old rotation
	if ( bTurnToNearest != 0 )
		TurnTowardNearestEnemy();
	else if ( bTurn180 != 0 )
		TurnAround();
	else
	{
		TurnTarget = None;
		bRotateToDesired = false;
		bSetTurnRot = false;
		ViewRotation.Yaw += 32.0 * DeltaTime * aTurn;
		ViewRotation.Pitch += 32.0 * DeltaTime * aLookUp;
	}
	ViewRotation.Pitch = ViewRotation.Pitch & 65535;
	If ((ViewRotation.Pitch > 18000) && (ViewRotation.Pitch < 49152))
	{
		If (aLookUp > 0) 
			ViewRotation.Pitch = 18000;
		else
			ViewRotation.Pitch = 49152;
	}

	SetRotation(ViewRotation);
	ViewShake(deltaTime);
	ViewFlash(deltaTime);
		
	NewRotation = ViewRotation;
	NewRotation.Roll = Rotation.Roll;

	if ( !bRotateToDesired && (Pawn != None) && (!bFreeCamera || !bBehindView) )
		Pawn.FaceRotation(NewRotation, deltatime);
}

// Player movement.
// Player Standing, walking, running, falling.
//NEW
state @ PlayerWalkingState
{
ignores SeeEnemy, SeeFriend, SeeOther, SeeAlertFriend, HearNoise, Bump;
/*OLD
{
state PlayerWalking
//ignores SeePlayer, HearNoise, Bump;
*/
	event bool NotifyPhysicsVolumeChange( PhysicsVolume NewVolume )
	{
		if ( NewVolume.bWaterVolume )
			GotoState(Pawn.WaterMovementState);
		return false;
	}

	function ProcessMove(float DeltaTime, vector NewAccel, eDoubleClickDir DoubleClickMove, rotator DeltaRot)	
	{
//NEW (mdf) not used
/*OLD
		local vector OldAccel;
		local bool OldCrouch;
*/

//NEW (mdf) not used
/*OLD
		OldAccel = Pawn.Acceleration;
*/
		Pawn.Acceleration = NewAccel;
//NEW
		if ( bPressedJump && Level.Pauser == None )
/*OLD
		if ( bPressedJump )
*/
			Pawn.DoJump(bUpdating);
		
		if ( Pawn.Physics != PHYS_Falling )
		{
//NEW (mdf)			
			if( GetDuckFlag() == 0 )
				Pawn.SetStance( ST_Standing );
			else if ( Pawn.bCanCrouch )
				Pawn.SetStance( ST_Crouching );
/*OLD			
			OldCrouch = Pawn.bWantsToCrouch;
			if (bDuck == 0)
				Pawn.ShouldCrouch(false);
			else if ( Pawn.bCanCrouch )
				Pawn.ShouldCrouch(true);
*/			
		}
	}

//NEW MJL: accel
	function vector GetAccel( vector X, vector Y, vector Z )
	{
		local vector ReturnedAcceleration;
		ReturnedAcceleration = aForward*X + aStrafe*Y; 
		ReturnedAcceleration.Z = 0;
		return ReturnedAcceleration;
	}
	function SetMovementVars( vector Accel )
	{
		 local vector LocalAccel;

		 LocalAccel = Accel << (rot(0,1,0)*Pawn.Rotation.Yaw);
		 //!!MJL (mdf) bForwardPressed = (LocalAccel.X > 0);
		 bUpPressed = (bJump != 0);
	}
//OLD

	function PlayerMove( float DeltaTime )
	{
		local vector X,Y,Z, NewAccel;
		local eDoubleClickDir DoubleClickMove;
		local rotator OldRotation, ViewRotation;
		local float Speed2D;
		local bool	bSaveJump;

		GetAxes( Pawn.Rotation, X, Y, Z );

		// Update acceleration.
		//NEW MJL: accel
		NewAccel = GetAccel( X, Y, Z );
		SetMovementVars( NewAccel );
		/*OLD
		NewAccel = aForward*X + aStrafe*Y; 
		NewAccel.Z = 0;
		*/
		if ( VSize(NewAccel) < 1.0 )
			NewAccel = vect(0,0,0);
		DoubleClickMove = PlayerInput.CheckForDoubleClickMove(DeltaTime);
		
		GroundPitch = 0;	
		ViewRotation = Rotation;
		if ( Pawn.Physics == PHYS_Walking )
		{
			// tell pawn about any direction changes to give it a chance to play appropriate animation
			//if walking, look up/down stairs - unless player is rotating view
			GroundPitch = FindStairRotation(deltaTime);
			if ( (bLook == 0) 
				&& (((Pawn.Acceleration != Vect(0,0,0)) && bAlwaysLevel && bSnapToLevel) || !bKeyboardLook) )
			{
				if ( bLookUpStairs || bSnapToLevel )
				{
					ViewRotation.Pitch = GroundPitch;
				}
				else if ( bCenterView )
				{
					ViewRotation.Pitch = ViewRotation.Pitch & 65535;
					if (ViewRotation.Pitch > 32768)
						ViewRotation.Pitch -= 65536;
					ViewRotation.Pitch = ViewRotation.Pitch * (1 - 12 * FMin(0.0833, deltaTime));
					if ( Abs(ViewRotation.Pitch) < 1000 )
						ViewRotation.Pitch = 0;	
				}
			}

			Speed2D = Sqrt(Pawn.Velocity.X * Pawn.Velocity.X + Pawn.Velocity.Y * Pawn.Velocity.Y);
			//add bobbing when walking
			CheckBob(DeltaTime, Speed2D, Y);
		}	
		else
		{
			if ( !bKeyboardLook && (bLook == 0) && bCenterView )
			{
				ViewRotation.Pitch = ViewRotation.Pitch & 65535;
				if (ViewRotation.Pitch > 32768)
					ViewRotation.Pitch -= 65536;
				ViewRotation.Pitch = ViewRotation.Pitch * (1 - 12 * FMin(0.0833, deltaTime));
				if ( Abs(ViewRotation.Pitch) < 1000 )
					ViewRotation.Pitch = 0;	
			}
			BobTime = 0;
			WalkBob = WalkBob * (1 - FMin(1, 8 * deltatime));
		}

		// Update rotation.
		SetRotation(ViewRotation);
		OldRotation = Rotation;
		UpdateRotation(DeltaTime, 1);

		if ( bPressedJump && Pawn.JumpInProgress() )
		{
			bSaveJump = true;
			bPressedJump = false;
		}
		else
			bSaveJump = false;

//NEW MJL
		HandleMove(DeltaTime, NewAccel, DoubleClickMove, OldRotation - Rotation);
/*
		if ( Role < ROLE_Authority ) // then save this move and replicate it
			ReplicateMove(DeltaTime, NewAccel, DoubleClickMove, OldRotation - Rotation);
		else
			ProcessMove(DeltaTime, NewAccel, DoubleClickMove, OldRotation - Rotation);
*/
		bPressedJump = bSaveJump;
	}

	event BeginState()
	{
		if ( Pawn.Mesh == None )
			Pawn.SetMesh();
		WalkBob = vect(0,0,0);
		DoubleClickDir = DCLICK_None;
//NEW (mdf)		
//		Pawn.SetStance( ST_Standing );
/*OLD
		Pawn.ShouldCrouch(false);
*/		
		bPressedJump = false;
		if (Pawn.Physics != PHYS_Falling) 
			Pawn.SetPhysics(PHYS_Walking);
		GroundPitch = 0;
	}
	
	event EndState()
	{
		GroundPitch = 0;
		WalkBob = vect(0,0,0);
//NEW (mdf)		
//		if ( Pawn != None )
//			Pawn.SetStance( ST_Standing );
/*OLD			
		if ( Pawn != None )
			Pawn.ShouldCrouch(false);
*/			
	}
} // PlayerWalkingState

// player is climbing ladder
//NEW (mdf)
function bool CanJumpOffLadder()
{
	return ( bPressedJump && (aForward != 0 || aStrafe != 0) && Level != None && Level.Pauser == None );
}

state @ PlayerClimbingState
{
	ignores SeeEnemy, SeeFriend, SeeOther, SeeAlertFriend, HearNoise, Bump;

	event bool NotifyPhysicsVolumeChange( PhysicsVolume NewVolume )
	{
		if ( NewVolume.bWaterVolume )
			GotoState(Pawn.WaterMovementState);
		else
			GotoState(Pawn.LandMovementState);
		return false;
	}

	function ProcessMove(float DeltaTime, vector NewAccel, eDoubleClickDir DoubleClickMove, rotator DeltaRot)	
	{
		Pawn.Acceleration = NewAccel;

//NEW (mdf) handle jumping in playermove for ladders
/*OLD
		if ( bPressedJump && Level.Pauser == None )
		{
			assert( false );
			Pawn.DoJump(bUpdating);
			if ( Pawn.Physics == PHYS_Falling )
				GotoState( PlayerWalkingState );
		}
*/
	}

	function PlayerMove( float DeltaTime )
	{
		local vector X,Y,Z, NewAccel;
		local eDoubleClickDir DoubleClickMove;
		local rotator OldRotation, ViewRotation;
		local float Speed2D;
		local bool	bSaveJump;
		local float aForwardLocal, aStrafeLocal; //NEW (mdf)
		
		// Update acceleration.
		if ( Pawn.OnLadder != None )
		{
			//DMTNS( "on Ladder" );
			
			/*
			+allow strafing on ladders
			+crouch key moves player down ladder
			+jump moves player up ladder
			+jump + any movement key = jump
			*/

			if( CanJumpOffLadder() )
			{
				//DMTNS( "CanJumpOffLadder!" );
				Pawn.DoJump( bUpdating );
				if( Pawn.Physics == PHYS_Falling )
					GotoState( PlayerWalkingState );
			}
			else
			{			
				if( aUp > 0.0 )
				{
					//DMTNS( "using aUp > 0" );
					aForwardLocal =  24000; // mdf-tbd: 24000 is about what aForward peaks at for me -- how to get this value?
				}
				else if( aUp < 0.0 )
				{
					//DMTNS( "using aUp < 0" );
					aForwardLocal = -24000;
				}
				else
				{
					aForwardLocal = aForward;
					
					// if looking down ladder, reverse aForward
					if( (vector( Rotation ) dot Pawn.OnLadder.ClimbDir) >= 0 )
					{
						//DMTNS( "keeping aForwardLocal" );
						aForwardLocal = aForward;
					}
					else
					{
						//DMTNS( "reversing aForwardLocal" );
						aForwardLocal = -aForward;
					}
				}

				// if looking away from ladder, reverse strafe
				if( (vector( Rotation ) dot Pawn.OnLadder.LookDir) >= 0 )
					aStrafeLocal = aStrafe;
				else
					aStrafeLocal = -aStrafe;

				// fix cross product wasn't normalized?
				//NewAccel = aForwardLocal*Pawn.OnLadder.ClimbDir + aStrafeLocal*(Pawn.OnLadder.ClimbDir cross Pawn.OnLadder.LookDir);
				NewAccel = aForwardLocal*Pawn.OnLadder.ClimbDir + aStrafeLocal*Normal( Pawn.OnLadder.ClimbDir cross Pawn.OnLadder.LookDir );
			}
		}
		else
		{
			//DMTNS( "not on Ladder" );
			GetAxes( Rotation, X, Y, Z );
			//NewAccel = aForward*X + aStrafe*Y;
			//NewAccel = aForward*Pawn.OnLadder.ClimbDir + aStrafeLocal*Normal( Pawn.OnLadder.ClimbDir cross Pawn.OnLadder.LookDir );
			NewAccel = aForward*X + aStrafe*Y;
			//NewAccel.Z = 0;
		}
			
		//DMTNS( "NewAccel: " $ NewAccel );
		
		if ( VSize(NewAccel) < 1.0 )
			NewAccel = vect(0,0,0);
		
		ViewRotation = Rotation;

		// Update rotation.
		SetRotation(ViewRotation);
		OldRotation = Rotation;
		UpdateRotation(DeltaTime, 1);

		HandleMove(DeltaTime, NewAccel, DoubleClickMove, OldRotation - Rotation);
		bPressedJump = bSaveJump;
	}

	event BeginState()
	{
//NEW (mdf)		
		Pawn.SetStance( ST_Standing );
/*OLD			
		Pawn.ShouldCrouch( false );
*/		
		SetDuckFlag( 0 );
		bPressedJump = false;
	}
	
	event EndState()
	{
		if( Pawn != None )
//NEW (mdf)		
			Pawn.SetStance( ST_Standing );
/*OLD			
			Pawn.ShouldCrouch( false );
*/			
		Acceleration = vect(0,0,0);
	}
} // PlayerClimbingState
/*OLD
state PlayerClimbing
{
//ignores SeePlayer, HearNoise, Bump;
	event bool NotifyPhysicsVolumeChange( PhysicsVolume NewVolume )
	{
		if ( NewVolume.bWaterVolume )
			GotoState(Pawn.WaterMovementState);
		else
			GotoState(Pawn.LandMovementState);
		return false;
	}

	function ProcessMove(float DeltaTime, vector NewAccel, eDoubleClickDir DoubleClickMove, rotator DeltaRot)	
	{
		local vector OldAccel;

		OldAccel = Pawn.Acceleration;
		Pawn.Acceleration = NewAccel;

		if ( bPressedJump )
		{
			Pawn.DoJump(bUpdating);
			if ( Pawn.Physics == PHYS_Falling )
				GotoState('PlayerWalking');
		}
	}

	function PlayerMove( float DeltaTime )
	{
		local vector X,Y,Z, NewAccel;
		local eDoubleClickDir DoubleClickMove;
		local rotator OldRotation, ViewRotation;
		local float Speed2D;
		local bool	bSaveJump;
		local float aForwardLocal, aStrafeLocal; //NEW (mdf)
		
		GetAxes(Rotation,X,Y,Z);

		// Update acceleration.
		if ( Pawn.OnLadder != None )
			NewAccel = aForward*Pawn.OnLadder.ClimbDir; 
		else
			NewAccel = aForward*X + aStrafe*Y;
			
		if ( VSize(NewAccel) < 1.0 )
			NewAccel = vect(0,0,0);
		
		ViewRotation = Rotation;

		// Update rotation.
		SetRotation(ViewRotation);
		OldRotation = Rotation;
		UpdateRotation(DeltaTime, 1);

		if ( Role < ROLE_Authority ) // then save this move and replicate it
			ReplicateMove(DeltaTime, NewAccel, DoubleClickMove, OldRotation - Rotation);
		else
			ProcessMove(DeltaTime, NewAccel, DoubleClickMove, OldRotation - Rotation);
		bPressedJump = bSaveJump;
	}

	event BeginState()
	{
		Pawn.ShouldCrouch(false);
		bPressedJump = false;
	}
	
	event EndState()
	{
		if ( Pawn != None )
			Pawn.ShouldCrouch(false);
		aForwardLocal =  24000; // mdf-tbd: 24000 is about what aForward peaks at for me -- how to get this value?
	}
}
*/

// Player movement.
// Player Driving a Karma vehicle.
state PlayerDriving
{
//NEW
ignores SeeEnemy, SeeFriend, SeeOther, SeeAlertFriend, HearNoise, Bump, Fire, AltFire, PressingFire, PressingAltFire;
/*OLD
{
//ignores SeePlayer, HearNoise, Bump;
*/
    event PlayerCalcView(out actor ViewActor, out vector CameraLocation, out rotator CameraRotation )
    {
        local vector View, CamLookAt, HitLocation, HitNormal;
        local plane CamView;
		local KVehicle DrivenVehicle;

	    if ( KVehicle(ViewTarget) == None )
	    {
		    if ( (Pawn.ControlledActor != None) && !Pawn.bDeleteMe )
			    SetViewTarget(Pawn.ControlledActor);
	    }

	    ViewActor = ViewTarget;
	    CameraLocation = ViewTarget.Location;

	    if ( ViewTarget == Pawn.ControlledActor )
	    {
		    if( !bBehindView ) // not drawing car
            {
    		    CalcBehindView(CameraLocation, CameraRotation, CameraDist * ViewTarget.Default.CollisionRadius);
            }
		    else // drawing car (use vehicles camera position info)
            {
				DrivenVehicle = KVehicle(Pawn.ControlledActor);
                CamView = DrivenVehicle.CamPos[DrivenVehicle.CamPosIndex];

                // Only follow vehicle rotation in 'in car' view.
                if(DrivenVehicle.CamPosIndex == 0)
	                CameraRotation = Rotation+ViewTarget.Rotation;
                else
	                CameraRotation = Rotation;

	            View = CamView >> ViewTarget.Rotation;
	            CameraLocation += View;
				CamLookAt = CameraLocation;

	            View = (vect(1, 0, 0) * CamView.W) >> CameraRotation;
	            CameraLocation -= View;
				
				if( Trace( HitLocation, HitNormal, CameraLocation, CamLookAt, false ) != None )
				{
					CameraLocation = HitLocation;
				}
            }
		    return;
	    }
	    if ( ViewTarget == self )
	    {
		    CameraRotation = Rotation;
		    return;
	    }
	    CameraRotation = ViewTarget.Rotation;
	    if ( bBehindView )
	    {
		    CameraLocation = CameraLocation + (ViewTarget.Default.CollisionHeight - ViewTarget.CollisionHeight) * vect(0,0,1);
		    CalcBehindView(CameraLocation, CameraRotation, CameraDist * ViewTarget.Default.CollisionRadius);
	    }
    }

	function ProcessMove(float DeltaTime, vector NewAccel, eDoubleClickDir DoubleClickMove, rotator DeltaRot)	
	{

	}

//NEW see above ignores
/*OLD
    exec function Fire()
    {

    }

    exec function AltFire()
    {

    }
*/
	function PlayerMove( float DeltaTime )
	{
		local KVehicle DrivenVehicle;
		DrivenVehicle = KVehicle(Pawn.ControlledActor);

        if(DrivenVehicle == None)
        {
            log("PlayerDriving.PlayerMove: No Vehicle");
            return;
        }

        // check for 'jump' to throw the driver out.
        if(bPressedJump)
        {
            GotoState('PlayerWalking');
			Pawn.SetPhysics(PHYS_Falling);
            return;
        }

		//log("Drive:"$aForward$" Steer:"$aStrafe);

        if(aForward > 1)
        {
            DrivenVehicle.Throttle = 1;
        }
        else if(aForward < -1)
        {
            DrivenVehicle.Throttle = -1;
        }
        else
        {
            DrivenVehicle.Throttle = 0;
        }

        if(aStrafe < -1)
            DrivenVehicle.Steering = 1;
        else if(aStrafe > 1)
            DrivenVehicle.Steering = -1;
        else
            DrivenVehicle.Steering = 0;

        // update 'looking' rotation - no affect on driving
		UpdateRotation(DeltaTime, 2);
	}


	event BeginState()
	{
        bBehindView = true;
	}
	
	event EndState()
	{
		local KVehicle DrivenVehicle;
		DrivenVehicle = KVehicle(Pawn.ControlledActor);

        SetViewTarget(Pawn);
        DrivenVehicle.KDriverLeave(Pawn); // execute 'Leave' event
		bBehindView = false;
	}
}

// Player movement.
// Player walking on walls
//NEW
state @ PlayerSpideringState
{
ignores SeeEnemy, SeeFriend, SeeOther, SeeAlertFriend, HearNoise, Bump;
/*OLD
state PlayerSpidering
{
//ignores SeePlayer, HearNoise, Bump;
*/
	event bool NotifyHitWall(vector HitNormal, actor HitActor)
	{
		// FIXME - pawn should have bool identifying if this was a voluntary jump
		Pawn.SetPhysics(PHYS_Spider);
		Pawn.SetBase(HitActor, HitNormal);	
		return true;
	}

	// if spider mode, update rotation based on floor					
	function UpdateRotation(float DeltaTime, float maxPitch)
	{
		local rotator TempRot, ViewRotation;
		local vector MyFloor, CrossDir, FwdDir, OldFwdDir, OldX, RealFloor;

		if ( bInterpolating || Pawn.bInterpolating )
		{
			ViewShake(deltaTime);
			return;
		}

		TurnTarget = None;
		bRotateToDesired = false;
		bSetTurnRot = false;

		if ( (Pawn.Base == None) || (Pawn.Floor == vect(0,0,0)) )
			MyFloor = vect(0,0,1);
		else
			MyFloor = Pawn.Floor;

		if ( MyFloor != OldFloor )
		{
			// smoothly change floor
			RealFloor = MyFloor;
			MyFloor = Normal(6*DeltaTime * MyFloor + (1 - 6*DeltaTime) * OldFloor);
			if ( (RealFloor Dot MyFloor) > 0.999 )
				MyFloor = RealFloor;

			// translate view direction
			CrossDir = Normal(RealFloor Cross OldFloor);
			FwdDir = CrossDir Cross MyFloor;
			OldFwdDir = CrossDir Cross OldFloor;
			ViewX = MyFloor * (OldFloor Dot ViewX) 
						+ CrossDir * (CrossDir Dot ViewX) 
						+ FwdDir * (OldFwdDir Dot ViewX);
			ViewX = Normal(ViewX);
			
			ViewZ = MyFloor * (OldFloor Dot ViewZ) 
						+ CrossDir * (CrossDir Dot ViewZ) 
						+ FwdDir * (OldFwdDir Dot ViewZ);
			ViewZ = Normal(ViewZ);
			OldFloor = MyFloor;  
			ViewY = Normal(MyFloor Cross ViewX); 
		}

		if ( (aTurn != 0) || (aLookUp != 0) )
		{
			// adjust Yaw based on aTurn
			if ( aTurn != 0 )
				ViewX = Normal(ViewX + 2 * ViewY * Sin(0.0005*DeltaTime*aTurn));

			// adjust Pitch based on aLookUp
			if ( aLookUp != 0 )
			{
				OldX = ViewX;
				ViewX = Normal(ViewX + 2 * ViewZ * Sin(0.0005*DeltaTime*aLookUp));
				ViewZ = Normal(ViewX Cross ViewY);

				// bound max pitch
				if ( (ViewZ Dot MyFloor) < 0.707   )
				{
					OldX = Normal(OldX - MyFloor * (MyFloor Dot OldX));
					if ( (ViewX Dot MyFloor) > 0)
						ViewX = Normal(OldX + MyFloor);
					else
						ViewX = Normal(OldX - MyFloor);

					ViewZ = Normal(ViewX Cross ViewY);
				}
			}
			
			// calculate new Y axis
			ViewY = Normal(MyFloor Cross ViewX);
		}
		ViewRotation =  OrthoRotation(ViewX,ViewY,ViewZ);
		SetRotation(ViewRotation);
		ViewShake(deltaTime);
		ViewFlash(deltaTime);
		Pawn.FaceRotation(ViewRotation, deltaTime );
	}

	event bool NotifyLanded(vector HitNormal)
	{
		Pawn.SetPhysics(PHYS_Spider);
		if ( bUpdating )
			return true;
		LandBob = FMin(50, 0.055 * Pawn.Velocity.Z); 
		return false;
	}

	event bool NotifyPhysicsVolumeChange( PhysicsVolume NewVolume )
	{
		if ( NewVolume.bWaterVolume )
			GotoState(Pawn.WaterMovementState);
		return false;
	}
	
	function ProcessMove(float DeltaTime, vector NewAccel, eDoubleClickDir DoubleClickMove, rotator DeltaRot)	
	{
//NEW (mdf) not used
/*OLD
		local vector OldAccel;

		OldAccel = Pawn.Acceleration;
*/
		Pawn.Acceleration = NewAccel;

		if ( bPressedJump )
			Pawn.DoJump(bUpdating);
	}

	function PlayerMove( float DeltaTime )
	{
		local vector NewAccel;
		local eDoubleClickDir OldDoubleClick;
		local eDoubleClickDir DoubleClickMove;
		local rotator OldRotation, ViewRotation;
		local float Speed2D;
		local bool	bSaveJump;

		GroundPitch = 0;	
		ViewRotation = Rotation;

		if ( !bKeyboardLook && (bLook == 0) && bCenterView )
		{
			// FIXME - center view rotation based on current floor
		}
		BobTime = 0;
		WalkBob = WalkBob * (1 - FMin(1, 8 * deltatime));

		// Update rotation.
		SetRotation(ViewRotation);
		OldRotation = Rotation;
		UpdateRotation(DeltaTime, 1);

		// Update acceleration.
		NewAccel = aForward*Normal(ViewX - OldFloor * (OldFloor Dot ViewX)) + aStrafe*ViewY; 
		if ( VSize(NewAccel) < 1.0 )
			NewAccel = vect(0,0,0);

		if ( bPressedJump && Pawn.JumpInProgress() )
		{
			bSaveJump = true;
			bPressedJump = false;
		}
		else
			bSaveJump = false;

//NEW MJL
		HandleMove(DeltaTime, NewAccel, DoubleClickMove, OldRotation - Rotation);
/*OLD
		if ( Role < ROLE_Authority ) // then save this move and replicate it
			ReplicateMove(DeltaTime, NewAccel, DoubleClickMove, OldRotation - Rotation);
		else
			ProcessMove(DeltaTime, NewAccel, DoubleClickMove, OldRotation - Rotation);
*/
		bPressedJump = bSaveJump;
	}

	event BeginState()
	{
		local Rotator NewRot;

		if ( Pawn.Mesh == None )
			Pawn.SetMesh();
		OldFloor = vect(0,0,1);
		GetAxes(Rotation,ViewX,ViewY,ViewZ);
		WalkBob = vect(0,0,0);
		DoubleClickDir = DCLICK_None;
//NEW (mdf)		
		Pawn.SetStance( ST_Standing );
/*OLD			
		Pawn.ShouldCrouch(false);
*/		
		bPressedJump = false;
		if (Pawn.Physics != PHYS_Falling) 
			Pawn.SetPhysics(PHYS_Spider);
		GroundPitch = 0;
		Pawn.bCrawler = true;
		Pawn.SetCollisionSize(Pawn.Default.CollisionHeight,Pawn.Default.CollisionHeight);
	}
	
	event EndState()
	{
		GroundPitch = 0;
		WalkBob = vect(0,0,0);
		if ( Pawn != None )
		{
			Pawn.SetCollisionSize(Pawn.Default.CollisionRadius,Pawn.Default.CollisionHeight);
//NEW (mdf)		
			Pawn.SetStance( ST_Standing );
/*OLD			
			Pawn.ShouldCrouch(false);
*/			
			Pawn.bCrawler = Pawn.Default.bCrawler;
		}
	}
} // PlayerSpideringState
	
// Player movement.
// Player Swimming
//NEW
state @ PlayerSwimmingState
{
ignores SeeEnemy, SeeFriend, SeeOther, SeeAlertFriend, HearNoise, Bump;
/*OLD
state PlayerSwimming
{
//ignores SeePlayer, HearNoise, Bump;
*/
	function bool WantsSmoothedView()
	{
		return ( !Pawn.bJustLanded );
	}

	event bool NotifyLanded(vector HitNormal)
	{
		if ( Pawn.PhysicsVolume.bWaterVolume )
			Pawn.SetPhysics(PHYS_Swimming);
		else
			GotoState(Pawn.LandMovementState);
		return bUpdating;
	}
	
//NEW (mdf) refactored
	function LaunchActorOutofWater()
	{
		//set here so physics uses this for remainder of tick
		Pawn.velocity.Z = 330 + 2 * Pawn.CollisionRadius;
		GotoState(Pawn.LandMovementState);
	}
//OLD

	event bool NotifyPhysicsVolumeChange( PhysicsVolume NewVolume )
	{
		local actor HitActor;
		local vector HitLocation, HitNormal, checkpoint;

		if ( !NewVolume.bWaterVolume )
		{
			Pawn.SetPhysics(PHYS_Falling);
			if (Pawn.bUpAndOut && Pawn.CheckWaterJump(HitNormal)) //check for waterjump
			{
//NEW (mdf) refactored
				LaunchActorOutofWater();
/*OLD
				Pawn.velocity.Z = 330 + 2 * Pawn.CollisionRadius; //set here so physics uses this for remainder of tick
				GotoState(Pawn.LandMovementState);
*/
			}				
			else if ( (Pawn.Velocity.Z > 160) || !Pawn.TouchingWaterVolume() )
				GotoState(Pawn.LandMovementState);
			else //check if in deep water
			{
				checkpoint = Pawn.Location;
				checkpoint.Z -= (Pawn.CollisionHeight + 6.0);
				HitActor = Trace(HitLocation, HitNormal, checkpoint, Pawn.Location, false);
				if (HitActor != None)
					GotoState(Pawn.LandMovementState);
				else
				{
					Enable('Timer');
					SetTimer(0.7,false);
				}
			}
		}
		else
		{
			Disable('Timer');
			Pawn.SetPhysics(PHYS_Swimming);
		}
		return false;
	}

	function ProcessMove(float DeltaTime, vector NewAccel, eDoubleClickDir DoubleClickMove, rotator DeltaRot)	
	{
//NEW (mdf) not used
		local vector X,Y,Z;
/*OLD
		local vector X,Y,Z, OldAccel;
*/
	
		GetAxes(Rotation,X,Y,Z);
//NEW (mdf) not used
/*OLD
		OldAccel = Pawn.Acceleration;
*/
		Pawn.Acceleration = NewAccel;
		Pawn.bUpAndOut = ((X Dot Pawn.Acceleration) > 0) && ((Pawn.Acceleration.Z > 0) || (Rotation.Pitch > 2048));
		if ( !Pawn.PhysicsVolume.bWaterVolume ) //check for waterjump
			NotifyPhysicsVolumeChange(Pawn.PhysicsVolume);
	}

//NEW
	function vector GetAccel( vector X, vector Y, vector Z )
	{
		local vector ReturnedAcceleration;
		
		ReturnedAcceleration = aForward*X + aStrafe*Y + aUp*vect(0,0,1); 
		ReturnedAcceleration.Z = 0;
		return ReturnedAcceleration;
	}
	function SetMovementVars( vector Accel )
	{
		 local vector LocalAccel;
		 
		 LocalAccel = Accel << (rot(0,1,0)*Rotation.Yaw);
		 //!!MJL (mdf) bForwardPressed = (LocalAccel.X > Pawn.SwimForwardThreshold);
		 bUpPressed = (LocalAccel.Z > 0);
	}
//OLD

	function PlayerMove(float DeltaTime)
	{
		local rotator oldRotation;
		local vector X,Y,Z, NewAccel;
		local float Speed2D;
	
		GetAxes( Rotation, X, Y, Z );

		NewAccel = aForward*X + aStrafe*Y + aUp*vect(0,0,1); 
		if ( VSize(NewAccel) < 1.0 )
			NewAccel = vect(0,0,0);
	
		GetAxes(Rotation,X,Y,Z);
//NEW
		NewAccel = GetAccel( X, Y, Z );
/*OLD
		NewAccel = aForward*X + aStrafe*Y + aUp*vect(0,0,1); 
*/
		//add bobbing when swimming
		Speed2D = Sqrt(Pawn.Velocity.X * Pawn.Velocity.X + Pawn.Velocity.Y * Pawn.Velocity.Y);
		WalkBob = Y * Bob *  0.5 * Speed2D * sin(4.0 * Level.TimeSeconds);
		WalkBob.Z = Bob * 1.5 * Speed2D * sin(8.0 * Level.TimeSeconds);

		// Update rotation.
		oldRotation = Rotation;
		UpdateRotation(DeltaTime, 2);

//NEW MJL
		HandleMove(DeltaTime, NewAccel, DCLICK_None, OldRotation - Rotation);
/*OLD
		if ( Role < ROLE_Authority ) // then save this move and replicate it
			ReplicateMove(DeltaTime, NewAccel, DCLICK_None, OldRotation - Rotation);
		else
			ProcessMove(DeltaTime, NewAccel, DCLICK_None, OldRotation - Rotation);
*/

		bPressedJump = false;
	}

	event Timer()
	{
		if ( !Pawn.PhysicsVolume.bWaterVolume && (Role == ROLE_Authority) )
			GotoState(Pawn.LandMovementState);
	
		Disable('Timer');
	}
	
//NEW (mdf)
	function HandleWalking()
	{
		if ( Pawn != None )
		{
			// Pawn is flying...
			Pawn.bIsWalking = false;
		}
	}
//OLD

	event BeginState()
	{
		Disable('Timer');
		Pawn.SetPhysics(PHYS_Swimming);
	}
} // PlayerClimbingState

//NEW (mdf) Fix
state @ PlayerFlyingState
{
ignores SeeEnemy, SeeFriend, SeeOther, SeeAlertFriend, HearNoise, NotifyBump;
/*OLD
state PlayerFlying
{
//ignores SeePlayer, HearNoise, Bump;
*/
	function PlayerMove(float DeltaTime)
	{
		local rotator newRotation;
		local vector X,Y,Z;

		GetAxes(Rotation,X,Y,Z);

		Pawn.Acceleration = aForward*X + aStrafe*Y; 
		if ( VSize(Pawn.Acceleration) < 1.0 )
			Pawn.Acceleration = vect(0,0,0);
		if ( bCheatFlying && (Pawn.Acceleration == vect(0,0,0)) )
//NEW
			Pawn.StopMovement( false, true );
/*OLD
			Pawn.Velocity = vect(0,0,0);
*/
		// Update rotation.
		UpdateRotation(DeltaTime, 2);
		
//NEW MJL
		HandleMove(DeltaTime, Pawn.Acceleration, DCLICK_None, rot(0,0,0));
/*OLD
		if ( Role < ROLE_Authority ) // then save this move and replicate it
			ReplicateMove(DeltaTime, Pawn.Acceleration, DCLICK_None, rot(0,0,0));
		else
			ProcessMove(DeltaTime, Pawn.Acceleration, DCLICK_None, rot(0,0,0));
*/
	}
	
//NEW (mdf)
	function HandleWalking()
	{
		if ( Pawn != None )
		{
			// Pawn is flying...
			Pawn.bIsWalking = false;
		}
	}
//OLD

	event BeginState()
	{
		Pawn.SetPhysics(PHYS_Flying);
	}
} // PlayerFlyingState

//NEW (mdf)
state @ PlayerHelicopteringState extends @ PlayerFlyingState
/*OLD
state PlayerHelicoptering extends PlayerFlying
*/
{
	function PlayerMove(float DeltaTime)
	{
		local rotator newRotation;
		local vector X,Y,Z;

		GetAxes(Rotation,X,Y,Z);

		Pawn.Acceleration = aForward*X + aStrafe*Y + aUp*vect(0,0,1); 
		if ( VSize(Pawn.Acceleration) < 1.0 )
			Pawn.Acceleration = vect(0,0,0);
		if ( bCheatFlying && (Pawn.Acceleration == vect(0,0,0)) )
			Pawn.Velocity = vect(0,0,0);
		// Update rotation.
		UpdateRotation(DeltaTime, 2);
		
//NEW MJL
		HandleMove(DeltaTime, Pawn.Acceleration, DCLICK_None, rot(0,0,0));
/*OLD
		if ( Role < ROLE_Authority ) // then save this move and replicate it
			ReplicateMove(DeltaTime, Pawn.Acceleration, DCLICK_None, rot(0,0,0));
		else
			ProcessMove(DeltaTime, Pawn.Acceleration, DCLICK_None, rot(0,0,0));
*/
	}
} // PlayerHelicopteringState

//NEW
state @ BaseSpectatingState
/*OLD
state BaseSpectating
*/
{
	function ProcessMove(float DeltaTime, vector NewAccel, eDoubleClickDir DoubleClickMove, rotator DeltaRot)	
	{
		Acceleration = NewAccel;
		MoveSmooth(Acceleration * DeltaTime);
	}

	function PlayerMove(float DeltaTime)
	{
		local rotator newRotation;
		local vector X,Y,Z;

		GetAxes(Rotation,X,Y,Z);
	
//NEW (mdf) default to faster movement when spectating and make the speed configurable		
		aUp *= 2.0; // goose up/down movement acceleration
		Acceleration = SpectatingAccelerationScale * (aForward*X + aStrafe*Y + aUp*vect(0,0,1));  
/*OLD
		Acceleration = 0.02 * (aForward*X + aStrafe*Y + aUp*vect(0,0,1));  
*/
		UpdateRotation(DeltaTime, 1);

//NEW MJL
		HandleMove(DeltaTime, Acceleration, DCLICK_None, rot(0,0,0));
/*OLD
		if ( Role < ROLE_Authority ) // then save this move and replicate it
			ReplicateMove(DeltaTime, Acceleration, DCLICK_None, rot(0,0,0));
		else
			ProcessMove(DeltaTime, Acceleration, DCLICK_None, rot(0,0,0));
*/
	}
} // BaseSpectatingState

//NEW
state @ SpectatingState extends @ BaseSpectatingState
/*OLD
state Spectating extends BaseSpectating
*/
{
//NEW
	ignores SwitchWeapon, RestartLevel, Suicide,
/*OLD
	ignores SwitchWeapon, RestartLevel, ClientRestart, Suicide,
*/
	 ThrowWeapon, NotifyPhysicsVolumeChange, NotifyHeadVolumeChange;

	exec function NextWeapon()
	{
		Fire();
	}

	exec function PrevWeapon()
	{
		if ( ViewTarget == self )
			bBehindView = false;
		else
			bBehindView = true; //bChaseCam;
	}

//NEW (mdf) weapon interface cleanup
	exec function Fire()
/*OLD
	exec function Fire( optional float F )
*/
	{
		local Controller C, Pick;
		local bool bFound;
			
		if ( Role == ROLE_Authority )
		{
			// view next player
			for ( C=Level.ControllerList; C!=None; C=C.NextController )
				if ( (C.Pawn != None) && Level.Game.CanSpectate(self,C.Pawn) )
				{
					if ( Pick == None )
						Pick = C;
					if ( bFound )
					{
						Pick = C;
						break;
					}	
					else
						bFound = ( ViewTarget == C.Pawn );
				}
			SetViewTarget(Pick.Pawn);		 
			if ( ViewTarget == self )
				bBehindView = false;
			else
				bBehindView = true; //bChaseCam;
		}
	}

	// Return to spectator's own camera.
//NEW (mdf) weapon interface cleanup
	exec function AltFire()
/*OLD
	exec function AltFire( optional float F )
*/
	{
		bBehindView = false;
		SetViewtarget(self);
		ClientMessage(OwnCamera, 'Event');
	}

	event BeginState()
	{
		if ( Pawn != None )
		{
			SetLocation(Pawn.Location);
			UnPossess();
		}
		bCollideWorld = true;
	}

	event EndState()
	{
		PlayerReplicationInfo.bIsSpectator = false;		
		bCollideWorld = false;
	}
} // SpectatingState

//NEW
auto state @ PlayerWaitingState extends @ BaseSpectatingState
{
ignores SeeEnemy, SeeFriend, SeeOther, SeeAlertFriend, HearNoise, NotifyBump, TakeDamage, PhysicsVolumeChange;
/*OLD
auto state PlayerWaiting extends BaseSpectating
{
//ignores SeePlayer, HearNoise, NotifyBump, TakeDamage, PhysicsVolumeChange;
*/
	exec function Jump( optional float F )
	{
	}

	exec function Suicide()
	{
	}

	function ChangeTeam( int N )
	{
		Level.Game.ChangeTeam(self, N);
	}

	function ServerReStartPlayer()
	{
		if ( Level.TimeSeconds < WaitDelay )
			return;
		if ( Level.NetMode == NM_Client )
			return;
		if ( Level.Game.bWaitingToStartMatch )
			PlayerReplicationInfo.bReadyToPlay = true;
		else
			Level.Game.RestartPlayer(self);
	}

//NEW (mdf) weapon interface cleanup
	exec function Fire()
/*OLD
	exec function Fire(optional float F)
*/
	{
		ServerReStartPlayer();
	}
	
//NEW (mdf) weapon interface cleanup
	exec function AltFire()
/*OLD
	exec function AltFire(optional float F)
*/
	{
		ServerReStartPlayer();
	}

	event EndState()
	{
		if ( Pawn != None )
			Pawn.SetMesh();
		PlayerReplicationInfo.SetWaitingPlayer(false);
		bCollideWorld = false;
	}

	event BeginState()
	{
		if ( PlayerReplicationInfo != None )
			PlayerReplicationInfo.SetWaitingPlayer(true);
		bCollideWorld = true;
		myHUD.bShowScores = false;
	}
} // PlayerWaitingState

//NEW MJL
/*OLD
state WaitingForPawn extends BaseSpectating
{
//ignores SeePlayer, HearNoise, KilledBy, SwitchWeapon;

	exec function Fire( optional float F )
	{
	}

	exec function AltFire( optional float F )
	{
	}

	function LongClientAdjustPosition
	(
		float TimeStamp, 
		name newState, 
		EPhysics newPhysics,
		float NewLocX, 
		float NewLocY, 
		float NewLocZ, 
		float NewVelX, 
		float NewVelY, 
		float NewVelZ,
		Actor NewBase,
		float NewFloorX,
		float NewFloorY,
		float NewFloorZ
	)
	{
	}

	function PlayerTick(float DeltaTime)
	{
		Global.PlayerTick(DeltaTime);

		if ( Pawn != None )
		{
			Pawn.Controller = self;
			ClientRestart();
		}
	}

	event Timer()
	{
		AskForPawn();
	}

	event BeginState()
	{
		SetTimer(0.2, true);
	}

	event EndState()
	{
		SetTimer(0.0, false);
	}
}
*/

//NEW (mdf)
state @ GameEndedState
{
ignores SeeEnemy, SeeFriend, SeeOther, SeeAlertFriend, HearNoise, KilledBy, NotifyBump, HitWall, NotifyHeadVolumeChange, NotifyPhysicsVolumeChange, BeginFalling, TakeDamage, Suicide;
/*OLD
state GameEnded
{
//ignores SeePlayer, HearNoise, KilledBy, NotifyBump, HitWall, NotifyHeadVolumeChange, NotifyPhysicsVolumeChange, Falling, TakeDamage, Suicide;
*/
	exec function ThrowWeapon()
	{
	}

	function ServerReStartGame()
	{
		Level.Game.RestartGame();
	}

//NEW (mdf) weapon interface cleanup
	exec function Fire()
/*OLD
	exec function Fire( optional float F )
*/
	{
		if ( Role < ROLE_Authority)
			return;
		if ( !bFrozen )
			ServerReStartGame();
		else if ( TimerRate <= 0 )
			SetTimer(1.5, false);
	}
	
//NEW (mdf) weapon interface cleanup
	exec function AltFire()
	{
		Fire();
	}
/*OLD
	exec function AltFire( optional float F )
	{
		Fire(F);
	}
*/

	function PlayerMove(float DeltaTime)
	{
		local vector X,Y,Z;
		local Rotator ViewRotation;

		GetAxes(Rotation,X,Y,Z);
		// Update view rotation.

		if ( !bFixedCamera )
		{
			ViewRotation = Rotation;
			ViewRotation.Yaw += 32.0 * DeltaTime * aTurn;
			ViewRotation.Pitch += 32.0 * DeltaTime * aLookUp;
			ViewRotation.Pitch = ViewRotation.Pitch & 65535;
			If ((ViewRotation.Pitch > 18000) && (ViewRotation.Pitch < 49152))
			{
				If (aLookUp > 0) 
					ViewRotation.Pitch = 18000;
				else
					ViewRotation.Pitch = 49152;
			}
			SetRotation(ViewRotation);
		}
		else if ( ViewTarget != None )
			SetRotation(ViewTarget.Rotation);

		ViewShake(DeltaTime);
		ViewFlash(DeltaTime);

//NEW MJL
		HandleMove(DeltaTime, vect(0,0,0), DCLICK_None, rot(0,0,0));
/*OLD
		if ( Role < ROLE_Authority ) // then save this move and replicate it
			ReplicateMove(DeltaTime, vect(0,0,0), DCLICK_None, rot(0,0,0));
		else
			ProcessMove(DeltaTime, vect(0,0,0), DCLICK_None, rot(0,0,0));
*/
		bPressedJump = false;
	}

	function ServerMove
	(
		float TimeStamp, 
		vector InAccel, 
		vector ClientLoc,
		bool NewbRun,
		bool NewbDuck,
		bool NewbJumpStatus, 
		eDoubleClickDir DoubleClickMove, 
		byte ClientRoll, 
		int View,
		optional byte OldTimeDelta,
		optional int OldAccel
	)
	{
		Global.ServerMove(TimeStamp, InAccel, ClientLoc, NewbRun, NewbDuck, NewbJumpStatus,
							DoubleClickMove, ClientRoll, (32767 & (Rotation.Pitch/2)) * 32768 + (32767 & (Rotation.Yaw/2)) );

	}

	function FindGoodView()
	{
		local vector cameraLoc;
		local rotator cameraRot, ViewRotation;
		local int tries, besttry;
		local float BestDist, newdist;
		local int startYaw;
		local actor ViewActor;
		
		ViewRotation = Rotation;
		ViewRotation.Pitch = 56000;
		tries = 0;
		besttry = 0;
		BestDist = 0.0;
		startYaw = ViewRotation.Yaw;
		
		for (tries=0; tries<16; tries++)
		{
			cameraLoc = ViewTarget.Location;
			PlayerCalcView(ViewActor, cameraLoc, cameraRot);
			newdist = VSize(cameraLoc - ViewTarget.Location);
			if (newdist > BestDist)
			{
				BestDist = newdist;	
				besttry = tries;
			}
			ViewRotation.Yaw += 4096;
		}
			
		ViewRotation.Yaw = startYaw + besttry * 4096;
		SetRotation(ViewRotation);
	}
	
	event Timer()
	{
		bFrozen = false;
	}
	
	event BeginState()
	{
		local Pawn P;

		EndZoom();
		bFire = 0;
		bAltFire = 0;
		if ( Pawn != None )
		{
			Pawn.SimAnim.AnimRate = 0;
			Pawn.bPhysicsAnimUpdate = false;
			Pawn.StopAnimating();
			Pawn.SetCollision(false,false,false);
		}
		myHUD.bShowScores = true;
		bFrozen = true;
		if ( !bFixedCamera )
		{
			FindGoodView();
			bBehindView = true;
		}
		SetTimer(1.5, false);
		SetPhysics(PHYS_None);
		ForEach DynamicActors(class'Pawn', P)
		{
			P.Velocity = vect(0,0,0);
			P.SetPhysics(PHYS_None);
		}
//NEW: update client player's state as well (formerly implemented in DeathMatchPlus.uc, TeamGamePlus.uc, and CTFGame
		if( Role == ROLE_Authority && Level.NetMode != NM_StandAlone )
		{
			ClientGameEnded();
		}
//OLD
	}
} // GameEndedState

//NEW MJL: unset crosshair when we die
function ClientDying(class<DamageType> DamageType, vector HitLocation, Pawn InstigatedBy, vector Momentum)
{
	if( Pawn != None && Pawn.Weapon != None)
		Pawn.Weapon.ClearWeaponEffects();
	Super.ClientDying( DamageType, HitLocation, InstigatedBy, Momentum );
}
//OLD

//NEW
state @ DeadState
{
ignores SeeEnemy, SeeFriend, SeeOther, SeeAlertFriend, HearNoise, KilledBy, SwitchWeapon;
/*OLD
state Dead
{
//ignores SeePlayer, HearNoise, KilledBy, SwitchWeapon;
*/
	function ServerRestartPlayer()
	{
		if ( bFrozen )
			return;
		Super.ServerRestartPlayer();
	}

//NEW (mdf) weapon interface cleanup
	exec function Fire()
/*OLD
	exec function Fire( optional float F )
*/
	{
		if ( !bFrozen )
			ServerReStartPlayer();
	}
	
//NEW (mdf) weapon interface cleanup
	exec function AltFire()
	{
		Fire();
	}

/*OLD
	exec function AltFire( optional float F )
	{
		Fire(F);
	}

*/

	function ServerMove
	(
		float TimeStamp, 
		vector Accel, 
		vector ClientLoc,
		bool NewbRun,
		bool NewbDuck,
		bool NewbJumpStatus,
		eDoubleClickDir DoubleClickMove, 
		byte ClientRoll, 
		int View,
		optional byte OldTimeDelta,
		optional int OldAccel
	)
	{
		Global.ServerMove(
					TimeStamp,
					Accel, 
					ClientLoc,
					false,
					false,
					false,
					DoubleClickMove, 
					ClientRoll, 
					View);
	}

	function PlayerMove(float DeltaTime)
	{
		local vector X,Y,Z;
		local rotator ViewRotation;

		if ( !bFrozen )
		{
			if ( bPressedJump )
			{
//NEW (mdf) weapon interface cleanup
				Fire();
/*OLD
				Fire(0);
*/
				bPressedJump = false;
			}
			GetAxes(Rotation,X,Y,Z);
			// Update view rotation.
			ViewRotation = Rotation;
			ViewRotation.Yaw += 32.0 * DeltaTime * aTurn;
			ViewRotation.Pitch += 32.0 * DeltaTime * aLookUp;
			ViewRotation.Pitch = ViewRotation.Pitch & 65535;
			If ((ViewRotation.Pitch > 18000) && (ViewRotation.Pitch < 49152))
			{
				If (aLookUp > 0) 
					ViewRotation.Pitch = 18000;
				else
					ViewRotation.Pitch = 49152;
			}
			SetRotation(ViewRotation);
//NEW MJL
			HandleMove(DeltaTime, vect(0,0,0), DCLICK_None, rot(0,0,0));
/*OLD
			if ( Role < ROLE_Authority ) // then save this move and replicate it
				ReplicateMove(DeltaTime, vect(0,0,0), DCLICK_None, rot(0,0,0));
*/
		}
		ViewShake(DeltaTime);
		ViewFlash(DeltaTime);
	}

	function FindGoodView()
	{
		local vector cameraLoc;
		local rotator cameraRot, ViewRotation;
		local int tries, besttry;
		local float BestDist, newdist;
		local int startYaw;
		local actor ViewActor;
		
		////log("Find good death scene view");
		ViewRotation = Rotation;
		ViewRotation.Pitch = 56000;
		tries = 0;
		besttry = 0;
		BestDist = 0.0;
		startYaw = ViewRotation.Yaw;
		
		for (tries=0; tries<16; tries++)
		{
			cameraLoc = ViewTarget.Location;
			PlayerCalcView(ViewActor, cameraLoc, cameraRot);
			newdist = VSize(cameraLoc - ViewTarget.Location);
			if (newdist > BestDist)
			{
				BestDist = newdist;	
				besttry = tries;
			}
			ViewRotation.Yaw += 4096;
		}
			
		ViewRotation.Yaw = startYaw + besttry * 4096;
		SetRotation(ViewRotation);
	}
	
	event Timer()
	{
		bFrozen = false;
		myHUD.bShowScores = true;
		bPressedJump = false;
	}
	
	event BeginState()
	{
		local SavedMove Next;

		//NEW (mdf)
		#debug   SetControllerEnemy( None, GetContext() );
		#release SetControllerEnemy( None );
		/*OLD 
		Enemy = None;
		*/
		bBehindView = true;
		bFrozen = true;
		bPressedJump = false;
		FindGoodView();
		SetTimer(1.0, false);

		// clean out saved moves
		while ( SavedMoves != None )
		{
			Next = SavedMoves.NextMove;
			SavedMoves.Destroy();
			SavedMoves = Next;
		}
		if ( PendingMove != None )
		{
			PendingMove.Destroy();
			PendingMove = None;
		}
	}
	
	event EndState()
	{
		local SavedMove Next;

		// clean out saved moves
		while ( SavedMoves != None )
		{
			Next = SavedMoves.NextMove;
			SavedMoves.Destroy();
			SavedMoves = Next;
		}
		if ( PendingMove != None )
		{
			PendingMove.Destroy();
			PendingMove = None;
		}
//NEW (mdf)
		StopMovement( true, true );
/*OLD
		Velocity = vect(0,0,0);
		Acceleration = vect(0,0,0);
*/
		bBehindView = false;
		myHUD.bShowScores = false;
		bPressedJump = false;
		//Log(self$" exiting dying with remote role "$RemoteRole$" and role "$Role);
	}
}

//------------------------------------------------------------------------------
// ngStats Accessors
function string GetNGSecret()
{
	return ngWorldSecret;
}

function SetNGSecret(string newSecret)
{
	ngWorldSecret = newSecret;
}

//------------------------------------------------------------------------------
// Control options	
function ChangeStairLook( bool B )
{
	bLookUpStairs = B;
	if ( bLookUpStairs )
		bAlwaysMouseLook = false;
}

function ChangeAlwaysMouseLook(Bool B)
{
	bAlwaysMouseLook = B;
	if ( bAlwaysMouseLook )
		bLookUpStairs = false;
}

//NEW
exec function SetAirControl( float F )
{
	//!!MJL (mwp) Restrict access (via AccessControl?).
	Pawn.AirControl = F;
}
//OLD

//NEW (mdf)
//-----------------------------------------------------------------------------
// ADDITIONAL INTERFACE FUNCTIONS 
//-----------------------------------------------------------------------------

function rotator GetViewRotation()				
{ 
	// !!mdf-tbd: ViewTarget initialized to Self, but TargetViewRotation not updated?
	if( ViewTarget != Pawn && ViewTarget != Self )
		return TargetViewRotation;
	else
		return Rotation;
}
//OLD

defaultproperties
{
	bAlwaysMouseLook=true
	bKeyboardLook=true
	bNeverSwitchOnPickup=true
	WeaponPriority(0)='weaponInvTakkra'
	WeaponPriority(1)='weaponInvFlamethrower'
	WeaponPriority(2)='weaponInvLeechGun'
	WeaponPriority(3)='weaponInvDispersion'
	WeaponPriority(4)='weaponInvPistol'
	WeaponPriority(5)='weaponInvEnergyRifle'
	WeaponPriority(6)='weaponInvSniperRifle'
	WeaponPriority(7)='weaponInvShotgun'
	WeaponPriority(8)='weaponInvGrenadeLauncher'
	WeaponPriority(9)='weaponInvRocketLauncher'
	WeaponPriority(10)='weaponInvAssaultRifle'
	WeaponPriority(11)='weaponInvSingularityCannon'
	WeaponPriority(12)='weaponInvLaserRifle'
	WeaponPriority(13)='weaponTutorialInvGrenadeLauncher'
	bCheatsEnabled=true
	bZeroRoll=true
	OrthoZoom=40000.000000
	CameraDist=9.000000
	DesiredFOV=90.000000
	DefaultFOV=90.000000
	FlashScale=(X=1.000000,Y=1.000000,Z=1.000000)
	AnnouncerVolume=4
	MaxTimeMargin=1.000000
	QuickSaveString="Quick Saving"
	NoPauseMessage="Game is not pauseable"
	ViewingFrom="Now viewing from"
	OwnCamera="Now viewing from own camera"
	LocalMessageClass=Class'Engine.LocalMessage'
	Bob=0.045000
	ShakePeriodX=31.000000
	ShakePeriodY=29.000000
	EnemyTurnSpeed=45000
	InputClass=Class'Engine.PlayerInput'
	SpectatingAccelerationScale=0.025000
	ShowSubtitles=true
	FovAngle=85.000000
	bIsPlayer=true
	NetPriority=3.000000
     UseReticleOnEvents(0)="UseReticleText"
     UseReticleOnEvents(1)="UseReticleCorners"
     UseReticleOnEvents(2)="UseReticleTopBars"
     ProximityReticleOnEvents(0)="ProximityReticleCorners"
     ProximityReticleOnEvents(1)="ProximityReticleTopBars"
}