U2.U2PlayerController

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

class U2PlayerController extends PlayerController
	config(User);

//const CinematicState					= 'Cinematic';
//const EndCinematicEvent				= 'EndCinematic';
const MissionFailedState				= 'MissionFailed';
const ImpaledState						= 'Impaled';
const LevelTransitionState				= 'LevelTransition';
const MantlingState						= 'Mantling';
const PlayerEndLevelImmediatelyState	= 'PlayerEndLevelImmediately';

const LeanRate							= 256.0;	// offset change in units per sec when transition to/from leaning
const LeanTraceFudge					= 16.0;		// fudge factor used when checking whether lean put camera into geometry
const LeanWalkingPctScale				= 1.0;		// pct of walking speed used when leaning

enum ELeanDir
{
	Lean_None,
	Lean_Forward,
	Lean_Left,
	Lean_Right,
	Lean_Up,
};

var globalconfig bool bInstantRocket;
var	globalconfig bool bAutoTaunt; // player automatically generates taunts when fragging someone
var	globalconfig bool bNoAutoTaunts; // don't receive auto-taunts
var globalconfig bool bNoVoiceTaunts; // don't receive any taunts
var globalconfig bool bNoMatureLanguage;
var globalconfig bool bNoVoiceMessages; // don't receive any voice messages
var globalconfig bool bNoVoices;
var bool bRising;

var NavigationPoint StartSpot; //where player started the match

var vector LastAutoAimLocation;

var() globalconfig bool bIgnoreNextWhenZoomed;

var bool bWeaponKickDisabled;				//ARL test code
var bool bWeaponKicking;					// true during recoil, false while idle or recovering
var bool bAltWeaponKick;					// true for AltFire(), false for Fire()
var float WeaponKickPercent;				// holds 0.0 (neutral position) to 1.0 (maximum kick offset)
var float LastWeaponKickTime;				// last time weapon kick was updated
var vector WeaponKickOffset;				// resulting offset -- stored for use by U2Weapon.CalcDrawOffset()
var() float ProneWeaponKickRatio;			// amount that kick effect is reduced while prone

// leaning
var ELeanDir LeanDir;						// set to lean direction
var ELeanDir LastLeanDir;					// previous lean dir (for use while unleaning)
var bool bWantsToLean;						// player wants to lean -- next movement update will set direction
var bool bReleaseLeanKeys;					// player needs to release lean keys before leaning direction can be set
var float LastLeaningCheck;
var vector DesiredLeanOffset;				// desired additional camera offset due to leaning

var vector LadderMoveLocation;				// hack to track ladder movement & play ladder climbing sound

var name UnFreezeState;
//var EPhysics UnFreezePhysics;

var() globalconfig byte UIAlpha;

var float AmmoFlashTime;

var U2Pawn U2P;

// WeaponPanel support.

struct native WeaponInfo
{
	var config string	WeaponName;	// User readable name of the weapon.
	var config byte		Priority;	// Order within the tray (lower numbers = higher priority) - essentially group offset.
	var /****/ Weapon	Weapon;		// Pointer to the associated weapon - if the player has it currently.
};

// NOTE[aleiby]: Stored as separate variables to make the ini cleaner and 
// to support weapon mods from clashing with U2 weapons with the same InventoryGroup/GroupOffsets
var /*config*/ array<WeaponInfo> WeaponOrder1;
var /*config*/ array<WeaponInfo> WeaponOrder2;
var /*config*/ array<WeaponInfo> WeaponOrder3;
var /*config*/ array<WeaponInfo> WeaponOrder4;
var /*config*/ array<WeaponInfo> WeaponOrder5;

// Autosave stuff.
var globalconfig int AutoSaveIndex;

var(Music) array<string> DeathMusic;

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

replication
{
	// Things the server should send to the client.
	unreliable if( Role==ROLE_Authority )
		ClientPlayTakeHit;
	reliable if ( Role == ROLE_Authority )
		PlayWinMessage; 

	// client to server
	reliable if ( Role < ROLE_Authority )
		// weapons
		ServerReload, 
		ServerSetTaunt, ServerSetInstantRocket, ServerTaunt, ServerAddBots;
}

// Autosave stuff.

function SetAutoSaveIndex( int i )
{
	AutoSaveIndex = Max( AutoSaveIndex, i );
	SaveConfig();
}

function bool AutoSaveEnabledA1(){ return AutoSaveIndex >= 0; }
function bool AutoSaveEnabledA2(){ return AutoSaveIndex >= 1; }
function bool AutoSaveEnabledA3(){ return AutoSaveIndex >= 2; }
function bool AutoSaveEnabledA4(){ return AutoSaveIndex >= 3; }
function bool AutoSaveEnabledB1(){ return AutoSaveIndex >= 4; }
function bool AutoSaveEnabledB2(){ return AutoSaveIndex >= 5; }
function bool AutoSaveEnabledB3(){ return AutoSaveIndex >= 6; }
function bool AutoSaveEnabledB4(){ return AutoSaveIndex >= 7; }
function bool AutoSaveEnabledC1(){ return AutoSaveIndex >= 8; }
function bool AutoSaveEnabledC2(){ return AutoSaveIndex >= 9; }
function bool AutoSaveEnabledC3(){ return AutoSaveIndex >= 10; }
function bool AutoSaveEnabledC4(){ return AutoSaveIndex >= 11; }
function bool AutoSaveEnabledD1(){ return AutoSaveIndex >= 12; }
function bool AutoSaveEnabledD2(){ return AutoSaveIndex >= 13; }
function bool AutoSaveEnabledD3(){ return AutoSaveIndex >= 14; }
function bool AutoSaveEnabledD4(){ return AutoSaveIndex >= 15; }
function bool AutoSaveEnabledE1(){ return AutoSaveIndex >= 16; }
function bool AutoSaveEnabledE2(){ return AutoSaveIndex >= 17; }
function bool AutoSaveEnabledE3(){ return AutoSaveIndex >= 18; }
function bool AutoSaveEnabledE4(){ return AutoSaveIndex >= 19; }
function bool AutoSaveEnabledF1(){ return AutoSaveIndex >= 20; }
function bool AutoSaveEnabledF2(){ return AutoSaveIndex >= 21; }
function bool AutoSaveEnabledF3(){ return AutoSaveIndex >= 22; }
function bool AutoSaveEnabledF4(){ return AutoSaveIndex >= 23; }
function bool AutoSaveEnabledG1(){ return false; }

// UI Callbacks.
simulated function float GetUIAlpha(){ return UIAlpha; }
simulated function SetUIAlpha( float A ){ UIAlpha=A; SaveConfig(); }

//-----------------------------------------------------------------------------
// Underwater sound modulation and sub-titles

function bool ActorHeadInWater( Actor SourceActor, vector Loc )
{
	local bool bWaterVolume;

	if( Pawn(SourceActor) != None )
	{
		bWaterVolume = Pawn(SourceActor).HeadVolume.bWaterVolume;
	}
	else
	{
		bWaterVolume = SourceActor.PhysicsVolume.bWaterVolume;
	}
	
	return bWaterVolume;
}

//-----------------------------------------------------------------------------
// Modify non-ambient sounds when player is underwater. Ambient sounds aren't
// relayed through ClientHearSound and these are currently modified in an
// identical fashion in AlAudioSubsystem.cpp UALAudioSubsystem::Update()
//-----------------------------------------------------------------------------

simulated event ClientHearSound ( 
	actor Actor, 
	int Id, 
	sound S, 
	vector SoundLocation, 
	vector Parameters,
	bool Attenuate
)
{
	//DMTNS( "ClientHearSound Vol: " $ Parameters.X $ " Radius: " $ Parameters.Y $ " Pitch: " $ Parameters.Z );
	
	// what does get pitched underwater
	//  sounds not in the above which
	//    either originate underwater or are being heard underwater
	//  ambient sounds are pitched in ALAudioSubsystem.cpp.

	// what doesn't get pitched underwater:
	//	any sound played in SLOT_Interface (UI sounds -- should always originate in player)
	//!!arl	if( Slot != SLOT_Interface )
	if( Pawn != None )
	{
		// modify the sound's pitch etc. in water
		if( Pawn.HeadVolume.bWaterVolume || ((SoundLocation != Pawn.Location) && ActorHeadInWater( Actor, SoundLocation )) )
		{
			// hearer underwater or sound source underwater 

			// if you change these, update ALAudioSubsystem.cpp as well
			Parameters.x *= 0.90;	// volume
			Parameters.y *= 0.80;	// radius
			Parameters.z *= 0.85;	// pitch
		}
	}

	super.ClientHearSound( Actor, Id, S, SoundLocation, Parameters, Attenuate );
}

