XIII.XIIIPlayerController

XIII
Class XIIIPlayerController

source: C:\XIII\XIII\Classes\XIIIPlayerController.uc

Core.Object
   |
   +--Engine.Actor
      |
      +--Engine.Controller
         |
         +--Engine.PlayerController
            |
            +--XIII.XIIIPlayerController

Direct Known Subclasses:XIIIMPPlayerController

class XIIIPlayerController
extends Engine.PlayerController

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

Variables
`Actor`	`CamView` Used for viewing through a cam.
`int`	`CamViewMode` time cumul
`HookPoint`	`ClimbHookPoint` HP to use when climbing up at top of the rope
`eDrawType`	`DT_mem` Used for viewing through a cam.
`vector`	`DoorClimbMove` Movement if climbing door to check the end of climb.
`vector`	`DoorLockedNormal` used for climbing doors
`vector`	`DoorLockedPos` used for climbing doors
`Actor`	`DoorToClimb` Door that is climbed
`ForceFeedbackController`	`FFController` For ForceFeedBack controls
`color`	`FilterColor` La couleur courante.
`float`	`FilterColorSpeed` La vitesse de convergence.
`color`	`FilterColorWanted` La couleur vers laquelle le moteur doit converger.
`Hook`	`HookUsed` the hook used when in Hooked State
`XIIIPlayerInteraction`	`MyInteraction` used for climbing doors
`string`	`MyInteractionClass` because color.a is int & we need float
`vector`	`OldDoorClimbPos` used for climbing doors
`XIIIItems`	`OldItem` to memorize Item when climbing doors
`byte`	`OldWeap` to memorize weapon when switching weapons/items modes
`OnoFalling`	`OnoF` used for climbing doors
`float`	`SniperPitch` Used for the breath movement in sniping zoom.
`float`	`SniperYaw` Used for the breath movement in sniping zoom.
`string`	`StatsMem` the string that will be used to memorize stats on clients
`HookNavPoint`	`TargetHookClimb` HNP to climb to
`VideoPlayer`	`VP` Used to play videos
`float`	`VignetteAlpha` because color.a is int & we need float
`float`	`VignetteAlphaDecFactor` Used for flash SFXs (FlashBang
`float`	`VignetteFlashDecFactor` Used for flash SFXs (FlashBang)
`float`	`VignetteSFXduration` Used for flash SFXs (FlashBang
`XIIIPorte`	`aDoor` Door to be lockpicked
`bool`	`bAltZoomingSystem` Used to block weapon switch while climbing doors.
`bool`	`bCheckTurnSpeed` check turning speed
`bool`	`bCheckTurnSpeed` check turning speed
`bool`	`bFixedCrosshair` Player is hooked (to use it in walk/swim
`bool`	`bFloatingCrosshair` Player is hooked (to use it in walk/swim
`bool`	`bHooked` Player is hooked (to use it in walk/swim
`bool`	`bMenuIsActive` If true, no other display allowed
`bool`	`bOkForMoving` Used to wait for first rendered frame (first postrender called) to activate player movement (else will be able to move while init).
`bool`	`bPickingUp` Bool to validate the GameInfo HandlePickupQuery
`bool`	`bPressedDuck` Used to block weapon switch while climbing doors.
`bool`	`bRenderPortal` if true, then rotation will be assisted by a 'lock' when strafing around target (Halo-like)
`bool`	`bRotationAssist` if true, then rotation will be assisted by a 'lock' when strafing around target (Halo-like)
`bool`	`bTurnWanted` For 90/180 turns
`bool`	`bWaitForWeaponMode` true if waiting for a changedweapon order
`bool`	`bWeaponBlock` Used to block weapon switch while climbing doors.
`bool`	`bWeaponMode` true if weapons are active, false if items are active
`float`	`fCamViewPercent` time cumul
`float`	`fCrosshairSize` 0 = off, 1 = On on target, 2 = always on.
`float`	`fSniperPrecision` Used for the breath movement in sniping zoom.
`float`	`fTurnDeltaTime` time cumul
`float`	`fTurnDeltaTime` time cumul
`int`	`fTurnInc` store turning values (90/180/270/360/720
`float`	`fTurnSpeed[5]` store turning values (90/180/270/360/720
`float`	`fTurnSpeed[5]` store turning values (90/180/270/360/720
`float`	`fTyrolSpeed` For Tyrol Behaviour
`sound`	`hCLimbDoorSound` used for climbing doors
`sound`	`hCamViewBeginUseSound` used for climbing doors
`sound`	`hCamViewInUseSound` used for climbing doors
`sound`	`hEndClimbDoorSound` used for climbing doors
`sound`	`hEndClimbLadderSound` used for climbing doors
`sound`	`hTyrolEndSound` because color.a is int & we need float
`sound`	`hTyrolStartSound` because color.a is int & we need float
`int`	`iCrosshairMode` 0 = off, 1 = On on target, 2 = always on.
`int`	`iGameEndedRandEffect` used for climbing doors
`MultiViewport`	`multiViewport` time cumul
`rotator`	`rGameEndedCamRot` used for climbing doors
`vector`	`vGameEndedCamLoc` used for climbing doors
`vector`	`vSniperOffset` Used for the breath movement in sniping zoom.
`vector`	`vSniperOffsetSpeed` Used for the breath movement in sniping zoom.
`vTyrolEnd,`	`vTyrolDir` For Tyrol Behaviour
`vector`	`vWeaponFeedBack` to simulate weapon feed back while firing
`vector`	`vWeaponFeedBackReturn` to return to normal pos after firing
`XboxLiveManager`	`xboxlive` time cumul

States
Kicked, NoMove, NoRotation, WaitForFirstDisplay, NoControl, PlayingVideo, GameEndedSuccess, GameEndedFalling, GameEndedDrown, GameEndedDeath, GameEnded, ClimbToHookNavPoint, OldItem, OldItem, PlayerGunning, ClimbDoor, MayClimbDoor, CameraView, BossView, Tyroling, Hooked, PlayerSwimming, PlayerWalking, PlayerClimbing

Function Summary
`void`	`AAM(int i)` //_____________________________________________________________________________
`void`	`ActivateItem()` //_____________________________________________________________________________ // The player wants to active selected item
`rotator`	`AdjustAim(Ammunition FiredAmmunition, vector projStart, int AimCalcMode)` // ELR computes AimSpot and return rotator(AimSpot - projStart) //Simulated function rotator AdjustAim(float projSpeed, vector projStart, int aimerror, bool bLeadTarget, bool bWarnTarget, bool bTossed, bool bTrySplash) // AimCalcMode is used as 0 = weapon firing, 1 = interface aim anticipation
`void`	`AdjustView(float DeltaTime)` //_____________________________________________________________________________ // ELR made zooming speed higher
`bool`	`AllowHooking()` //_____________________________________________________________________________
`void`	`AltFire(optional float)` //_____________________________________________________________________________
`void`	`AutoPickup(bool b)` //_____________________________________________________________________________
`void`	`BehindView(Bool B)` //____________________________________________________________________________ // ELR Override this
`bool`	`CanUseLockPick()` //_____________________________________________________________________________ // ELR - Do we still pick the lock ? return true if no.
`void`	`CancelPickLock()` //_____________________________________________________________________________ // ELR - Do we still pick the lock ? return true if no.
`void`	`ChangeSkin(string NewSkinCode)` //_____________________________________________________________________________
`bool`	`CheckPickLock()` //_____________________________________________________________________________ // ELR - Do we still pick the lock ? return true if no.
`simulated`	`ClientAddDamageWarn(int RelativeHitLoc)` //____________________________________________________________________
`void`	`ClientGameEnded()` //_____________________________________________________________________________
`void`	`ClientRestart()` //_____________________________________________________________________________
`void`	`ClientSetBehindView(bool B)`
`void`	`ClientTargetHighLight(int Alpha, float TargetHighLight, float Duration)` //_____________________________________________________________________________
`void`	`CrosshairMode(int i)` //_____________________________________________________________________________ exec
`void`	`CrosshairSize(Float f)` //_____________________________________________________________________________
`void`	`DBInput(bool b)` //_____________________________________________________________________________ exec
`void`	`DBTurn()` //_____________________________________________________________________________ exec
`void`	`DetailLevel(int i)` //_____________________________________________________________________________
`void`	`DisplayDebug(Canvas C, out float, out float)` //_____________________________________________________________________________
`void`	`DoHideHUD(bool B)` //_____________________________________________________________________________
`void`	`Duck(optional float)` //_____________________________________________________________________________
`void`	`EnterStartState()` //_____________________________________________________________________________
`void`	`Fire(optional float)` //_____________________________________________________________________________ // The player wants to fire.
`void`	`FixCrosshairMode(int i)` //_____________________________________________________________________________ exec
`void`	`FloatCrosshairMode(int i)` //_____________________________________________________________________________ exec
`void`	`FlowerPower(int i)` //_____________________________________________________________________________
`void`	`ForceReload()` //_____________________________________________________________________________ // can't reload if have grabbed corpse/pawn
`void`	`GoClimbHookNavPoint(HookPoint HP, HookNavPoint HNP)` //_____________________________________________________________________________ // at top of a rope, climb up to the hooknavpoint
`void`	`GoHooking(Hook H)` //_____________________________________________________________________________ // ELR - Here we send the controller into hooked state
`void`	`GoTyroling(XIIITyrolNavPoint StartPoint, XIIITyrolNavPoint EndPoint, float TyrolSpeed)` //_____________________________________________________________________________ // Set up the tyroling params, called by TyrolTrigger
`void`	`GoreLevel(int i)` //_____________________________________________________________________________
`void`	`Grab()` //_____________________________________________________________________________
`void`	`HideWeapon()` //_____________________________________________________________________________ // ELR hide/unhide Weapon (Used by the DecoWeapon to hide weapon then put it back when used)
`void`	`ImBoss()` //_____________________________________________________________________________ exec
`void`	`Jump(optional float)` //_____________________________________________________________________________ // Normal gameplay execs // Type the name of the exec function at the console to execute it
`void`	`KillTarget(int i)` //_____________________________________________________________________________
`void`	`LogInteraction()` //_____________________________________________________________________________ exec
`void`	`LogInteractives()` //_____________________________________________________________________________ exec
`simulated`	`MatchStarting()` //_____________________________________________________________________________ // called when gameplay actually starts
`bool`	`NearWall(float walldist)` //_____________________________________________________________________________ // ELR
`void`	`NextWeapon()` //_____________________________________________________________________________
`void`	`PawnDied()` //_____________________________________________________________________________ // ::DBUG::
`void`	`PrevWeapon()` //_____________________________________________________________________________
`void`	`QuickHeal()` //_____________________________________________________________________________
`void`	`ReLoad()` //_____________________________________________________________________________ // ELR Use the ForceReload function of base weapons functions
`simulated`	`RenderScreenOverlays(Canvas C)` //_____________________________________________________________________________
`void`	`RestartLevel()` //_____________________________________________________________________________
`void`	`RestoreView()` //_____________________________________________________________________________
`Actor`	`ReturnTrace(out vector, out vector, vector End, vector Start, bool bActor, optional vector, optional out, optional int)` //_____________________________________________________________________________ // ::TODO:: put in native (may not optimize the trace but everytinh else & called each frame so...)
`void`	`RumbleFX(int FXNum)` //_____________________________________________________________________________ // Setup the ForceFeedbackController
`void`	`SearchPawn(XIIIPawn P)` //_____________________________________________________________________________
`void`	`SelectWeapon(byte F)` //_____________________________________________________________________________ // The player wants to switch to weapon group number F.
`void`	`ServerUpdateSkin(string NewSkinCode)` //_____________________________________________________________________________
`void`	`SetCamView(Actor C, optional float)` //_____________________________________________________________________________
`void`	`SetCamViewPortal(Actor C, optional float)`
`void`	`SetRumbleFX(bool B)` //_____________________________________________________________________________ // Setup the ForceFeedbackController
`void`	`SetZoomSystem(bool B)` //_____________________________________________________________________________ exec
`void`	`ShowInfo()`
`void`	`ShowMenu()` //_____________________________________________________________________________
`void`	`SpawnDefaultHUD()` //_____________________________________________________________________________ // SpawnDefaultHUD() // Spawn a HUD (make sure that PlayerController always has valid HUD, even if // ClientSetHUD() hasn't been called
`void`	`StatUpdate()` //_____________________________________________________________________________
`void`	`SwitchWeapon(byte F)` //_____________________________________________________________________________ // we want the player to switch to weapon group number F.
`simulated`	`SwitchWeaponMode()` //_____________________________________________________________________________ // ELR hide/unhide Weapon
`void`	`Teleport(name N)` //_____________________________________________________________________________ exec
`void`	`TeleportNext()` /* exec
`void`	`TestNI()` //_____________________________________________________________________________ exec
`bool`	`TryClimbDoor(Actor pDoorLocked, vector pDoorLockedPos, vector pDoorLockedNormal)` //_____________________________________________________________________________
`Powerups`	`TryInteractWithDoor(Actor A)` //_____________________________________________________________________________ // return the inventory object to be used to interact with A // should be used w/ Grab Controller function to automatically get the item out.
`Powerups`	`TryInteractWithTrigger(Actor A)` //_____________________________________________________________________________ // return the inventory object to be used to interact with A // should be used w/ Grab Controller function to automatically get the item out.
`bool`	`TryPickLock()` //_____________________________________________________________________________ // ELR - Here we define if the controller allow the use of a lockpick
`bool`	`TryTyroling()` //_____________________________________________________________________________ // ELR - check if we can send the controller into Tyrol state
`void`	`TurnAround()` //_____________________________________________________________________________ // ELR Added to make b180Left and b180Right working. // (Actually used as b90Left and b90Right :)
`void`	`UnFire(optional float)` //_____________________________________________________________________________ // The player Release fire.
`void`	`UpdateRotation(float DeltaTime, float maxPitch)` //_____________________________________________________________________________
`void`	`WeaponZoom()` //_____________________________________________________________________________
`void`	`cNextItem()` //_____________________________________________________________________________ // ELR Just to cancel it in some states
`void`	`cPrevItem()` //_____________________________________________________________________________ // ELR Just to cancel it in some states

State Kicked Function Summary
`void`	`PlayerMove(float DeltaTime)`
`void`	`UpdateRotation(float DeltaTime, float maxPitch)`

State NoMove Function Summary
`void`	`PlayerMove(float DeltaTime)`

State NoRotation Function Summary
`void`	`UpdateRotation(float DeltaTime, float maxPitch)` // Anticrash if target actor was a breakable mover // Log("NoControl End State"); }

State WaitForFirstDisplay Function Summary
`void`	`PlayerMove(float DeltaTime)`
`void`	`UpdateRotation(float DeltaTime, float maxPitch)`

State NoControl Function Summary

void

PlayerMove(float DeltaTime)

//      Log("NoControl End State");
    }


    event PlayerCalcView(out actor ViewActor, out vector CameraLocation, out rotator CameraRotation )
    {
      Log("NoControl PlayerCalcView");
    	ViewActor = ViewTarget;
      CameraLocation = Location;
      CameraRotation = Rotation;
    }
*/

void UpdateRotation(float DeltaTime, float maxPitch)

State PlayingVideo Function Summary
`void`	`Fire(optional float)`

State GameEndedSuccess Function Summary

State GameEndedFalling Function Summary
`void`	`EndState()` // dont replay the GameEnded BeginState()
`void`	`BeginState()`

State GameEndedDrown Function Summary
`void`	`BeginState()`

State GameEndedDeath Function Summary
`void`	`BeginState()`

State GameEnded Function Summary
`void`	`BeginState()`
`void`	`Timer()`
`void`	`FindGoodView()`
`void`	`ServerMove(float TimeStamp, vector InAccel, vector ClientLoc, bool NewbRun, bool NewbDuck, bool NewbJumpStatus, eDoubleClickDir DoubleClickMove, byte ClientRoll, int View, optional byte, optional int)`
`void`	`PlayerMove(float DeltaTime)` { Fire(F); } */
`void`	`AltFire(optional float)` { if ( Role < ROLE_Authority) return; if ( !bFrozen ) ServerReStartGame(); else if ( TimerRate <= 0 ) SetTimer(1.5, false); } exec
`void`	`Fire(optional float)` /* exec
`void`	`AltFire(optional float)`
`void`	`Fire(optional float)` // ELR E3 CHEAT
`void`	`ServerReStartGame()`
`bool`	`IsInLethalVolume(out optional)`
`void`	`ThrowWeapon()`
`void`	`PawnDied()`

State ClimbToHookNavPoint Function Summary
`void`	`ProcessMove(float DeltaTime, vector NewAccel, eDoubleClickDir DoubleClickMove, rotator DeltaRot)`
`void`	`EndState()`
`void`	`BeginState()`

State OldItem Function Summary
`void`	`Fire(float value)`
`void`	`AltFire(float value)`
`void`	`Grab()`
`void`	`PlayerMove(float DeltaTime)`
`void`	`Leave()`

State OldItem Function Summary

State PlayerGunning Function Summary
`void`	`EndState()`
`void`	`BeginState()`

State ClimbDoor Function Summary
`void`	`ProcessMove(float DeltaTime, vector NewAccel, eDoubleClickDir DoubleClickMove, rotator DeltaRot)`
`void`	`EndState()`

State MayClimbDoor Function Summary
`void`	`Timer()`
`void`	`BeginState()`

State CameraView Function Summary
`void`	`EndState()`
`void`	`BeginState()`

State BossView Function Summary
`void`	`EndState()`
`void`	`BeginState()`

State Tyroling Function Summary
`void`	`ProcessMove(float DeltaTime, vector NewAccel, eDoubleClickDir DoubleClickMove, rotator DeltaRot)` //__________________
`void`	`PlayerMove(float DeltaTime)` //__________________
`void`	`EndState()`
`void`	`BeginState()`

State Hooked Function Summary
`void`	`ProcessMove(float DeltaTime, vector NewAccel, eDoubleClickDir DoubleClickMove, rotator DeltaRot)` // ELR 2nd ProcessMove, trying to get rid of vel/acc and setting the player's pos
`void`	`PlayerMove(float DeltaTime)` //_________________
`void`	`EndState()` { Pawn.bCanCrouch=False; Pawn.bCanClimbLadders=False; bPressedDuck=false; }
`void`	`BeginState()` extends PlayerWalking {

State PlayerSwimming Function Summary
`void`	`EndState()`
`void`	`BeginState()`
`bool`	`NotifyPhysicsVolumeChange(PhysicsVolume NewVolume)`
`void`	`PlayerMove(float DeltaTime)`
`void`	`ProcessMove(float DeltaTime, vector NewAccel, eDoubleClickDir DoubleClickMove, rotator DeltaRot)`

State PlayerWalking Function Summary
`void`	`PlayerMove(float DeltaTime)`
`void`	`ProcessMove(float DeltaTime, vector NewAccel, eDoubleClickDir DoubleClickMove, rotator DeltaRot)`

State PlayerClimbing Function Summary
`void`	`ProcessMove(float DeltaTime, vector NewAccel, eDoubleClickDir DoubleClickMove, rotator DeltaRot)`
`void`	`EndState()`
`void`	`BeginState()`

Source Code


00001	//-----------------------------------------------------------
00002	//
00003	//-----------------------------------------------------------
00004	class XIIIPlayerController extends PlayerController;
00005	
00006	var bool bTurnWanted;           // For 90/180 turns
00007	var bool bWeaponMode;           // true if weapons are active, false if items are active
00008	var bool bWaitForWeaponMode;    // true if waiting for a changedweapon order
00009	var bool bPickingUp;            // Bool to validate the GameInfo HandlePickupQuery
00010	var bool bWeaponBlock;          // Used to block weapon switch while climbing doors.
00011	var bool bPressedDuck;
00012	var config bool bAltZoomingSystem;
00013	var bool bHooked;               // Player is hooked (to use it in walk/swim
00014	var config bool bFixedCrosshair;
00015	var config bool bFloatingCrosshair;
00016	
00017	var bool bMenuIsActive;         // If true, no other display allowed
00018	var config bool bRotationAssist;// if true, then rotation will be assisted by a 'lock' when strafing around target (Halo-like)
00019	// SE XBox Specific, for Cameras portal rendering
00020	var bool bRenderPortal;
00021	var bool bOkForMoving;          // Used to wait for first rendered frame (first postrender called) to activate player movement (else will be able to move while init).
00022	
00023	/*
00024	var config bool bCheckTurnSpeed;// check turning speed
00025	var float fTurnSpeed[5];        // store turning values (90/180/270/360/720�)
00026	var int fTurnInc;
00027	var float fTurnDeltaTime;       // time cumul
00028	*/
00029	
00030	var float fCamViewPercent;
00031	var int CamViewMode;
00032	var MultiViewport multiViewport;
00033	// SE Xbox End
00034	var XboxLiveManager xboxlive;
00035	var string StatsMem;            // the string that will be used to memorize stats on clients
00036	
00037	var byte OldWeap;               // to memorize weapon when switching weapons/items modes
00038	var XIIIItems OldItem;          // to memorize Item when climbing doors
00039	var XIIIPorte aDoor;            // Door to be lockpicked
00040	
00041	var float SniperYaw;            // Used for the breath movement in sniping zoom.
00042	var float SniperPitch;          // Used for the breath movement in sniping zoom.
00043	var float fSniperPrecision;     // Used for the breath movement in sniping zoom.
00044	var vector vSniperOffset;       // Used for the breath movement in sniping zoom.
00045	var vector vSniperOffsetSpeed;  // Used for the breath movement in sniping zoom.
00046	
00047	var Hook HookUsed;              // the hook used when in Hooked State
00048	var HookPoint ClimbHookPoint;   // HP to use when climbing up at top of the rope
00049	var HookNavPoint TargetHookClimb; // HNP to climb to
00050	
00051	var vector vTyrolStart, vTyrolEnd, vTyrolDir;     // For Tyrol Behaviour
00052	var float fTyrolSpeed;                            // For Tyrol Behaviour
00053	
00054	var eDrawType DT_mem;           // Used for viewing through a cam.
00055	var actor CamView;              // Used for viewing through a cam.
00056	
00057	var actor DoorToClimb;          // Door that is climbed
00058	var vector DoorLockedNormal;    // used for climbing doors
00059	var vector DoorLockedPos;       // used for climbing doors
00060	var vector DoorClimbMove;       // Movement if climbing door to check the end of climb.
00061	var vector OldDoorClimbPos;     // used for climbing doors
00062	
00063	var XIIIPlayerInteraction MyInteraction;
00064	var sound hCLimbDoorSound;
00065	var sound hEndClimbDoorSound;
00066	
00067	// EndGame Vars
00068	var vector vGameEndedCamLoc;
00069	var rotator rGameEndedCamRot;
00070	var int iGameEndedRandEffect;
00071	var OnoFalling OnoF;
00072	
00073	var sound hCamViewBeginUseSound;
00074	var sound hCamViewInUseSound;
00075	//var sound hCamViewEndUseSound;
00076	
00077	var sound hEndClimbLadderSound;
00078	//var sound hEnteringWaterSound;
00079	//var sound hExitingWaterSound;
00080	
00081	var vector vWeaponFeedBack;       // to simulate weapon feed back while firing
00082	var vector vWeaponFeedBackReturn; // to return to normal pos after firing
00083	
00084	var ForceFeedbackController FFController;   // For ForceFeedBack controls
00085	var VideoPlayer VP;               // Used to play videos
00086	
00087	var float VignetteFlashDecFactor; // Used for flash SFXs (FlashBang)
00088	var float VignetteAlphaDecFactor; // Used for flash SFXs (FlashBang
00089	var float VignetteSFXduration;    // Used for flash SFXs (FlashBang
00090	var float VignetteAlpha;          // because color.a is int & we need float
00091	
00092	var string MyInteractionClass;
00093	
00094	var sound hTyrolStartSound;
00095	var sound hTyrolEndSound;
00096	
00097	var globalconfig int iCrosshairMode;    // 0 = off, 1 = On on target, 2 = always on.
00098	var globalconfig float fCrosshairSize;
00099	
00100	//_____________________________________________________________________________
00101	// ELR Replicate things
00102	replication
00103	{
00104	    // Variables the server should send to the client.
00105	    reliable if ( Role==ROLE_Authority )
00106	      bWeaponMode, bWaitForWeaponMode, ClientTargetHighLight;
00107	
00108	    // Functions the server should send to the client.
00109	  	unreliable if( Role==ROLE_Authority )
00110	      ClientViewFeedBackSetup, ClientAddDamageWarn;
00111	
00112	  	reliable if( Role<ROLE_Authority )
00113	  	  ServerUpdateSkin;
00114	}
00115	
00116	//_____________________________________________________________________________
00117	// The player wants to switch to weapon group number F.
00118	exec function SelectWeapon( byte F )
00119	{
00120	    local weapon newWeapon;
00121	
00122	    if ( Pawn.region.Zone.FlashEffectDesc.IsActivated )
00123	      return;
00124	    if ( (Pawn.PendingWeapon != none) && (DecoWeapon(Pawn.PendingWeapon) != none) )
00125	      return;
00126	    if ( (Level.Pauser!=None) || (Pawn == None) || (Pawn.Inventory == None) )
00127	      return;
00128	
00129	    if ( (Pawn.Weapon != None) && (Pawn.Weapon.Inventory != None) )
00130	      newWeapon = Pawn.Weapon.Inventory.WeaponSelect(F);
00131	    else
00132	      newWeapon = None;
00133	    if ( newWeapon == None )
00134	      newWeapon = Pawn.Inventory.WeaponSelect(F);
00135	
00136	    if ( newWeapon == None )
00137	      return;
00138	
00139	//    Log("SelectWeapon"@NewWeapon);
00140	    if ( Pawn.Weapon == None )
00141	    {
00142	//      Log("  No Weapon");
00143	      if ( bWeaponMode )
00144	      {
00145	        if ( Pawn.Weapon != newWeapon )
00146	        {
00147	          Pawn.PendingWeapon = newWeapon;
00148	          Pawn.ChangedWeapon();
00149	        }
00150	      }
00151	      else if ( !bWaitForWeaponMode )
00152	      {
00153	        XIIIBaseHud(MyHud).fDrawWeaponsTimer = Level.TimeSeconds+2.0;
00154	        bWaitForWeaponMode = true;
00155	        Pawn.Weapon = NewWeapon;
00156	        SwitchWeaponMode();
00157	      }
00158	    }
00159	    else
00160	    {
00161	      if ( bWeaponMode )
00162	      {
00163	        if ( Pawn.Weapon != newWeapon )
00164	        {
00165	          Pawn.PendingWeapon = newWeapon;
00166	          if ( !Pawn.Weapon.PutDown() )
00167	            Pawn.PendingWeapon = None;
00168	        }
00169	      }
00170	      else
00171	      {
00172	        XIIIBaseHud(MyHud).fDrawWeaponsTimer = Level.TimeSeconds+2.0;
00173	        bWaitForWeaponMode = true;
00174	        Pawn.Weapon = NewWeapon;
00175	        SwitchWeaponMode();
00176	      }
00177	    }
00178	}
00179	
00180	//_____________________________________________________________________________
00181	simulated event IAmKicked()
00182	{
00183	    GotoState('Kicked', 'Begin');
00184	    Pawn.bTearOff = true;
00185	    bTearOff = true;
00186	    Pawn.Died( None, class'DTSuicided', Pawn.Location );
00187	    PlayerReplicationInfo.destroy();
00188	    PlayerReplicationInfo = none;
00189	}
00190	
00191	
00192	//_____________________________________________________________________________
00193	exec function ChangeSkin(string NewSkinCode)
00194	{
00195	    local int i;
00196	
00197	    // DO nothing in solo.
00198	    if ( Level.bLonePlayer )
00199	      return;
00200	
00201	//    Log("SKIN Exec ChangeSkin");
00202	
00203	    // don't replicate things for nothing if non valid code.
00204	    i = class'MeshSkinList'.Static.StaticFindSkinIndex(NewSkinCode);
00205	    if ( i > class'MeshSkinList'.default.MeshSkinListInfo.Length )
00206	      return;
00207	
00208	    ServerUpdateSkin(Caps(left(NewSkinCode,4)));
00209	//    Pawn.PlayerReplicationInfo.SkinCodeName = NewSkinCode;
00210	//    XIIIMPPlayerPawn(Pawn).ChangeSkin();
00211	}
00212	
00213	//_____________________________________________________________________________
00214	function ServerUpdateSkin(string NewSkinCode)
00215	{
00216	//    Log("SKIN ServerUpdateSkin");
00217	    PlayerReplicationInfo.SkinCodeName = NewSkinCode; // will be replicated to all clients
00218	    Pawn.ChangeSkin();  // local change on server
00219	}
00220	
00221	//____________________________________________________________________
00222	simulated function ClientAddDamageWarn(int RelativeHitLoc)
00223	{
00224	    XIIIBaseHud(MyHud).AddDamageWarn(RelativeHitLoc);
00225	}
00226	
00227	//_____________________________________________________________________________
00228	function EnterStartState()
00229	{
00230		local name NewState;
00231	
00232		if ( Level.bLonePlayer && !bOkForMoving )
00233		{
00234		  GotoState('WaitForFirstDisplay');
00235		  return;
00236		}
00237	  else
00238	    Super.EnterStartState();
00239	}
00240	
00241	/*
00242	//_____________________________________________________________________________
00243	exec function ImBoss()
00244	{
00245	    XIIIBaseHud(MyHud).AddBossBar(XIIIPawn(Pawn));
00246	}
00247	*/
00248	/*
00249	//_____________________________________________________________________________
00250	exec function LogInteractives()
00251	{
00252	    local Actor A;
00253	    local int i;
00254	
00255	    Log("BEGIN Interactive List");
00256	    i = 0;
00257	    foreach AllActors(class'Actor', A)
00258	    {
00259	      if ( A.bInteractive )
00260	      {
00261	        i++;
00262	        Log(" -"@i@A);
00263	      }
00264	    }
00265	    Log("END Interactive List");
00266	}
00267	*/
00268	//_____________________________________________________________________________
00269	exec function GoreLevel(int i)
00270	{
00271	    Level.Game.GoreLevel = i%2;
00272	    Level.Game.SaveConfig();
00273	}
00274	
00275	//_____________________________________________________________________________
00276	exec function FlowerPower(int i)
00277	{
00278	    if ( i != 0 )
00279	      Level.Game.GoreLevel = 0;
00280	    Level.Game.bAlternateMode = (i%2 == 1);
00281	    Level.Game.SaveConfig();
00282	}
00283	
00284	//_____________________________________________________________________________
00285	exec function DetailLevel(int i)
00286	{
00287	    Level.Game.DetailLevel = i%3;
00288	    Level.Game.SaveConfig();
00289	}
00290	
00291	//_____________________________________________________________________________
00292	exec function KillTarget(int i)
00293	{
00294	    if ( MyInteraction.FiringTargetActor != none )
00295	      MyInteraction.FiringTargetActor.TakeDamage(10000,Pawn,vect(0,0,1),vect(0,0,1),class'DTSuicided');
00296	}
00297	
00298	/*
00299	//_____________________________________________________________________________
00300	exec function SetZoomSystem(bool B)
00301	{
00302	    bAltZoomingSystem = B;
00303	    SaveConfig();
00304	}
00305	*/
00306	
00307	//_____________________________________________________________________________
00308	exec function AAM(int i)
00309	{
00310	    iAutoAimMode = i%2;
00311	    SaveConfig();
00312	}
00313	
00314	/*
00315	//_____________________________________________________________________________
00316	exec function DBTurn()
00317	{
00318	    bCheckTurnSpeed = !bCheckTurnSpeed;
00319	    SaveConfig();
00320	}
00321	
00322	//_____________________________________________________________________________
00323	exec function DBInput(bool b)
00324	{
00325	    PlayerInput.bCheckInputRanges = b;
00326	    PlayerInput.SaveConfig();
00327	}
00328	*/
00329	
00330	/*
00331	//_____________________________________________________________________________
00332	exec function CrosshairMode(int i)
00333	{
00334	    iCrossHairMode = i%3;
00335	    SaveConfig();
00336	}
00337	*/
00338	
00339	//_____________________________________________________________________________
00340	exec function AutoPickup(bool b)
00341	{
00342	    bAutoPickup = b;
00343	    SaveConfig();
00344	}
00345	
00346	/*
00347	//_____________________________________________________________________________
00348	exec function FixCrosshairMode(int i)
00349	{
00350	    bFixedCrosshair = (i%2 == 1);
00351	    SaveConfig();
00352	}
00353	
00354	//_____________________________________________________________________________
00355	exec function FloatCrosshairMode(int i)
00356	{
00357	    bFixedCrosshair = false;
00358	    bFloatingCrosshair = (i%2 == 1);
00359	    SaveConfig();
00360	}
00361	*/
00362	
00363	//_____________________________________________________________________________
00364	exec function CrosshairSize(Float f)
00365	{
00366	    fCrossHairSize = fClamp(f, 0.1, 3.0);
00367	    SaveConfig();
00368	}
00369	
00370	/*
00371	//_____________________________________________________________________________
00372	exec function LogInteraction()
00373	{
00374	    log("LogInteraction");
00375	    MyInteraction.SwitchLog();
00376	}
00377	*/
00378	
00379	//_____________________________________________________________________________
00380	exec function DoHideHUD( bool B )
00381	{
00382	    log("DoHideHUD call with B="$B);
00383	    MYHud.bHideHud = B;
00384	}
00385	
00386	/*
00387	//_____________________________________________________________________________
00388	exec function Teleport(name N)
00389	{
00390	    local XIIITeleportCheat XTC;
00391	
00392	//    Log("Trying to Teleport to "$N);
00393	
00394	    foreach AllActors(class'XIIITeleportCheat', XTC, N)
00395	    {
00396	      if (XTC != none)
00397	      {
00398	//        Log("Teleporting player to Spot "$XTC);
00399	        XTC.TeleportPlayer(XIIIPlayerPawn(Pawn));
00400	        break;
00401	      }
00402	    }
00403	}
00404	*/
00405	
00406	/*
00407	exec function TeleportNext()
00408	{
00409	    local XIIITeleportCheat XTC, XTCfirst;
00410	
00411	//    Log("Trying to Teleport to next teleporter");
00412	
00413	    foreach AllActors(class'XIIITeleportCheat', XTC)
00414	    {
00415	      if (XTCfirst == none)
00416	        XTCfirst = XTC;
00417	      if ( (XTC != none) && XTC.bLastUsed )
00418	      {
00419	        if ( XTC.NextXIIITeleportCheat != none )
00420	        {
00421	//          Log("Teleporting player to Spot "$XTC.NextXIIITeleportCheat);
00422	          XTC.NextXIIITeleportCheat.TeleportPlayer(XIIIPlayerPawn(Pawn));
00423	          XTC.NextXIIITeleportCheat.bLastUsed = true;
00424	          XTC.bLastUsed = false;
00425	          return;
00426	        }
00427	        else
00428	        {
00429	//          Log("Teleporting player to Spot "$XTCfirst);
00430	          XTCfirst.TeleportPlayer(XIIIPlayerPawn(Pawn));
00431	          XTCFirst.bLastUsed = true;
00432	          return;
00433	        }
00434	      }
00435	    }
00436	    // if we are here it's because none have bCurrent
00437	    if (XTCFirst != none)
00438	    {
00439	//      Log("Teleporting player to Spot "$XTCfirst);
00440	      XTCfirst.TeleportPlayer(XIIIPlayerPawn(Pawn));
00441	      XTCFirst.bLastUsed = true;
00442	      return;
00443	    }
00444	}
00445	*/
00446	
00447	//____________________________________________________________________________
00448	// ELR Override this
00449	exec function BehindView( Bool B )
00450	{
00451	    if (!(Left(Level.GetLocalURL(), 7) ~= "mapmenu"))
00452	      Super.BehindView(B);
00453	    if ( B )
00454	    {
00455	        Pawn.weapon.bHidden = true;
00456	        Pawn.weapon.RefreshDisplaying();
00457	    }
00458	    else
00459	    {
00460	        Pawn.weapon.bHidden = false;
00461	        Pawn.weapon.RefreshDisplaying();
00462	    }
00463	}
00464	
00465	function ClientSetBehindView(bool B)
00466	{
00467	    bBehindView = B;
00468	    if ( !B && Pawn.Shadow != none )
00469	      Pawn.Shadow.DetachProjector(true);
00470	}
00471	
00472	//____________________________________________________________________________
00473	event PlayerCalcView(out actor ViewActor, out vector CameraLocation, out rotator CameraRotation )
00474	{
00475	    local int i;
00476	
00477	    super.PlayerCalcView(ViewActor, CameraLocation, CameraRotation);
00478	    // following lines needed to have weapon in 3D overlays using bDelayDisplay instead of RenderOverlays
00479	    if ( ((Pawn == none) || Pawn.bIsDead) && (Attached.Length > 0) )
00480	    { // may have died, if something attached (must be 1rst person/inventory weapons) then detach else crash in SetLoc if something happen to inventory
00481	      for ( i=0; i<Attached.Length; i++)
00482	      {
00483	//        Log("DETACH"@Attached[i]@"from"@self);
00484	        Attached[i].SetBase(none);
00485	      }
00486	    }
00487	    SetLocation(CameraLocation);
00488	    SetRotation(CameraRotation);
00489	}
00490	
00491	//____________________________________________________________________________
00492	simulated event SetInitialState()
00493	{
00494	    if (Left(Level.GetLocalURL(), 7) ~= "mapmenu")
00495	    {
00496	      MyHud.bHideHUD = true;
00497	//      ConsoleCommand("ShowMenu");
00498	      GotoState('NoControl');
00499	      return;
00500	    }
00501	    Super.SetInitialState();
00502	
00503	}
00504	
00505	//____________________________________________________________________________
00506	// MLK: Superset to launch the briefing before the game starts
00507	// ELR First place it is safe to use Player Var so to spawn interactions.
00508	event InitInputSystem()
00509	{
00510	    local MapInfo Map;
00511	    local int i;
00512	    local XIIIPlayerInteraction XPI;
00513	
00514	    Super.InitInputSystem();
00515	
00516	    Player.Console = Player.InteractionMaster.Console;
00517	    if (Player.Console == none)
00518	    {
00519	        log("PAS de Console !?!");
00520	        return;
00521	    }
00522	    if (Player.Console.ViewportOwner == none)
00523	      Player.Console.ViewportOwner = Player;
00524	
00525	    for (i=0; i<Player.LocalInteractions.Length; i++)
00526	    {
00527	      if ( XIIIPlayerInteraction(Player.LocalInteractions[i]) != none )
00528	        MyInteraction = XIIIPlayerInteraction(Player.LocalInteractions[i]);
00529	    }
00530	// if an interaction already exists (coming from previous map) then reuse it, don't create another
00531	
00532	    if ( MyInteraction != none )
00533	    {
00534	        Player.InteractionMaster.RemoveInteraction(MyInteraction);
00535	        MyInteraction = none;
00536	    }
00537	
00538	    if ( MyInteraction == none )
00539	    {
00540	      XPI = XIIIPlayerInteraction(Player.InteractionMaster.AddInteraction(MyInteractionClass, Player));
00541	      if ( XPI != none )
00542	      {
00543	        XPI.Level = Level;
00544	        XPI.MyPC = Self;
00545	        MyInteraction = XPI;
00546	      }
00547	    }
00548	    else
00549	    {
00550	      MyInteraction.Level = Level;
00551	      MyInteraction.MyPC = Self;
00552	    }
00553	
00554	    SetRumbleFX(bUseRumble);
00555	
00556	    // Autolaunch Menu if in the 'menustart'.
00557	    if (Left(Level.GetLocalURL(), 7) ~= "mapmenu")
00558	    {
00559	      MyHud.bHideHUD = true;
00560	      ConsoleCommand("ShowMenu");
00561	      XIIIGameInfo(Level.Game).MapInfo.EndCartoonEffect = true;
00562	      GotoState('NoControl');
00563	    }
00564	
00565	    if ( !Level.bLonePlayer && (Level.GetPlateforme() == 2) )
00566	    {
00567	      if (xboxlive == none) // Southend!!!!!!!!!1 safe for other platforms..
00568	        xboxlive=New Class'XboxLiveManager';
00569	
00570	      if (xboxlive.IsLoggedIn(xboxlive.GetCurrentUser()))
00571	        ConsoleCommand("ShowMenu"); // SOUTHEND!!!!!!!!!  Need this for XBOX!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!1
00572	      return;
00573	    }
00574	
00575	// SOLO ONLY INIT
00576	    foreach AllActors(class'XIII.Mapinfo',map)
00577	      break;
00578	    if ( Map != none && Map.bBriefing )
00579	    {
00580	      XIIIGameInfo(Level.Game).MapInfo = Map;
00581	      ConsoleCommand("ShowBriefing");
00582	    }
00583	}
00584	
00585	//_____________________________________________________________________________
00586	// ::DBUG::
00587	simulated event Destroyed()
00588	{
00589	    Log("PLAYER"@self@"destroyed !!");
00590	    Super.Destroyed();
00591	}
00592	
00593	//_____________________________________________________________________________
00594	// ::DBUG::
00595	function PawnDied()
00596	{
00597	  Log("PLAYER"@self@"PawnDied call bIsPlayer="$bIsPlayer);
00598	  Super.PawnDied();
00599	  // Unflash player if under flashbang sfx
00600	  ClientFilter(
00601	    class'Canvas'.Static.MakeColor(128,128,128,255),
00602	    class'Canvas'.Static.MakeColor(128,128,128,255),
00603	    1.0
00604	  );
00605	  ClientHighLight( class'Canvas'.Static.MakeColor(0,0,0,0), 0.0);
00606	  ClientTargetHighLight(0,0,0.001);
00607	  UseVignetteFilter = 0;
00608	  UseVignetteHighlight = 0;
00609	}
00610	
00611	//_____________________________________________________________________________
00612	// Setup the ForceFeedbackController
00613	function SetRumbleFX(bool B)
00614	{
00615	    if ( B )
00616	    {
00617	      if ( FFController != none )
00618	      {
00619	        FFController.EnableForceFeedback(true);
00620	      }
00621	      else
00622	      {
00623	        FFController = new class'ForceFeedbackController';
00624	        FFController.EnableForceFeedback(true);
00625	      }
00626	    }
00627	    else
00628	    {
00629	      if ( FFController != none )
00630	      {
00631	        FFController.EnableForceFeedback(false);
00632	      }
00633	    }
00634	}
00635	
00636	//_____________________________________________________________________________
00637	// Setup the ForceFeedbackController
00638	function RumbleFX(int FXNum)
00639	{
00640	    if ( (FFController != none) && FFController.IsForceFeedbackEnable() )
00641	    {
00642	      switch(FXNum)
00643	      {
00644	        Case 1: // Beretta
00645	          FFController.StartEffect(0, 0.45, 0.45, 0.00, 1.00, 0.20, 0.70, 0.35 ); Break;
00646	        Case 2: // Hunting Gun, Left
00647	          FFController.StartEffect(0, 0.00, 0.75, 0.00, 1.00, 0.25, 0.50, 0.35 ); Break;
00648	        Case 3: // Hunting Gun, Right
00649	          FFController.StartEffect(0, 0.75, 0.00, 0.00, 1.00, 0.25, 0.50, 0.35 ); Break;
00650	        Case 4: // ShotGun
00651	          FFController.StartEffect(0, 0.60, 0.00, 0.00, 1.00, 0.35, 0.50, 0.40 ); Break;
00652	        Case 5: // Magnum
00653	          FFController.StartEffect(0, 0.60, 0.60, 0.00, 1.00, 0.20, 0.70, 0.35 ); Break;
00654	        Case 6: // M16 FX 1
00655	          FFController.StartEffect(0, 0.15, 0.45, 0.00, 1.00, 0.10, 0.70, 0.15 ); Break;
00656	        Case 7: // M16 inv. FX 1
00657	          FFController.StartEffect(0, 0.45, 0.15, 0.00, 1.00, 0.10, 0.70, 0.15 ); Break;
00658	        Case 8: // Kalash FX 1
00659	          FFController.StartEffect(0, 0.25, 0.45, 0.00, 1.00, 0.10, 0.70, 0.15 ); Break;
00660	        Case 9: // Kalash inv. FX 1
00661	          FFController.StartEffect(0, 0.45, 0.25, 0.00, 1.00, 0.10, 0.70, 0.15 ); Break;
00662	        Case 10: // Minigun FX 1
00663	          FFController.StartEffect(0, 0.10, 0.35, 0.00, 0.70, 0.10, 0.70, 0.15 ); Break;
00664	        Case 11: // Minigun inv. FX 1
00665	          FFController.StartEffect(0, 0.35, 0.10, 0.00, 0.70, 0.10, 0.70, 0.15 ); Break;
00666	        Case 12: // Sniper Rifle
00667	          FFController.StartEffect(0, 0.90, 0.90, 0.00, 1.00, 0.15, 0.70, 0.25 ); Break;
00668	        Case 13: // Bazooka
00669	          FFController.StartEffect(0, 0.90, 0.90, 0.00, 0.70, 0.25, 1.00, 1.00 ); Break;
00670	        Case 14: // CrossBow, CrossBow X3
00671	          FFController.StartEffect(0, 0.50, 0.50, 0.00, 0.10, 0.10, 1.00, 0.25 ); Break;
00672	        Case 15: // M60 FX 1
00673	          FFController.StartEffect(0, 0.80, 0.40, 0.00, 1.00, 0.10, 0.70, 0.15 ); Break;
00674	        Case 16: // M60 inv. FX 1
00675	          FFController.StartEffect(0, 0.40, 0.80, 0.00, 1.00, 0.10, 0.70, 0.15 ); Break;
00676	        Case 17: // Harpoon
00677	          FFController.StartEffect(0, 0.30, 0.30, 0.00, 0.10, 0.10, 1.00, 0.20 ); Break;
00678	/*
00679	        Case 5:
00680	          FFController.StartEffect(0, fRumb1, fRumb2, t1, Amplit1, t2, Amplit2, t3 );
00681	          Break;
00682	*/
00683	      }
00684	    }
00685	}
00686	
00687	//_____________________________________________________________________________
00688	// SpawnDefaultHUD()
00689	// Spawn a HUD (make sure that PlayerController always has valid HUD, even if
00690	//  ClientSetHUD() hasn't been called
00691	function SpawnDefaultHUD()
00692	{
00693	     myHUD = spawn(class'XIIIBaseHUD',self);
00694	}
00695	
00696	//_____________________________________________________________________________
00697	function DisplayDebug(Canvas C, out float YL, out float YPos)
00698	{
00699	    Super.DisplayDebug(C, YL, YPos);
00700	
00701	    C.DrawText("rotation "$rotation);
00702	    YPos += YL;
00703	    C.SetPos(4,YPos);
00704	
00705	    C.DrawText("Weapon Mode "$bWeaponMode);
00706	    YPos += YL;
00707	    C.SetPos(4,YPos);
00708	
00709	    if ( Pawn != none )
00710	    {
00711	/*
00712	      if ( Pawn.PendingWeapon != none )
00713	      {
00714	        C.DrawText("PendingWeapon="$Pawn.PendingWeapon@"STATE"@Pawn.PendingWeapon.GetStateName());
00715	        YPos += YL;
00716	        C.SetPos(4,YPos);
00717	      }
00718	      if ( Pawn.PendingWeapon != none )
00719	      {
00720	        C.DrawText("Weapon="$Pawn.Weapon@"STATE"@Pawn.Weapon.GetStateName());
00721	        YPos += YL;
00722	        C.SetPos(4,YPos);
00723	      }
00724	      if ( Pawn.PendingItem != none )
00725	      {
00726	        C.DrawText("PendingItem="$Pawn.PendingItem@"STATE"@Pawn.PendingItem.GetStateName());
00727	        YPos += YL;
00728	        C.SetPos(4,YPos);
00729	      }
00730	      if ( Pawn.SelectedItem != none )
00731	      {
00732	        C.DrawText("Item="$Pawn.SelectedItem@"STATE"@Pawn.SelectedItem.GetStateName());
00733	        YPos += YL;
00734	        C.SetPos(4,YPos);
00735	      }
00736	
00737	*/
00738	      if ( XIIIPawn(Pawn).LHand != none )
00739	      {
00740	        C.DrawText("LeftHand="$XIIIPawn(Pawn).LHand);
00741	        YPos += YL;
00742	        C.SetPos(4,YPos);
00743	      }
00744	    }
00745	
00746	    C.DrawText("Rotation="$Rotation@"AdjustedAimForFiring"@rotator(AdjustedAimForFiring)@"OldAdjustAim"@rotator(OldAdjustAim));
00747	    YPos += YL;
00748	    C.SetPos(4,YPos);
00749	
00750	/*    C.DrawText("bAlwaysLevel="$bAlwaysLevel@"bCenterView="$bCenterView@"bLook="$bLook@"bLookUpStairs="$bLookUpStairs@"bSnapToLevel="$bSnapToLevel);
00751	    YPos += YL;
00752	    C.SetPos(4,YPos); */
00753	}
00754	
00755	//_____________________________________________________________________________
00756	exec function RestartLevel()
00757	{
00758	//    if( Level.Netmode==NM_Standalone )
00759	    if ( Level.bLonePlayer )
00760	      ClientTravel( "?restart", TRAVEL_Relative, false );
00761	}
00762	
00763	//_____________________________________________________________________________
00764	function ClientRestart()
00765	{
00766	  Log("ClientRestart"@self@"Pawn="$Pawn);
00767		if ( Pawn == None )
00768		{
00769			GotoState('WaitingForPawn');
00770			return;
00771		}
00772		if ( PlayerInput != none )
00773		{
00774		  PlayerInput.iDuckMem = 0;
00775		  PlayerInput.bDuckCheck = false;
00776		  Pawn.ShouldCrouch(false);
00777		}
00778		bDuck = 0;
00779		Pawn.ClientRestart();
00780		SetViewTarget(Pawn);
00781		bBehindView = Pawn.PointOfView();
00782		EnterStartState();
00783	}
00784	
00785	//_____________________________________________________________________________
00786	simulated function RenderScreenOverlays( canvas C )
00787	{
00788	    if ( fCamViewPercent > 0.0 )
00789	    {
00790	      CamView.Instigator = pawn;
00791	      CamView.RenderOverlays(C);
00792	    }
00793	}
00794	
00795	//_____________________________________________________________________________
00796	// ELR
00797	simulated event RenderOverlays( canvas C )
00798	{
00799	    if ( !Level.bCineFrame )
00800	      MyInteraction.MyPCPostRender(C);
00801	    else
00802	      MyInteraction.TargetActor = none;
00803	    // ::TODO:: Optimize using NoControl state test or overriding RenderOverlays in NoControl State ?
00804	/*
00805	    if ( (Pawn != none) && Pawn.region.Zone.FlashEffectDesc.IsActivated )
00806	    { // do not simply return but hide weapons/items
00807	      if ( Pawn.Weapon != none )
00808	      { // should be in the flashback end effect
00809	      }
00810	      return;
00811	    }
00812	*/
00813	
00814	/*
00815	    if ( (Level.Game != none) && Level.Game.bGameEnded )
00816	    {
00817	//      Log("RenderOverlays w/ bGameEnded !!!");
00818	      return;
00819	    }
00820	*/
00821	
00822	    if ( (Level.Game != none) && (Level.Game.DetailLevel < 2) )
00823	    { // On anything else than XBOX, use full screen render.
00824	      if ( IsInState('CameraView') )
00825	      {
00826	        CamView.Instigator = pawn;
00827	        CamView.RenderOverlays(C);
00828	        return;
00829	      }
00830	    }
00831	    else
00832	    { // on XBox, use portal
00833	      switch (CamViewMode)
00834	      {
00835	        case 0:
00836	          fCamViewPercent -= 0.05;
00837	          if (fCamViewPercent < 0.0)
00838	          {
00839	            fCamViewPercent = 0.0;
00840	            CamView = none;
00841	          }
00842	        break;
00843	        case 1:
00844	          fCamViewPercent += 0.05;
00845	          if (fCamViewPercent > 1.0)
00846	            fCamViewPercent = 1.0;
00847	        break;
00848	      }
00849	
00850	      if (multiViewport != none)
00851	      {
00852	        multiViewport.RenderOverlays(C);
00853	        if (multiViewport.bEnded)
00854	        {
00855	          multiViewport.Destroy();
00856	          multiViewport = none;
00857	          Level.SetOnlyPostRender(false);
00858	        }
00859	      }
00860	
00861	      if ( fCamViewPercent > 0.0 )
00862	      {
00863	        CamView.Instigator = pawn;
00864	        CamView.RenderOverlays(C);
00865	//        return; // don't return as we render in a viewport.
00866	      }
00867	    }
00868	
00869	    if ( bWeaponMode && (Pawn != none) && (Pawn.Weapon != none) )
00870	    {
00871	//      if ( !Pawn.Weapon.IsAnimating() )
00872	//        Pawn.Weapon.AnimEnd(0); // Anti bug, if selected MUST Have an animation
00873	      if ( Pawn.Weapon.Instigator != Pawn ) // don't bNetDirty by instigator changed each frame
00874	        Pawn.Weapon.Instigator = Pawn;
00875	      Pawn.Weapon.RenderOverlays(C);
00876	    }
00877	    if ( !bWeaponMode && (Pawn != none) )
00878	    {
00879	//      if ( !Pawn.SelectedItem.IsAnimating() )
00880	//        Pawn.SelectedItem.AnimEnd(0); // Anti bug, if selected MUST Have an animation
00881	      if ( Pawn.SelectedItem != none )
00882	        Pawn.SelectedItem.RenderOverlays(C);
00883	      else
00884	      { // bug ?
00885	        NextWeapon();
00886	        Pawn.ChangedWeapon();
00887	      }
00888	    }
00889	
00890	    if ( (Pawn != none) && (XIIIPawn(Pawn).LHand != None) && (XIIIPawn(Pawn).LHand.bActive) )
00891	    {
00892	      XIIIPawn(Pawn).LHand.RenderOverlays(C);
00893	    }
00894	}
00895	
00896	//_____________________________________________________________________________
00897	function ClientTargetHighLight( int Alpha, float TargetHighLight, float Duration)
00898	{ // compute Dec values per millsec
00899	    VignetteFlashDecFactor = (TargetHighLight - VignetteHighLight) / Duration;
00900	    VignetteAlphaDecFactor = (Alpha - VignetteColor.A) / Duration;
00901	    VignetteSFXduration = Duration;
00902	    VignetteAlpha = VignetteColor.A;
00903	}
00904	
00905	//_____________________________________________________________________________
00906	// ELR made zooming speed higher
00907	function AdjustView(float DeltaTime )
00908	{
00909	    // teleporters affect your FOV, so adjust it back down
00910	    if ( FOVAngle != DesiredFOV )
00911	    {
00912	      if ( FOVAngle > DesiredFOV )
00913	        FOVAngle = FOVAngle - FMax(7, 0.9 * DeltaTime * (FOVAngle - DesiredFOV));
00914	      else
00915	        FOVAngle = FOVAngle - FMin(-7, 0.9 * DeltaTime * (FOVAngle - DesiredFOV));
00916	      if ( Abs(FOVAngle - DesiredFOV) <= 10 )
00917	        FOVAngle = DesiredFOV;
00918	    }
00919	
00920	    // adjust FOV for weapon zooming
00921	    if ( bZooming )
00922	    {
00923	      ZoomLevel += DeltaTime * 1.5;
00924	      if (ZoomLevel > 0.95)
00925	        ZoomLevel = 0.95;
00926	      DesiredFOV = FClamp(90.0 - (ZoomLevel * 88.0), 1, 170);
00927	    }
00928	
00929	    // Handle here because we do have DeltaTime
00930	    if ( ((UseVignetteFilter != 0) || (UseVignetteHighlight != 0)) && ( VignetteSFXduration > 0) )
00931	    {
00932	      VignetteHighLight += (DeltaTime * VignetteFlashDecFactor);
00933	      VignetteAlpha += (Deltatime * VignetteAlphaDecFactor);
00934	      VignetteColor.A = VignetteAlpha;
00935	      VignetteSFXduration -= DeltaTime;
00936	//      Log("VignetteSFXduration="$VignetteSFXduration@"VignetteHighLight="$VignetteHighLight@"VignetteColor="$VignetteColor.R$"."$VignetteColor.G$"."$VignetteColor.B$"."$VignetteAlpha);
00937	      if ( VignetteSFXduration <= 0 )
00938	      {
00939	        UseVignetteFilter = 0;
00940	        UseVignetteHighlight = 0;
00941	      }
00942	    }
00943	}
00944	
00945	//_____________________________________________________________________________
00946	/* AdjustAim()
00947	  Calls this version for player aiming help.
00948	  Aimerror not used in this version.
00949	  Only adjusts aiming at pawns
00950	*/
00951	// ELR computes AimSpot and return rotator(AimSpot - projStart)
00952	//Simulated function rotator AdjustAim(float projSpeed, vector projStart, int aimerror, bool bLeadTarget, bool bWarnTarget, bool bTossed, bool bTrySplash)
00953	// AimCalcMode is used as 0 = weapon firing, 1 = interface aim anticipation
00954	Simulated function rotator AdjustAim(Ammunition FiredAmmunition, vector projStart, int AimCalcMode)
00955	{
00956	    if ( Pawn != None && !Pawn.IsLocallyControlled() )
00957	      AdjustAimForDisplay(FiredAmmunition, ProjStart);
00958	
00959	    if ( !FiredAmmunition.bInstantHit )
00960	      return rotator(AdjustedAimForFiring);
00961	    else
00962	      return rotator(OldAdjustAim);
00963	}
00964	
00965	//_____________________________________________________________________________
00966	exec function ShowMenu()
00967	{
00968	    log("SHOWMENU: "$self);
00969	    if ( !Level.bLonePlayer || !Level.Game.bGameEnded || (XIIIGameInfo(Level.Game).XIIIEndGameType!=4) )
00970	      ConsoleCommand("ShowTheMenu "$self);
00971	    if ( VP != none )
00972	      VP.Stop();
00973	}
00974	
00975	exec function ShowInfo()
00976	{
00977	    log("SHOWINFO: "$self);
00978	    if (!bMenuIsActive)
00979	      MyHud.ShowScores();
00980	}
00981	
00982	//_____________________________________________________________________________
00983	exec function Duck( optional float F )
00984	{
00985	  bPressedDuck = true;
00986	}
00987	
00988	//_____________________________________________________________________________
00989	exec function QuickHeal()
00990	{
00991	    Local inventory Inv;
00992	
00993	    DebugLog("Quick Heal Call");
00994	    if ( (Pawn != none) && (Pawn.region.zone != none) && Pawn.region.Zone.FlashEffectDesc.IsActivated )
00995	      return;
00996	
00997	    if ( bWeaponBlock )
00998	      return;
00999	
01000	    if ( !bWeaponMode )
01001	    {
01002	      if ( Med(Pawn.SelectedItem) != none )
01003	      {
01004	        ActivateItem();
01005	        return;
01006	      }
01007	      if ( Med(Pawn.PendingItem) != none )
01008	      { // don't use a possible pending item to avoid pb switching
01009	        return;
01010	      }
01011	    }
01012	
01013	    if ( XIIIPawn(Pawn).HealthPercent() <= 25 )
01014	    { //seek FullMedKit
01015	      Inv = Pawn.FindInventoryType(class'FullMedKit');
01016	      if ( Inv == none )
01017	        Inv = Pawn.FindInventoryType(class'MedKit');
01018	    }
01019	    else if ( XIIIPawn(Pawn).IsWounded() )
01020	    { //seek MedKit
01021	      Inv = Pawn.FindInventoryType(class'MedKit');
01022	      if ( Inv == none )
01023	        Inv = Pawn.FindInventoryType(class'FullMedKit');
01024	    }
01025	    if ( Inv != none )
01026	    {
01027	      DebugLog("Quick Heal Should HEAL using "$Inv);
01028	      Med(Inv).UseMeQuick(self);
01029	      if ( Med(Inv).Charge <=0 )
01030	      {
01031	        if ( Pawn.SelectedItem == Inv )
01032	          Pawn.SelectedItem = none;
01033	        if ( Pawn.PendingItem == Inv )
01034	          Pawn.PendingItem = none;
01035	        if ( OldItem == Inv )
01036	          OldItem = none;
01037	        Med(Inv).UsedUpNoChange();
01038	      }
01039	    }
01040	
01041	}
01042	
01043	//_____________________________________________________________________________
01044	// ELR Use the ForceReload function of base weapons functions
01045	exec function ReLoad()
01046	{
01047	    if ( (Pawn != none) && (Pawn.region.zone != none) && Pawn.region.Zone.FlashEffectDesc.IsActivated )
01048	      return;
01049	
01050	    ForceReload();
01051	}
01052	
01053	//_____________________________________________________________________________
01054	// can't reload if have grabbed corpse/pawn
01055	exec function ForceReload()
01056	{
01057	//    Log("ForceReLoad, Pawn="$Pawn@"Pawn.Weapon="$Pawn.Weapon);
01058	    if ( Level.bLonePlayer )
01059	    {
01060	      if ( (Pawn != None) && (Pawn.Weapon != None) && (XIIIPawn(Pawn).LHand.pOnShoulder == none) )
01061	        Pawn.Weapon.ForceReload();
01062	    }
01063	    else
01064	      if ( (Pawn != None) && (Pawn.Weapon != None) )
01065	        Pawn.Weapon.ForceReload();
01066	}
01067	
01068	//_____________________________________________________________________________
01069	// The player wants to fire.
01070	exec function Fire( optional float F )
01071	{
01072	    if ( Pawn.region.Zone.FlashEffectDesc.IsActivated )
01073	      return;
01074	
01075	    XIIIBaseHud(MyHud).fDrawWeaponsTimer = Level.TimeSeconds-10; // get rid of weapon/item drawing list
01076	
01077	    if ( XIIIPlayerPawn(Pawn).SSSk != none )
01078	      XIIIPlayerPawn(Pawn).SSSk.ResetTimer();
01079	
01080	    if ( IsInState('CameraView') )
01081	    {
01082	      RestoreView();
01083	      return;
01084	    }
01085	    if ( bWeaponMode )
01086	    {
01087	      if ( Pawn.Weapon != None )
01088	        Pawn.Weapon.Fire(F);
01089	    }
01090	    else
01091	    {
01092	      if ( !bWeaponMode && (Hook(Pawn.SelectedItem) != none) )
01093	      {
01094	        if ( !Hook(Pawn.SelectedItem).bGoUp && (!Hook(Pawn.SelectedItem).bGoDown || Hook(Pawn.SelectedItem).ActivatedByFire) )
01095	        {
01096	          Hook(Pawn.SelectedItem).ActivatedByFire = true;
01097	          ActivateItem();
01098	        }
01099	      }
01100	      else
01101	      {
01102	//        log("Activating item via fire call");
01103	        ActivateItem();
01104	      }
01105	      if (Level.NetMode == NM_Client)
01106	      {
01107	//        Log("Activate Item (on client) "@Pawn.SelectedItem);
01108	        if ( Level.Pauser!=None )
01109	          return;
01110	        if ( (Pawn != None) && (Pawn.SelectedItem!=None) )
01111	          Pawn.SelectedItem.Activate();
01112	      }
01113	    }
01114	}
01115	
01116	//_____________________________________________________________________________
01117	// The player Release fire.
01118	exec function UnFire( optional float F )
01119	{
01120	//    Log("Calling Unfire");
01121	    if ( bWeaponMode )
01122	    {
01123	      if ( (Pawn != none) && (XIIIWeapon(Pawn.Weapon) != None) )
01124	        XIIIWeapon(Pawn.Weapon).UnFire(F);
01125	    }
01126	}
01127	
01128	//_____________________________________________________________________________
01129	exec function AltFire( optional float F )
01130	{
01131	    if ( Pawn.region.Zone.FlashEffectDesc.IsActivated )
01132	      return;
01133	
01134	    if ( IsInState('CameraView') )
01135	    {
01136	      RestoreView();
01137	      return;
01138	    }
01139	    if ( !bWeaponMode && (Hook(Pawn.SelectedItem) != none) && bHooked && !Hook(Pawn.SelectedItem).bGoDown && !Hook(Pawn.SelectedItem).bGoUp)
01140	    {
01141	      Hook(Pawn.SelectedItem).ActivatedByAltFire = true;
01142	      ActivateItem();
01143	    }
01144	/*
01145	    else if ( XIIIPawn(Pawn).LHand.pOnShoulder != none )
01146	    {
01147	      XIIIPawn(Pawn).LHand.UnGrabPawn();
01148	    }
01149	    else if ( MyInteraction.bCanGrabCorpse || MyInteraction.bCanTakePrisonner )
01150	    {
01151	      XIIIPawn(Pawn).LHand.GrabPawn(XIIIPawn(MyInteraction.TargetActor));
01152	      XIIIPawn(Pawn).CheckMaluses();
01153	    }
01154	*/
01155	//    else if ( !bWeaponMode && (Micro(Pawn.SelectedItem) != none) ) // Creates dependency
01156	    else if ( !bWeaponMode && Pawn.SelectedItem.IsA('Micro') ) // don't create dependency
01157	      Fire();
01158	    else if ( bWeaponMode )
01159	      WeaponZoom();
01160	}
01161	
01162	//_____________________________________________________________________________
01163	// ELR hide/unhide Weapon
01164	simulated function SwitchWeaponMode()
01165	{
01166	    local inventory I;
01167	
01168	    DebugLog(">>> SwitchWeaponMode call, bWeaponMode="$bWeaponMode@"bWaitForWeaponMode="$bWaitForWeaponMode);
01169	
01170	    if ( !bWeaponMode )
01171	    {
01172	      DebugLog("  > Calling PutDown for"@XIIIItems(Pawn.SelectedItem));
01173	      XIIIItems(Pawn.SelectedItem).PutDown();
01174	      if ( XIIIPawn(Pawn).bHaveOnlyOneHandFree && (XIIIWeapon(Pawn.Weapon).WHand == WHA_2HShot) )
01175	        Pawn.PendingWeapon = Pawn.Inventory.NextWeapon(None, Pawn.Weapon);
01176	      else
01177	        Pawn.PendingWeapon = Pawn.Weapon;
01178	    }
01179	    else
01180	    {
01181	      if ( !bHooked ) // Reset to MedKits priority
01182	        XIIIPawn(Pawn).SelectedItem = Pawn.Inventory.NextItem(none, none);
01183	      else
01184	        XIIIPawn(Pawn).SelectedItem = HookUsed;
01185	      if ( XIIIPawn(Pawn).bHaveOnlyOneHandFree && (XIIIItems(Pawn.SelectedItem).IHand == IH_2H) )
01186	        XIIIPawn(Pawn).SelectedItem = Pawn.Inventory.NextItem(none, XIIIPawn(Pawn).SelectedItem);
01187	      if ( XIIIPawn(Pawn).SelectedItem != none )
01188	      {
01189	//        XIIIPawn(Pawn).PendingItem = Pawn.SelectedItem;
01190	        DebugLog("  > Calling PutDown for"@Pawn.Weapon);
01191	        Pawn.Weapon.PutDown();
01192	      }
01193	      else
01194	      { // Cancel Change
01195	        bWaitForWeaponMode = true;
01196	      }
01197	/*
01198	      I = Pawn.Inventory.SelectNext();
01199	//      log("  > SelectNext Result="$I);
01200	      if (I != none )
01201	      {
01202	        XIIIPawn(Pawn).PendingItem = Pawn.SelectedItem;
01203	//        log("  > Calling Putdown for"@Pawn.Weapon);
01204	        Pawn.Weapon.PutDown();
01205	      }
01206	      else
01207	      {
01208	        bWaitForWeaponMode = true;
01209	      }
01210	*/
01211	    }
01212	//    ServerSwitchWeaponMode(bWeaponMode, bWaitForWeaponMode);
01213	}
01214	
01215	//_____________________________________________________________________________
01216	// ELR hide/unhide Weapon (Used by the DecoWeapon to hide weapon then put it back when used)
01217	exec function HideWeapon()
01218	{
01219	    if ( XIIIWeapon(pawn.Weapon) != none )
01220	    {
01221	      if ( bWeaponMode )
01222	        SwitchWeapon( OldWeap );
01223	      else
01224	      {
01225	        OldWeap = pawn.weapon.InventoryGroup;
01226	        switchweapon( 0 );
01227	      }
01228	    }
01229	}
01230	
01231	//_____________________________________________________________________________
01232	exec function PrevWeapon()
01233	{
01234	    if ( Pawn.region.Zone.FlashEffectDesc.IsActivated )
01235	      return;
01236	
01237	    if ( (Pawn.PendingWeapon != none) && (DecoWeapon(Pawn.PendingWeapon) != none) )
01238	      return;
01239	
01240	//    if ( (XIIIItems(Pawn.SelectedItem) != none) && XIIIItems(Pawn.SelectedItem).bChangeItem && !Pawn.SelectedItem.IsAnimating() )
01241	//    { // Bug chance for freezed inventory switching
01242	//      Pawn.SelectedItem.AnimEnd(0);
01243	//    }
01244	//    if ( (Pawn.Weapon != none) && Pawn.Weapon.bChangeWeapon && !Pawn.Weapon.IsAnimating() )
01245	//    { // Bug chance for freezed inventory switching
01246	//      Pawn.Weapon.AnimEnd(0);
01247	//    }
01248	
01249	    Pawn.PendingItem = none;
01250	
01251	    XIIIBaseHud(MyHud).bDrawWeapons = true;
01252	    XIIIBaseHud(MyHud).bDrawItems = false;
01253	    XIIIBaseHud(MyHud).fDrawWeaponsTimer = Level.TimeSeconds + 1.0;
01254	    XIIIBaseHud(MyHud).fDrawItemsTimer = Level.TimeSeconds - 1.0;
01255	
01256	//    if ( bWeaponMode || bWaitForWeaponMode )
01257	    if ( bWaitForWeaponMode )
01258	    {
01259	      if ( Level.Pauser != None )
01260	        return;
01261	      if ( Pawn.Weapon == None )
01262	      {
01263	        SwitchToBestWeapon();
01264	        return;
01265	      }
01266	      if ( Pawn.PendingWeapon != None )
01267	        Pawn.PendingWeapon = Pawn.Inventory.PrevWeapon(None, Pawn.PendingWeapon);
01268	      else
01269	        Pawn.PendingWeapon = Pawn.Inventory.PrevWeapon(None, Pawn.Weapon);
01270	
01271	      if ( Pawn.PendingWeapon != None )
01272	      {
01273	        Pawn.Weapon.PutDown();
01274	      }
01275	    }
01276	    else
01277	    {
01278	      XIIIBaseHud(MyHud).fDrawWeaponsTimer = Level.TimeSeconds+2.0;
01279	      bWaitForWeaponMode = true;
01280	      SwitchWeaponMode();
01281	    }
01282	}
01283	
01284	//_____________________________________________________________________________
01285	exec function NextWeapon()
01286	{
01287	    if ( Pawn.region.Zone.FlashEffectDesc.IsActivated )
01288	      return;
01289	
01290	    if ( (Pawn.PendingWeapon != none) && (DecoWeapon(Pawn.PendingWeapon) != none) )
01291	      return;
01292	
01293	//    if ( (XIIIItems(Pawn.SelectedItem) != none) && XIIIItems(Pawn.SelectedItem).bChangeItem && !Pawn.SelectedItem.IsAnimating() )
01294	//    { // Bug chance for freezed inventory switching
01295	//      Pawn.SelectedItem.AnimEnd(0);
01296	//    }
01297	//    if ( (Pawn.Weapon != none) && Pawn.Weapon.bChangeWeapon && !Pawn.Weapon.IsAnimating() )
01298	//    { // Bug chance for freezed inventory switching
01299	//      Pawn.Weapon.AnimEnd(0);
01300	//    }
01301	    Pawn.PendingItem = none;
01302	
01303	    XIIIBaseHud(MyHud).bDrawWeapons = true;
01304	    XIIIBaseHud(MyHud).bDrawItems = false;
01305	    XIIIBaseHud(MyHud).fDrawWeaponsTimer = Level.TimeSeconds + 1.0;
01306	    XIIIBaseHud(MyHud).fDrawItemsTimer = Level.TimeSeconds - 1.0;
01307	
01308	//    if ( bWeaponMode || bWaitForWeaponMode )
01309	    if ( bWaitForWeaponMode )
01310	    {
01311	//      Log("> NextWeapon call in "$self);
01312	      if( Level.Pauser!=None )
01313	        return;
01314	      if ( Pawn.Weapon == None )
01315	      {
01316	        SwitchToBestWeapon();
01317	        return;
01318	      }
01319	      if ( Pawn.PendingWeapon != None )
01320	        Pawn.PendingWeapon = Pawn.Inventory.NextWeapon(None, Pawn.PendingWeapon);
01321	      else
01322	        Pawn.PendingWeapon = Pawn.Inventory.NextWeapon(None, Pawn.Weapon);
01323	
01324	      if ( Pawn.PendingWeapon != None )
01325	      {
01326	        Pawn.Weapon.PutDown();
01327	      }
01328	    }
01329	    else
01330	    {
01331	      XIIIBaseHud(MyHud).fDrawWeaponsTimer = Level.TimeSeconds+2.0;
01332	      bWaitForWeaponMode = true;
01333	      SwitchWeaponMode();
01334	    }
01335	}
01336	
01337	
01338	//_____________________________________________________________________________
01339	// we want the player to switch to weapon group number F.
01340	exec function SwitchWeapon( byte F )
01341	{
01342		local weapon newWeapon;
01343	
01344		if ( (Pawn == none) || Pawn.bIsDead )
01345		  return;
01346	
01347		if ( (Level.Pauser!=None) || (Pawn == None) || (Pawn.Inventory == None) )
01348			return;
01349		if ( (Pawn.Weapon != None) && (Pawn.Weapon.Inventory != None) )
01350			newWeapon = Pawn.Weapon.Inventory.WeaponChange(F);
01351		else
01352			newWeapon = None;
01353		if ( newWeapon == None )
01354			newWeapon = Pawn.Inventory.WeaponChange(F);
01355	
01356		if ( newWeapon == None )
01357		{ // ELR Don't just return, switchweapon(0) instead
01358	    SwitchWeapon(0);
01359	  	return;
01360	  }
01361	
01362		if ( Pawn.Weapon == None )
01363		{
01364			Pawn.PendingWeapon = newWeapon;
01365			Pawn.ChangedWeapon();
01366		}
01367		else if ( Pawn.Weapon != newWeapon )
01368		{
01369			Pawn.PendingWeapon = newWeapon;
01370			if ( !Pawn.Weapon.PutDown() )
01371				Pawn.PendingWeapon = None;
01372		}
01373	}
01374	
01375	/*
01376	//_____________________________________________________________________________
01377	exec function TestNI()
01378	{
01379	    local int i;
01380	    local inventory Inv;
01381	
01382	    Inv = Pawn.Inventory;
01383	    Log("BEGIN Testing NextItem From PawnInventory"@Inv);
01384	    for (i=0; i<5; i++)
01385	    {
01386	      if ( inv != none )
01387	      {
01388	        if ( PowerUps(Inv) != none )
01389	          Inv = Inv.NextItem(none, PowerUps(Inv));
01390	        else
01391	          Inv = Inv.NextItem(none, none);
01392	        if ( Inv != none )
01393	          Log("  Next Inv="$Inv);
01394	        else
01395	          Log("  Next Inv=NONE");
01396	      }
01397	    }
01398	    Log("END Testing NextItem");
01399	    Inv = Pawn.Inventory;
01400	    Log("BEGIN Testing NextItem From PawnSelectedItem"@Pawn.SelectedItem);
01401	    for (i=0; i<5; i++)
01402	    {
01403	      if ( inv != none )
01404	      {
01405	        if ( Pawn.SelectedItem != none )
01406	          Inv = Inv.NextItem(none, Pawn.SelectedItem);
01407	        else
01408	          Inv = Inv.NextItem(none, none);
01409	        if ( Inv != none )
01410	          Log("  Next Inv="$Inv);
01411	        else
01412	          Log("  Next Inv=NONE");
01413	      }
01414	    }
01415	    Log("END Testing NextItem");
01416	}
01417	*/
01418	
01419	//_____________________________________________________________________________
01420	// ELR Just to cancel it in some states
01421	exec function cPrevItem()
01422	{
01423	    Local inventory tInv;
01424	
01425	    if ( Pawn.region.Zone.FlashEffectDesc.IsActivated )
01426	      return;
01427	
01428	    DebugLog("PREVITEM bWeaponMode="$bWeaponMode@"PendingWeapon="$Pawn.PendingWeapon);
01429	
01430	    if ( DecoWeapon(Pawn.PendingWeapon) != none )
01431	      return;
01432	
01433	//    if ( (XIIIItems(Pawn.SelectedItem) != none) && XIIIItems(Pawn.SelectedItem).bChangeItem && !Pawn.SelectedItem.IsAnimating() )
01434	//    { // Bug chance for freezed inventory switching
01435	//      Pawn.SelectedItem.AnimEnd(0);
01436	//    }
01437	//    if ( (Pawn.Weapon != none) && Pawn.Weapon.bChangeWeapon && !Pawn.Weapon.IsAnimating() )
01438	//    { // Bug chance for freezed inventory switching
01439	//      Pawn.Weapon.AnimEnd(0);
01440	//    }
01441	
01442	    Pawn.PendingWeapon = none;
01443	
01444	    XIIIBaseHud(MyHud).bDrawWeapons=false;
01445	    XIIIBaseHud(MyHud).bDrawItems = true;
01446	    XIIIBaseHud(MyHud).fDrawItemsTimer = 1.0+Level.TimeSeconds;
01447	    XIIIBaseHud(MyHud).fDrawWeaponsTimer = Level.TimeSeconds-1.0;
01448	
01449	//    if ( !bWeaponMode || !bWaitForWeaponMode )
01450	    if ( !bWaitForWeaponMode )
01451	    { // Selecting next item
01452	      DebugLog("  > cPrevItem call in "$self$", switching items w/ SelectedItem="$Pawn.SelectedItem);
01453	      if( Level.Pauser != None )
01454	        return;
01455	      if ( XIIIPawn(Pawn).PendingItem == none )
01456	        XIIIPawn(Pawn).PendingItem = Pawn.Inventory.PrevItem(none, Pawn.SelectedItem);
01457	      else
01458	        XIIIPawn(Pawn).PendingItem = Pawn.Inventory.PrevItem(none, XIIIPawn(Pawn).PendingItem);
01459	      if ( (XIIIPawn(Pawn).PendingItem != None) && (XIIIPawn(Pawn).PendingItem != Pawn.SelectedItem) )
01460	      {
01461	        if(  XIIIItems(Pawn.SelectedItem) != none )
01462	        {
01463	          XIIIItems(Pawn.SelectedItem).PutDown();
01464	          DebugLog("  > cPrevItem puting down"@XIIIItems(Pawn.SelectedItem));
01465	        }
01466	        else
01467	        {
01468	          Pawn.SelectedItem = XIIIPawn(Pawn).PendingItem;
01469	          XIIIItems(XIIIPawn(Pawn).PendingItem).BringUp();
01470	          DebugLog("  > cPrevItem BringUp"@XIIIPawn(Pawn).PendingItem@"because selected = none");
01471	        }
01472	        return;
01473	      }
01474	      if ( (XIIIPawn(Pawn).PendingItem == None) && (Pawn.SelectedItem == none) )
01475	      {
01476	        Warn("!@! PrevItem w/ Pending item & Item none");
01477	        NextWeapon();
01478	        Pawn.ChangedWeapon();
01479	      }
01480	    }
01481	    else
01482	    {
01483	      DebugLog(">>> cPrevItem call in "$self$", going to item mode");
01484	      XIIIBaseHud(MyHud).fDrawItemsTimer = 2.0+Level.TimeSeconds;
01485	      bWaitForWeaponMode = false;
01486	      SwitchWeaponMode();
01487	    }
01488	}
01489	
01490	//_____________________________________________________________________________
01491	// ELR Just to cancel it in some states
01492	exec function cNextItem()
01493	{
01494	    Local inventory tInv;
01495	
01496	    if ( Pawn.region.Zone.FlashEffectDesc.IsActivated )
01497	      return;
01498	
01499	    DebugLog("NEXTITEM bWeaponMode="$bWeaponMode@"PendingWeapon="$Pawn.PendingWeapon);
01500	
01501	    if ( DecoWeapon(Pawn.PendingWeapon) != none )
01502	      return;
01503	
01504	//    if ( (XIIIItems(Pawn.SelectedItem) != none) && XIIIItems(Pawn.SelectedItem).bChangeItem && !Pawn.SelectedItem.IsAnimating() )
01505	//    { // Bug chance for freezed inventory switching
01506	//      Pawn.SelectedItem.AnimEnd(0);
01507	//    }
01508	//    if ( (Pawn.Weapon != none) && Pawn.Weapon.bChangeWeapon && !Pawn.Weapon.IsAnimating() )
01509	//    { // Bug chance for freezed inventory switching
01510	//      Pawn.Weapon.AnimEnd(0);
01511	//    }
01512	
01513	    Pawn.PendingWeapon = none;
01514	
01515	    XIIIBaseHud(MyHud).bDrawWeapons = false;
01516	    XIIIBaseHud(MyHud).bDrawItems = true;
01517	    XIIIBaseHud(MyHud).fDrawItemsTimer = 1.0+Level.TimeSeconds;
01518	    XIIIBaseHud(MyHud).fDrawWeaponsTimer = Level.TimeSeconds-1.0;
01519	
01520	//    if ( !bWeaponMode || !bWaitForWeaponMode )
01521	    if ( !bWaitForWeaponMode )
01522	    { // Selecting next item
01523	      DebugLog("  > cNextItem call in "$self$", switching items w/ SelectedItem="$Pawn.SelectedItem);
01524	      if( Level.Pauser != None )
01525	        return;
01526	      if ( XIIIPawn(Pawn).PendingItem == none )
01527	        XIIIPawn(Pawn).PendingItem = Pawn.Inventory.NextItem(none, Pawn.SelectedItem);
01528	      else
01529	        XIIIPawn(Pawn).PendingItem = Pawn.Inventory.NextItem(none, XIIIPawn(Pawn).PendingItem);
01530	      if ( (XIIIPawn(Pawn).PendingItem != None) && (XIIIPawn(Pawn).PendingItem != Pawn.SelectedItem) )
01531	      {
01532	        if ( XIIIItems(Pawn.SelectedItem) != none )
01533	        {
01534	          XIIIItems(Pawn.SelectedItem).PutDown();
01535	          DebugLog("  > cNextItem puting down"@XIIIItems(Pawn.SelectedItem));
01536	        }
01537	        else
01538	        {
01539	          Pawn.SelectedItem = XIIIPawn(Pawn).PendingItem;
01540	          XIIIItems(XIIIPawn(Pawn).PendingItem).BringUp();
01541	          DebugLog("  > cNextItem BringUp"@XIIIPawn(Pawn).PendingItem@"because selected = none");
01542	        }
01543	        return;
01544	      }
01545	      if ( (XIIIPawn(Pawn).PendingItem == None) && (Pawn.SelectedItem == none) )
01546	      {
01547	        Warn("!@! PrevItem w/ Pending item & Item none");
01548	        NextWeapon();
01549	        Pawn.ChangedWeapon();
01550	      }
01551	    }
01552	    else
01553	    {
01554	      DebugLog(">>> cNextItem call in "$self$", going to item mode");
01555	      XIIIBaseHud(MyHud).fDrawItemsTimer = 2.0+Level.TimeSeconds;
01556	      bWaitForWeaponMode = false;
01557	      SwitchWeaponMode();
01558	    }
01559	}
01560	
01561	//_____________________________________________________________________________
01562	exec function WeaponZoom()
01563	{
01564	//    Log(self@" WeaponZoom");
01565	    if ( (Pawn != None) && (Pawn.Weapon != None) )
01566	    {
01567	      if ( XIIIWeapon(Pawn.Weapon).bHaveAltFire )
01568	      {
01569	//        Log(self@" calling Altfire");
01570	        Pawn.Weapon.AltFire(0);
01571	      }
01572	      else
01573	      {
01574	//        Log(self@" calling zoom");
01575	        Pawn.Weapon.Zoom();
01576	      }
01577	    }
01578	}
01579	
01580	//_____________________________________________________________________________
01581	exec function Grab()
01582	{
01583	    local PowerUps PwrU;
01584	
01585	    DebugLog("GRAB");
01586	    // If in cameraview, restore view instead of interaction
01587	    if ( IsInState('CameraView') )
01588	    {
01589	      RestoreView();
01590	      return;
01591	    }
01592	
01593	    // Hook interactions
01594	    if ( bHooked )
01595	    {
01596	      if ( !bWeaponMode  )
01597	      {
01598	        if ( (Hook(Pawn.SelectedItem) != none) )
01599	        {
01600	          Hook(Pawn.SelectedItem).Release();
01601	          return;
01602	        }
01603	      }
01604	      else if ( bWaitForWeaponMode )
01605	      {
01606	        cNextItem();
01607	        return;
01608	      }
01609	    }
01610	    if ( MyInteraction.bCanHook )
01611	    {
01612	      ActivateItem();
01613	      return;
01614	    }
01615	
01616	    if ( MyInteraction.bCanBreak )
01617	    {
01618	      MyInteraction.TargetActor.TakeDamage(50, Pawn, MyInteraction.TargetActor.Location, vect(0,0,0), class'DTFisted');
01619	      MyInteraction.TargetActor = none;
01620	      return;
01621	    }
01622	
01623	    // Priority to interaction w/ door
01624	    if ( MyInteraction.bCanDoor && !MyInteraction.bCanTrigger )
01625	    {
01626	      if ( MyInteraction.bCanUnLockDoor )
01627	      {
01628	        PwrU = TryInteractWithDoor(MyInteraction.TargetActor);
01629	        if ( ( bWeaponMode ) && (PwrU != none) )
01630	        {
01631	          cNextItem();
01632	          XIIIPawn(Pawn).PendingItem = PwrU;
01633	          if ( (XIIIPawn(Pawn).PendingItem != None) && (XIIIPawn(Pawn).PendingItem != Pawn.SelectedItem) )
01634	            XIIIItems(Pawn.SelectedItem).PutDown();
01635	          return;
01636	        }
01637	        else if ( (!bWeaponMode) && (PwrU != none) )
01638	        {
01639	          if (PwrU == Pawn.SelectedItem)
01640	            Pawn.SelectedItem.Activate();
01641	          else
01642	          {
01643	            cNextItem();
01644	            XIIIPawn(Pawn).PendingItem = PwrU;
01645	            if ( (XIIIPawn(Pawn).PendingItem != None) && (XIIIPawn(Pawn).PendingItem != Pawn.SelectedItem) )
01646	              XIIIItems(Pawn.SelectedItem).PutDown();
01647	          }
01648	          return;
01649	        }
01650	        else if ( XIIIMover(MyInteraction.TargetActor) != none )
01651	        {
01652	          if ( XIIIBaseHud(MyHud).HudDlg == none ) // only send this message if not in a dialog already
01653	            MyHud.LocalizedMessage( class'XIIIDialogMessage', 1, none, none, none, XIIIMover(MyInteraction.TargetActor).LockedMessage );
01654	          return;
01655	        }
01656	      }
01657	      else
01658	      {
01659	        if ( XIIIMover(MyInteraction.TargetActor) != none )
01660	        {
01661	          XIIIMover(MyInteraction.TargetActor).PlayerTrigger(self, Pawn);
01662	          XIIIPawn(Pawn).PlayOpenDoor();
01663	          return;
01664	        }
01665	        else if ( MagneticPassTrigger(MyInteraction.TargetActor) != none )
01666	        {
01667	          MagneticPassTrigger(MyInteraction.TargetActor).PlayerTrigger(self, Pawn);
01668	          XIIIPawn(Pawn).PlayOpenDoor();
01669	          return;
01670	        }
01671	      }
01672	    }
01673	
01674	    // next priority to search a corpse
01675	    if ( MyInteraction.bCanSearchCorpse )
01676	    {
01677	      SearchPawn(XIIIPawn(MyInteraction.TargetActor));
01678	      return;
01679	    }
01680	
01681	    if ( MyInteraction.bCanPickup )
01682	    {
01683	      DebugLog("GRAB PICKUP");
01684	      if ( MyInteraction.TargetActor.IsA('XIIIDecoPickup')
01685	//        && ((DecoWeapon(Pawn.Weapon) != none) || (DecoWeapon(Pawn.PendingWeapon) != none)) )
01686	        && ((DecoWeapon(Pawn.PendingWeapon) != none) || (DecoWeapon(Pawn.Weapon) != none)) )
01687	        return;
01688	      bPickingUp = true;
01689	      MyInteraction.TargetActor.Touch(Pawn);
01690	      bPickingUp = false;
01691	      MyInteraction.TargetActor = none;
01692	      return;
01693	    }
01694	
01695	    // then trigger actor
01696	    if ( MyInteraction.bCanTrigger )
01697	    {
01698	      PwrU = TryInteractWithTrigger(MyInteraction.TargetActor);
01699	//      Log("GRAB TRIGGER, Interaction item should be PwrU="$PwrU);
01700	      if ( ( bWeaponMode ) && (PwrU != none) )
01701	      {
01702	        cNextItem();
01703	        XIIIPawn(Pawn).PendingItem = PwrU;
01704	        if ( (XIIIPawn(Pawn).PendingItem != None) && (XIIIPawn(Pawn).PendingItem != Pawn.SelectedItem) )
01705	          XIIIItems(Pawn.SelectedItem).PutDown();
01706	      }
01707	      else if ( (!bWeaponMode) && (PwrU != none) )
01708	      {
01709	        if (PwrU == Pawn.SelectedItem)
01710	          Pawn.SelectedItem.Activate();
01711	        else
01712	        {
01713	          cNextItem();
01714	          XIIIPawn(Pawn).PendingItem = PwrU;
01715	          if ( (XIIIPawn(Pawn).PendingItem != None) && (XIIIPawn(Pawn).PendingItem != Pawn.SelectedItem) )
01716	            XIIIItems(Pawn.SelectedItem).PutDown();
01717	        }
01718	      }
01719	      else
01720	        XIIITriggers(MyInteraction.TargetActor).PlayerTrigger(self, Pawn);
01721	      return;
01722	    }
01723	
01724	    if ( MyInteraction.bCantDoor )
01725	    {
01726	      XIIIMover(MyInteraction.TargetActor).PlayerTrigger(self, Pawn);
01727	      return;
01728	    }
01729	
01730	    // next priority to grab/ungrab pawn
01731	    if ( XIIIPawn(Pawn).LHand != none )
01732	    {
01733	      if ( XIIIPawn(Pawn).LHand.pOnShoulder != none )
01734	      {
01735	        XIIIPawn(Pawn).LHand.UnGrabPawn();
01736	        return;
01737	      }
01738	      else if (
01739	          (MyInteraction.bCanGrabCorpse && XIIIPawn(Pawn).CanGrabCorpse(XIIIPawn(MyInteraction.TargetActor)) )
01740	       || (MyInteraction.bCanTakePrisonner && XIIIPawn(Pawn).CanTakePrisonner(XIIIPawn(MyInteraction.TargetActor))) )
01741	      {
01742	        if ( bWeaponMode && Pawn.Weapon.bHaveSlave )
01743	          Pawn.Weapon.MySlave.PutDown();
01744	        XIIIPawn(Pawn).LHand.GrabPawn(XIIIPawn(MyInteraction.TargetActor));
01745	        XIIIPawn(Pawn).CheckMaluses();
01746	        return;
01747	      }
01748	    }
01749	
01750	    if ( bWeaponMode && (Pawn.Weapon.Default.ReloadCount > Pawn.Weapon.ReloadCount) )
01751	    {
01752	      ReLoad();
01753	      return;
01754	    }
01755	
01756	    if ( !bWeaponMode && Pawn.SelectedItem.IsA('Med') )
01757	    {
01758	      Pawn.SelectedItem.Activate();
01759	      return;
01760	    }
01761	}
01762	
01763	//_____________________________________________________________________________
01764	// The player wants to active selected item
01765	exec function ActivateItem()
01766	{
01767	    DebugLog("Activate Item"@Pawn.SelectedItem);
01768	    if ( Level.Pauser!=None )
01769	      return;
01770	    if ( (Pawn != None) && (Pawn.SelectedItem!=None) )
01771	      Pawn.SelectedItem.Activate();
01772	}
01773	
01774	//_____________________________________________________________________________
01775	// ELR - Do we still pick the lock ? return true if no.
01776	function bool CanUseLockPick()
01777	{
01778	    if ( XIIIPorte(MyInteraction.TargetActor) == none )
01779	      return false;
01780	    return ( XIIIPorte(MyInteraction.TargetActor).IsInState('Locked') );
01781	}
01782	
01783	//_____________________________________________________________________________
01784	// ELR - Do we still pick the lock ? return true if no.
01785	function bool CheckPickLock()
01786	{
01787	    local actor HitActor;
01788	
01789	    HitActor = MyInteraction.TargetActor;
01790	    if ( (HitActor == none) || (aDoor != HitActor) )
01791	    {
01792	      if ( aDoor != none )
01793	        aDoor.UnTrigger( Pawn.SelectedItem, pawn );
01794	      aDoor = none;
01795	      return true;
01796	    }
01797	    if ( aDoor.IsInState('PlayerTriggerToggle') )
01798	    { // Unlocked
01799	      aDoor = none;
01800	      MyHud.LocalizedMessage(class'XIIISoloMessage', 2);
01801	    }
01802	    return false;
01803	}
01804	
01805	//_____________________________________________________________________________
01806	// ELR - Do we still pick the lock ? return true if no.
01807	function CancelPickLock()
01808	{
01809	    if ( aDoor != none )
01810	      aDoor.UnTrigger( Pawn.SelectedItem, pawn );
01811	    aDoor = none;
01812	}
01813	
01814	//_____________________________________________________________________________
01815	// ELR - Here we define if the controller allow the use of a lockpick
01816	function bool TryPickLock()
01817	{
01818	    aDoor = XIIIPorte(MyInteraction.TargetActor);
01819	//    DebugLog("TryPickLock "$aDoor);
01820	    if ( (aDoor != none) && aDoor.IsInState('Locked') )
01821	    {
01822	      aDoor.Trigger( Pawn.SelectedItem, Pawn );
01823	//      MyHud.LocalizedMessage(class'XIIISoloMessage', 1);
01824	      return true;
01825	    }
01826	    else
01827	      aDoor = none;
01828	    return false;
01829	}
01830	
01831	//_____________________________________________________________________________
01832	// return the inventory object to be used to interact with A
01833	// should be used w/ Grab Controller function to automatically get the item out.
01834	function PowerUps TryInteractWithDoor(actor A)
01835	{
01836	  Local XIIIPorte XP;
01837	  local PowerUps I;
01838	
01839	  XP = XIIIPorte(A);
01840	  if ( (XP != none) && XP.IsInState('Locked') )
01841	  {
01842	    I = XIIIPawn(Pawn).FindPowerUpItemName(XP.UnLockItemName);
01843	    if ( I == none )
01844	      I = XIIIPawn(Pawn).FindPowerUpItemName(XP.UnLockItemCode);
01845	//    Log(">> "$I$" should be used to interact with "$A);
01846	    return I;
01847	  }
01848	
01849	  return none;
01850	}
01851	
01852	//_____________________________________________________________________________
01853	// return the inventory object to be used to interact with A
01854	// should be used w/ Grab Controller function to automatically get the item out.
01855	function PowerUps TryInteractWithTrigger(actor A)
01856	{
01857	  Local XIIITriggers XT;
01858	  local PowerUps I;
01859	
01860	  XT = XIIITriggers(A);
01861	  if ( XT != none )
01862	  {
01863	//    Log("TryInteractWithTrigger XT="$XT$" TAG="$XT.Tag);
01864	    I = XIIIPawn(Pawn).FindPowerUpItemNameForTrigger(XT.Tag);
01865	//    Log(">> "$I$" should be used to interact with "$A);
01866	    return I;
01867	  }
01868	
01869	  return none;
01870	}
01871	
01872	//_____________________________________________________________________________
01873	// ::TODO:: put in native (may not optimize the trace but everytinh else & called each frame so...)
01874	function actor ReturnTrace(out vector HitLoc, out vector HitNorm, vector End, vector Start, bool bActor, optional vector Extent, optional out Material HitMat, optional int TraceType)
01875	{
01876	    local actor PickMe, PotentialDoor;
01877	    local vector HitLoc2, HitNorm2;
01878	
01879	    foreach TraceActors(class'actor', Pickme, HitLoc, HitNorm, End, Start, vect(0,0,0), TraceType)
01880	    {
01881	      if ( Pickme == Level ) // stop the iterator at first Level hit
01882	        return none;
01883	      if ( (Pickme != none) && Pickme.bInteractive && (PickMe != Pawn) )
01884	      {
01885	        if ( XIIIPorte(Pickme) != none )
01886	        {
01887	          PotentialDoor = Trace(HitLoc2, HitNorm2, HitLoc - HitNorm, Start, false, vect(0,0,0), HitMat, TraceType);
01888	          if ( PotentialDoor != none )
01889	          {
01890	            HitLoc = hitLoc2;
01891	            HitNorm = hitNorm2;
01892	            Pickme = PotentialDoor;
01893	            return PickMe;
01894	          }
01895	          else if ( FastTrace(HitLoc, Start) )
01896	            return PickMe;
01897	        }
01898	        else
01899	        {
01900	          if ( FastTrace(HitLoc, Start) )
01901	          {
01902	            if ( Pickup(PickMe) != none )
01903	              return PickMe;
01904	            else
01905	              return PickMe;
01906	          }
01907	        }
01908	      }
01909	    }
01910	    return none;
01911	}
01912	
01913	//_____________________________________________________________________________
01914	function bool AllowHooking()
01915	{
01916	    return ( !bWeaponMode && (Hook(Pawn.SelectedItem)!=none) );
01917	}
01918	
01919	//_____________________________________________________________________________
01920	// ELR - check if we can send the controller into Tyrol state
01921	function bool TryTyroling()
01922	{
01923	    return true;
01924	}
01925	
01926	//_____________________________________________________________________________
01927	// Set up the tyroling params, called by TyrolTrigger
01928	function GoTyroling(XIIITyrolNavPoint StartPoint, XIIITyrolNavPoint EndPoint, float TyrolSpeed)
01929	{
01930	//    Log("SetUpTyrol w/ StartPoint="$StartPoint$" EndPoint="$EndPoint$" TyrolSpeed="$TyrolSpeed);
01931	    fTyrolSpeed = TyrolSpeed;
01932	    vTyrolStart = StartPoint.Location - vect(0,0,1)*Pawn.CollisionHeight;
01933	    vTyrolEnd = EndPoint.Location - vect(0,0,1)*Pawn.CollisionHeight;
01934	    vTyrolDir = normal(vTyrolEnd - vTyrolStart);
01935	    Pawn.SetPhysics(PHYS_None);
01936	    Pawn.SetLocation(vTyrolStart);
01937	    Pawn.SetRotation(rotator(vTyrolDir));
01938	    Pawn.Velocity = vTyrolDir * 5.0;
01939	    Pawn.Acceleration = vect(0,0,0);
01940	    SetLocation(vTyrolStart);
01941	    SetRotation(rotator(vTyrolDir));
01942	    gotoState('Tyroling');
01943	}
01944	
01945	//_____________________________________________________________________________
01946	function SearchPawn(XIIIPawn P)
01947	{
01948	    local inventory I, OwnI;
01949	    local class<ammo> A;
01950	    local bool bDBSearch;
01951	    local ammunition IAmmo, IAltAmmo;
01952	
01953	    bDBSearch = false;
01954	
01955	    if ( !P.bIsDead )
01956	      return;
01957	    if ( bDBSearch ) Log(" investigating "$P$" corpse");
01958	
01959	    XIIIPawn(Pawn).PlaySearchCorpse();
01960	
01961	//    XIIICheatManager(CheatManager).LogInventory();
01962	    if (P.Inventory == none)
01963	    {
01964	      ReceiveLocalizedMessage( class'XIIISoloMessage', 4, None, None);
01965	      return;
01966	    }
01967	
01968	    if ( P.Shadow != none )
01969	    {
01970	      P.Shadow.bShadowIsStatic = false;
01971	      P.SetTimer2(0.2, false);
01972	    }
01973	
01974	    if ( bDBSearch ) Log(">>> SearchPawn");
01975	    I = P.Inventory;
01976	    while ( I != none )
01977	    {
01978	      if ( bDBSearch )
01979	      {
01980	        if ( Weapon(I) != none )
01981	          Log(" >> Processing Weapon "$I$" ReloadCount="$Weapon(I).ReloadCount@"AmmoType="$Weapon(i).AmmoType@"AltAmmoType="$Weapon(i).AltAmmoType);
01982	        else
01983	          Log(" >> Processing "$I);
01984	      }
01985	      I.Transfer(Pawn); // all transfer handling is in subclasses.
01986	      I = P.Inventory;
01987	    }
01988	}
01989	
01990	//_____________________________________________________________________________
01991	// ELR Added to make b180Left and b180Right working.
01992	// (Actually used as b90Left and b90Right :)
01993	function TurnAround()
01994	{
01995	    if ( !bSetTurnRot )
01996	    {
01997	      TurnRot180 = Rotation;
01998	      // For 90� turn
01999	      TurnRot180.Yaw += 16384 * (b90Right - b90Left);
02000	      // For 180� turn
02001	      TurnRot180.Yaw += 32768 * b180turn;
02002	      bSetTurnRot = true;
02003	    }
02004	    DesiredRotation = TurnRot180;
02005	    bTurnWanted = ( DesiredRotation.Yaw != Rotation.Yaw );
02006	}
02007	
02008	//_____________________________________________________________________________
02009	// Simulated weapon feedback
02010	// Not called by H2HAmmo
02011	function ClientViewFeedBackSetup(class<XIIIWeapon> WeapClass, optional bool bAmplify)
02012	{
02013	    if ( bAmplify ) // used for dual weapons amplified feedback
02014	      vWeaponFeedBack += vect(1.5,0,0)*WeapClass.default.ViewFeedBack.x*(fRand()-0.5) + vect(0,1.5,0)*WeapClass.default.ViewFeedBack.y*(abs(fRand()*0.7)+0.3);
02015	    else
02016	      vWeaponFeedBack = vect(0.5,0,0)*WeapClass.default.ViewFeedBack.x*(fRand()-0.5) + vect(0,0.5,0)*WeapClass.default.ViewFeedBack.y*(abs(fRand()*0.7)+0.3);
02017	    if ( (Level.GetPlateforme() == 1) || (Level.GetPlateforme() == 3) ) // PS2 + GC, reduce feedback
02018	      vWeaponFeedBack *= 0.4;
02019	}
02020	
02021	//_____________________________________________________________________________
02022	// Simulated weapon feedback
02023	// Not called by H2HAmmo
02024	function ClientViewAltFeedBackSetup(class<XIIIWeapon> WeapClass, optional bool bAmplify)
02025	{
02026	    if ( bAmplify ) // used for dual weapons amplified feedback
02027	      vWeaponFeedBack = vect(1.5,0,0)*WeapClass.default.AltViewFeedBack.x*(fRand()-0.5) + vect(0,1.5,0)*WeapClass.default.AltViewFeedBack.y*(abs(fRand()*0.7)+0.3);
02028	    else
02029	      vWeaponFeedBack = vect(0.5,0,0)*WeapClass.default.AltViewFeedBack.x*(fRand()-0.5) + vect(0,0.5,0)*WeapClass.default.AltViewFeedBack.y*(abs(fRand()*0.7)+0.3);
02030	    if ( (Level.GetPlateforme() == 1) || (Level.GetPlateforme() == 3) ) // PS2 + GC, reduce feedback
02031	      vWeaponFeedBack *= 0.4;
02032	}
02033	
02034	//_____________________________________________________________________________
02035	function UpdateRotation(float DeltaTime, float maxPitch)
02036	{
02037	    local rotator newRotation, ViewRotation;
02038	    local int WeaponFeedBackPitch;
02039	    local vector LocalAim;
02040	    local int i;
02041	    local float fSpeedLimit, fDistFact;
02042	
02043	    if ( bInterpolating || ((Pawn != None) && Pawn.bInterpolating) )
02044	    { // only treat shakes when interpolating
02045	      ViewShake(deltaTime);
02046	      return;
02047	    }
02048	
02049	    ViewRotation = Rotation;
02050	    DesiredRotation = ViewRotation; //save old rotation
02051	
02052	    if ( (b90Left != 0) || (b90Right != 0) || (b180Turn != 0) )
02053	      TurnAround();
02054	    else
02055	      bSetTurnRot = false;
02056	
02057	    if ( bTurnToNearest != 0 )
02058	      TurnTowardNearestEnemy();
02059	    else if ( Pawn != none )
02060	    {
02061	      TurnTarget = None;
02062	      if ( bTurnWanted )
02063	      {
02064	        ViewRotation.Yaw = (ViewRotation.Yaw * (1/Deltatime)/10 + DesiredRotation.Yaw)/((1/Deltatime)/10+1);
02065	      }
02066	      bTurnWanted = false;
02067	
02068	      if ( !bFixedCrosshair )
02069	      {
02070	        // ELR Try reducing turn speed when locking someone.
02071	        if ( bLocked )
02072	        {
02073	//          aTurn *= 0.5;
02074	//          aLookUp *= 0.5;
02075	          fSpeedLimit = fClamp(Abs(LocalAim.Y) / 0.7, 0.5, 1.0);
02076	          PlayerInput.ViewTurnAcc = fClamp(PlayerInput.ViewTurnAcc, -fSpeedLimit, fSpeedLimit);
02077	          PlayerInput.ViewUpAcc = fClamp(PlayerInput.ViewUpAcc, -0.5, 0.5); // don't limit as much as pawns have more height than width.
02078	          PlayerInput.ViewTurnBoost = 0.0;
02079	          if ( bRotationAssist && (aTurn == 0) && ((aStrafe != 0) || (aForward != 0)) && (Level.Game != none) && (Level.Game.Difficulty <= 1) )
02080	  //        if ( bRotationAssist && ((aStrafe != 0) || (aForward != 0)) && (Level.Game != none) && (Level.Game.Difficulty <= 1) )
02081	  //        if ( bRotationAssist )// && (aTurn == 0) ) // test, to help guys w/ no arms playing XIII
02082	          { // Assist rotation toward besttarget
02083	            LocalAim = OldAdjustAim << Rotation; // Adjustaim vector in local coords
02084	            aTurn += LocalAim.y * 1800;
02085	          }
02086	        }
02087	      }
02088	      else
02089	      {
02090	        //============== CYD+b
02091	        // mode bFixedCrosshair : true
02092	
02093	        if ( bLocked )
02094	        {
02095	          // AdjustAim vector in local coords
02096	          LocalAim = OldAdjustAim << Rotation;
02097	          fDistFact = fClamp(vSize(BestTarget.Location - Pawn.Location)/3000.f, 0.1, 1.0);
02098	
02099	//          Log("turning toward target="$(aTurn*LocalAim.Y >= 0));
02100	          // TURN SPEED
02101	          fSpeedLimit = fClamp(Abs(LocalAim.Y) / 0.7 / fDistFact, 0.40, 1.0);
02102	          // Try to avoid 'bumper' effect
02103	          PlayerInput.ViewTurnAcc = fClamp(PlayerInput.ViewTurnAcc, -fSpeedLimit, fSpeedLimit);
02104	          PlayerInput.ViewUpAcc = fClamp(PlayerInput.ViewUpAcc, -0.5, 0.5); // don't limit as much as pawns have more height than width.
02105	          PlayerInput.ViewTurnBoost = 0.0;
02106	
02107	          // HELP ON TARGETING
02108	          if ( bRotationAssist
02109	            && (aTurn == 0) && (aLookUp == 0)
02110	            && ((aStrafe != 0) || (aForward != 0))
02111	            && ( (Level.Game == none) // either on Clients
02112	               || !Level.bLonePlayer  // or not in solo
02113	               || (Level.Game.Difficulty <= 1)) )  // or in solo w/ low difficulty
02114	          {
02115	            if (aStrafe != 0)
02116	            {
02117	              aTurn += localAim.y * 200.0;
02118	              if( !Pawn.bIsCrouched )
02119	              {
02120	                aTurn -= aStrafe * 0.048f * (1.0-fDistFact)*(1.0-fDistFact);
02121	              }
02122	            }
02123	            if (aForward != 0) // Help more if player moving forward/backward
02124	              aTurn += 315.f * LocalAim.y;
02125	
02126	            // limit feedback & try to avoid speed up when exiting 'cushion'
02127	            vWeaponFeedBack.y       *= 0.90f;
02128	            vWeaponFeedBackReturn.y *= 0.90f;
02129	          }
02130	        }
02131	        //============== CYD+e
02132	      }
02133	
02134	      // if turning around, SpeedUp taptaps fade
02135	      if ( (aTurn != 0) || (aLookUp != 0) )
02136	        for (i=0; i<5; i++ )
02137	          if ( MyHud.fDrawSixSenseTimer[i] > 0 )
02138	            MyHud.fDrawSixSenseTimer[i] -= XIIIBaseHud(MyHud).dT*6.0;
02139	
02140	      if ( bCenterView )
02141	      {
02142	//        Log("Cancelling aLook because centerview command");
02143	        aLookUp = 0;
02144	      }
02145	      // ELR WeaponFeedBack
02146	      if ( Pawn.IsLocallyControlled() && ((abs(vWeaponFeedBack.y) > 0.1) || (abs(vWeaponFeedBack.x) > 0.1))
02147	        )
02148	      { // Move view because of weapon feedback
02149	        vWeaponFeedBack.x *= 1.0 - fMin(1.0, 0.25 * 64.0 * DeltaTime); // not really proportional to framerate but
02150	        vWeaponFeedBack.y *= 1.0 - fMin(1.0, 0.25 * 64.0 * DeltaTime); // sfx is more attenuated if low framerate so it's ok
02151	
02152	        WeaponFeedBackPitch = (100.0 * vWeaponFeedBack.y) * 64 * DeltaTime + ViewRotation.Pitch;
02153	        WeaponFeedBackPitch = WeaponFeedBackPitch & 65535;
02154	        // Memorize offset
02155	        If ((WeaponFeedBackPitch < 15500) || (WeaponFeedBackPitch > 50000))
02156	        { // only memorize this displacement if it will occur (not limited by view)
02157	          vWeaponFeedBackReturn.y += 100.0 * vWeaponFeedBack.y * 64 * DeltaTime;
02158	        }
02159	        // these one are memorized
02160	        vWeaponFeedBackReturn.x += 100.0 * vWeaponFeedBack.x * 64 * DeltaTime;
02161	        vWeaponFeedBackReturn.y += aLookUp;
02162	        // Update view
02163	        aTurn += 100.0 * vWeaponFeedBack.x * 64 * DeltaTime;
02164	        aLookUp += 100.0 * vWeaponFeedBack.y * 64 * DeltaTime;
02165	        // reduce effect
02166	      }
02167	      else
02168	      { // Return smoothly to pos.
02169	//        XIIIPawn(Pawn).bJumpFeedBack=false;
02170	        aTurn -= vWeaponFeedBackReturn.x * 0.20 * 64 * DeltaTime;
02171	        aLookUp -= vWeaponFeedBackReturn.y * 0.20 * 64 * DeltaTime;
02172	        vWeaponFeedBackReturn *= (1.0 - 0.20 * 64 * DeltaTime);
02173	        vWeaponFeedBack *= (1.0 - 0.20 * 64 * DeltaTime);
02174	      }
02175	      // End Weapon FeedBack
02176	
02177	/*
02178	var config bool bCheckTurnSpeed;// check turning speed
02179	var float fTurnSpeed[5];        // store turning values (90/180/270/360/720�)
02180	var float fTurnDeltaTime;       // time cumul
02181	*/
02182	/*
02183	      // Check turning speed
02184	      if ( bCheckTurnSpeed )
02185	      {
02186	        if ( aTurn != 0 )
02187	        {
02188	          fTurnInc += abs(43.0 * DeltaTime * aTurn);
02189	
02190	          fTurnDeltaTime += DeltaTime;
02191	          if ( fTurnSpeed[0] == 0.0 )
02192	          { // first check
02193	            if ( fTurnInc > 65536/4.0 )
02194	            {
02195	              fTurnSpeed[0] = fTurnDeltaTime;
02196	              fTurnSpeed[1] = 0.0;
02197	              MyHud.Message(none, "90 turn "$fTurnSpeed[0], 'CHEAT');
02198	            }
02199	          }
02200	          else if ( fTurnSpeed[1] == 0.0 )
02201	          { // first check
02202	            if ( fTurnInc > 65536/2.0 )
02203	            {
02204	              fTurnSpeed[1] = fTurnDeltaTime;
02205	              fTurnSpeed[2] = 0.0;
02206	              MyHud.Message(none, "180 turn "$fTurnSpeed[1], 'CHEAT');
02207	            }
02208	          }
02209	          else if ( fTurnSpeed[2] == 0.0 )
02210	          { // first check
02211	            if ( fTurnInc > 65536*3.0/4.0 )
02212	            {
02213	              fTurnSpeed[2] = fTurnDeltaTime;
02214	              fTurnSpeed[3] = 0.0;
02215	              MyHud.Message(none, "270 turn "$fTurnSpeed[2], 'CHEAT');
02216	            }
02217	          }
02218	          else if ( fTurnSpeed[3] == 0.0 )
02219	          { // first check
02220	            if ( fTurnInc > 65536 )
02221	            {
02222	              fTurnSpeed[3] = fTurnDeltaTime;
02223	              fTurnSpeed[4] = 0.0;
02224	              MyHud.Message(none, "360 turn "$fTurnSpeed[3], 'CHEAT');
02225	            }
02226	          }
02227	          else if ( fTurnSpeed[4] == 0.0 )
02228	          { // first check
02229	            if ( fTurnInc > 65536*2 )
02230	            {
02231	              fTurnSpeed[4] = fTurnDeltaTime;
02232	              MyHud.Message(none, "720 turn "$fTurnSpeed[4], 'CHEAT');
02233	            }
02234	          }
02235	
02236	
02237	        }
02238	        else
02239	        {
02240	          fTurnDeltaTime = 0.0;
02241	          fTurnSpeed[0] = 0.0;
02242	          fTurnInc = 0;
02243	        }
02244	      }
02245	*/
02246	      if ( DesiredFOV != DefaultFov )
02247	      {
02248	        ViewRotation.Yaw += 21.5 * DeltaTime * aTurn;
02249	        ViewRotation.Pitch += 21.5 * DeltaTime * aLookUp;
02250	      }
02251	      else
02252	      {
02253	        ViewRotation.Yaw += 43.0 * DeltaTime * aTurn;
02254	        ViewRotation.Pitch += 43.0 * DeltaTime * aLookUp;
02255	      }
02256	
02257	      // ELR Handle the SniperSkill Here
02258	      if ( (DesiredFOV != defaultFov) && (Pawn!=none) && Level.bLonePlayer && !XIIIPlayerPawn(Pawn).bIsSniper )
02259	      {
02260	        if ( Pawn.Acceleration == vect(0,0,0) )
02261	        {
02262	          if ( Pawn.bIsCrouched )
02263	            fSniperPrecision = fmax(0.0, fSniperPrecision - DeltaTime/3.0);
02264	          else
02265	            fSniperPrecision = fmax(0.0, fSniperPrecision - DeltaTime/6.0);
02266	        }
02267	        else
02268	          fSniperPrecision = fMin(1.0, fSniperPrecision + DeltaTime/1.8);
02269	        ViewRotation.Pitch -= SniperPitch;
02270	        Viewrotation.Yaw -= SniperYaw;
02271	        // End reinit Viewrotation
02272	        // Processing of SniperPitch & SniperYaw
02273	        vSniperOffset.z = 0.0;
02274	        vSniperOffsetSpeed.z = 0.0;
02275	        vSniperOffset += vSniperOffsetSpeed * (DeltaTime/1000.0);
02276	        vSniperOffsetSpeed -= (vSniperOffset) / (DeltaTime*Deltatime*200.0);
02277	        vSniperOffsetSpeed += normal(vSniperOffset cross vect(0,0,1)) * 8.0;
02278	        if ( vSize(vSniperOffsetSpeed) > 4000.0 )
02279	          vSniperOffsetSpeed = normal(vSniperOffsetSpeed)*4000.0;
02280	        SniperPitch = fSniperPrecision * 212.0 * sin(vsniperOffset.X) * ((DefaultFov - DesiredFOV) / DefaultFov);
02281	        SniperYaw = fSniperPrecision * 212.0 * sin(vsniperOffset.Y) * ((DefaultFov - DesiredFOV) / DefaultFov);
02282	        // End Processing
02283	        // Set Viewrotation
02284	        Viewrotation.Pitch += SniperPitch;
02285	        Viewrotation.Yaw += SniperYaw;
02286	      }
02287	      else if ( pawn != none )
02288	      { // ::TODO:: this is executed each frame whne not sniping, should be optimized
02289	        if ( XIIIPlayerPawn(Pawn).bIsSniper )
02290	          fSniperPrecision = 0.0;
02291	        else
02292	        {
02293	          fSniperPrecision = 1.0;
02294	          vSniperOffset = vRand()*1.56;
02295	          vSniperOffsetSpeed = vRand();
02296	          SniperPitch = 0.0;
02297	          SniperYaw = 0.0;
02298	        }
02299	      }
02300	      // END Sniper Handle
02301	    }
02302	
02303	    ViewRotation.Pitch = ViewRotation.Pitch & 65535;
02304	    if ((ViewRotation.Pitch > 15500) && (ViewRotation.Pitch < (50000+15500)/2))
02305	      ViewRotation.Pitch = 15500;
02306	    else if ((ViewRotation.Pitch > (50000+15500)/2) && (ViewRotation.Pitch < 50000))
02307	      ViewRotation.Pitch = 50000;
02308	/*
02309	    if ((ViewRotation.Pitch > 15500) && (ViewRotation.Pitch < 50000))
02310	    {
02311	      if (aLookUp > 0)
02312	        ViewRotation.Pitch = 15500;
02313	      else if (aLookUp < 0)
02314	        ViewRotation.Pitch = 50000;
02315	    }
02316	*/
02317	
02318	    SetRotation(ViewRotation);
02319	    ViewShake(deltaTime);
02320	    ViewFlash(deltaTime);
02321	
02322	    NewRotation = ViewRotation;
02323	    NewRotation.Roll = Rotation.Roll;
02324	
02325	    If ( (newRotation.Pitch > maxPitch * RotationRate.Pitch) && (newRotation.Pitch < 65536 - maxPitch * RotationRate.Pitch) )
02326	    {
02327	      If (ViewRotation.Pitch < 32768)
02328	        newRotation.Pitch = maxPitch * RotationRate.Pitch;
02329	      else
02330	        newRotation.Pitch = 65536 - maxPitch * RotationRate.Pitch;
02331	    }
02332	    if ( !bRotateToDesired && (Pawn != None) && (!bFreeCamera || !bBehindView) )
02333	      Pawn.FaceRotation(newRotation, deltatime);
02334	
02335	//    Pawn.ControllerPitch = newRotation.Pitch;
02336	
02337	//    log("Update Pitch");
02338	}
02339	
02340	//_____________________________________________________________________________
02341	function SetCamView( actor C, optional float F )
02342	{
02343	    if ( F==0 )
02344	      F = 90;
02345	    GotoState('CameraView');
02346	    CamView = C;
02347	    DT_mem = C.DrawType;
02348	    C.SetDrawType(DT_none);
02349	//    SetViewTarget(C);
02350	    DesiredFOV = F;
02351	    FOVAngle = F;
02352	    DefaultFov = F;
02353	}
02354	
02355	function SetCamViewPortal( actor C, optional float F )
02356	{
02357	  if (CamView != C)
02358	  {
02359	    if ( F == 0 )
02360	      F = 90;
02361	    CamView = C;
02362	    CamView.Trigger(self, Pawn);
02363	  }
02364	}
02365	
02366	//_____________________________________________________________________________
02367	function RestoreView()
02368	{
02369	//    SetViewTarget(Pawn);
02370	    GotoState('PlayerWalking');
02371	    CamView.SetDrawType(DT_mem);
02372	    DefaultFOV = default.DefaultFOV;
02373	    DesiredFOV = DefaultFOV;
02374	    FOVAngle = DefaultFOV;
02375	}
02376	
02377	//_____________________________________________________________________________
02378	// ELR - Here we send the controller into hooked state
02379	function GoHooking(Hook H)
02380	{
02381	    HookUsed = H;
02382	    bHooked = true;
02383	//    GotoState('Hooked');
02384	}
02385	
02386	//_____________________________________________________________________________
02387	// at top of a rope, climb up to the hooknavpoint
02388	function GoClimbHookNavPoint(HookPoint HP, HookNavPoint HNP)
02389	{
02390	    ClimbHookPoint = HP;
02391	    TargetHookClimb = HNP;
02392	    bHooked = false;
02393	    GotoState('ClimbToHookNavPoint');
02394	}
02395	
02396	/*
02397	//_____________________________________________________________________________
02398	// ELR
02399	function bool NearWall(float walldist)
02400	{
02401	    local actor HitActor;
02402	    local vector HitLocation, HitNormal, ViewSpot, ViewDist, LookDir;
02403	
02404	    LookDir = vector(Rotation);
02405	    ViewSpot = Pawn.Location + Pawn.BaseEyeHeight * vect(0,0,1);
02406	    ViewDist = LookDir * walldist;
02407	    HitActor = Trace(HitLocation, HitNormal, ViewSpot + ViewDist, ViewSpot, false);
02408	    if ( HitActor == None )
02409	      return false;
02410	    return true;
02411	}
02412	*/
02413	
02414	//_____________________________________________________________________________
02415	function bool TryClimbDoor(actor pDoorLocked, vector pDoorLockedPos, vector pDoorLockedNormal)
02416	{
02417	    local vector X, Y, Z, Start, End, HitLoc, HitNorm;
02418	    local actor A;
02419	
02420	    if ( (XIIIPawn(Pawn).LHand.pOnShoulder != none) || Pawn.bIsCrouched || (XIIIPorte(pDoorLocked)==none) )
02421	      return false;
02422	
02423	    if ( bWeaponMode && (Pawn.Weapon.WHand == WHA_Deco) )
02424	      return false;
02425	
02426	    if ( !XIIIPorte(pDoorLocked).bClimbAble )
02427	      return false;
02428	//    if ( !XIIIPorte(pDoorLocked).bOpened && !XIIIPorte(pDoorLocked).bClosed) )
02429	    if ( !XIIIPorte(pDoorLocked).bOpened )
02430	      return false; // don't climb if the door is moving or not climbable.
02431	
02432	    GetAxes(Rotation,X,Y,Z);
02433	//    if ( X.z > -0.25 ) // ELR Just check we are not looking really down
02434	//    {
02435	      Start = pDoorLockedPos + pDoorLockedNormal;
02436	      End = Start + vect(0,0,1) * Pawn.CollisionHeight;
02437	      if ( FastTrace(End,Start) )
02438	      {
02439	        A=Trace(HitLoc, HitNorm, End, Start, false);
02440	        return true;
02441	      }
02442	//    }
02443	    return false;
02444	}
02445	
02446	//_____________________________________________________________________________
02447	// Normal gameplay execs
02448	// Type the name of the exec function at the console to execute it
02449	exec function Jump( optional float F )
02450	{
02451	    if ( LadderVolume(Pawn.PhysicsVolume) != none )
02452	    { // Jumping in a ladder volume mean we do want to climb
02453	      Pawn.PhysicsVolume.PawnEnteredVolume(Pawn);
02454	      if (Pawn.Physics == PHYS_Ladder)
02455	        return;
02456	    }
02457	
02458	    if ( MyInteraction.bCanClimbDoor )
02459	    {
02460	      DoorToClimb = MyInteraction.TargetActor;
02461	      DoorLockedNormal = MyInteraction.TargHitNorm;
02462	      DoorLockedPos = MyInteraction.TargHitLoc;
02463	
02464	      GotoState('MayClimbDoor');
02465	    }
02466	
02467	    bPressedJump = true;
02468	}
02469	
02470	//_____________________________________________________________________________
02471	event HearNoise( float Loudness, Actor NoiseMaker)
02472	{
02473	//    Log("__"@self@"Heard"@NoiseMaker);
02474	//    if ( XIIIPlayerPawn(Pawn).bSixSenseOn )
02475	    if ( vSize(NoiseMaker.location - Pawn.Location) < 2500/1.27 )
02476	      XIIIPlayerPawn(Pawn).Heard(Loudness, NoiseMaker);
02477	}
02478	
02479	//_____________________________________________________________________________
02480	// called when gameplay actually starts
02481	simulated function MatchStarting()
02482	{
02483	    Log("MP-] MatchStarting for"@self);
02484	    UseVignetteFilter = 0;
02485	    UseVignetteHighlight = 0;
02486	    bWeaponBlock = false;
02487	    if ( Level.Game != none )
02488	      Level.Game.RestartPlayer(Self);
02489	    if ( PlayerInput != none )
02490	    {
02491	      PlayerInput.bDuckCheck = false;
02492	      PlayerInput.iDuckMem = 0;
02493	    }
02494	}
02495	
02496	//_____________________________________________________________________________
02497	event TeamMessage( PlayerReplicationInfo PRI, coerce string S, name Type )
02498	{
02499	    local string ConsoleString;
02500	
02501	//    log("Teammessage with PRI "$PRI$" hud "$myHud$" Player "$Player$" console "$Player.console$" string "$S@"Type "$Type);
02502	    ConsoleString = S;
02503	    if ( (Type == 'Say') || (Type == 'TeamSay') )
02504	      ConsoleString = PRI.PlayerName$": "$ConsoleString;
02505	
02506	//    Player.Console.Message( ConsoleString, 6.0 );
02507	    myHUD.Message( PRI, S, Type );
02508	}
02509	
02510	//_____________________________________________________________________________
02511	function StatUpdate();
02512	
02513	//_____________________________________________________________________________
02514	function ClientGameEnded()
02515	{
02516	//    if ( (Role < ROLE_Authority) || (Level.NetMode == NM_StandAlone) )
02517	    if (Role < ROLE_Authority)
02518	      GotoState('GameEnded');
02519	}
02520	
02521	//_____________________________________________________________________________
02522	state PlayerClimbing
02523	{
02524	    event bool NotifyHitWall(vector HitNormal, actor Wall)
02525	    { // ELR don't send HitWall to pawn while in ladder.
02526	      return true;
02527	    }
02528	    function BeginState()
02529	    {
02530	      if ( Pawn != None )
02531	      {
02532	        Pawn.ShouldCrouch(false);
02533	        bPressedJump = false;
02534	        bDuck = 0;
02535	        bPressedDuck = false;
02536	        Pawn.ChangeAnimation();
02537	      }
02538	    }
02539	    function EndState()
02540	    {
02541	      if ( Pawn != None )
02542	      {
02543	        Pawn.ShouldCrouch(false);
02544	        bPressedJump = false;
02545	        bDuck = 0;
02546	        bPressedDuck = false;
02547	        Pawn.ChangeAnimation();
02548	        Pawn.PlaySound(hEndClimbLadderSound);
02549	      }
02550	    }
02551	    function ProcessMove(float DeltaTime, vector NewAccel, eDoubleClickDir DoubleClickMove, rotator DeltaRot)
02552	    {
02553	      local vector OldAccel;
02554	
02555	      OldAccel = Pawn.Acceleration;
02556	      if ( bAltDuck != 0 )
02557	        NewAccel.Z = -2048.0;
02558	      if ( bAltJump != 0 )
02559	        NewAccel.Z = 2048.0;
02560	
02561	      Pawn.Acceleration = NewAccel;
02562	//      Log("Accel="$Pawn.Acceleration@"bIsCrouched="$Pawn.bIsCrouched$"bIsWalking="$Pawn.bIsWalking);
02563	/*
02564	      if ( bPressedJump )
02565	      {
02566	        Pawn.DoJump(bUpdating);
02567	        if ( Pawn.Physics == PHYS_Falling )
02568	          GotoState('PlayerWalking');
02569	      }
02570	*/
02571	    }
02572	}
02573	
02574	//_____________________________________________________________________________
02575	state PlayerWalking
02576	{
02577	    function ProcessMove(float DeltaTime, vector NewAccel, eDoubleClickDir DoubleClickMove, rotator DeltaRot)
02578	    {
02579	      local vector OldAccel, HookDir, HookMove, CenterDir;
02580	      local bool OldCrouch;
02581	
02582	      if ( Pawn == none )
02583	        return;
02584	      // ELR Limit speed there ::FIXME:: but not for on-line because on serveur FOV don't change.
02585	      if ( (Level.NetMode == NM_StandAlone) && (DefaultFOV != DesiredFOV) )
02586	      {
02587	        NewAccel *= 0.01;
02588	        XIIIPawn(Pawn).SetGroundspeed(Pawn.WalkingPct / 2.0);
02589	      }
02590	      else
02591	      {
02592	        if ( bWeaponMode )
02593	        {
02594	          if ( (XIIIWeapon(Pawn.Weapon) != none) && XIIIWeapon(Pawn.Weapon).bHeavyWeapon )
02595	            XIIIPawn(Pawn).SetGroundspeed(0.666);
02596	          else if ( (XIIIPawn(Pawn).LHand != none) && XIIIPawn(Pawn).LHand.bActive )
02597	            XIIIPawn(Pawn).SetGroundspeed(0.333);
02598	          else
02599	            XIIIPawn(Pawn).SetGroundspeed(1.0);
02600	        }
02601	        else
02602	        {
02603	          if ( (XIIIPawn(Pawn).LHand != none) && XIIIPawn(Pawn).LHand.bActive )
02604	            XIIIPawn(Pawn).SetGroundspeed(0.333);
02605	          else
02606	            XIIIPawn(Pawn).SetGroundspeed(1.0);
02607	        }
02608	      }
02609	
02610	      if ( bHooked )
02611	      {
02612	        if ( (Pawn.Physics==PHYS_Walking) && (Pawn.Location.z > HookUsed.HookPoint.z) )
02613	          HookUsed.HookLength = vSize(HookUsed.HookPoint - Pawn.Location) + 1.0;
02614	        if ( (vSize(HookUsed.HookPoint - Pawn.Location) > HookUsed.HookLength) && (Pawn.Location.z < HookUsed.HookPoint.z) )
02615	        {
02616	          Pawn.SetPhysics(PHYS_Falling);
02617	          HookDir = normal(HookUsed.HookPoint - Pawn.Location);
02618	          HookMove = HookDir * (vSize(HookUsed.HookPoint - Pawn.Location) - HookUsed.HookLength);
02619	          Pawn.Move( HookMove );
02620	          // Look for the speed to set the player (remove speed along rope axis).
02621	          Pawn.Velocity -= HookDir * (HookDir dot Pawn.velocity);
02622	        }
02623	      }
02624	
02625	      OldAccel = Pawn.Acceleration;
02626	      Pawn.Acceleration = NewAccel;
02627	
02628	//      Log("bDuck="$bDuck@"bWantsToCrouch="$Pawn.bWantsToCrouch);
02629	      if ( bPressedJump )
02630	      {
02631	        if ( bHooked && !HookUsed.bGoUp && !HookUsed.bGoDown && (Hook(Pawn.SelectedItem) != none) )
02632	        {
02633	//          Log("Hook ActivatedByJump");
02634	          Hook(Pawn.SelectedItem).ActivatedByJump = true;
02635	          ActivateItem();
02636	          return;
02637	        }
02638	        Pawn.DoJump(bUpdating);
02639	      }
02640	      if ( Pawn.Physics != PHYS_Falling )
02641	      {
02642	        OldCrouch = Pawn.bWantsToCrouch;
02643	        if (bDuck == 0)
02644	          Pawn.ShouldCrouch(false);
02645	        else if ( Pawn.bCanCrouch )
02646	          Pawn.ShouldCrouch(true);
02647	      }
02648	      else
02649	      {
02650	        // should reset Crouch
02651	        if ( PlayerInput != none )
02652	        {
02653	          PlayerInput.bDuckCheck = false;
02654	          PlayerInput.iDuckMem = 0;
02655	        }
02656	        Pawn.bWantsToCrouch = false;
02657	        Pawn.ShouldCrouch(false);
02658	        bDuck = 0;
02659	        if ( !bHooked )
02660	          bAltDuck = 0;
02661	        if ( bHooked && bPressedDuck && !HookUsed.bGoUp && !HookUsed.bGoDown && (Hook(Pawn.SelectedItem) != none) )
02662	        {
02663	  //        Log("Hook ActivatedByDuck");
02664	          HookUsed.ActivatedByDuck = true;
02665	          ActivateItem();
02666	          bPressedDuck = false;
02667	          return;
02668	        }
02669	      }
02670	      if ( (Hook(Pawn.SelectedItem) != none) && (Pawn.SelectedItem.IsInState('Idle') || Pawn.SelectedItem.IsInState('DownItemRopeCut')) )
02671	        bhooked = false;
02672	    }
02673	
02674	    function PlayerMove( float DeltaTime )
02675	    {
02676	      local vector X,Y,Z, NewAccel;
02677	      local eDoubleClickDir DoubleClickMove;
02678	      local rotator OldRotation, ViewRotation;
02679	      local float Speed2D;
02680	      local bool bSaveJump;
02681	
02682	      if ( Pawn != none ) // May happen in on-line game
02683	        GetAxes(Pawn.Rotation,X,Y,Z);
02684	      else
02685	        GetAxes(Rotation,X,Y,Z);
02686	
02687	      // ELR Add to avoid CenterView if mid-air
02688	      if ( bHooked && (Pawn.Physics != PHYS_Walking) )
02689	        bCenterView = False;
02690	
02691	      // Update acceleration.
02692	      NewAccel = aForward*X + aStrafe*Y;
02693	      NewAccel.Z = 0;
02694	      if ( VSize(NewAccel) < 1.0 )
02695	        NewAccel = vect(0,0,0);
02696	//      DoubleClickMove = PlayerInput.CheckForDoubleClickMove(DeltaTime);
02697	
02698	      if ( bHooked && (Pawn.Base == none) )
02699	        NewAccel *= 0.03*1.5;
02700	
02701	      GroundPitch = 0;
02702	      // ELR don't do snapview if zoomed
02703	//      if ( (DefaultFov != DesiredFov) || (XIIIWeapon(Pawn.Weapon).bZoomed) )
02704	//      {
02705	//        Log("             ...reseting view because fov not ok or weapon zoom");
02706	
02707	/* ELR // take this back ;)
02708	        bSnaptoLevel = false;
02709	        bCenterView = false;
02710	*/
02711	
02712	//      }
02713	/*
02714	      if ( bCenterView )
02715	        log("Centering view");
02716	*/
02717	      if ( (Pawn != none) && Pawn.Pressingfire() )
02718	      {
02719	        bSnaptoLevel = false;
02720	        bCenterView = false;
02721	      }
02722	
02723	      ViewRotation = Rotation;
02724	      if ( (Pawn != none) && (Pawn.Physics == PHYS_Walking) )
02725	      {
02726	//        Log("PlayerWalking...");
02727	        // tell pawn about any direction changes to give it a chance to play appropriate animation
02728	        //if walking, look up/down stairs - unless player is rotating view
02729	//        GroundPitch = FindStairRotation(deltaTime);
02730	//        if ( GroundPitch != 0 )
02731	//          Log("GroundPitch="$GroundPitch@"bLookUpStairs="$bLookUpStairs@"bSnapToLevel="$bSnapToLevel);
02732	        if ( (bLook == 0)
02733	          && (((Pawn.Acceleration != Vect(0,0,0)) && bAlwaysLevel && bSnapToLevel) || !bKeyboardLook) )
02734	        {
02735	//          Log("             ...aligning view");
02736	          if ( bLookUpStairs && bSnapToLevel )
02737	          {
02738	//            Log("             ...aligning view Setting GroundPitch ViewRotation.Pitch="$ViewRotation.Pitch@"GroundPitch="$GroundPitch);
02739	            ViewRotation.Pitch -= (GroundPitch / (DeltaTime*1000));
02740	          }
02741	          else if ( bCenterView && (DefaultFOV == DesiredFOV) )
02742	          {
02743	//            Log("             ...aligning view Centering view");
02744	            ViewRotation.Pitch = ViewRotation.Pitch & 65535;
02745	            if (ViewRotation.Pitch > 32768)
02746	              ViewRotation.Pitch -= 65536;
02747	            ViewRotation.Pitch = ViewRotation.Pitch * (1 - 12 * FMin(0.0833, deltaTime));
02748	            if ( Abs(ViewRotation.Pitch) < 1000 )
02749	              ViewRotation.Pitch = 0;
02750	          }
02751	        }
02752	
02753	        Speed2D = Sqrt(Pawn.Velocity.X * Pawn.Velocity.X + Pawn.Velocity.Y * Pawn.Velocity.Y);
02754	        //add bobbing when walking
02755	        CheckBob(DeltaTime, Speed2D, Y);
02756	      }
02757	      else
02758	      {
02759	        if ( !bKeyboardLook && (bLook == 0) && bCenterView )
02760	        {
02761	          ViewRotation.Pitch = ViewRotation.Pitch & 65535;
02762	          if (ViewRotation.Pitch > 32768)
02763	               ViewRotation.Pitch -= 65536;
02764	          ViewRotation.Pitch = ViewRotation.Pitch * (1 - 12 * FMin(0.0833, deltaTime));
02765	          if ( Abs(ViewRotation.Pitch) < 1000 )
02766	               ViewRotation.Pitch = 0;
02767	        }
02768	        BobTime = 0;
02769	        WalkBob = WalkBob * (1 - FMin(1, 8 * deltatime));
02770	      }
02771	
02772	      // Update rotation.
02773	      SetRotation(ViewRotation);
02774	      OldRotation = Rotation;
02775	      // ELR Rotation Speed Down when holding corpse/Pawn
02776	      if ( (Pawn != none) && (XIIIPawn(Pawn).LHand!=none) && (XIIIPawn(Pawn).LHand.pOnShoulder != none) )
02777	        UpdateRotation(DeltaTime*0.75, 0);
02778	      else
02779	        UpdateRotation(DeltaTime, 0);
02780	
02781	      if ( bPressedJump && Pawn.CannotJumpNow() )
02782	      {
02783	        bSaveJump = true;
02784	        bPressedJump = false;
02785	      }
02786	      else
02787	        bSaveJump = false;
02788	
02789	      if ( Role < ROLE_Authority ) // then save this move and replicate it
02790	        ReplicateMove(DeltaTime, NewAccel, DoubleClickMove, OldRotation - Rotation);
02791	      else
02792	        ProcessMove(DeltaTime, NewAccel, DoubleClickMove, OldRotation - Rotation);
02793	      if ( (Pawn != none) && (Pawn.ControllerPitch != Rotation.Pitch / 256) )
02794	        Pawn.ControllerPitch = Rotation.Pitch / 256; // needed for ListenServer -> Client
02795	      bPressedJump = bSaveJump;
02796	    }
02797	}
02798	
02799	//_____________________________________________________________________________
02800	// ELR
02801	state PlayerSwimming
02802	{
02803	    function ProcessMove(float DeltaTime, vector NewAccel, eDoubleClickDir DoubleClickMove, rotator DeltaRot)
02804	    {
02805	      local vector X,Y,Z, OldAccel, HookDir, HookMove, CenterDir;
02806	
02807	      GetAxes(Rotation,X,Y,Z);
02808	
02809	      if ( bHooked )
02810	      { // while swimming only update hooklength
02811	        if ( (vSize(HookUsed.HookPoint - Pawn.Location) > HookUsed.HookLength) && (Pawn.Location.z < HookUsed.HookPoint.z) )
02812	        {
02813	          HookDir = normal(HookUsed.HookPoint - Pawn.Location);
02814	          HookMove = HookDir * (vSize(HookUsed.HookPoint - Pawn.Location) - HookUsed.HookLength);
02815	          Pawn.Move( HookMove );
02816	          // Look for the speed to set the player (remove speed along rope axis).
02817	          Pawn.Velocity -= HookDir * (HookDir dot Pawn.velocity);
02818	        }
02819	      }
02820	
02821	      OldAccel = Pawn.Acceleration;
02822	      Pawn.Acceleration = NewAccel;
02823	
02824	      Pawn.bUpAndOut = ((X Dot Pawn.Acceleration) > 0) && ((Pawn.Acceleration.Z > 0) || (Rotation.Pitch > 2048));
02825	      if ( !Pawn.PhysicsVolume.bWaterVolume ) //check for waterjump
02826	        NotifyPhysicsVolumeChange(Pawn.PhysicsVolume);
02827	      if ( (Hook(Pawn.SelectedItem) != none) && (Pawn.SelectedItem.IsInState('Idle') || Pawn.SelectedItem.IsInState('DownItemRopeCut')) )
02828	        bhooked = false;
02829	    }
02830	
02831	    function PlayerMove(float DeltaTime)
02832	    {
02833	      local rotator oldRotation;
02834	      local vector X,Y,Z, NewAccel;
02835	      local float Speed2D;
02836	
02837	      GetAxes(Rotation,X,Y,Z);
02838	
02839	      NewAccel = aForward*X + aStrafe*Y + aUp*vect(0,0,1);
02840	      if ( VSize(NewAccel) < 1.0 )
02841	        NewAccel = vect(0,0,0);
02842	
02843	      //add bobbing when swimming
02844	      Speed2D = Sqrt(Pawn.Velocity.X * Pawn.Velocity.X + Pawn.Velocity.Y * Pawn.Velocity.Y);
02845	      WalkBob = Y * Bob *  0.5 * Speed2D * sin(4.0 * Level.TimeSeconds);
02846	      WalkBob.Z = Bob * 1.5 * Speed2D * sin(8.0 * Level.TimeSeconds);
02847	
02848	      // Update rotation.
02849	      oldRotation = Rotation;
02850	      UpdateRotation(DeltaTime, 2);
02851	
02852	      if ( Role < ROLE_Authority ) // then save this move and replicate it
02853	        ReplicateMove(DeltaTime, NewAccel, DCLICK_None, OldRotation - Rotation);
02854	      else
02855	        ProcessMove(DeltaTime, NewAccel, DCLICK_None, OldRotation - Rotation);
02856	      bPressedJump = false;
02857	    }
02858	    function bool NotifyPhysicsVolumeChange( PhysicsVolume NewVolume )
02859	    {
02860	      local actor HitActor;
02861	      local vector HitLocation, HitNormal, checkpoint;
02862	
02863	      if ( !NewVolume.bWaterVolume )
02864	      {
02865	        Pawn.SetPhysics(PHYS_Falling);
02866	        if (Pawn.bUpAndOut && Pawn.CheckWaterJump(HitNormal)) //check for waterjump
02867	        {
02868	        // ONLY CHANGE HERE
02869	          Pawn.velocity.Z = 400 + Pawn.CollisionHeight; //set here so physics uses this for remainder of tick
02870	        // ONLY CHANGE HERE
02871	//          Pawn.velocity.Z = 330 + 2 * Pawn.CollisionRadius; //set here so physics uses this for remainder of tick
02872	          GotoState(Pawn.LandMovementState);
02873	        }
02874	        else if ( (Pawn.Velocity.Z > 160) || !Pawn.TouchingWaterVolume() )
02875	          GotoState(Pawn.LandMovementState);
02876	        else //check if in deep water
02877	        {
02878	          checkpoint = Pawn.Location;
02879	          checkpoint.Z -= (Pawn.CollisionHeight + 6.0);
02880	          HitActor = Trace(HitLocation, HitNormal, checkpoint, Pawn.Location, false);
02881	          if (HitActor != None)
02882	            GotoState(Pawn.LandMovementState);
02883	          else
02884	          {
02885	            Enable('Timer');
02886	            SetTimer(0.7,false);
02887	          }
02888	        }
02889	      }
02890	      else
02891	      {
02892	        Disable('Timer');
02893	        Pawn.SetPhysics(PHYS_Swimming);
02894	      }
02895	      return false;
02896	    }
02897	    function BeginState()
02898	    {
02899	      Disable('Timer');
02900	      Pawn.SetPhysics(PHYS_Swimming);
02901	//      Pawn.PlaySound(hEnteringWaterSound);
02902	    }
02903	    function EndState()
02904	    {
02905	//      Pawn.PlaySound(hExitingWaterSound);
02906	    }
02907	}
02908	
02909	/*
02910	//_____________________________________________________________________________
02911	// ELR
02912	State Hooked extends PlayerWalking
02913	{
02914	    function BeginState()
02915	    {
02916	      Pawn.bCanCrouch=False;
02917	      Pawn.bCanClimbLadders=False;
02918	      bPressedDuck=false;
02919	    }
02920	    function EndState()
02921	    {
02922	      Pawn.bCanCrouch=True;
02923	      Pawn.bCanClimbLadders=True;
02924	    }
02925	
02926	    //_________________
02927	    function PlayerMove( float DeltaTime )
02928	    {
02929	      local vector X,Y,Z, NewAccel;
02930	      local eDoubleClickDir DoubleClickMove;
02931	      local rotator OldRotation, ViewRotation;
02932	      local float Speed2D;
02933	      local bool bSaveJump;
02934	
02935	      GetAxes(Pawn.Rotation,X,Y,Z);
02936	      // ELR Add to avoid CenterView if mid-air
02937	      if ( Pawn.Physics != PHYS_Walking )
02938	        bCenterView = False;
02939	
02940	//      Log("aForward="$aForward@"aStrafe="$aStrafe);
02941	
02942	      // Update acceleration.
02943	      NewAccel = aForward*4*X + aStrafe*4*Y;
02944	      NewAccel.Z = 0;
02945	//      if ( NewAccel == vect(0,0,0) )
02946	//        NewAccel = -Pawn.Velocity*200;
02947	      if ( Pawn.Base == none )
02948	        NewAccel *= 0.0075;
02949	
02950	//      log("NewAccel="$NewAccel);
02951	//      DoubleClickMove = PlayerInput.CheckForDoubleClickMove(DeltaTime);
02952	
02953	      GroundPitch = 0;
02954	      ViewRotation = Rotation;
02955	      if (Pawn.Physics == PHYS_Walking)
02956	      {
02957	        //if walking, look up/down stairs - unless player is rotating view
02958	        GroundPitch = FindStairRotation(deltaTime);
02959	        if (DefaultFov != DesiredFov)
02960	        {
02961	          bSnaptoLevel = false;
02962	          bCenterView = false;
02963	        }
02964	
02965	        if ( (bLook == 0)
02966	          && (((Pawn.Acceleration != Vect(0,0,0)) && bAlwaysLevel && bSnapToLevel) || !bKeyboardLook) )
02967	        {
02968	          if ( bLookUpStairs || bSnapToLevel )
02969	          {
02970	            ViewRotation.Pitch = GroundPitch;
02971	          }
02972	          else if ( bCenterView && (DefaultFOV == DesiredFOV) )
02973	          {
02974	            ViewRotation.Pitch = ViewRotation.Pitch & 65535;
02975	            if (ViewRotation.Pitch > 32768)
02976	              ViewRotation.Pitch -= 65536;
02977	            ViewRotation.Pitch = ViewRotation.Pitch * (1 - 12 * FMin(0.0833, deltaTime));
02978	            if ( Abs(ViewRotation.Pitch) < 1000 )
02979	              ViewRotation.Pitch = 0;
02980	          }
02981	        }
02982	        Speed2D = Sqrt(Pawn.Velocity.X * Pawn.Velocity.X + Pawn.Velocity.Y * Pawn.Velocity.Y);
02983	        //add bobbing when walking
02984	        CheckBob(DeltaTime, Speed2D, Y);
02985	      }
02986	
02987	      // Update rotation.
02988	      SetRotation(ViewRotation);
02989	      OldRotation = Rotation;
02990	      UpdateRotation(DeltaTime, 1);
02991	
02992	      if ( bPressedJump && Pawn.CannotJumpNow() )
02993	      {
02994	        bSaveJump = true;
02995	        bPressedJump = false;
02996	      }
02997	      else
02998	        bSaveJump = false;
02999	
03000	      // ELR If jump pressed and colliding/facing a wall then impulse
03001	      if ( NearWall(Pawn.CollisionRadius + 15.0) )
03002	      {
03003	//        Pawn.Velocity.Z = 0.0;
03004	        if ( bPressedJump && (Pawn.Physics == PHYS_Falling) )
03005	        {
03006	          Pawn.Velocity -= X * 300.0;
03007	        }
03008	      }
03009	
03010	      if ( Role < ROLE_Authority ) // then save this move and replicate it
03011	        ReplicateMove(DeltaTime, NewAccel, DoubleClickMove, OldRotation - Rotation);
03012	      else
03013	        ProcessMove(DeltaTime, NewAccel, DoubleClickMove, OldRotation - Rotation);
03014	      bPressedJump = bSaveJump;
03015	    }
03016	
03017	    //_________________
03018	    // ELR 2nd ProcessMove, trying to get rid of vel/acc and setting the player's pos
03019	    function ProcessMove(float DeltaTime, vector NewAccel, eDoubleClickDir DoubleClickMove, rotator DeltaRot)
03020	    {
03021	      local vector OldAccel, HookDir, HookMove, CenterDir;
03022	      local bool OldCrouch;
03023	
03024	      OldAccel = Pawn.Acceleration;
03025	
03026	      // Not in Hook because need every frame treatment
03027	      if ( Pawn.Physics==PHYS_Walking )
03028	      {
03029	        if ( Pawn.Location.z > HookUsed.HookPoint.z )
03030	        {
03031	          HookUsed.HookLength = vSize(HookUsed.HookPoint - Pawn.Location) + 1.0;
03032	        }
03033	      }
03034	
03035	      if ( (vSize(HookUsed.HookPoint - Pawn.Location) > HookUsed.HookLength) && (Pawn.Location.z < HookUsed.HookPoint.z) )
03036	      {
03037	        Pawn.SetPhysics(PHYS_Falling);
03038	        HookDir = normal(HookUsed.HookPoint - Pawn.Location);
03039	        HookMove = HookDir * (vSize(HookUsed.HookPoint - Pawn.Location) - HookUsed.HookLength);
03040	        Pawn.Move( HookMove );
03041	        // Look for the speed to set the player (remove speed along rope axis).
03042	        Pawn.Velocity -= HookDir * (HookDir dot Pawn.velocity);
03043	      }
03044	
03045	      Pawn.Acceleration = NewAccel;
03046	
03047	      if ( bPressedJump )
03048	      {
03049	        if ( !HookUsed.bGoUp && !HookUsed.bGoDown )
03050	        {
03051	          Log("Hook ActivatedByJump");
03052	          Hook(Pawn.SelectedItem).ActivatedByJump = true;
03053	          ActivateItem();
03054	          return;
03055	        }
03056	        else
03057	          Pawn.DoJump(bUpdating);
03058	      }
03059	      if ( Pawn.Physics != PHYS_Falling )
03060	      {
03061	        OldCrouch = Pawn.bWantsToCrouch;
03062	        if (bDuck == 0)
03063	          Pawn.ShouldCrouch(false);
03064	        else if ( Pawn.bCanCrouch )
03065	          Pawn.ShouldCrouch(true);
03066	      }
03067	      else
03068	      {
03069	        if ( bPressedDuck && !HookUsed.bGoUp && !HookUsed.bGoDown )
03070	        {
03071	          Log("Hook ActivatedByDuck");
03072	          HookUsed.ActivatedByDuck = true;
03073	          ActivateItem();
03074	          bPressedDuck=false;
03075	          return;
03076	        }
03077	      }
03078	
03079	//      if ( !bWeaponMode && (Hook(Pawn.SelectedItem) != none) && Pawn.SelectedItem.isInState('Idle') )
03080	    // ELR we can release hook while having weapon in hand, so...
03081	      if ( (Hook(Pawn.SelectedItem) != none) && Pawn.SelectedItem.isInState('Idle') )
03082	      {
03083	        GotoState('PlayerWalking');
03084	      }
03085	    }
03086	}
03087	*/
03088	
03089	//_____________________________________________________________________________
03090	// ELR
03091	State Tyroling extends PlayerWalking
03092	{
03093	    function BeginState()
03094	    {
03095	      Pawn.PlaySound(hTyrolStartSound);
03096	    }
03097	    function EndState()
03098	    {
03099	      Pawn.PlaySound(hTyrolEndSound);
03100	      Pawn.SetPhysics(PHYS_Falling);
03101	    }
03102	
03103	    //__________________
03104	    function PlayerMove( float DeltaTime )
03105	    {
03106	      local vector X,Y,Z, NewAccel;
03107	      local eDoubleClickDir DoubleClickMove;
03108	      local rotator OldRotation, ViewRotation;
03109	      local float Speed2D;
03110	      local bool     bSaveJump;
03111	
03112	      if ( (vTyrolDir dot (Pawn.Location - vTyrolEnd) > 0.0) || (vTyrolDir dot Pawn.Velocity < 0.0) )
03113	      {
03114	        Gotostate('PlayerWalking');
03115	        return;
03116	      }
03117	      GetAxes(Pawn.Rotation,X,Y,Z);
03118	
03119	      // Update acceleration.
03120	//      NewAccel = aForward*X + aStrafe*Y;
03121	      if ( vSize(vTyrolEnd - Pawn.Location) > 512.0 )
03122	        // SpeedUp
03123	        NewAccel = vTyrolDir * 400.0;
03124	      else
03125	        //SlowDown
03126	        NewAccel = - vTyrolDir * 200.0;
03127	//      DoubleClickMove = PlayerInput.CheckForDoubleClickMove(DeltaTime);
03128	
03129	      GroundPitch = 0;
03130	      ViewRotation = Rotation;
03131	      if (Pawn.Physics == PHYS_Walking)
03132	      {
03133	        //if walking, look up/down stairs - unless player is rotating view
03134	//        GroundPitch = FindStairRotation(deltaTime);
03135	        if (DefaultFov != DesiredFov)
03136	        {
03137	          bSnaptoLevel = false;
03138	          bCenterView = false;
03139	        }
03140	        if ( (bLook == 0)
03141	          && (((Pawn.Acceleration != Vect(0,0,0)) && bAlwaysLevel && bSnapToLevel) || !bKeyboardLook) )
03142	        {
03143	          if ( bLookUpStairs || bSnapToLevel )
03144	          {
03145	            ViewRotation.Pitch = GroundPitch;
03146	          }
03147	          else if ( bCenterView && (DefaultFOV == DesiredFOV) )
03148	          {
03149	            ViewRotation.Pitch = ViewRotation.Pitch & 65535;
03150	            if (ViewRotation.Pitch > 32768)
03151	              ViewRotation.Pitch -= 65536;
03152	            ViewRotation.Pitch = ViewRotation.Pitch * (1 - 12 * FMin(0.0833, deltaTime));
03153	            if ( Abs(ViewRotation.Pitch) < 1000 )
03154	              ViewRotation.Pitch = 0;
03155	          }
03156	        }
03157	
03158	        Speed2D = Sqrt(Pawn.Velocity.X * Pawn.Velocity.X + Pawn.Velocity.Y * Pawn.Velocity.Y);
03159	        //add bobbing when walking
03160	        CheckBob(DeltaTime, Speed2D, Y);
03161	      }
03162	
03163	      // Update rotation.
03164	      SetRotation(ViewRotation);
03165	      OldRotation = Rotation;
03166	      UpdateRotation(DeltaTime, 1);
03167	
03168	      if ( bPressedJump && Pawn.CannotJumpNow() )
03169	      {
03170	        bSaveJump = true;
03171	        bPressedJump = false;
03172	      }
03173	      else
03174	        bSaveJump = false;
03175	
03176	      if ( Role < ROLE_Authority ) // then save this move and replicate it
03177	        ReplicateMove(DeltaTime, NewAccel, DoubleClickMove, OldRotation - Rotation);
03178	      else
03179	        ProcessMove(DeltaTime, NewAccel, DoubleClickMove, OldRotation - Rotation);
03180	      bPressedJump = bSaveJump;
03181	    }
03182	
03183	    //__________________
03184	    function ProcessMove(float DeltaTime, vector NewAccel, eDoubleClickDir DoubleClickMove, rotator DeltaRot)
03185	    {
03186	      local vector OldAccel;
03187	      local bool OldCrouch;
03188	
03189	      OldAccel = Pawn.Acceleration;
03190	      Pawn.Acceleration = NewAccel;
03191	      Pawn.SetPhysics(PHYS_None);
03192	      Pawn.Velocity += NewAccel * Deltatime;
03193	      if ( vSize(Pawn.Velocity) > fTyrolSpeed )
03194	        Pawn.Velocity = normal(Pawn.Velocity) * fTyrolSpeed;
03195	      Pawn.Move(Pawn.Velocity * Deltatime);
03196	
03197	      // ELR No more jump there
03198	
03199	      if ( Pawn.Physics != PHYS_Falling )
03200	      {
03201	        OldCrouch = Pawn.bWantsToCrouch;
03202	        if (bDuck == 0)
03203	          Pawn.ShouldCrouch(false);
03204	        else if ( Pawn.bCanCrouch )
03205	          Pawn.ShouldCrouch(true);
03206	      }
03207	    }
03208	}
03209	
03210	//_____________________________________________________________________________
03211	
03212	state BossView
03213	{
03214	    ignores ReLoad, NextWeapon, cNextItem, AltFire, Jump;
03215	
03216	    function BeginState() {}
03217	    function EndState() {}
03218	
03219	    event PlayerCalcView(out actor ViewActor, out vector CameraLocation, out rotator CameraRotation )
03220	    {
03221	//    	ViewActor = ViewTarget; // ELR don't set ViewActor else sound will come as heard from it
03222	        CameraLocation = CamView.Location;
03223	        CameraRotation = rotator( CamView.Location - CamView.Location);
03224	    }
03225	}
03226	
03227	//_____________________________________________________________________________
03228	state CameraView
03229	{
03230	    ignores AltFire, Jump;
03231	    ignores Reload, cNextItem, cPrevItem, PrevWeapon, NextWeapon;
03232	
03233	    function BeginState()
03234	    {
03235	      Pawn.Playsound(hCamViewBeginUseSound);
03236	      Pawn.Playsound(hCamViewInUseSound);
03237	      Pawn.Velocity = vect(0,0,0);
03238	      Pawn.Acceleration = vect(0,0,0);
03239	    }
03240	    function EndState()
03241	    {
03242	      Pawn.StopSound(hCamViewInUseSound);
03243	      Pawn.Playsound(hCamViewBeginUseSound);
03244	      DefaultFOV = default.DefaultFOV;
03245	      DesiredFOV = DefaultFOV;
03246	      FOVAngle = DefaultFOV;
03247	    }
03248	    event PlayerCalcView(out actor ViewActor, out vector CameraLocation, out rotator CameraRotation )
03249	    {
03250	//    	ViewActor = ViewTarget; // ELR don't set ViewActor else sound will come as heard from it
03251	      CameraLocation = CamView.Location;
03252	      CameraRotation = CamView.Rotation;
03253	    }
03254	}
03255	
03256	//_____________________________________________________________________________
03257	state MayClimbDoor extends PlayerWalking
03258	{
03259	    ignores NextWeapon, cNextItem, Grab;
03260	
03261	    function BeginState()
03262	    {
03263	      SetTimer(0.1, true);
03264	      if ( bWeaponMode )
03265	      {
03266	        OldWeap = pawn.weapon.InventoryGroup;
03267	        Pawn.Weapon.PutDown();
03268	      }
03269	      else
03270	      {
03271	        if ( OldItem != none )
03272	        {
03273	          cNextItem();
03274	          XIIIPawn(Pawn).PendingItem = OldItem;
03275	        }
03276	        else
03277	        {
03278	          NextWeapon();
03279	          Switchweapon( 0 );
03280	        }
03281	      }
03282	      bWeaponBlock = true;
03283	    }
03284	    function Timer()
03285	    {
03286	      if (Pawn.Velocity.Z < 0.0 )
03287	      {
03288	//        log(self$" should try to climb");
03289	        SetTimer(0.0, false);
03290	        OldDoorClimbPos = Pawn.Location;
03291	        DoorClimbMove = vect(0,0,1.0);
03292	        Pawn.PlaySound(hClimbDoorSound);
03293	        GotoState('ClimbDoor');
03294	      }
03295	    }
03296	    event bool NotifyLanded(vector HitNormal)
03297	    {
03298	      GotoState('PlayerWalking');
03299	      return true;
03300	    }
03301	}
03302	
03303	//_____________________________________________________________________________
03304	state ClimbDoor extends PlayerWalking
03305	{
03306	    ignores NextWeapon, cNextItem, Grab;
03307	
03308	    function EndState()
03309	    {
03310	//      Pawn.PlaySound(hEndClimbDoorSound); // ELR don't play this anytime, just in case we could have succeeded
03311	      bWeaponBlock = false;
03312	      if ( bWeaponMode )
03313	      {
03314	        Switchweapon( OldWeap );
03315	        Pawn.ChangedWeapon();
03316	      }
03317	      else
03318	      {
03319	        if ( OldItem != none )
03320	        {
03321	          cNextItem();
03322	          XIIIPawn(Pawn).PendingItem = OldItem;
03323	        }
03324	        else
03325	        {
03326	          NextWeapon();
03327	          Switchweapon( 0 );
03328	        }
03329	        Pawn.ChangedWeapon();
03330	      }
03331	    }
03332	
03333	    function ProcessMove(float DeltaTime, vector NewAccel, eDoubleClickDir DoubleClickMove, rotator DeltaRot)
03334	    {
03335	      local vector OldAccel;
03336	      local vector Start,End,HitLoc,HitNorm;
03337	      local actor A;
03338	
03339	      DoorClimbMove = Pawn.Location - OldDoorClimbPos;
03340	      if ( DoorClimbMove.z == 0.0 )
03341	      {
03342	//        log(self$" ending the climb because no more vertical speed.");
03343	        Pawn.Acceleration = vect(0,0,0);
03344	        Pawn.Velocity = - DoorLockedNormal * 200.0;
03345	        GotoState('PlayerWalking');
03346	        return;
03347	      }
03348	      DoorClimbMove.z = 0.0;
03349	      if ( vSize(DoorClimbMove) > 1.0 )
03350	      {
03351	//        log(self$" ending the climb because the move is not the one predicted");
03352	        Pawn.Acceleration = vect(0,0,0);
03353	        Pawn.Velocity = - DoorLockedNormal * 200.0;
03354	        Pawn.PlaySound(hEndClimbDoorSound); // ELR don't play this anytime, just in case we could have succeeded
03355	        GotoState('PlayerWalking');
03356	        return;
03357	      }
03358	
03359	      Start = Pawn.Location;
03360	      End = Start - DoorLockedNormal * Pawn.CollisionRadius * 1.5;
03361	      A = Trace(HitLoc, HitNorm, End, Start);
03362	      if ( (A != DoorToClimb) && (A != none) )
03363	      {
03364	//        log(self$" ending the climb because there is obstacle in front");
03365	//        log("DoorNormal="$DoorLockedNormal);
03366	        Pawn.Acceleration = vect(0,0,0);
03367	        Pawn.Velocity = - DoorLockedNormal * 200.0;
03368	        GotoState('PlayerWalking');
03369	        return;
03370	      }
03371	
03372	      OldDoorClimbPos = Pawn.Location;
03373	      OldAccel = Pawn.Acceleration;
03374	      Pawn.Acceleration = vect(0,0,0);
03375	      Pawn.Velocity = - DoorLockedNormal * 400.0 + vect(0,0,1) * 150.0;
03376	
03377	      if ( bPressedJump )
03378	        GotoState('PlayerWalking');
03379	    }
03380	}
03381	
03382	//_____________________________________________________________________________
03383	// Player is controlling orientation of a gun turret.
03384	state PlayerGunning
03385	{
03386	    ignores Reload, cNextItem, cPrevItem, PrevWeapon, NextWeapon;
03387	
03388	    function BeginState()
03389	    {
03390	      local MitraillTop GunnedTurret;
03391	      Local vector V,W;
03392	
03393	      GunnedTurret = MitraillTop(Pawn.ControlledActor);
03394	      V = GunnedTurret.location;
03395	      W = vector(GunnedTurret.owner.Rotation);
03396	      W.z = 0.0;
03397	      W = Normal(W);
03398	      V -= GunnedTurret.CollisionRadius * W;
03399	      V -= Pawn.CollisionRadius * W;
03400	      V.z = Pawn.Location.z;
03401	      Pawn.SetCollision(false,false,false);
03402	      Pawn.Velocity = vect(0,0,0);
03403	      Pawn.Acceleration = vect(0,0,0);
03404	      Pawn.SetLocation(V);
03405	      Pawn.SetCollision(true,true,true);
03406	      Pawn.bHidden = true;
03407	      Pawn.RefreshDisplaying();
03408	      Pawn.bStasis = true;
03409	      if ( bWeaponMode )
03410	      {
03411	        OldWeap = pawn.weapon.InventoryGroup;
03412	        Pawn.Weapon.PutDown();
03413	      }
03414	      else
03415	      {
03416	        OldItem = XIIIItems(Pawn.SelectedItem);
03417	        OldItem.PutDown();
03418	      }
03419	      bWeaponBlock = true;
03420	      SetViewTarget(Pawn.ControlledActor);
03421	      DesiredFOV = 70;
03422	      FOVAngle = 70;
03423	    }
03424	    function EndState()
03425	    {
03426	      Pawn.bHidden = false;
03427	      Pawn.RefreshDisplaying();
03428	      Pawn.bStasis = false;
03429	      SetViewTarget(Pawn);
03430	      DesiredFOV = DefaultFOV;
03431	      FOVAngle = DefaultFOV;
03432	      bWeaponBlock = false;
03433	      DebugLog("GUNNING EndState OldItem="$OldItem@"bWeaponMode="$bWeaponMode);
03434	      if ( bWeaponMode )
03435	      {
03436	        Switchweapon( OldWeap );
03437	        Pawn.ChangedWeapon();
03438	      }
03439	      else
03440	      {
03441	        if ( OldItem != none )
03442	        {
03443	          cNextItem();
03444	          XIIIPawn(Pawn).PendingItem = OldItem;
03445	        }
03446	        else
03447	        {
03448	          bWaitForWeaponMode = true;
03449	          bWeaponMode = true;
03450	          SwitchWeapon( 0 );
03451	        }
03452	        Pawn.ChangedWeapon();
03453	      }
03454	      DebugLog("GUNNING AFTER EndState OldItem="$OldItem@"bWeaponMode="$bWeaponMode);
03455	    }
03456	
03457	    event PlayerCalcView(out actor ViewActor, out vector CameraLocation, out rotator CameraRotation )
03458	    {
03459	      Local vector X,Y,Z;
03460	
03461	      GetAxes(ViewTarget.rotation, X,Y,Z);
03462	      ViewActor = ViewTarget;
03463	      CameraLocation = ViewActor.Location - X * 60 + Z * 20.0; // + ShakeOffset;
03464	      CameraRotation = ViewActor.Rotation;
03465	      CalcFirstPersonView( CameraLocation, CameraRotation );
03466	      CameraLocation -= Pawn.EyePosition();
03467	    }
03468	
03469	    function Leave()
03470	    {
03471	      local MitraillTop GunnedTurret;
03472	
03473	      GunnedTurret = MitraillTop(Pawn.ControlledActor);
03474	      GotoState('PlayerWalking');
03475	      Pawn.SetPhysics(PHYS_Falling);
03476	      GunnedTurret.LeaveControl();
03477	    }
03478	    function PlayerMove( float DeltaTime )
03479	    {
03480	      local MitraillTop GunnedTurret;
03481	
03482	      GunnedTurret = MitraillTop(Pawn.ControlledActor);
03483	      UpdateRotation(DeltaTime, 1);
03484	      GunnedTurret.TrySetRotation(Rotation);
03485	      SetRotation(GunnedTurret.Rotation);
03486	      if ( bPressedJump )
03487	        Leave();
03488	    }
03489	    exec function Grab() { Leave(); }
03490	    exec function AltFire(float value) { Leave(); }
03491	
03492	    exec function Fire(float value)
03493	    {
03494	      Mitrailltop(Pawn.ControlledActor).Fire();
03495	    }
03496	
03497	    simulated event RenderOverlays( canvas C )
03498	    {
03499	      Pawn.ControlledActor.RenderOverlays(C);
03500	    }
03501	}
03502	
03503	//_____________________________________________________________________________
03504	state ClimbToHookNavPoint extends PlayerWalking
03505	{
03506	    function BeginState()
03507	    {
03508	      Pawn.SetCollision(false,false,false);
03509	      SetPhysics(PHYS_None);
03510	    }
03511	    function EndState()
03512	    {
03513	      Pawn.SetCollision(true,true,true);
03514	      SetPhysics(PHYS_Walking);
03515	    }
03516	    function ProcessMove(float DeltaTime, vector NewAccel, eDoubleClickDir DoubleClickMove, rotator DeltaRot)
03517	    {
03518	//      Log("ClimbToHookNavPoint ProcessMove");
03519	      Pawn.Acceleration = vect(0,0,0);
03520	      if ( Pawn.Location.Z < (TargetHookClimb.Location.Z) )
03521	      {
03522	//        Log("                    ProcessMove going up");
03523	        Pawn.Velocity = vect(0,0,256);
03524	      }
03525	      else
03526	      {
03527	//        Log("                    ProcessMove going to nav point");
03528	        Pawn.Velocity = normal(TargetHookClimb.Location - Pawn.Location)*256;
03529	      }
03530	      if ( vSize(TargetHookClimb.Location - Pawn.Location) < 20.0 )
03531	      {
03532	//        Log("                    GOTO PlayerWalking because reached target");
03533	        GotoState('PlayerWalking');
03534	      }
03535	    }
03536	}
03537	
03538	//_____________________________________________________________________________
03539	state GameEnded
03540	{
03541	    ignores SeePlayer, HearNoise, KilledBy, NotifyBump, HitWall, NotifyHeadVolumeChange,
03542	      NotifyPhysicsVolumeChange, Falling, TakeDamage, Suicide, Reload, cNextItem, NextWeapon, PrevWeapon, cPrevItem, Grab;
03543	
03544	    simulated event RenderOverlays( canvas C ) {}
03545	    function PawnDied() {}
03546	    exec function ThrowWeapon() {}
03547	
03548	    function bool IsInLethalVolume(out optional volume Vol)
03549	    {
03550	      local Volume V;
03551	
03552	      ForEach Pawn.TouchingActors(class'Volume',V)
03553	        if ( V.IsA('Lethalvolume') )
03554	        {
03555	          Vol = V;
03556	          return true;
03557	        }
03558	      return false;
03559	    }
03560	
03561	    function ServerReStartGame()
03562	    {
03563	      Level.Game.RestartGame();
03564	    }
03565	
03566	// ELR E3 CHEAT
03567	    exec function Fire( optional float F )
03568	    {
03569	//      ConsoleCommand("RestartLevel");
03570	    }
03571	    exec function AltFire( optional float F )
03572	    {
03573	//      ConsoleCommand("RestartLevel");
03574	    }
03575	// ELR END E3 CHEATS
03576	/*
03577	    exec function Fire( optional float F )
03578	    {
03579	      if ( Role < ROLE_Authority)
03580	        return;
03581	      if ( !bFrozen )
03582	        ServerReStartGame();
03583	      else if ( TimerRate <= 0 )
03584	        SetTimer(1.5, false);
03585	    }
03586	
03587	    exec function AltFire( optional float F )
03588	    {
03589	      Fire(F);
03590	    }
03591	*/
03592	
03593	    function PlayerMove(float DeltaTime)
03594	    {
03595	      local vector X,Y,Z;
03596	      local Rotator ViewRotation;
03597	
03598	      GetAxes(Rotation,X,Y,Z);
03599	      // Update view rotation.
03600	
03601	      if ( !bFixedCamera )
03602	      {
03603	        ViewRotation = Rotation;
03604	        ViewRotation.Yaw += 32.0 * DeltaTime * aTurn;
03605	        ViewRotation.Pitch += 32.0 * DeltaTime * aLookUp;
03606	        ViewRotation.Pitch = ViewRotation.Pitch & 65535;
03607	        If ((ViewRotation.Pitch > 18000) && (ViewRotation.Pitch < 49152))
03608	        {
03609	          If (aLookUp > 0)
03610	            ViewRotation.Pitch = 18000;
03611	          else
03612	            ViewRotation.Pitch = 49152;
03613	        }
03614	        SetRotation(ViewRotation);
03615	      }
03616	      else if ( ViewTarget != None )
03617	        SetRotation(ViewTarget.Rotation);
03618	
03619	      ViewShake(DeltaTime);
03620	      ViewFlash(DeltaTime);
03621	
03622	      if ( Role < ROLE_Authority ) // then save this move and replicate it
03623	        ReplicateMove(DeltaTime, vect(0,0,0), DCLICK_None, rot(0,0,0));
03624	      else
03625	        ProcessMove(DeltaTime, vect(0,0,0), DCLICK_None, rot(0,0,0));
03626	      bPressedJump = false;
03627	    }
03628	
03629	    function ServerMove
03630	    (
03631	      float TimeStamp,
03632	      vector InAccel,
03633	      vector ClientLoc,
03634	      bool NewbRun,
03635	      bool NewbDuck,
03636	      bool NewbJumpStatus,
03637	      eDoubleClickDir DoubleClickMove,
03638	      byte ClientRoll,
03639	      int View,
03640	      optional byte OldTimeDelta,
03641	      optional int OldAccel
03642	    )
03643	    {
03644	      Global.ServerMove(TimeStamp, InAccel, ClientLoc, NewbRun, NewbDuck, NewbJumpStatus,
03645	        DoubleClickMove, ClientRoll, (32767 & (Rotation.Pitch/2)) * 32768 + (32767 & (Rotation.Yaw/2)) );
03646	
03647	    }
03648	
03649	    event PlayerCalcView(out actor ViewActor, out vector CameraLocation, out rotator CameraRotation )
03650	    {
03651	      ViewActor = ViewTarget;
03652	      CameraLocation = vGameEndedCamLoc;
03653	      CameraRotation = rGameEndedCamRot;
03654	    }
03655	
03656	    function FindGoodView()
03657	    {
03658	      local vector cameraLoc;
03659	      local rotator cameraRot, ViewRotation;
03660	      local int tries, besttry;
03661	      local float bestdist, newdist;
03662	      local int startYaw;
03663	      local actor ViewActor;
03664	
03665	      ViewRotation = Rotation;
03666	      ViewRotation.Pitch = 56000;
03667	      tries = 0;
03668	      besttry = 0;
03669	      bestdist = 0.0;
03670	      startYaw = ViewRotation.Yaw;
03671	
03672	      for (tries=0; tries<16; tries++)
03673	      {
03674	        cameraLoc = ViewTarget.Location;
03675	        PlayerCalcView(ViewActor, cameraLoc, cameraRot);
03676	        newdist = VSize(cameraLoc - ViewTarget.Location);
03677	        if (newdist > bestdist)
03678	        {
03679	          bestdist = newdist;
03680	          besttry = tries;
03681	        }
03682	        ViewRotation.Yaw += 4096;
03683	      }
03684	
03685	      ViewRotation.Yaw = startYaw + besttry * 4096;
03686	      SetRotation(ViewRotation);
03687	    }
03688	
03689	    function Timer()
03690	    {
03691	      bFrozen = false;
03692	    }
03693	
03694	    function BeginState()
03695	    {
03696	      local Pawn P;
03697	      Local Actor A;
03698	      Local Volume V;
03699	      local int XIIIEndGameType;
03700	
03701	      bFixedCamera = true;
03702	      DesiredFOV = DefaultFOV;
03703	      FOVAngle = DefaultFOV;
03704	
03705	      if ( Level.Game != none )
03706	        XIIIEndGameType = XIIIGameInfo(Level.Game).XIIIEndGameType;
03707	      else
03708	        XIIIEndGameType = 0;
03709	
03710	      Log("Game Ended for "$self$" w/ mode "$XIIIEndGameType);
03711	
03712	      // Hide all inventory that should be rendered
03713	      if ( Pawn != none )
03714	      {
03715	        Pawn.bCanClimbLadders = false; // no more ladder climb (in case player jumps in a laddervolume just before gameended
03716	        Pawn.bCanJump = false;
03717	        bWeaponBlock = true;
03718	/*
03719	        Pawn.PendingWeapon = none;
03720	        Pawn.PendingItem = none;
03721	        if ( pawn.weapon != none )
03722	        {
03723	          OldWeap = pawn.weapon.InventoryGroup;
03724	          Pawn.Weapon.PutDown();
03725	        }
03726	        if ( Pawn.SelectedItem != none )
03727	        {
03728	          OldItem = XIIIItems(Pawn.SelectedItem);
03729	          OldItem.PutDown();
03730	        }
03731	*/
03732	        if ( Pawn.Weapon != none )
03733	        {
03734	          Pawn.Weapon.bOwnerNoSee = true;
03735	          Pawn.Weapon.bHidden = true;
03736	          Pawn.Weapon.Refreshdisplaying();
03737	          if ( Pawn.Weapon.MySlave != none )
03738	          {
03739	            Pawn.Weapon.MySlave.bOwnerNoSee = true;
03740	            Pawn.Weapon.MySlave.bHidden = true;
03741	            Pawn.Weapon.MySlave.Refreshdisplaying();
03742	          }
03743	        }
03744	        if ( Pawn.SelectedItem != none )
03745	        {
03746	          Pawn.SelectedItem.bOwnerNoSee = true;
03747	          Pawn.SelectedItem.bHidden = true;
03748	          Pawn.SelectedItem.Refreshdisplaying();
03749	        }
03750	        if ( XIIIPawn(Pawn).LHand != none )
03751	        {
03752	          XIIIPawn(Pawn).LHand.bOwnerNoSee = true;
03753	          XIIIPawn(Pawn).LHand.bHidden = true;
03754	          XIIIPawn(Pawn).LHand.Refreshdisplaying();
03755	        }
03756	      }
03757	
03758	      Global.PlayerCalcView(A, vGameEndedCamLoc, rGameEndedCamRot);
03759	
03760	      if ( XIIIEndGameType == 1 ) // SoloDeath
03761	      {
03762	        if ( fRand() < 0.5 )
03763	          iGameEndedRandEffect = 1;
03764	        else
03765	          iGameEndedRandEffect = -1;
03766	        if ( XIIIPawn(pawn).HitDamageType != class'XIII.DTDrowned' )
03767	          GotoState('GameEndedDeath');
03768	        else
03769	          GotoState('GameEndedDrown');
03770	      }
03771	      else if ( XIIIEndGameType == 3 ) // Falling
03772	      {
03773	        if ( IsInLethalVolume(V) )
03774	        {
03775	//          Log("I'm in Lethalvolume V="$V);
03776	          OnoF = Spawn(class'OnoFalling', Pawn,,Pawn.Location);
03777	          vGameEndedCamLoc = Lethalvolume(V).PointOfViewWhenFalling.Location;
03778	        }
03779	//        Log("Volume V="$V$" PointOfViewWhenFalling="$Lethalvolume(V).PointOfViewWhenFalling);
03780	        iGameEndedRandEffect = 1;
03781	        bBehindView = true;
03782	        GotoState('GameEndedFalling');
03783	      }
03784	      else if ( XIIIEndGameType == 4 ) // Success
03785	      {
03786	        GotoState('GameEndedSuccess');
03787	      }
03788	
03789	      EndZoom();
03790	      bFire = 0;
03791	      bAltFire = 0;
03792	      if ( Pawn != None )
03793	      {
03794	        Pawn.SimAnim.AnimRate = 0;
03795	        Pawn.bPhysicsAnimUpdate = false;
03796	        Pawn.StopAnimating();
03797	        Pawn.SetCollision(false,false,false);
03798	      }
03799	      myHUD.bShowScores = true;
03800	      bFrozen = true;
03801	      if ( !bFixedCamera )
03802	      {
03803	        FindGoodView();
03804	        bBehindView = true;
03805	      }
03806	      SetTimer(1.5, false);
03807	      SetPhysics(PHYS_None);
03808	      ForEach DynamicActors(class'Pawn', P)
03809	      {
03810	        P.Velocity = vect(0,0,0);
03811	        P.SetPhysics(PHYS_None);
03812	      }
03813	    }
03814	begin:
03815	      if ( !Level.bLonePlayer || XIIIGameInfo(Level.Game).XIIIEndGameType==4)
03816			  stop;
03817		  Sleep(4);
03818	      ConsoleCommand("ShowTheMenu "$self);
03819	}
03820	
03821	//_____________________________________________________________________________
03822	state GameEndedDeath Extends GameEnded
03823	{
03824	    event PlayerTick(float dT)
03825	    {
03826	      DeltaT = dT;
03827	//      Log("DeltaT="$DeltaT);
03828	      Pawn.region.Zone.FlashEffectDesc.LayerBrightness = min(255, Pawn.region.Zone.FlashEffectDesc.LayerBrightness + DeltaT*200.0);
03829	      Pawn.region.Zone.FlashEffectDesc.Brightness = max(10, Pawn.region.Zone.FlashEffectDesc.Brightness - DeltaT*0.05);
03830	    }
03831	//      Global.PlayerCalcView(A, vGameEndedCamLoc, rGameEndedCamRot);
03832	    event PlayerCalcView(out actor ViewActor, out vector CameraLocation, out rotator CameraRotation )
03833	    {
03834	      Local vector TargetCamLoc;
03835	
03836	      TargetCamLoc = Pawn.Location - Pawn.CollisionHeight * 0.75 * vect(0,0,1);
03837	
03838	      if (rGameEndedCamRot.Pitch <= 15500)
03839	        rGameEndedCamRot.Pitch = max(0, rGameEndedCamRot.Pitch - (DeltaT * 300.0));
03840	//        rGameEndedCamRot.Pitch = max(0, rGameEndedCamRot.Pitch*0.97);
03841	      else if (rGameEndedCamRot.Pitch >= 50000)
03842	        rGameEndedCamRot.Pitch = min(65535, rGameEndedCamRot.Pitch + (DeltaT * 300.0));
03843	//        rGameEndedCamRot.Pitch = min(65535, rGameEndedCamRot.Pitch*1.007);
03844	
03845	      rGameEndedCamRot.Roll += 150.0 * (DeltaT*30.0) * iGameEndedRandEffect;
03846	      if ( iGameEndedRandEffect > 0 )
03847	        rGameEndedCamRot.Roll = min(rGameEndedCamRot.Roll, 12000);
03848	      else
03849	        rGameEndedCamRot.Roll = max(rGameEndedCamRot.Roll, -12000);
03850	      vGameEndedCamLoc = (vGameEndedCamLoc*45.0*(DeltaT*30.0) + TargetCamLoc)/(45.0*(DeltaT*30.0)+1);
03851	
03852	      ViewActor = ViewTarget;
03853	      CameraLocation = vGameEndedCamLoc;
03854	      CameraRotation = rGameEndedCamRot;
03855	    }
03856	
03857	    function BeginState()
03858	    {
03859	      Log("GameEndedDeath BeginState");
03860	      Pawn.region.Zone.FlashEffectDesc.IsActivated = true;
03861	      Pawn.region.Zone.FlashEffectDesc.NoGrey = true;
03862	      Pawn.region.Zone.FlashEffectDesc.Contrast = 255;
03863	      Pawn.region.Zone.FlashEffectDesc.LayerBrightness = 0;
03864	      Pawn.region.Zone.FlashEffectDesc.Brightness = 128;
03865	      Pawn.region.Zone.FlashEffectDesc.LayerColor = class'canvas'.static.makecolor(255,0,0,0);
03866	      DeltaT = 1.0/30.0;  // init to 30 fps
03867	      enable('Tick');
03868	      bStasis = false;
03869	//      SetTimer(1.5, false);
03870	//      Log("GameEndedDeath BeginState");
03871	    } // dont replay the GameEnded BeginState()
03872	/*
03873	    event Timer()
03874	    {
03875				ShakeView(5.0, 300, vect(0,0,10), 120000, vect(50,50,50), 3);
03876	    }
03877	*/
03878	}
03879	
03880	//_____________________________________________________________________________
03881	state GameEndedDrown Extends GameEnded
03882	{
03883	//      Global.PlayerCalcView(A, vGameEndedCamLoc, rGameEndedCamRot);
03884	    event PlayerCalcView(out actor ViewActor, out vector CameraLocation, out rotator CameraRotation )
03885	    {
03886	      Local vector TargetCamLoc;
03887	
03888	      TargetCamLoc = Pawn.Location; // - Pawn.CollisionHeight * 0.8 * vect(0,0,1);
03889	
03890	//      if ( (rGameEndedCamRot.Pitch > 15500) && (rGameEndedCamRot.Pitch < 50000))
03891	      if (rGameEndedCamRot.Pitch <= 15500)
03892	        rGameEndedCamRot.Pitch = min(15500, rGameEndedCamRot.Pitch + 300);
03893	      else if (rGameEndedCamRot.Pitch >= 50000)
03894	      {
03895	        rGameEndedCamRot.Pitch = rGameEndedCamRot.Pitch + 300;
03896	        rGameEndedCamRot.Pitch = rGameEndedCamRot.Pitch & 65535;
03897	      }
03898	
03899	/*
03900	      rGameEndedCamRot.Roll += 160*iGameEndedRandEffect;
03901	      if ( iGameEndedRandEffect > 0 )
03902	        rGameEndedCamRot.Roll = min(rGameEndedCamRot.Roll, 12000);
03903	      else
03904	        rGameEndedCamRot.Roll = max(rGameEndedCamRot.Roll, -12000);
03905	*/
03906	
03907	      vGameEndedCamLoc = (vGameEndedCamLoc*24.0 + TargetCamLoc)/25.0;
03908	
03909	      ViewActor = ViewTarget;
03910	      CameraLocation = vGameEndedCamLoc;
03911	      CameraRotation = rGameEndedCamRot;
03912	    }
03913	
03914	    function BeginState()
03915	    {
03916	//      Log("GameEndedDeath BeginState");
03917	    } // dont replay the GameEnded BeginState()
03918	}
03919	
03920	//_____________________________________________________________________________
03921	state GameEndedFalling Extends GameEnded
03922	{
03923	    event PlayerCalcView(out actor ViewActor, out vector CameraLocation, out rotator CameraRotation )
03924	    {
03925	      ViewActor = ViewTarget;
03926	      CameraLocation = vGameEndedCamLoc;
03927	      CameraRotation = Rotator(ViewActor.Location - vGameEndedCamLoc);
03928	    }
03929	
03930	    function BeginState()
03931	    {
03932	//      Log("GameEndedFalling BeginState");
03933	      FilterColorWanted=class'canvas'.static.makecolor(0,0,0,0);
03934	      FilterColorSpeed=0.5;
03935	/*
03936	var color FilterColor;                // La couleur courante.
03937	var color FilterColorWanted;          // La couleur vers laquelle le moteur doit converger.
03938	var float FilterColorSpeed;           // La vitesse de convergence.
03939	*/
03940	    } // dont replay the GameEnded BeginState()
03941	
03942	    function EndState()
03943	    {
03944	      FilterColorWanted=class'canvas'.static.makecolor(128,128,128,128);
03945	      FilterColorSpeed=10.0;
03946	    }
03947	
03948	    Event bool NotifyLanded(vector HitNorm)
03949	    {
03950	      OnoF.OnoEnd();
03951	      FilterColor=class'canvas'.static.makecolor(200,0,0,64);
03952	      FilterColorWanted=class'canvas'.static.makecolor(200,0,0,64);
03953	      Settimer(0.10, false);
03954	      return true;
03955	    }
03956	
03957	    event Timer()
03958	    {
03959	      FilterColorWanted=class'canvas'.static.makecolor(0,0,0,0);
03960	      FilterColorSpeed=5.0;
03961	    }
03962	}
03963	
03964	//_____________________________________________________________________________
03965	// the mission is a success, play video if available then travel
03966	state GameEndedSuccess extends GameEnded
03967	{
03968	    event BeginState()
03969	    {
03970	//      Log("GameEndedSucess BeginState");
03971	      SetTimer(3.0, false);
03972	    }
03973	    event Timer()
03974	    {
03975	//      Log("GameEndedSucess Timer");
03976	      if ( (XIIIGameInfo(Level.Game).MapInfo != none) && (XIIIGameInfo(Level.Game).MapInfo.EndMapVideo != "") )
03977	      { // Play video
03978	        if ( VP == none )
03979	          VP = new class'VideoPlayer';
03980	        if ( VP != none )
03981	          VP.Open(XIIIGameInfo(Level.Game).MapInfo.EndMapVideo);
03982	        GotoState('PlayingVideo');
03983	      }
03984	      else
03985	      { // travel
03986	        GotoState('GameEndedSuccess', 'DoTravel');
03987	      }
03988	    }
03989	Begin:
03990	  Stop;
03991	DoTravel:
03992	//  Log("GameEndedSucess DoTravel... Sleep 0.3");
03993	  sleep(1.0);
03994	//  Log("GameEndedSucess DoTravel... End sleep");
03995	  Level.ServerTravel(XIIIGameInfo(Level.Game).MapInfo.NextMapLevelWithUnr, true);
03996	}
03997	
03998	//_____________________________________________________________________________
03999	state PlayingVideo
04000	{
04001	    event BeginState()
04002	    {
04003	      KillAllSounds();
04004	      VP.Play();
04005	      StopAllSounds();
04006	    }
04007	    event PlayerTick(float dT)
04008	    {
04009	      if ( VP == none )
04010	        Level.ServerTravel(XIIIGameInfo(Level.Game).MapInfo.NextMapLevelWithUnr, true);
04011	      else
04012	      {
04013	        switch (VP.GetStatus())
04014	        {
04015	          Case 0: // End video or no play
04016	            Log("End video or no play");
04017	            Level.ServerTravel(XIIIGameInfo(Level.Game).MapInfo.NextMapLevelWithUnr, true);
04018	            break;
04019	          Case 2: // Error while playing
04020	            Log("Error playing video");
04021	            Level.ServerTravel(XIIIGameInfo(Level.Game).MapInfo.NextMapLevelWithUnr, true);
04022	            break;
04023	          Case 1: // continue playing
04024	        }
04025	      }
04026	    }
04027	    exec function Fire( optional float F );
04028	}
04029	
04030	//_____________________________________________________________________________
04031	State NoControl extends PlayerWalking
04032	{
04033	    ignores ReLoad, NextWeapon, PrevWeapon, cNextItem, cPrevItem, Fire, AltFire, Jump, Grab, QuickHeal;
04034	
04035	//    simulated event RenderOverlays( canvas C ) {}
04036	
04037	    event BeginState()
04038	    {
04039	      Pawn.bCanCrouch=false;
04040	//      Log("NoControl Begin State");
04041	      Super.BeginState();
04042	      velocity=vect(0,0,0);
04043	      if (!bMenuIsActive)
04044	      Level.bCineFrame = true;
04045	//      PlayerInput.bForceCrouch = true;
04046	    }
04047	
04048	    event EndState()
04049	    {
04050	      Pawn.bCanCrouch=true;
04051	      Level.bCineFrame = false;
04052	      MyInteraction.TargetActor = none; // Anticrash if target actor was a breakable mover
04053	//      Log("NoControl End State");
04054	//      PlayerInput.bForceCrouch = false;
04055	    }
04056	
04057	    function UpdateRotation(float DeltaTime, float maxPitch)
04058	    {
04059	      local Rotator r;
04060	      r=Rotation;
04061	      //		DesiredRotation=Rotation;
04062	      ViewShake(deltaTime);
04063	      SetRotation(r); // Force Rotation even if shaking camera
04064	      ViewFlash(deltaTime);
04065	    }
04066	/*
04067	    event Playertick(float dT)
04068	    {
04069	//      Log("NoControl End State");
04070	    }
04071	
04072	
04073	    event PlayerCalcView(out actor ViewActor, out vector CameraLocation, out rotator CameraRotation )
04074	    {
04075	      Log("NoControl PlayerCalcView");
04076	    	ViewActor = ViewTarget;
04077	      CameraLocation = Location;
04078	      CameraRotation = Rotation;
04079	    }
04080	*/
04081	
04082	    function PlayerMove( float DeltaTime )
04083	    {
04084	      local vector X,Y,Z, NewAccel;
04085	      local eDoubleClickDir DoubleClickMove;
04086	      local rotator OldRotation; //, ViewRotation;
04087	      //local float Speed2D;
04088	      //local bool bSaveJump;
04089	
04090	//      Log("NoControl PlayerMove");
04091	      GetAxes(Pawn.Rotation,X,Y,Z);
04092	
04093	      // Update acceleration.
04094	      NewAccel = vect(0,0,0);
04095	//      DoubleClickMove = PlayerInput.CheckForDoubleClickMove(DeltaTime);
04096	
04097	      GroundPitch = 0;
04098	      bSnaptoLevel = false;
04099	      bCenterView = false;
04100	      OldRotation = Rotation;
04101	      // MLK: Otherwise the player moves while in menu
04102	      if (!(Left(Level.GetLocalURL(), 7) ~= "mapmenu"))
04103	  		UpdateRotation(DeltaTime, 1);
04104	//      ViewShake(deltaTime);
04105	//      ViewFlash(deltaTime);
04106	
04107	      if ( Pawn.Physics != PHYS_Falling )
04108	      {
04109	        Pawn.bWantsToCrouch = PlayerInput.bForceCrouch;
04110	        Pawn.ShouldCrouch(PlayerInput.bForceCrouch);
04111	      }
04112	
04113	      if ( Role < ROLE_Authority ) // then save this move and replicate it
04114	        ReplicateMove(DeltaTime, NewAccel, DoubleClickMove, OldRotation - Rotation);
04115	      else
04116	        ProcessMove(DeltaTime, NewAccel, DoubleClickMove, OldRotation - Rotation);
04117	      bPressedJump = false;
04118	    }
04119	}
04120	
04121	//_____________________________________________________________________________
04122	// waiting for first display to give controls to the player (else can trigger unwanted/unseen events)
04123	// by moving while engine init (w/out screen refresh)
04124	state WaitForFirstDisplay
04125	{
04126	    simulated event RenderOverLays(Canvas C)
04127	    {
04128	      if ( !bOkForMoving )
04129	      {
04130	        bOkForMoving = true;
04131	        SetTimer(0.2, false);
04132	      }
04133	    }
04134	    simulated event Timer()
04135	    {
04136	      EnterStartState();
04137	    }
04138	    function UpdateRotation(float DeltaTime, float maxPitch);
04139	    function PlayerMove( float DeltaTime );
04140	}
04141	
04142	
04143	//_____________________________________________________________________________
04144	/*State NoRotation extends PlayerWalking
04145	{
04146	    ignores ReLoad, NextWeapon, PrevWeapon, cNextItem, cPrevItem, Fire, AltFire, Jump, Grab, QuickHeal;
04147	
04148	    simulated event RenderOverlays( canvas C ) {}
04149	
04150	    event BeginState()
04151	    {
04152	//      Log("NoControl Begin State");
04153	      Super.BeginState();
04154	      velocity=vect(0,0,0);
04155	    }
04156	
04157	    event EndState()
04158	    {
04159	      MyInteraction.TargetActor = none; // Anticrash if target actor was a breakable mover
04160	//      Log("NoControl End State");
04161	    }
04162	
04163	    function UpdateRotation(float DeltaTime, float maxPitch)
04164	    {
04165			LOCAL Rotator r;
04166			r=Rotation;
04167			ViewShake(deltaTime);
04168			SetRotation(r); // Force Rotation even if shaking camera
04169			ViewFlash(deltaTime);
04170	    }
04171	}*/
04172	//_____________________________________________________________________________
04173	State NoMove extends PlayerWalking
04174	{
04175	    ignores ReLoad, NextWeapon, PrevWeapon, cNextItem, cPrevItem, Fire, AltFire, Jump, Grab, QuickHeal;
04176	    event BeginState()
04177	    {
04178	      Super.BeginState();
04179	      velocity=vect(0,0,0);
04180	  	  rGameEndedCamRot=Rotation;
04181	      Pawn.bCanCrouch=false;
04182	    }
04183	    event EndState()
04184	    {
04185	      MyInteraction.TargetActor = none; // Anticrash if target actor was a breakable mover
04186	      Pawn.bCanCrouch=true;
04187	//      Log("NoMove End State");
04188	    }
04189	
04190	    function PlayerMove( float DeltaTime )
04191	    {
04192	      local vector NewAccel;
04193	      local eDoubleClickDir DoubleClickMove;
04194	      local rotator OldRotation,r;
04195	
04196	      NewAccel = vect(0,0,0);
04197	
04198	      GroundPitch = 0;
04199	      bSnaptoLevel = false;
04200	      bCenterView = false;
04201	      OldRotation = Rotation;
04202	  	  r=Rotation-rGameEndedCamRot;
04203	
04204	      DesiredRotation = r; //save old rotation
04205	      r.Yaw += 32.0 * DeltaTime * aTurn;
04206	      r.Pitch += 32.0 * DeltaTime * aLookUp;
04207	
04208	      r.Pitch = r.Pitch & 65535;
04209	      if ((r.Pitch > 15500) && (r.Pitch < 50000))
04210	      {
04211	        if (aLookUp > 0)
04212	          r.Pitch = 15500;
04213	        else
04214	          r.Pitch = 50000;
04215	      }
04216	
04217	      r.yaw=Clamp(((r.yaw+32768)&65535)-32768,-6144,6144);
04218	      r.Roll=0;
04219	      r.Pitch=Clamp(((r.Pitch+32768)&65535)-32768,-3072,3072);
04220	      SetRotation(r+rGameEndedCamRot);
04221	      ViewShake(deltaTime);
04222	      ViewFlash(deltaTime);
04223	
04224	      if ( Role < ROLE_Authority ) // then save this move and replicate it
04225	        ReplicateMove(DeltaTime, NewAccel, DoubleClickMove, OldRotation - Rotation);
04226	      else
04227	        ProcessMove(DeltaTime, NewAccel, DoubleClickMove, OldRotation - Rotation);
04228	      bPressedJump = false;
04229	    }
04230	}
04231	
04232	//_____________________________________________________________________________
04233	simulated State Kicked
04234	{
04235	    ignores ReLoad, NextWeapon, PrevWeapon, cNextItem, cPrevItem, Fire, AltFire, Jump, Grab, QuickHeal;
04236	    simulated event BeginState()
04237	    {
04238	      //Log("KICKED"@self@"BeginState");
04239	    }
04240	    simulated event EndState()
04241	    { // kicked are not allowed to go out of this state
04242	      //Log("KICKED"@self@"EndState");
04243	      SetTimer3(0.01, false);
04244	    }
04245	    function UpdateRotation(float DeltaTime, float maxPitch);
04246	    function PlayerMove( float DeltaTime );
04247	Begin:
04248	  Sleep(4);
04249	}
04250	
04251	//_____________________________________________________________________________
04252	// use to force player in Kicked State (else will go to dead after kicked
04253	simulated event timer3()
04254	{
04255	//    Log("KICKED"@self@"timer3");
04256	    GotoState('Kicked');
04257	}
04258	
04259	FUNCTION ClientSetHUD(class<HUD> newHUDType, class<Scoreboard> newScoringType)
04260	{
04261		SUPER.ClientSetHUD( newHUDType, newScoringType);
04262	
04263		if ( int(ConsoleCommand("Get GameInfo GoreLevel") ) != 0 )
04264	    {
04265	// PARENTAL LOCL ON
04266			ReplaceATextureByAnOther( Texture'XIIICine.effets.blodspotA', Texture'XIIICine.effets.blodspotAPL' );
04267			ReplaceATextureByAnOther( Texture'XIIICine.effets.bloodheadshotA', Texture'XIIICine.effets.bloodheadshotAPL' );
04268			ReplaceATextureByAnOther( Texture'XIIICine.effets.bloodprojM', Texture'XIIICine.effets.bloodprojMPL' );
04269			ReplaceATextureByAnOther( Texture'XIIICine.effets.goutteblood', Texture'XIIICine.effets.gouttebloodPL' );
04270			ReplaceATextureByAnOther( Texture'XIIICine.effets.jikleblood', Texture'XIIICine.effets.jiklebloodPL' );
04271			ReplaceATextureByAnOther( Texture'XIIICine.effets.projectionblodA', Texture'XIIICine.effets.projectionblodAPL' );
04272			ReplaceATextureByAnOther( Texture'XIIICine.effets.vignetteblood', Texture'XIIICine.effets.vignettebloodPL' );
04273		}
04274		else
04275		{
04276	// PARENTAL LOCL OFF
04277			ReplaceATextureByAnOther( Texture'XIIICine.effets.blodspotAPL', Texture'XIIICine.effets.blodspotA' );
04278			ReplaceATextureByAnOther( Texture'XIIICine.effets.bloodheadshotAPL', Texture'XIIICine.effets.bloodheadshotA' );
04279			ReplaceATextureByAnOther( Texture'XIIICine.effets.bloodprojMPL', Texture'XIIICine.effets.bloodprojM' );
04280			ReplaceATextureByAnOther( Texture'XIIICine.effets.gouttebloodPL', Texture'XIIICine.effets.goutteblood' );
04281			ReplaceATextureByAnOther( Texture'XIIICine.effets.jiklebloodPL', Texture'XIIICine.effets.jikleblood' );
04282			ReplaceATextureByAnOther( Texture'XIIICine.effets.projectionblodAPL', Texture'XIIICine.effets.projectionblodA' );
04283			ReplaceATextureByAnOther( Texture'XIIICine.effets.vignettebloodPL', Texture'XIIICine.effets.vignetteblood' );
04284		}
04285	
04286	
04287	}
04288	
04289	
04290	defaultproperties
04291	{
04292	     bWeaponMode=True
04293	     bWaitForWeaponMode=True
04294	     bAltZoomingSystem=True
04295	     bFixedCrosshair=True
04296	     hCLimbDoorSound=Sound'XIIIsound.SpecActions.LeonClimb1'
04297	     hEndClimbDoorSound=Sound'XIIIsound.SpecActions.LeonClimb2'
04298	     hCamViewBeginUseSound=Sound'XIIIsound.Items.CameraOn'
04299	     hCamViewInUseSound=Sound'XIIIsound.Items.CameraRumble'
04300	     hEndClimbLadderSound=Sound'XIIIsound.SpecActions__LadderClimb.LadderClimb__hEndClimbLadder'
04301	     MyInteractionClass="XIII.XIIIPlayerInteraction"
04302	     hTyrolStartSound=Sound'XIIIsound.Movers__TyrolCable.TyrolCable__hCableStart'
04303	     hTyrolEndSound=Sound'XIIIsound.Movers__TyrolCable.TyrolCable__hCableEnded'
04304	     iCrosshairMode=1
04305	     fCrosshairSize=2.000000
04306	     fLookSpeed=1.000000
04307	     bUseRumble=True
04308	     CheatClass=Class'XIII.XIIICheatManager'
04309	     PlayerReplicationInfoClass=Class'XIII.XIIIPlayerReplicationInfo'
04310	     bHasRollOff=False
04311	     bHasPosition=False
04312	}

End Source Code

XIII Class XIIIPlayerController

XIII
Class XIIIPlayerController