//-----------------------------------------------------------------------------
// HUD Stuff
//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------
// WeaponPanel convenience functions

function WeaponPanel GetWeaponPanel()
{
	local UIConsole Console;
	local WeaponPanel WP;
	local int i;

	if( Viewport(Player) != None )
	{
		Console = UIConsole(Player.Console);
		if( Console != None )
		{
			// Fix ARL: This code may break if we don't force Root to be loaded first.  (make changes in Console then delete this note)
			for(i=0;i<Console.Helpers.length;i++)
			{
				WP=WeaponPanel(Console.Helpers[i]);
				if(WP!=None) break;
			}
		}
	}

	return WP;
}

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

function HighlightPendingWeapon( Pawn P )
{
	local WeaponPanel Panel;
	if( P != None && P.PendingWeapon != None )
		Panel = GetWeaponPanel();
	if( Panel != None )
		Panel.HighlightWeapon( P.PendingWeapon );
}

//-----------------------------------------------------------------------------
// Inventory notifications

function NotifyAddInventory(inventory AddedItem)
{
	local WeaponPanel WP;
	WP = GetWeaponPanel();
	if( WP != None && Weapon(AddedItem) != None )
		WP.DoAddWeapon( Weapon(AddedItem), true );
	Super.NotifyAddInventory( AddedItem );
}

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

function NotifyRemoveInventory(inventory RemovedItem)
{
	local WeaponPanel WP;
	WP = GetWeaponPanel();
	if( WP != None && Weapon(RemovedItem) != None )
	{
		WP.DoRemoveWeapon( Weapon(RemovedItem), true);
		WP.HighlightWeapon( Pawn.Weapon );
	}
	Super.NotifyRemoveInventory( RemovedItem );
}

//-----------------------------------------------------------------------------
// Weapon exec overrides

exec function ThrowWeapon()
{
	// ThrowWeapon is disabled in Unreal II SP -- re-enable only for multiplayer
/*
	Super.ThrowWeapon();
*/
}
	
//-----------------------------------------------------------------------------

exec function PrevWeapon()
{
	Super.PrevWeapon();
	HighlightPendingWeapon( Pawn );
}

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

exec function NextWeapon()
{
	Super.NextWeapon();
	HighlightPendingWeapon( Pawn );
}

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

exec function SwitchWeapon (byte F )
{
	Super.SwitchWeapon(F);
	HighlightPendingWeapon( Pawn );
}

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

exec function bool SwitchToBestWeapon( optional out float Rating, optional out byte bUseAltMode )
{
	local bool WeaponHasChanged;
	WeaponHasChanged = Super.SwitchToBestWeapon( Rating, bUseAltMode );
	if( WeaponHasChanged )
		HighlightPendingWeapon( Pawn );
	return WeaponHasChanged;
}

//-----------------------------------------------------------------------------
// Hud Accessors
simulated function float GetHealthPct()
{
	if( Pawn != None )
		return float(Pawn.Health) / float(Pawn.default.Health);
	else
		return 0;
}

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

simulated function string GetHealthString()
{
	local int Value;
	if( Pawn != None )
		Value = Pawn.Health;
	if		( Value < 1    ) return "000";
	else if	( Value < 10   ) return "00"$Value;
	else if	( Value < 100  ) return "0"$Value;
	else if	( Value < 1000 ) return string(Value);
	else				     return "ERR";
}

//-----------------------------------------------------------------------------
// in case the controller doesn't have a pawn (dead, spectating)
simulated function float GetPowerSuitPct()
{
	local U2Pawn AccessedPawn;

	AccessedPawn = U2Pawn(Pawn);

	if( AccessedPawn != None )
		return AccessedPawn.GetPowerSuitPct();
	else
		return 0;
}

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

simulated function string GetPowerSuitString()
{
	local int Power;
	local int Max;
	local U2Pawn AccessedPawn;

	AccessedPawn = U2Pawn(Pawn);

	if( AccessedPawn != None )
	{
		Power = AccessedPawn.GetPowerSuit();
		Max = AccessedPawn.GetPowerSuitMax();

		if ( Max > 0 )
			return Power $ "/" $ Max;
	}

	return "0";
}

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

simulated function string GetPowerSuitPowerString()
{
	local int Value;
	local U2Pawn AccessedPawn;
	AccessedPawn = U2Pawn(Pawn);
	if( AccessedPawn != None )
		Value = AccessedPawn.GetPowerSuit();
	if		( Value < 1    ) return "000";
	else if	( Value < 10   ) return "00"$Value;
	else if	( Value < 100  ) return "0"$Value;
	else if	( Value < 1000 ) return string(Value);
	else				     return "ERR";
}

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

simulated function string GetPowerSuitMaxString()
{
	local int Value;
	local U2Pawn AccessedPawn;
	AccessedPawn = U2Pawn(Pawn);
	if( AccessedPawn != None )
		Value = AccessedPawn.GetPowerSuitMax();
	if		( Value < 1    ) return "000";
	else if	( Value < 10   ) return "00"$Value;
	else if	( Value < 100  ) return "0"$Value;
	else if	( Value < 1000 ) return string(Value);
	else				     return "ERR";
}

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

simulated function string GetWeaponString()
{
	local Inventory Inv;
	local string Weapons;

	for(Inv=Inventory;Inv!=None;Inv=Inv.Inventory)
		if(Inv.IsA('U2Weapon'))
			Weapons = Weapons$" "$Inv.ItemName;

	return Weapons;
}

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

simulated function string GetArtifactString()
{
	local Inventory Inv;
	local string Artifacts;

	for(Inv=Inventory;Inv!=None;Inv=Inv.Inventory)
		if(Inv.IsA('Artifact'))
			Artifacts = Artifacts$" "$Inv.ItemName;

	return Artifacts;
}

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

simulated function float GetAmmoClipPct()
{
	if ( Pawn != None && Pawn.Weapon != None )
		return float(Pawn.Weapon.GetClipAmount()) / float(Pawn.Weapon.GetClipSize());
	else
		return 0;
}

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

simulated function float GetAmmoTotalPct()
{
	if( Pawn != None && Pawn.Weapon != None )
		return float(Pawn.Weapon.GetAmmoAmount() - Pawn.Weapon.GetClipAmount()) / float(Pawn.Weapon.GetMaxAmmo());
	else
		return 0;
}

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

simulated function string GetTotalAmmoString()
{
	local int Value;
	if( Pawn != None && Pawn.Weapon != None )
		Value = Pawn.Weapon.GetAmmoAmount() - Pawn.Weapon.GetClipAmount();
	if		( Value < 1    ) return "000";
	else if	( Value < 10   ) return "00"$Value;
	else if	( Value < 100  ) return "0"$Value;
	else if	( Value < 1000 ) return string(Value);
	else				     return "ERR";
}

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

simulated function string GetClipRoundsRemaining()
{
	local int Value;
	if ( Pawn != None && Pawn.Weapon != None )
		Value = Pawn.Weapon.GetClipAmount();
	if		( Value < 1    ) return "000";
	else if	( Value < 10   ) return "00"$Value;
	else if	( Value < 100  ) return "0"$Value;
	else if	( Value < 1000 ) return string(Value);
	else				     return "ERR";
}

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

simulated function string GetClipSize()
{
	local int Value;
	if ( Pawn != None && Pawn.Weapon != None )
		Value = Pawn.Weapon.GetClipSize();
	if		( Value < 1    ) return "000";
	else if	( Value < 10   ) return "00"$Value;
	else if	( Value < 100  ) return "0"$Value;
	else if	( Value < 1000 ) return string(Value);
	else				     return "ERR";
}

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

simulated function array<string> GetObjectives()
{
	return U2GameInfo(Level.Game).GetObjectives();
}

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

simulated function bool GetAutoTaunt()
{
	return bAutoTaunt;
}

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

simulated function SetPlayVoiceMessages( bool B )
{ 
	bNoVoiceMessages = !B; 
}

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

simulated function bool GetPlayVoiceMessages()
{ 
	return !bNoVoiceMessages;
}

//-----------------------------------------------------------------------------
// Weapon Stuff
//-----------------------------------------------------------------------------

exec function Fire()
{
	if ( Level.Pauser == PlayerReplicationInfo )
	{
		SetPause(False);
		return;
	}

	if( !InLeanMode() )
	{
		if( Pawn != None )
		{
			if( Pawn.Weapon!=None )
			{
				Pawn.Weapon.Fire();
				if (Role == ROLE_Authority && Pawn.Weapon != None ) //NOTE (mdf): call to Fire can clear Pawn.Weapon if "firing" deployable inventory
				{
					Pawn.Weapon.bPointing = true;
				}
			}
		}
	}
	else
	{
		LeanEnd();
	}
}

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

exec function AltFire()
{
	if ( Level.Pauser == PlayerReplicationInfo )
	{
		SetPause(False);
		return;
	}

	if( !InLeanMode() )
	{
		if( Pawn != None )
		{
			if( Pawn.Weapon!=None )
			{
				Pawn.Weapon.AltFire();	
				if (Pawn.Weapon!=None && Role == ROLE_Authority)
				{
					Pawn.Weapon.bPointing = true;
				}
			}
		}
	}
	else
	{
		LeanEnd();
	}
}

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

exec function Reload()
{
//DM( Self$".Reload()" );
	if( Level.NetMode == NM_Client )
	{
		ServerReload();
	}

	if( U2Weapon(Pawn.Weapon) != None )
	{
		U2Weapon(Pawn.Weapon).Reload();
	}
}

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

function ServerReload()
{
//DM( Self$".ServerReload()" );
	Reload();
}

//-----------------------------------------------------------------------------
/*NEW(arl): removed
exec function ToggleWeaponKick()
{
	bWeaponKickDisabled = !bWeaponKickDisabled;
}

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

simulated function ClientWeaponKick( bool bAlt )
{
	if( bWeaponKickDisabled )
		return;

	// don't assert in multiplayer (Weapon is not always replicated in time)
	if( Level.NetMode != NM_Standalone && U2Weapon(Pawn.Weapon) == None )
		return;

	assert( U2Weapon(Pawn.Weapon) != None );
	if( U2Weapon(Pawn.Weapon).WeaponKickDirection != vect(0,0,0) && ( !bAlt || U2Weapon(Pawn.Weapon).AltWeaponKickDirection != vect(0,0,0) ) )
	{
		bWeaponKicking = true;
		bAltWeaponKick = bAlt;
		LastWeaponKickTime = Level.TimeSeconds;
	}
}
*/
//-----------------------------------------------------------------------------

function CalcFirstPersonView( out vector CameraLocation, out rotator CameraRotation )
{
	//local vector CameraOffsetVector;
	//local U2Weapon W;
	//local float DeltaTime;
	//local vector WeaponKickDirection;
	//local float WeaponKickDuration;
	//local float WeaponKickRecoveryDuration;
	//local vector ViewDirection;
	local Actor HitActor;
	local vector CheckLocation, HitLocation, HitNormal;
	local float DeltaLen;
	local vector AddedOffset;

	Super.CalcFirstPersonView( CameraLocation, CameraRotation );

/* It throws off the aim....ask people whether they really want this?
	ViewDirection = vector(CameraRotation);
	ViewDirection.Z = 0;
	if (Pawn != None)
		CameraLocation -= ViewDirection*Pawn.CollisionRadius;
*/
	
	/*MJL/!!mdf tbd
	if( Stance == ST_Prone )
	{
		CameraRotation = ViewRotation;

		CameraLocation = Pawn.Location;
		CameraLocation.Z += EyeHeight;
		CameraLocation += WalkBob; // !!mdf-tbd: bob less when prone?

		// when prone put camera closer to where head is
		// !!mdf/arl-tbd: this borks aiming (aims high)
		CameraOffsetVector = vector(Rotation);
		CameraOffsetVector.Z = 0;
		CameraLocation += Pawn.CollisionRadius*CameraOffsetVector;

		// note: above calculation doesn't take mesh alignment into account so sometimes
		// the camera will be floating above where head really is. Eventually switch to
		// using head bone location? !!cdh (mdf) tbd:
	}
	else
	{
		Super.CalcFirstPersonView( CameraLocation, CameraRotation );
	}
	*/

	if( LeanDir != Lean_None || LeanOffset != vect(0,0,0) )
	{
		SetDesiredLeanOffset();

		if( LeanOffset != DesiredLeanOffset )
		{
			DeltaLen = (Level.TimeSeconds - LastLeaningCheck) * LeanRate;
			if( LeanDir != Lean_None )
			{
				LeanOffset += DeltaLen*Normal( DesiredLeanOffset ) ;
				if( VSize(LeanOffset) >= VSize(DesiredLeanOffset) )
					LeanOffset = DesiredLeanOffset;
			}
			else
			{
				if( VSize(LeanOffset) <= DeltaLen )
					LeanOffset = vect(0,0,0);
				else
					LeanOffset -= DeltaLen*Normal( LeanOffset );
			}
	
			LastLeaningCheck = Level.TimeSeconds;
		}

		if( LeanOffset != vect(0,0,0) )
		{
			// make sure LeanOffset doesn't put camera into geometry
			CheckLocation = CameraLocation;
			
			HitActor = Pawn.Trace( HitLocation, HitNormal, CheckLocation + LeanOffset + LeanTraceFudge*Normal( LeanOffset ), CheckLocation, true );
			//if( HitActor != None )
			//	DMTNS( "hit middle: " $ HitActor );
							
			if( HitActor == None )
			{
				// try from front
				CheckLocation = CameraLocation + 0.5*LeanTraceFudge * vector(Pawn.Rotation);
				HitActor = Pawn.Trace( HitLocation, HitNormal, CheckLocation + LeanOffset + LeanTraceFudge*Normal( LeanOffset ), CheckLocation, true );
				//if( HitActor != None )
				//	DMTNS( "hit front: " $ HitActor );
			}

			if( HitActor == None )
			{
				// try from front
				CheckLocation = CameraLocation + 0.5*LeanTraceFudge * vector(Pawn.Rotation);
				HitActor = Pawn.Trace( HitLocation, HitNormal, CheckLocation + LeanOffset + LeanTraceFudge*Normal( LeanOffset ), CheckLocation, true );
				//if( HitActor != None )
				//	DMTNS( "hit front: " $ HitActor );
			}

			if( HitActor != None )
			{
				//#debug AddArrow( CheckLocation, HitLocation );
				//AddCylinder( HitLocation, 4, 4, ColorOrange() );
				//AddedOffset = HitLocation - CheckLocation - LeanTraceFudge*Normal( LeanOffset );
				//AddedOffset = LeanOffset - (VSize( HitLocation - CheckLocation ) + LeanTraceFudge) * Normal( LeanOffset );
				AddedOffset = (VSize( HitLocation - CheckLocation ) - LeanTraceFudge) * Normal( LeanOffset );
				//AddCylinder( CameraLocation + AddedOffset, 4, 4, ColorGreen() );
			}
			else
			{
				AddedOffset = LeanOffset;
			}

			// add any offset to normal camera location
			CameraLocation += AddedOffset;

			// for left/right lean change camera roll
			if( LastLeanDir == Lean_Left )
				CameraRotation.Roll -= VSize(AddedOffset)/48.0*2048.0;
			else if( LastLeanDir == Lean_Right )
				CameraRotation.Roll += VSize(AddedOffset)/48.0*2048.0;
		}
	}
/*NEW(arl): removed
	// adjust camera position for weapon kick and recovery
	if( bWeaponKicking || WeaponKickPercent != 0.0 )
	{
		DeltaTime = Level.TimeSeconds - LastWeaponKickTime;
		LastWeaponKickTime = Level.TimeSeconds;

		W = U2Weapon(Pawn.Weapon);
		if( W != None )
		{
			if( bAltWeaponKick )
			{
				WeaponKickDirection = W.AltWeaponKickDirection;
				WeaponKickDuration = W.AltWeaponKickDuration;
				WeaponKickRecoveryDuration = W.AltWeaponKickRecoveryDuration;
			}
			else
			{
				WeaponKickDirection = W.WeaponKickDirection;
				WeaponKickDuration = W.WeaponKickDuration;
				WeaponKickRecoveryDuration = W.WeaponKickRecoveryDuration;
			}
		}
		else
		{
			WeaponKickDirection = class'U2Weapon'.default.WeaponKickDirection;
			WeaponKickDuration = class'U2Weapon'.default.WeaponKickDuration;
			WeaponKickRecoveryDuration = class'U2Weapon'.default.WeaponKickRecoveryDuration;
		}
		if( bWeaponKicking )
		{
			WeaponKickPercent += DeltaTime / WeaponKickDuration;
			if( WeaponKickPercent > 1.0 )
			{
				WeaponKickPercent = 1.0;
				bWeaponKicking = false;
			}
		}
		else
		{
			WeaponKickPercent -= DeltaTime / WeaponKickRecoveryDuration;
			if( WeaponKickPercent < 0.0 )
			{
				WeaponKickPercent = 0.0;
			}
		}
		WeaponKickOffset = WeaponKickPercent * WeaponKickDirection >> Pawn.GetViewRotation();

		//MJL/!!mdf-tbd
		//if( Stance == ST_Prone )
		//{
		//	WeaponKickOffset *= ProneWeaponKickRatio;
		//}

		CameraLocation += WeaponKickOffset;
	}
*/
}

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

function bool ViewingSelf()
{
	return ( ViewTarget == Self || ViewTarget == Pawn );
}

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

simulated function bool ThirdPerson()
{
	return bBehindView;
}

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

function SetViewTarget( Actor NewViewTarget )
{
	Super.SetViewTarget( NewViewTarget );

	if( !ViewingSelf() )
	{
		if( InLeanMode() )
			LeanEnd();
	}
}

//-----------------------------------------------------------------------------
// If ViewTarget is a Controller use Pawn's Location if possible.

event PlayerCalcView( out Actor ViewActor, out vector CameraLocation, out rotator CameraRotation )
{
	local Actor OldViewTarget;

	OldViewTarget = ViewTarget;
	if( Controller(ViewTarget) != None && Controller(ViewTarget).Pawn != None )
		SetViewTarget( Controller(ViewTarget).Pawn );

	Super.PlayerCalcView( ViewActor, CameraLocation, CameraRotation );

	SetViewTarget( OldViewTarget );
}

//-----------------------------------------------------------------------------
// MAIN U2PLAYERCONTROLLER CODE
//-----------------------------------------------------------------------------

event /*probe*/ PlayerTick( float DeltaTime )
{
	local vector CameraLocation;
	local rotator CameraRotation;
	local Actor HitActor;
	local vector HitLocation, HitNormal;
	local float ClipPct;
	
	if( Pawn != None )
	{
		PlayerCalcView( HitActor, CameraLocation, CameraRotation );

		HitActor = Pawn.Trace( HitLocation, HitNormal, CameraLocation + class'U2UseManagerPlayer'.default.UseDistance*vector(CameraRotation), CameraLocation, true, vect(0,0,0), /*material*/, TRACE_AllColliding | TRACE_Usable );
		class'U2UseManagerPlayer'.static.LookingAt( U2P, HitActor );

		if( Pawn.Weapon != None )
		{
			ClipPct = GetAmmoClipPct();
			if( ClipPct<0.5 )
			{
				AmmoFlashTime -= DeltaTime;
				if( AmmoFlashTime <= 0 )
				{
					class'UIConsole'.static.SendEvent("ClipFlash");
					AmmoFlashTime = Blend( 0.25, 4.0, ClipPct );
				}
			}
		}
	}

	Super.PlayerTick( DeltaTime );
}

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

function UnPossessMatinee()
{
	if (U2Weapon(Pawn.Weapon)?) 
		U2Weapon(Pawn.Weapon).NotifyCutsceneBegin();

	Super.UnPossessMatinee();
}

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

simulated event RenderOverlays( Canvas Canvas )
{
	class'U2UseManagerPlayer'.static.RenderOverlaysStatic( U2P, Canvas );
	Super.RenderOverlays( Canvas );
}

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

exec function Use()
{
	class'U2UseManagerPlayer'.static.UseTarget( U2P );
}

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

exec function Unuse()
{
	class'U2UseManagerPlayer'.static.UnuseTarget( U2P );
}

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

exec function ActivateInventoryItem( class InvItem )
{
	local U2Inventory Inv;

	Inv = U2Inventory(Pawn.FindInventoryType(InvItem));
	if ( Inv != None && Inv.bActivatable )
		Inv.Activate( false );
}

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

exec function DeactivateInventoryItem( class InvItem )
{
	local U2Inventory Inv;

	Inv = U2Inventory(Pawn.FindInventoryType(InvItem));
	if ( Inv != None && Inv.bActivatable )
		Inv.Deactivate();
}

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

function EnableProne()
{
	SetDuckFlag( 2 );
}

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

function bool CanDodge()
{
	return ( Pawn != None && Pawn.Health > 0 && Pawn.IsStanding() && Pawn.Physics == PHYS_Walking );
}	

//-----------------------------------------------------------------------------
// Leaning
//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------
// Return true if any of the keys used for selecting the lean direction are 
// currently being pressed.

function bool PressingAnyLeanKey()
{
	return ( aForward != 0	|| aStrafe != 0	|| aStrafe != 0	|| aUp != 0 );
}

//-----------------------------------------------------------------------------
// Return true if key used to select lean direction was released

function bool PressingSelectedLeanKey()
{
	return ( (LeanDir == Lean_Forward && aForward > 0)	||
			 (LeanDir == Lean_Left    && aStrafe < 0)	||
			 (LeanDir == Lean_Right   && aStrafe > 0)	||
			 (LeanDir == Lean_Up      && aUp > 0) );
}

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

function bool LeanTransition()
{
	if( bWantsToLean )
	{
		if( bReleaseLeanKeys )
			bReleaseLeanKeys = PressingAnyLeanKey();

		if( !bReleaseLeanKeys )
		{
			if( aForward > 0 )
				ToggleLeanForward();
			else if( aStrafe < 0 )
				ToggleLeanLeft();
			else if( aStrafe > 0 )
				ToggleLeanRight();
			else if( aUp > 0 )
				ToggleLeanUp();
		}
	}
	else if( bReleaseLeanKeys )
	{
		bReleaseLeanKeys = PressingSelectedLeanKey();
	}

	// disable normal movement if lean direction selected and selected key still pressed
	return ( LeanDir != Lean_None && bReleaseLeanKeys );
}

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

function ELeanDir GetLeanDir()	{ return LeanDir; }

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

function vector GetLeanLeftRightVector()
{
	local vector LeanVector;

	LeanVector = vector(Pawn.Rotation);
	LeanVector.Z = 0;
	LeanVector = Normal( LeanVector cross vect(0,0,1) );

	return LeanVector;
}

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

function SetDesiredLeanOffset()
{
	switch( LeanDir )
	{
	case Lean_Forward:
		// shift camera forward
		DesiredLeanOffset = vector(Pawn.Rotation);
		DesiredLeanOffset.Z = 0.0;
		DesiredLeanOffset = 32.0*Normal( DesiredLeanOffset );
		break;
	case Lean_Left:
		// shift camera left and slightly down
		DesiredLeanOffset = 48.0*GetLeanLeftRightVector();
		DesiredLeanOffset.Z = -16.0;
		break;
	case Lean_Right:	
		// shift camera right and slightly down
		DesiredLeanOffset = -48.0*GetLeanLeftRightVector();
		DesiredLeanOffset.Z = -16.0;
		break;
	case Lean_Up:
		// shift camera slightly up
		DesiredLeanOffset = vect(0,0,32);
		break;
	default:
		DesiredLeanOffset = vect(0,0,0);
	}
}

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

function ClearWeaponEffects()
{
	if( Pawn != None && Pawn.Weapon != None )
		Pawn.Weapon.ClearWeaponEffects();
}

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

function float GetWalkingPctScale()
{
	if( InLeanMode() )
		return LeanWalkingPctScale;
	else
		return 1.0 / U2GameInfo(Level.Game).SpeedRatio;
}

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

function bool CanLean()
{
	//!!SBB (mdf) replace with a "can't lean now" sound (or use a generic "fail" 
	// sound for this and other situations such as not being able to go prone
	// because there is no room for the new collision size).
	DM( "can't lean now" );
	return false;
}

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

function bool InLeanMode()
{
	return( bWantsToLean || LeanDir != Lean_None || LeanOffset != vect(0,0,0) );
}

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

function LeanBegin( ELeanDir NewLeanDir )
{
	LastLeaningCheck = Level.TimeSeconds;
	bWantsToLean = false;
	bReleaseLeanKeys = true; // need to release selected lean key to be able to move again
	LeanDir = NewLeanDir;
	LastLeanDir = NewLeanDir;
	if( LPawn != None )
	    LPawn.UpdateWalkingPct();

	// clear again so selected lean mode crosshair shown
	ClearWeaponEffects();
}

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

function LeanReset()
{
	// restore usual camera position
	DesiredLeanOffset = vect(0,0,0);
	LastLeaningCheck = Level.TimeSeconds;
	LeanDir = Lean_None;
	bWantsToLean = false;
 	bReleaseLeanKeys = false;	// player needs to release lean keys before leaning direction can be set
	if( LPawn != None )
		LPawn.UpdateWalkingPct();
}

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

function LeanEnd()
{
	LeanReset();

	// clear so weapon crosshair restored
	ClearWeaponEffects();

	bFire = 0;
	bAltFire = 0;
}

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

function ToggleLeanForward()
{
	if( LeanDir != Lean_None )
		LeanEnd();
	else if( CanLean() )
		LeanBegin( Lean_Forward );
}

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

function ToggleLeanLeft()
{
	if( LeanDir != Lean_None )
		LeanEnd();
	else if( CanLean() )
		LeanBegin( Lean_Left );
}

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

function ToggleLeanRight()
{
	if( LeanDir != Lean_None )
		LeanEnd();
	else if( CanLean() )
		LeanBegin( Lean_Right );
}

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

function ToggleLeanUp()
{
	if( LeanDir != Lean_None )
		LeanEnd();
	else if( CanLean() )
		LeanBegin( Lean_Up );
}

//-----------------------------------------------------------------------------
// Weapon checks this to determine whether its own crosshair should be used.

function bool HandlingCrosshair()
{
	return InLeanMode();
}

//-----------------------------------------------------------------------------
// misc
//-----------------------------------------------------------------------------

function HandleWalking()
{
	if( Pawn != None )
	{
		//NOTE: checking bDuck isn't enough since player might not have this set (not
		//holding duck key) but might be in an area where he is unable to stand up.
		Pawn.SetWalking( (LeanDir != Lean_None || GetRunFlag() > 0 || GetDuckFlag() > 0 || !Pawn.IsStanding() ) && WarpZoneInfo(Pawn.Region.Zone) == None ); 
	}
}

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

exec function Taunt( name Sequence )
{
	// !!mdf-tbd: don't allow taunting if player is moving -- prevents key binding cheats
	if( Pawn.Acceleration == vect(0,0,0) )
	{
		/* SERVOTBD */
		// cdh/arl-tbd: how to support choice of named gestures/taunts (wave, grab crotch, flip etc.)
		// on UI and map these to specific animations -- seems like we'll need some way to tag animations
		// as was done using GROUP=previously?
		// allowing any animation could be fun
		if( Pawn != None && Pawn.Health > 0 )
		{
			ServerTaunt( Sequence );
			Pawn.PlayAnim( Sequence, 0.7, 0.2 );
		}
	}
}

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

function ServerTaunt( name Sequence )
{
	Pawn.PlayAnim(Sequence, 0.7, 0.2);
}

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

exec function AddBots( optional int N )
{
	if( N == 0 )
		N = 1;

	ServerAddBots( N );
}

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

function ServerAddBots( int N )
{
	local int i;

	//!!mdf-tbd (stevep's comment) FIXME - should only work for standalone games!!!
	if( U2GameInfo(Level.Game) != None )
	{
		for ( i=0; i<N; i++ )
			U2GameInfo(Level.Game).ForceAddBot();
	}
}

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

function NotifyTakeHit( Pawn InstigatedBy, vector HitLocation, int Damage, class<DamageType> DamageType, vector Momentum )
{
	local bool bServerGuessWeapon;
	local int iDam;
	local float rnd;

/*ARL: removed
	if( Damage > 1 )
	{
		rnd = FClamp(Damage, 20, 60);
		ClientFlash(DamageType.Default.FlashScale*rnd,DamageType.Default.FlashFog*rnd);
	}
*/
	//ARL (mdf) -- shouldn't shake view when drowning? other?
	if( DamageType != class'DamageTypeDrowned' && Damage > 0 )
		ShakeView(Damage);
//	ShakeView(0.15 + 0.005 * Damage, Damage * 30, Damage * vect(0,0,0.03), 120000, vect(1,1,1), 0.2); 
	bServerGuessWeapon = ( ((Pawn.Weapon != None) && Pawn.Weapon.bPointing) || Pawn.JumpInProgress() );
	iDam = Clamp(Damage,0,200);
	ClientPlayTakeHit( HitLocation - Pawn.Location, iDam, DamageType, bServerGuessWeapon ); 

	if( !bServerGuessWeapon && (Level.NetMode == NM_DedicatedServer || Level.NetMode == NM_ListenServer) )
	{
		//servo-tbd: Enable( AnimEndEvent );

		// !!mdf-tbd: would bork eye height if prone/crouched
		//Pawn.BaseEyeHeight = Pawn.default.BaseEyeHeight;
		Pawn.PlayTakeHit( HitLocation, Damage, DamageType );
	}
}

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

function ClientPlayTakeHit( vector HitLocation, byte Damage, class<DamageType> DamageType, bool bServerGuessWeapon )
{
	HitLocation += Pawn.Location;
	if ( bServerGuessWeapon && (Pawn.JumpInProgress() || ((Pawn.Weapon != None) && Pawn.Weapon.bPointing)) )
		return;

	//servo-tbd: Enable( AnimEndEvent );
	// !!mdf-tbd: would bork eye height if prone/crouched
	//Pawn.BaseEyeHeight = Pawn.Default.BaseEyeHeight;
	Pawn.PlayTakeHit( HitLocation, Damage, DamageType );
}
	
//-----------------------------------------------------------------------------

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

	ConsoleString = S;
	if( PRI != None && ((Type == 'Say') || (Type == 'TeamSay')) )
		ConsoleString = PRI.PlayerName$": "$ConsoleString;

	if( Player != None && Player.Console != None )
		Player.Console.Message( ConsoleString, 6.0 );


	//TBI
}

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

function PlayWinMessage(bool bWinner)
{
	local Sound Announcement;

	if ( bWinner )
		Announcement = Sound(DynamicLoadObject("Announcer.Winner", class'Sound'));
	else
		Announcement = Sound(DynamicLoadObject("Announcer.LostMatch", class'Sound'));

	ClientPlaySound(Announcement, true);
}

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

function bool SaveEnabled()
{
	return ( Pawn != None && Pawn.Health > 0 && Level.NetMode == NM_Standalone );
}

exec function QuickSave()
{
	if ( SaveEnabled() && Level.Pauser == None )
		class'UIConsole'.static.SendEvent("QuickSave");
}

exec function QuickLoad()
{
	if ( Level.NetMode == NM_Standalone && Level.Pauser == None && !Player.Console.bNoDrawWorld )
		class'UIConsole'.static.SendEvent("QuickLoad");
}

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

exec function ClearProgressMessages()
{
//	class'UIConsole'.static.ClearProgressMessages(self);
	Super.ClearProgressMessages();
}

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

event bool EncroachingOn( actor Other )
{
	if ( GameReplicationInfo.bTeamGame && Pawn(Other) != None )
	{
		if ( (Role == ROLE_Authority) && Level.Game.bWaitingToStartMatch )
			return Super.EncroachingOn(Other);
		else
			return true;
	}
	return Super.EncroachingOn(Other);
}

//-----------------------------------------------------------------------------
/*!!CDH/MJL
function ClientReplicateSkins(texture Skin1, optional texture Skin2, optional texture Skin3, optional texture Skin4)
{
	local class<Actor> C;

	// do nothing (just loading other player skins onto client)
	log("Getting "$Skin1$", "$Skin2$", "$Skin3$", "$Skin4);
}
*/

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

/*
//MWP:	 
function TimeMessage(int Num)
{
	if ( TimeMessageClass == None )
		TimeMessageClass = class<CriticalEventPlus>(DynamicLoadObject("GamePlay.TimeMessage", class'Class'));
	ReceiveLocalizedMessage( TimeMessageClass, 16 - Num );
}

function SetVoice(class<ChallengeVoicePack> V)
{
	PlayerReplicationInfo.VoiceType = V;
	UpdateURL("Voice", string(V), True);
	ServerSetVoice(V);
}

function ServerSetVoice(class<ChallengeVoicePack> V)
{
	PlayerReplicationInfo.VoiceType = V;
}
*/

function ServerSetTaunt(bool B)
{
	bAutoTaunt = B;
}

function SetAutoTaunt(bool B)
{
	bAutoTaunt = B;
	ServerSetTaunt(B);
}

function ServerSetInstantRocket(bool B)
{
	bInstantRocket = B;
}

function bool GetInstantRocket()
{
	return bInstantRocket;
}

exec function SetInstantRocket(bool B)
{
	bInstantRocket = B;
	ServerSetInstantRocket(B);
}

/*
function ChangeSetHand( string S )
{
	Super.ChangeSetHand(S);
	if ( Handedness == -1 )
		LoadLeftHand();
}
*/
function LoadLeftHand()
{
	local mesh M;

	// load left handed weapon meshes
	M = mesh(DynamicLoadObject("Weapons.PulseGunL", class'Mesh'));
	M = mesh(DynamicLoadObject("Weapons.Rifle2mL", class'Mesh'));
	M = mesh(DynamicLoadObject("Weapons.EightML", class'Mesh'));
	M = mesh(DynamicLoadObject("Weapons.Minigun2L", class'Mesh'));
}

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

event PostBeginPlay()
{
	Super.PostBeginPlay();

	if( U2GameInfo(Level.Game).DefaultFOV != 0.0 )
		DesiredFOV = U2GameInfo(Level.Game).DefaultFOV;
}

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

function Possess( Pawn P )
{
	U2P = U2Pawn( P );
	Super.Possess( P );

/*
	if ( Handedness == -1 )
		LoadLeftHand();

	if ( Level.Netmode == NM_Client )
	{
		ServerSetTaunt(bAutoTaunt);
		ServerSetInstantRocket(bInstantRocket);
	}
*/
}

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

function ClientVoiceMessage(PlayerReplicationInfo Sender, PlayerReplicationInfo Recipient, name messagetype, byte messageID)
{
	if ( bNoVoiceMessages )
		return;
	if ( bNoVoiceTaunts && ((messageType == 'TAUNT') || (messageType == 'AUTOTAUNT')) )
		return;
	if ( bNoAutoTaunts && (messageType == 'AUTOTAUNT') )
		return;

	Super.ClientVoiceMessage(Sender, Recipient, messagetype, messageID);
}

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

function SendMessage(PlayerReplicationInfo Recipient, name MessageType, byte MessageID, float Wait, name BroadcastType)
{
	if ( Level.TimeSeconds - OldMessageTime < 10 )
		return;

	SendVoiceMessage(PlayerReplicationInfo, Recipient, MessageType, MessageID, BroadcastType);
}

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

exec function Loaded()
{
	local inventory Inv;
	local weapon Weap;

	if( !OKToCheat() )
		return;

	if( Level.Netmode!=NM_Standalone )
		return;

	Pawn.GiveWeapon("Weapons.PulseWeapon");
	Pawn.GiveWeapon("Weapons.ShockWeapon");
	Pawn.GiveWeapon("Weapons.FlakCannon");
	Pawn.GiveWeapon("Weapons.Minigun");
	Pawn.GiveWeapon("Weapons.Rifle");
	Pawn.GiveWeapon("Weapons.Eightball");
	
	for ( inv=Pawn.inventory; inv!=None; inv=inv.inventory )
	{
		weap = Weapon(inv);
		if ( (weap != None) && (weap.AmmoType != None) )
			weap.AmmoType.AmmoAmount = weap.AmmoType.MaxAmmo;
	}
}

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

function CheckBob(float DeltaTime, float Speed2D, vector Y)
{
	local float OldBobTime;
	local int m,n;

	OldBobTime = BobTime;
	Super.CheckBob(DeltaTime,Speed2D,Y);

	if ( bBehindView || (Speed2D < 10) )
		return;

	m = int(0.5 * Pi + 9.0 * OldBobTime/Pi);
	n = int(0.5 * Pi + 9.0 * BobTime/Pi);
}

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

function bool TurnTowardNearestEnemy()
{
	local Pawn P;
	local Controller C;
	local vector LookDir, EnemyDir, Look;
	local float BestVal, NewVal;
	local rotator GoalRot;
	local float MinVal, MaxVal;

	// NOTE (mdf) this is basically a built-in aimbot. Presumably this was done
	// to help with aiming on consoles but I'm guessing we'll want to make sure 
	// this is disabled for multiplayer games?

	MinVal = 0.93;
	MaxVal = 0.995;

	Look = Pawn.Location + Pawn.Eyeheight * vect(0,0,1);
	LookDir = vector(Rotation);
	if ( (TurnTarget == None) || (TurnTarget.Health <= 0) )
		TurnTarget = None;
	else
	{
		NewVal = LookDir dot Normal(LastAutoAimLocation - Look);
		if ( NewVal > MaxVal )
		{
			TurnTarget = None;
			return false;
		}
		if ( FastTrace(TurnTarget.Location, Look) )
			LastAutoAimLocation = TurnTarget.Location;
		else if ( NewVal > MinVal )
			TurnTarget = None;
	}

	if ( TurnTarget == None )
	{
		BestVal = -2;
		if ( Level.NetMode == NM_Client )
		{
			foreach DynamicActors(class'Pawn',P)
				if ( P.IsPlayerPawn() && (P.Controller != self) && (P.Health > 0) && (P.Visibility > 0) 
					&& (!GameReplicationInfo.bTeamGame || (P.PlayerReplicationInfo.Team != PlayerReplicationInfo.Team)) )
				{
					NewVal = LookDir dot Normal(P.Location - Look);
					if ( (NewVal > MinVal) && (VSize(P.Location - Look) < 2600) && FastTrace(P.Location, Look) )
						return false;	// already close enough
					if ( (NewVal > BestVal) && FastTrace(P.Location, Look) )
					{
						BestVal = NewVal;
						TurnTarget = P;
					}
				}
		}
		else
		{
			for ( C=Level.ControllerList; C!=None; C=C.NextController )
				if ( C.bIsPlayer && (C != self) && (C.Pawn != None) && (C.Pawn.Visibility > 0) 
					&& (!GameReplicationInfo.bTeamGame || (P.PlayerReplicationInfo.Team != PlayerReplicationInfo.Team)) )
				{
					NewVal = LookDir dot Normal(C.Pawn.Location - Look);
					if ( (NewVal > MinVal) && FastTrace(C.Pawn.Location, Look) )
						return false;	// already close enough
					else if ( (NewVal > BestVal) && FastTrace(C.Pawn.Location, Look) )
					{
						BestVal = NewVal;
						TurnTarget = C.Pawn;
					}
				}
		}
		if ( TurnTarget == None )
			return false;
		LastAutoAimLocation = TurnTarget.Location;
	}

	// Rotate towards best, but with as little up/down as possible
	bRotateToDesired = true;
	DesiredRotation = Rotator(LastAutoAimLocation - Look);
	GroundPitch = GroundPitch & 65535;
	if ( (DesiredFOV == DefaultFOV)
		&& ((abs(DesiredRotation.Pitch - GroundPitch) < 12000) 
			|| (abs(DesiredRotation.Pitch - GroundPitch) > 53535)) )
		DesiredRotation.Pitch = GroundPitch;
		
	return true;
}

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

function PlayerEndLevel()
{
	GotoState( PlayerEndLevelImmediatelyState );
}

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

function LevelChange()
{
	GotoState( LevelTransitionState );
}

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

function SetMovementVars( vector NewAccel )
{
	//!!MJL (mdf) bForwardPressed = false;
	bUpPressed = false;
}

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

function Freeze()
{
	UnFreezeState = GetStateName();
	//UnFreezePhysics = Pawn.Physics;
	GotoState( CantMoveState );
}
function UnFreeze();

//-----------------------------------------------------------------------------
/*
exec function StartCinematic()
{
	GotoState( CinematicState );
}

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

exec function EndCinematic()
{
}
*/

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

function DialogInitiate( Actor Other, optional name Topic, optional Actor WaitingActor )
{
	if( Pawn != None )
		class'DialogEngine'.static.Initiate( Pawn, Other, Topic, WaitingActor );
}

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

function DialogTerminate()
{
	if( Pawn != None )
		class'DialogEngine'.static.NotifyDialogScriptedAbort( Pawn );
}

//-----------------------------------------------------------------------------
// STATE CODE
//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------
// while player is being impaled

state @ ImpaledState extends @ CantMoveState
{
	//-------------------------------------------------------------------------

	function PlayerMove( float DeltaTime )
	{
		ViewFlash( DeltaTime );
		ViewShake( DeltaTime );
		UpdateRotation( DeltaTime, 2 );
	}

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

	event BeginState()
	{
		Super.BeginState();
		bFreeCamera=true;
	}

} // ImpaledState

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

state @ CantMoveState
{
	//-------------------------------------------------------------------------

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

		if( bUpdatePosition )
			ClientUpdatePosition();

		PlayerMove( DeltaTime );
	}

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

	function PlayerMove( float DeltaTime )
	{
		local vector NewAccel;

		ViewFlash( DeltaTime );
		ViewShake( DeltaTime );

		// Update rotation.
		UpdateRotation( DeltaTime, 2 );

		// prevent movement		
		NewAccel = vect(0,0,0);

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

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

	function bool IsFrozen()		{ return true; }
	function Freeze();
	function UnFreeze()
	{
		//!!mdf -- why is this needed -- could bork AnimationController...
		//Pawn.SetPhysics( UnFreezePhysics );
		GotoState( UnFreezeState );
	}

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

	event BeginState()
	{
		Super.BeginState();

		//!!mdf -- why is this needed -- could bork AnimationController...
		//!!Pawn.SetPhysics( PHYS_None );
		//!!mdf and therefore, why is unfreezephysics needed above?
		bPressedJump = false;
		bRising = false;
		LeanEnd();
	}
}

//-----------------------------------------------------------------------------
// Impaled behavior

function NotifyImpaled()
{
	//!!mib-tbd could use a push / pop state here
	UnFreezeState = GetStateName();
	GotoState( ImpaledState );
}

function NotifyUnImpaled()
{
	GotoState( UnFreezeState );
}

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

state @ LandedHardState
{
	//-------------------------------------------------------------------------
	// can't move during hard landing
	
	function PlayerMove( float DeltaTime )
	{
		ViewFlash( DeltaTime );
		ViewShake( DeltaTime );
		
		// mdf-tbd: for singleplayer, allow looking around and firing during a 
		// hard landing? This will have animation issues with 3rd person views
		// which is why its not enabled for networked games.
		//if( Level.NetMode == NM_Standalone )
		//	UpdateRotation( DeltaTime, 2 );
	}
	
	//-------------------------------------------------------------------------

	function LandedHardDone()
	{
		GotoState( PlayerWalkingState );
	}
	
	//-------------------------------------------------------------------------
/*ARL: removed		
	event BeginState()
	{
		Super.BeginState();
		// NOTE: if applicable, damage handling code will also add its own flash
		ClientFlash( class'Fell'.default.FlashScale*20, class'Fell'.default.FlashFog*20 );
	}	
*/
} // LandedHardState

//-----------------------------------------------------------------------------
// state Mantling

state @ MantlingState
{
	ignores Fire, AltFire, PressingFire, PressingAltFire;

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

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

		if( bUpdatePosition )
			ClientUpdatePosition();

		PlayerMove( DeltaTime );

		// !!mdf-tbi: squash CC as model steps onto ledge
	}

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

	function bool CanCrouch()
	{
		return false;
	}
	
	//-------------------------------------------------------------------------
	
	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 NewAccel )
	{
		bUpPressed = (bJump != 0);
	}

	//-------------------------------------------------------------------------
		
	function PlayerMove( float DeltaTime )
	{
		local vector X, Y, Z, NewAccel;
		
		//NEW MJL: accel
		GetAxes( Pawn.Rotation, X, Y, Z );
		NewAccel = GetAccel( X, Y, Z);
		SetMovementVars( NewAccel );

		aLookup  *= 0.24;
		aTurn    *= 0.24;
		aUp		 *= 0.1;

		HandleMove( DeltaTime, NewAccel, DCLICK_None, Rot(0,0,0) );
	}

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

//	function PlayTakeHit( vector HitLocation, int Damage, , class<DamageType> DamageType )
//	{
//		if( IsAnimating() )
//		{
//			Global.PlayTakeHit( HitLoc, Damage, DamageType );
//		}
//	}

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

	event MantleEnd()
	{
		GotoState( PlayerWalkingState );
	}

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

	event BeginState()
	{
		U2Pawn(Pawn).AssetsHelperClass.static.HandleMantleBeginSound( U2Pawn(Pawn) );
		Pawn.AirSpeed = LPawn.MantleSpeed;
		Pawn.SetPhysics( PHYS_Flying );

		LeanEnd();

		// !!mdf-tbd: current animation is shifting within CC = bad
		LPawn.MantlingBegin();

		if( LPawn.MantleHeight < LPawn.MantleMaxStandingMantleHeight )
		{
			// !!CDH - need to be able to tween to a specified frame
			AnimFrame = 1.0 - (LPawn.MantleHeight / LPawn.MantleMaxStandingMantleHeight);
		}

		// !!mdf-tbd: doesn't look great IMO
		//if( Pawn.Weapon != None )
		//	Pawn.Weapon.PutDown();
	}

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

	event EndState()
	{
		Pawn.AirSpeed = Pawn.default.AirSpeed;
		LPawn.bMantling = false;

		// !!mdf-tbd: doesn't look great IMO
		//if( Pawn.Weapon != None )
		//	Pawn.Weapon.BringUp();
	}
} // MantlingState

//-----------------------------------------------------------------------------
// Allow firing only for the player in singleplayer games.

state @ PlayerClimbingState
{
	exec function Fire()
	{
		if( Level.NetMode == NM_Standalone )
			Global.Fire();
	}
	exec function AltFire()
	{
		if( Level.NetMode == NM_Standalone )
			Global.AltFire();
	}
	function bool CanLean()
	{
		return ( ViewingSelf() && Pawn.Physics == PHYS_Ladder );
	}
	function PlayerMove( float DeltaTime )
	{
		Super.PlayerMove( DeltaTime );
		
		if( VSize(Pawn.Location - LadderMoveLocation) > 64.0 )
		{
			U2Pawn(Pawn).PlayMovementSound();
			LadderMoveLocation = Pawn.Location;
		}
	}
	event BeginState()
	{
		Super.BeginState();
		LadderMoveLocation = Pawn.Location;
	}
} // PlayerClimbingState

//-----------------------------------------------------------------------------
// When ghosted, don't change eye height (don't call PlaySwimming which
// currently mucks with this).

state @ PlayerFlyingState
{
	ignores SeeEnemy, SeeFriend, SeeOther, SeeAlertFriend, HearNoise, NotifyBump, TakeDamage;

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

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

		GetAxes( Rotation, X, Y, Z );

		if ( bCheatFlying )
		{
			if( CheatFlyingSpeed ~= 0.0 )
				CheatFlyingSpeed = 1.0;

			Pawn.AirSpeed = CheatFlyingSpeed*Pawn.default.AirSpeed;
				
			aUp *= 2.0;
		}

		Pawn.Acceleration = (aForward*X + aStrafe*Y + aUp*vect(0,0,1));  
								   
		// !!mdf-tbr: for some reason moving down speed is 1/2x moving up speed (somewhere in engine?)
		if ( bCheatFlying && (Pawn.Acceleration == vect(0,0,0)) )
			Pawn.StopMovement( false, true );

		// 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) );
*/
	}

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

	event BeginState()
	{
		LeanEnd();
		Pawn.AdjustEyeHeight( LPawn.default.ProneEyeHeight );
		Pawn.SetPhysics( PHYS_Flying );
	}

	//-------------------------------------------------------------------------
	
	event EndState()
	{
		if( Pawn != None )
			Pawn.AirSpeed = Pawn.default.AirSpeed;
	}
} // PlayerFlyingState

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

state @ GameEndedState
{
	ignores SeeEnemy, SeeFriend, SeeOther, SeeAlertFriend, HearNoise, KilledBy, NotifyBump, NotifyHitWall, NotifyHeadVolumeChange, NotifyPhysicsVolumeChange, BeginFalling, TakeDamage;

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

	exec function Fire()
	{
		if( Role < ROLE_Authority )
			return;

		if( (Level.NetMode == NM_Standalone) && !bFrozen )
			ServerReStartGame();
	}

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

	event BeginState()
	{
		Super.BeginState();

		LeanEnd();
		Pawn.RestoreEyeHeight();
	}
} // GameEndedState

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

state @ LevelTransitionState
{
	ignores SeeEnemy, SeeFriend, SeeOther, SeeAlertFriend, HearNoise, KilledBy, NotifyBump; 
	ignores HitWall, NotifyHeadVolumeChange, NotifyPhysicsVolumeChange, BeginFalling, NotifyTakeHit, TakeDamage, Suicide;

	//-------------------------------------------------------------------------
	
	exec function ThrowWeapon();
	exec function Fire();
	exec function AltFire();
	function PlayerMove( float DeltaTime );

	//-------------------------------------------------------------------------
	
	event BeginState()
	{
		local Controller C;
		
		EndZoom();
		bFire = 0;
		bAltFire = 0;
		if ( Pawn != None )
		{
			Pawn.SimAnim.AnimRate = 0;
			Pawn.bPhysicsAnimUpdate = false;
			Pawn.StopAnimating();
			//Pawn.SetCollision( false, true, false );
			StopMovement( true, true );
			//Pawn.SetPhysics( PHYS_None );
			Pawn.bUpdateEyeHeight = false;
		}
		bFrozen = true;
		
		// disable NPCs
		for ( C=Level.ControllerList; C!=None; C=C.NextController )
		{
			if( C.Pawn != None && !C.IsRealPlayer() && C.Pawn.Health > 0 )
			{
				//!!mdf-tbd: is this ok?
				C.Pawn.bStasis = true;
				C.Pawn.SetPhysics( PHYS_None );
				C.bStasis = true;
				
				//C.Pawn.AnimRate = 0.0;
				//C.StopMovement( true, true );
				//C.Pawn.AmbientSound = None;
				//U2Pawn(C.Pawn).bServoEnabled = false;
				//AIController(C).DisableSenses( true );
				//C.RemoveAllTimers();
				//C.Pawn.RemoveAllTimers();
				//C.SetClassStatic( class'AIController', true );
				C.SetFrozen( true ); 
			}
		}
	}
}

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

state @ PlayerEndLevelImmediatelyState extends @ GameEndedState
{
	ignores TakeDamage;

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

	// !!mdf-tbd: any of this not needed?
	event BeginState()
	{
		// For now we "kill" the player, make him 
		// hidden, put him in the dying state and "press" the fire key in order to 
		// restart the player / bring up the load menu.
			
		Pawn.SetPhysics( Phys_None );
		StopMovement( true, false );
		Pawn.RestoreEyeHeight();
		Pawn.Health = 0;
		bFrozen = false;
	    Pawn.bHidden = true;
		bPressedJump = false;
	}

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

	event EndState()
	{
	}
} // PlayerEndLevelImmediatelyState

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

state @ BaseSpectatingState
{
	//-------------------------------------------------------------------------

	event BeginState()
	{
		Super.BeginState();
		LeanEnd();
	}
}

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

state @ DeadState
{
	ignores SeeEnemy, SeeFriend, SeeOther, SeeAlertFriend, HearNoise, KilledBy, SwitchWeapon;

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

	function HandleMissionFailed( Pawn ViewTarget );

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

	event BeginState()
	{
		if (!Player) return;	// level transition (not safe to play music, etc.)

		Super.BeginState();

		bFrozen = false;

		LeanEnd();
		ResetFOV();
		if( U2GameInfo(Level.Game) != None && U2GameInfo(Level.Game).bSinglePlayerMission )
		{
			SetLevelAction();

			class'MusicScriptEvent'.static.CallRoutine(Self,"dmFadeout");
			StopAllMusic( 1.0 );
			PlayMusic( DeathMusic[ Rand(DeathMusic.length) ], 0.0 );

			Level.TimeDilation = 0.2;
		}
	}

	/* (mdf) fix music not playing issue with some levels
	exec function RestartLevel()
	{
		class'MusicScriptEvent'.static.CallRoutine(Self,"","");		// Shutdown DirectMusic so we don't get double dmFadeouts.
		Super.RestartLevel();
	}
	*/
	
	//-------------------------------------------------------------------------

	event PlayerTick( float DeltaTime )
	{
		Super.PlayerTick( DeltaTime );
		Level.TimeDilation = FMin( Level.TimeDilation + (Level.TimeDilation * DeltaTime), 1.0 );
	}

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

	function SetLevelAction()
	{
		Level.LevelAction = LEVACT_GameOver;
		class'UIConsole'.static.SendEvent("EndGame");
	}
}

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

function HandleMissionFailed( Pawn ViewTarget  )  // derived from PawnDied() -- modified
{
	Unuse();

	//!!MWP (mdf) can't this happen if player died / gibbed sometime before mission failed?
	//assert( Pawn != None );
	if( U2P != None )
	{
		U2P.HandleMissionFailed();
		SetLocation( U2P.Location );
		U2P.UnPossessed();
	}
	
	SetViewTarget( ViewTarget ); // reset the view target set in UnPossessed()

	Pawn = None;
	PendingMover = None;
	GotoState( MissionFailedState );
}

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

state @ MissionFailedState extends @ DeadState
{
	ignores SeeEnemy, SeeFriend, SeeOther, SeeAlertFriend, HearNoise, KilledBy, SwitchWeapon;

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

	function SetLevelAction()
	{
		Level.LevelAction = LEVACT_MissionFailed;
		class'UIConsole'.static.SendEvent("EndGame");
	}
}

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

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

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

	function bool CanLean()
	{
		return ( ViewingSelf() && Pawn.Physics == PHYS_Swimming );
	}

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

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

		GetAxes( Rotation, X, Y, Z );

		//Pawn.Acceleration = (aForward*X + aStrafe*Y + aUp*vect(0,0,1));  
		//!!mdf-tbd: give up/down the same weight as forward/back (engine will maintain waterspeed)
		if( aUp > 0 )
			Pawn.Acceleration = (aForward*X + aStrafe*Y + vect(0,0,24000));  
		else if( aUp < 0 )
			Pawn.Acceleration = (aForward*X + aStrafe*Y - vect(0,0,24000));  
		else
			Pawn.Acceleration = (aForward*X + aStrafe*Y);
		/*								   
		!!mdf-tbr: not needed for swimming
		// !!mdf-tbr: for some reason moving down speed is 1/2x moving up speed (somewhere in engine?)
		if (  Pawn.Acceleration == vect(0,0,0) )
			Pawn.StopMovement( false, true );
		*/
		
		// 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) );
		*/
	}

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

	event BeginState()
	{
		Super.BeginState();
		Pawn.AdjustEyeHeight( 0.7*Pawn.default.BaseEyeHeight );
	}
} // PlayerSwimmingState

//-----------------------------------------------------------------------------
// Player movement.
// standing, walking, running, falling

state @ PlayerWalkingState
{
	ignores SeeEnemy, SeeFriend, SeeOther, SeeAlertFriend, HearNoise;

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

	function bool CanLean()
	{
		return ( ViewingSelf() && Pawn.Physics == PHYS_Walking );
	}

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

	event MantleBegin()
	{
		// MantleBegin still called if player almost mantled but was moving too fast
		if( LPawn.bMantling )
			GotoState( MantlingState );
		else
			U2Pawn(Pawn).AssetsHelperClass.static.HandleTakeHitSound( U2Pawn(Pawn), 0, class'DamageTypeImpact' ); // !!mdf-tbd: use a hurt sound?
	}

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

	event bool NotifyLanded( vector HitNormal )
	{
		if( Pawn.GetStance() == ST_Standing )
			Pawn.RestoreEyeHeight();

		if ( Global.NotifyLanded( HitNormal ) )
			return true;

		if( DoubleClickDir == DCLICK_Active )
		{
			DoubleClickDir = DCLICK_Done;
			PlayerInput.DoubleClickTimer = 0.0;
			Pawn.Velocity = 0.1*Pawn.Velocity;
		}
		else
			DoubleClickDir = DCLICK_None;

		return false;
	}

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

	function ProcessMove( float DeltaTime, vector NewAccel, eDoubleClickDir DoubleClickMove, rotator DeltaRot )
	{
		if( DoubleClickMove == DCLICK_Active && Pawn.Physics == PHYS_Falling )
			DoubleClickDir = DCLICK_Active;
		else if( DoubleClickMove != DCLICK_None && DoubleClickMove < DCLICK_Active )
		{
			if( U2Pawn(Pawn) != None && CanDodge() )
			{
				U2Pawn(Pawn).Dodge( DoubleClickMove, true );
				DoubleClickDir = DCLICK_Active;
			}
		}

		Super.ProcessMove( DeltaTime,NewAccel,DoubleClickMove,DeltaRot );
	}

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

	event BeginState()
	{
		Super.BeginState();
		Pawn.RestoreEyeHeight();
	}
} // PlayerWalkingState

//-----------------------------------------------------------------------------
// Spectator state for cutscenes
/*
state @ CinematicState
{
	ignores SeeEnemy, SeeFriend, SeeOther, SeeAlertFriend, HearNoise, KilledBy, NotifyBump, NotifyHitWall, NotifyHeadVolumeChange, NotifyPhysicsVolumeChange, BeginFalling, TakeDamage;

	event BeginState()
	{
		// Hide UI
		local UIConsole C;
		C = UIConsole(Player.Console);
		if( C != None )
			C.bHideUI = true;

		// Hide Player
		ConsoleCommand( "invisible 1" );
		Pawn.ClearReferencesTo();

		// Register key and mouse listeners - disabling all keyboard and mouse events
		// Intercept a key (space) to end cinematic
	}

	// Hide crosshair too
	function bool HandlingCrosshair()
	{
		return true;
	}

	exec function EndCinematic()
	{
		// Show UI
		local UIConsole C;
		C = UIConsole(Player.Console);
		if( C != None )
			C.bHideUI = false;

		// Show Player
		ConsoleCommand( "invisible 0" );

		// Trigger level change
		TriggerEvent( EndCinematicEvent, Self, None );

		// tbd: Return player to default state

		// Remove key and mouse listeners
	}

} // CinematicState
*/
//-----------------------------------------------------------------------------

defaultproperties
{
	bIgnoreNextWhenZoomed=true
	ProneWeaponKickRatio=0.500000
	UIAlpha=255
	AutoSaveIndex=22
     DeathMusic(0)="DEATH_1.ogg"
     DeathMusic(1)="DEATH_2.ogg"
     DeathMusic(2)="DEATH_3.ogg"
     DeathMusic(3)="DEATH_4.ogg"
     ExecManagerClasses(0)=Class'U2.CheatManager'
     ExecManagerClasses(1)=Class'U2.AdminManager'
     UseReticleOnEvents(0)="UseReticleText"
     UseReticleOnEvents(1)="UseReticleCorners"
     UseReticleOnEvents(2)="UseReticleTopBars"
     ProximityReticleOnEvents(0)="ProximityReticleCorners"
     ProximityReticleOnEvents(1)="ProximityReticleTopBars"
}