SaveText.Ru

Witcher 3 #2
  1. /***********************************************************************/
  2. /**     © 2015 CD PROJEKT S.A. All rights reserved.
  3. /**     THE WITCHER® is a trademark of CD PROJEKT S. A.
  4. /**     The Witcher game is based on the prose of Andrzej Sapkowski.
  5. /***********************************************************************/
  6. statemachine abstract import class CR4Player extends CPlayer
  7. {
  8.        
  9.         protected               var pcGamePlayInitialized                       : bool;                                
  10.  
  11.        
  12.         private                 var pcMode                                                      : bool;                                
  13.         default pcMode = true;
  14.  
  15.        
  16.         protected saved var weaponHolster                                       : WeaponHolster;               
  17.         public                  var rangedWeapon                                        : Crossbow;                            
  18.         public                  var crossbowDontPopStateHack            : bool;                                 default crossbowDontPopStateHack = false;
  19.        
  20.         private                 var hitReactTransScale                          : float;                               
  21.        
  22.         private                 var bIsCombatActionAllowed                      : bool;
  23.         private                 var currentCombatAction                         : EBufferActionType;
  24.        
  25.         private                 var uninterruptedHitsCount                      : int;                                 
  26.         private                 var uninterruptedHitsCameraStarted      : bool;                                
  27.         private                 var uninterruptedHitsCurrentCameraEffect : name;                       
  28.        
  29.         private                 var counterTimestamps                           : array<EngineTime>;   
  30.        
  31.         private                 var hitReactionEffect                           : bool;                                
  32.        
  33.         private                 var lookAtPosition                                      : Vector;                              
  34.         private                 var orientationTarget                           : EOrientationTarget;
  35.         private                 var customOrientationTarget                     : EOrientationTarget;
  36.         protected               var customOrientationStack                      : array<SCustomOrientationParams>;
  37.        
  38.         public                  var delayOrientationChange                      : bool;
  39.         protected               var delayCameraOrientationChange        : bool;
  40.         private                 var actionType                                          : int;
  41.         private                 var customOrientationStackIndex         : int;
  42.        
  43.         private                 var emptyMoveTargetTimer                        : float;
  44.        
  45.         private                 var onlyOneEnemyLeft                            : bool;
  46.        
  47.         public                  var isInFinisher                                        : bool;
  48.         private                 var finisherTarget                                      : CGameplayEntity;
  49.  
  50.         private                 var combatStance                                        : EPlayerCombatStance; 
  51.  
  52.         public                  var approachAttack                                      : int;                                 
  53.                                         default approachAttack                          = 1;
  54.         protected               var specialAttackCamera                         : bool;
  55.        
  56.         private                 var specialAttackTimeRatio                      : float;
  57.                
  58.         public saved    var itemsPerLevel                                       : array<name>;  
  59.         public                  var itemsPerLevelGiven                          : array<bool>;  
  60.        
  61.         private                 var     playerTickTimerPhase                    : int;
  62.                 default playerTickTimerPhase = 0;
  63.                
  64.         protected               var evadeHeading                                        : float;
  65.  
  66.         public                  var vehicleCbtMgrAiming                         : bool;        
  67.        
  68.         public                  var specialHeavyChargeDuration          : float;                               
  69.         public                  var specialHeavyStartEngineTime         : EngineTime;                  
  70.         public                  var playedSpecialAttackMissingResourceSound : bool;                    
  71.         public function SetPlayedSpecialAttackMissingResourceSound(b : bool) {playedSpecialAttackMissingResourceSound = b;}
  72.        
  73.         public var counterCollisionGroupNames : array<name>;
  74.        
  75.         public saved    var lastInstantKillTime                         : GameTime;
  76.        
  77.        
  78.         private                 var noSaveLockCombatActionName          : string;               default noSaveLockCombatActionName      = 'combat_action';     
  79.         private                 var noSaveLockCombatAction                      : int; 
  80.         private                 var deathNoSaveLock                                     : int; 
  81.         private                 var noSaveLock                                          : int;
  82.        
  83.        
  84.         protected saved var newGamePlusInitialized                      : bool;
  85.                 default newGamePlusInitialized = false;
  86.        
  87.        
  88.         protected                       var BufferAllSteps                                      : bool;
  89.         protected                       var BufferCombatAction                          : EBufferActionType;
  90.         protected                       var BufferButtonStage                           : EButtonStage; 
  91.        
  92.                 default BufferAllSteps = false; 
  93.                 default customOrientationTarget = OT_None;     
  94.                 default hitReactionEffect = true;       
  95.                 default uninterruptedHitsCount = 0;
  96.                 default uninterruptedHitsCameraStarted = false; 
  97.                 default customOrientationStackIndex = -1;
  98.                        
  99.        
  100.         private var keepRequestingCriticalAnimStart : bool;                            
  101.        
  102.                 default keepRequestingCriticalAnimStart = false;
  103.        
  104.        
  105.         private         var currentCustomAction         : EPlayerExplorationAction;
  106.         public          var substateManager                     : CExplorationStateManager;
  107.         protected       var isOnBoat                            : bool;                                                
  108.         protected       var isInShallowWater            : bool;
  109.         public          var medallion                           : W3MedallionFX;
  110.         protected       var lastMedallionEffect         : float;
  111.         private         var isInRunAnimation            : bool;
  112.         public          var     interiorTracker                 :CPlayerInteriorTracker;
  113.         public          var m_SettlementBlockCanter : int;
  114.        
  115.        
  116.        
  117.         private var fistFightMinigameEnabled    : bool;
  118.         private var isFFMinigameToTheDeath              : bool;
  119.         private var FFMinigameEndsithBS                 : bool;
  120.         public  var fistFightTeleportNode               : CNode;
  121.         public  var isStartingFistFightMinigame : bool;
  122.         public  var GeraltMaxHealth                     : float;
  123.         public  var fistsItems                                  : array< SItemUniqueId >;
  124.        
  125.                 default FFMinigameEndsithBS = false;
  126.                 default fistFightMinigameEnabled = false;
  127.                 default isFFMinigameToTheDeath = false;
  128.        
  129.        
  130.         private var gwintAiDifficulty                   : EGwintDifficultyMode; default gwintAiDifficulty = EGDM_Easy;
  131.         private var gwintAiAggression                   : EGwintAggressionMode; default gwintAiAggression = EGAM_Defensive;
  132.         private var gwintMinigameState                  : EMinigameState;               default gwintMinigameState  = EMS_None;
  133.  
  134.        
  135.         import private  var horseWithInventory          : EntityHandle;                
  136.         private                 var currentlyMountedHorse       : CNewNPC;     
  137.         private                 var horseSummonTimeStamp        : float;
  138.         private saved   var isHorseRacing                       : bool;
  139.         private                 var horseCombatSlowMo           : bool;
  140.         default isHorseRacing = false;
  141.         default horseCombatSlowMo = true;
  142.        
  143.        
  144.         private var HudMessages : array <string>;
  145.         protected var fShowToLowStaminaIndication       : float;
  146.         public var showTooLowAdrenaline : bool;
  147.         private var HAXE3Container : W3Container;
  148.         private var HAXE3bAutoLoot: bool;
  149.         private var bShowHud : bool;
  150.         private var dodgeFeedbackTarget : CActor;
  151.        
  152.                 default HAXE3bAutoLoot = false;
  153.                 default fShowToLowStaminaIndication     = 0.0f; 
  154.                 default bShowHud = true;
  155.                
  156.         saved var displayedQuestsGUID : array< CGUID >;
  157.         saved var rewardsMultiplier : array< SRewardMultiplier >;
  158.         saved var glossaryImageOverride : array< SGlossaryImageOverride >;
  159.        
  160.        
  161.         private                         var prevRawLeftJoyRot                   : float;
  162.         protected                       var explorationInputContext             : name;
  163.         protected                       var combatInputContext                  : name;
  164.         protected                       var combatFistsInputContext             : name;
  165.  
  166.        
  167.         private var isInsideInteraction                 : bool;                                                
  168.         private var isInsideHorseInteraction    : bool;                                                
  169.         public  var horseInteractionSource              : CEntity;
  170.         public  var nearbyLockedContainersNoKey : array<W3LockableEntity>;             
  171.        
  172.        
  173.         private var bMoveTargetChangeAllowed    : bool;         default bMoveTargetChangeAllowed = true;
  174.         private var moveAdj                                     : CMovementAdjustor;
  175.         private var defaultLocomotionController : CR4LocomotionPlayerControllerScript;
  176.        
  177.        
  178.         private var canFollowNpc                                : bool;
  179.         private var actorToFollow                               : CActor;
  180.         public var terrainPitch                                 : float;
  181.         public var steepSlopeNormalPitch                : float;        default steepSlopeNormalPitch = 65.f;
  182.         public var disableSprintTerrainPitch    : float;        default disableSprintTerrainPitch = 54.f;
  183.         private var submergeDepth                       : float;
  184.        
  185.         private var m_useSelectedItemIfSpawned  : bool; default m_useSelectedItemIfSpawned = false;
  186.        
  187.        
  188.         var navQuery : CNavigationReachabilityQueryInterface;
  189.        
  190.        
  191.         public saved var rememberedCustomHead : name;
  192.  
  193.        
  194.         public saved var disableWeatherDisplay : bool;
  195.        
  196.        
  197.         public saved var proudWalk : bool;
  198.         private var etherealCount : int;
  199.         default etherealCount = 0;
  200.        
  201.        
  202.         public saved var injuredWalk : bool;
  203.         public saved var tiedWalk : bool;
  204.         private var insideDiveAttackArea : bool;
  205.         default insideDiveAttackArea = false;
  206.         private var diveAreaNumber : int;
  207.         default diveAreaNumber = -1;
  208.        
  209.        
  210.         private var flyingBossCamera : bool;
  211.         default flyingBossCamera = false;
  212.        
  213.         public function SetFlyingBossCamera( val : bool ) { flyingBossCamera = val; }
  214.         public function GetFlyingBossCamera() : bool { return flyingBossCamera; }
  215.        
  216.        
  217.         public saved var upscaledTooltipState : bool;
  218.         default upscaledTooltipState = false;
  219.        
  220.        
  221.         private var phantomWeaponMgr : CPhantomWeaponManager;
  222.        
  223.        
  224.  
  225.         function EnablePCMode( flag : bool )
  226.         {
  227.                 pcMode = flag;
  228.         }
  229.        
  230.         public function IsPCModeEnabled() : bool
  231.         {
  232.                 return pcMode && theInput.LastUsedPCInput();
  233.         }       
  234.        
  235.         public function ShouldUsePCModeTargeting() : bool
  236.         {
  237.                 return IsPCModeEnabled() && !lastAxisInputIsMovement;
  238.         }              
  239.        
  240.         public function SetDodgeFeedbackTarget( target : CActor )
  241.         {
  242.                 dodgeFeedbackTarget = target;
  243.         }
  244.  
  245.         public function GetDodgeFeedbackTarget() : CActor
  246.         {
  247.                 return dodgeFeedbackTarget;
  248.         }
  249.        
  250.         public function SetSubmergeDepth( depth : float )
  251.         {
  252.                 submergeDepth = depth;
  253.         }
  254.  
  255.         public function GetSubmergeDepth() : float
  256.         {
  257.                 return submergeDepth;
  258.         }       
  259.        
  260.        
  261.         editable var delayBetweenIllusionOneliners : float;
  262.                
  263.                 hint delayBetweenIllusionOneliners = "delay in secs between oneliners about illusionary objects";
  264.                
  265.                 default delayBetweenIllusionOneliners = 5;
  266.        
  267.        
  268.         private                 var battlecry_timeForNext                       : float;
  269.         private                 var battlecry_delayMin                          : float;        default battlecry_delayMin = 15;
  270.         private                 var battlecry_delayMax                          : float;        default battlecry_delayMax = 60;
  271.         private                 var battlecry_lastTry                           : name;
  272.        
  273.        
  274.         private                 var previousWeather                             : name;
  275.         private                 var previousRainStrength                        : float;
  276.        
  277.        
  278.         protected var receivedDamageInCombat    : bool;                
  279.         protected var prevDayNightIsNight               : bool;                
  280.         public  var failedFundamentalsFirstAchievementCondition : bool;        
  281.        
  282.         private var spawnedTime                                 : float;
  283.  
  284.         public  var currentMonsterHuntInvestigationArea : W3MonsterHuntInvestigationArea;              
  285.  
  286.         private var isPerformingPhaseChangeAnimation : bool;   
  287.         default isPerformingPhaseChangeAnimation = false;
  288.        
  289.                 default receivedDamageInCombat = false;
  290.                
  291.        
  292.         public                          var playerMode                                  : W3PlayerMode; 
  293.                
  294.        
  295.         protected saved var selectedItemId                                      : SItemUniqueId;       
  296.         protected saved var blockedRadialSlots                          : array < SRadialSlotDef >;
  297.        
  298.        
  299.         public                          var enemyCollectionDist                 : float;
  300.         public                          var findMoveTargetDistMin               : float;                       
  301.         public                          var findMoveTargetDistMax               : float;                       
  302.         private                         var findMoveTargetScaledFrame   : float;                       
  303.         public                          var interactDist                                : float;                       
  304.         protected                       var bCanFindTarget                              : bool;
  305.         private                         var bIsConfirmingEmptyTarget    : bool;
  306.         private                         var displayTarget                               : CGameplayEntity;     
  307.         private                         var isShootingFriendly                  : bool;
  308.        
  309.                 default findMoveTargetDistMax = 18.f;
  310.                 default findMoveTargetScaledFrame = 0.5f;
  311.                 default interactDist = 3.5f;
  312.        
  313.        
  314.         private var currentSelectedTarget                       : CActor;
  315.         private var selectedTargetToConfirm                     : CActor;
  316.         private var bConfirmTargetTimerIsEnabled        : bool;
  317.                
  318.        
  319.         public saved            var thrownEntityHandle                  : EntityHandle;        
  320.         private                         var isThrowingItemWithAim               : bool;
  321.         private saved           var isThrowingItem                              : bool;                        
  322.         private                         var isThrowHoldPressed                  : bool;
  323.        
  324.        
  325.         private                         var isAimingCrossbow                    : bool;
  326.        
  327.                 default isThrowingItemWithAim = false;
  328.                
  329.        
  330.         public                          var playerAiming                                : PlayerAiming;
  331.                        
  332.        
  333.         public var forceDismember                       : bool;
  334.         public var forceDismemberName           : name;
  335.         public var forceDismemberChance         : int;
  336.         public var forceDismemberExplosion      : bool;
  337.        
  338.        
  339.         private var finisherVictim                      : CActor;
  340.         public var forceFinisher                        : bool;
  341.         public var forceFinisherAnimName        : name;
  342.         public var forceFinisherChance          : int; 
  343.         public var forcedStance                         : bool; 
  344.  
  345.        
  346.         private var m_WeaponFXCollisionGroupNames       : array <name>;
  347.         private var m_CollisionEffect                           : CEntity;
  348.         private var m_LastWeaponTipPos                          : Vector;
  349.         private var m_CollisionFxTemplate                       : CEntityTemplate;
  350.         private var m_RefreshWeaponFXType                       : bool;
  351.         private var m_PlayWoodenFX                                      : bool;
  352.        
  353.        
  354.         private var m_activePoster                                      : W3Poster;
  355.        
  356.         public function SetActivePoster ( poster :  W3Poster )
  357.         {
  358.                 m_activePoster = poster;
  359.         }
  360.        
  361.         public function RemoveActivePoster ()
  362.         {
  363.                 m_activePoster = NULL;
  364.         }
  365.        
  366.         public function GetActivePoster () : W3Poster
  367.         {
  368.                 return m_activePoster;
  369.         }
  370.        
  371.        
  372.        
  373.        
  374.        
  375.         public var horseOnNavMesh : bool;
  376.         default horseOnNavMesh = true;
  377.        
  378.         public function SetHorseNav( val : bool ) { horseOnNavMesh = val; }
  379.        
  380.        
  381.         public var testAdjustRequestedMovementDirection : bool;
  382.                 default testAdjustRequestedMovementDirection = false;
  383.                
  384.        
  385.         default autoState       = 'Exploration';
  386.        
  387.        
  388.        
  389.        
  390.        
  391.        
  392.         import final function GetEnemiesInRange( out enemies : array< CActor > );
  393.         import final function GetVisibleEnemies( out enemies : array< CActor > );
  394.         import final function IsEnemyVisible( enemy : CActor ) : bool;
  395.        
  396.        
  397.         import final function SetupEnemiesCollection(   range, heightTolerance  : float,
  398.                                                                                                         maxEnemies                              : int,
  399.                                                                                                         optional tag                    : name,
  400.                                                                                                         optional flags                  : int );
  401.  
  402.         import final function IsInInterior() : bool;
  403.         import final function IsInSettlement() : bool;
  404.         import final function EnterSettlement( isEntering : bool );
  405.         import final function ActionDirectControl( controller : CR4LocomotionDirectController ) : bool;
  406.         import final function SetPlayerTarget( target : CActor );
  407.         import final function SetPlayerCombatTarget( target : CActor );
  408.         import final function ObtainTicketFromCombatTarget( ticketName : CName, ticketsCount : int );
  409.         import final function FreeTicketAtCombatTarget();
  410.         import final function SetScriptMoveTarget( target : CActor );
  411.         import final function GetRiderData() : CAIStorageRiderData;
  412.         import final function SetIsInCombat( inCombat : bool );
  413.         import final function SaveLastMountedHorse( mountedHorse : CActor );
  414.        
  415.         import final function SetBacklightFromHealth( healthPercentage : float );
  416.         import private final function SetBacklightColor( color : Vector );
  417.        
  418.         import final function GetCombatDataComponent() : CCombatDataComponent;
  419.        
  420.         import final function GetTemplatePathAndAppearance( out templatePath : string, out appearance : name );
  421.        
  422.         import final function HACK_BoatDismountPositionCorrection( slotPos : Vector );
  423.        
  424.         import final function HACK_ForceGetBonePosition( boneIndex : int ) : Vector;
  425.        
  426.        
  427.         public function GetLevel() : int
  428.         {
  429.                 return 0;
  430.         }
  431.        
  432.        
  433.        
  434.        
  435.         var targeting                           : CR4PlayerTargeting;
  436.         var targetingPrecalcs           : SR4PlayerTargetingPrecalcs;
  437.         var targetingIn                         : SR4PlayerTargetingIn;
  438.         var targetingOut                        : SR4PlayerTargetingOut;       
  439.         var useNativeTargeting          : bool;
  440.         default useNativeTargeting      = true;
  441.        
  442.         var visibleActors                       : array< CActor >;
  443.         var visibleActorsTime           : array< float >;
  444.        
  445.        
  446.                
  447.         event OnSpawned( spawnData : SEntitySpawnData )
  448.         {
  449.                 var atts : array<name>;
  450.                 var skill : ESkill;
  451.                 var i : int;
  452.                 var item : SItemUniqueId;
  453.                
  454.                 AddAnimEventCallback('ThrowHoldTest',                   'OnAnimEvent_ThrowHoldTest');
  455.                 AddAnimEventCallback('OnWeaponDrawReady',               'OnAnimEvent_OnWeaponDrawReady');
  456.                 AddAnimEventCallback('OnWeaponHolsterReady',    'OnAnimEvent_OnWeaponHolsterReady');
  457.                 AddAnimEventCallback('AllowTempLookAt',                 'OnAnimEvent_AllowTempLookAt');
  458.                 AddAnimEventCallback('SlideToTarget',                   'OnAnimEvent_SlideToTarget');
  459.                 AddAnimEventCallback('PlayFinisherBlood',               'OnAnimEvent_PlayFinisherBlood');
  460.                 AddAnimEventCallback('SlowMo',                                  'OnAnimEvent_SlowMo');
  461.                 AddAnimEventCallback('BloodTrailForced',                'OnAnimEvent_BloodTrailForced');
  462.                 AddAnimEventCallback('FadeOut',                                 'OnAnimEvent_FadeOut');
  463.                 AddAnimEventCallback('FadeIn',                                  'OnAnimEvent_FadeIn');
  464.                 AddAnimEventCallback('DisallowHitAnim',                 'OnAnimEvent_DisallowHitAnim');
  465.                 AddAnimEventCallback('AllowFall',                               'OnAnimEvent_AllowFall');
  466.                 AddAnimEventCallback('AllowFall2',                              'OnAnimEvent_AllowFall2');     
  467.                 AddAnimEventCallback('DettachGround',                   'OnAnimEvent_DettachGround');   
  468.                 AddAnimEventCallback('KillWithRagdoll',                 'OnAnimEvent_KillWithRagdoll'); 
  469.                 AddAnimEventCallback('pad_vibration',                   'OnAnimEvent_pad_vibration');   
  470.                 AddAnimEventCallback('pad_vibration_light',             'OnAnimEvent_pad_vibration_light');
  471.                 AddAnimEventCallback('RemoveBurning',                   'OnAnimEvent_RemoveBurning');
  472.                 AddAnimEventCallback('RemoveTangled',                   'OnAnimEvent_RemoveTangled');
  473.                 AddAnimEventCallback('MoveNoise',                               'OnAnimEvent_MoveNoise');
  474.                
  475.                 AddItemPerLevelList();
  476.                
  477.                 enemyCollectionDist = findMoveTargetDistMax;
  478.                
  479.                
  480.                 theGame.RemoveTimeScale('horse_melee');
  481.                
  482.                
  483.                 if(!spawnData.restored && !((W3ReplacerCiri)this) )
  484.                 {
  485.                         AddTimer('GiveStartingItems', 0.00001, true, , , true);
  486.                        
  487.                         if(!theGame.IsFinalBuild())
  488.                         {
  489.                                
  490.                                 AddAbility('GeraltSkills_Testing');                            
  491.                                 AddTimer('Debug_GiveTestingItems',0.0001,true);                
  492.                         }
  493.                        
  494.                        
  495.                         FactsAdd("tut_stash_fresh_playthrough");
  496.                 }
  497.                
  498.                 InitTargeting();
  499.                
  500.                
  501.                 if( spawnData.restored )
  502.                 {
  503.                        
  504.                        
  505.                        
  506.                         theGame.GameplayFactsRemove( "in_combat" );
  507.                 }
  508.                
  509.                
  510.                
  511.                 if ( !weaponHolster )
  512.                 {
  513.                         weaponHolster = new WeaponHolster in this;
  514.                 }              
  515.                
  516.                 weaponHolster.Initialize( this, spawnData.restored );
  517.                
  518.                 if ( !interiorTracker )
  519.                 {
  520.                         interiorTracker = new CPlayerInteriorTracker in this;
  521.                 }
  522.                 interiorTracker.Init( spawnData.restored );
  523.                
  524.                
  525.                 super.OnSpawned( spawnData );
  526.  
  527.                
  528.                 medallion = new W3MedallionFX in this;
  529.                
  530.                 playerMode = new W3PlayerMode in this;
  531.                 playerMode.Initialize( this );
  532.                
  533.                
  534.                 playerAiming = new PlayerAiming in this;
  535.                 playerAiming.Initialize( this );
  536.                
  537.                
  538.                 navQuery = new CNavigationReachabilityQueryInterface in this;
  539.                
  540.                
  541.                 EnableFindTarget( true );
  542.                 AddTimer( 'CombatCheck', 0.2f, true );
  543.                
  544.                
  545.                 substateManager = ( CExplorationStateManager ) GetComponentByClassName( 'CExplorationStateManager' );
  546.                
  547.                 findMoveTargetDist = findMoveTargetDistMax;
  548.                
  549.                 SetupEnemiesCollection( enemyCollectionDist, findMoveTargetDist, 10, 'None', FLAG_Attitude_Neutral + FLAG_Attitude_Hostile + FLAG_Attitude_Friendly + FLAG_OnlyAliveActors );
  550.                
  551.                
  552.                 inputHandler.RemoveLocksOnSpawn();
  553.                
  554.                
  555.                 ((CActor) this ).SetInteractionPriority( IP_Prio_0 );
  556.                
  557.                 prevDayNightIsNight = theGame.envMgr.IsNight();
  558.                 CheckDayNightCycle();
  559.                
  560.                
  561.                 EnableVisualDebug( SHOW_AI, true );
  562.                
  563.                
  564.                 FactsRemove("blocked_illusion_oneliner");       
  565.                
  566.                 SetFailedFundamentalsFirstAchievementCondition(false);
  567.                 m_CollisionFxTemplate   = (CEntityTemplate) LoadResource( 'sword_colision_fx' );
  568.                 if( m_WeaponFXCollisionGroupNames.Size() == 0 )
  569.                 {
  570.                         m_WeaponFXCollisionGroupNames.PushBack('Static');
  571.                         m_WeaponFXCollisionGroupNames.PushBack('Foliage');
  572.                         m_WeaponFXCollisionGroupNames.PushBack('Fence');
  573.                         m_WeaponFXCollisionGroupNames.PushBack('BoatSide');
  574.                         m_WeaponFXCollisionGroupNames.PushBack('Door');
  575.                         m_WeaponFXCollisionGroupNames.PushBack('RigidBody');
  576.                         m_WeaponFXCollisionGroupNames.PushBack('Dynamic');
  577.                         m_WeaponFXCollisionGroupNames.PushBack('Destructible');
  578.                 }
  579.                
  580.                 if ( counterCollisionGroupNames.Size() == 0 )
  581.                 {
  582.                         counterCollisionGroupNames.PushBack('Static');
  583.                         counterCollisionGroupNames.PushBack('Foliage');
  584.                         counterCollisionGroupNames.PushBack('Fence');
  585.                         counterCollisionGroupNames.PushBack('Terrain');
  586.                         counterCollisionGroupNames.PushBack('Door');
  587.                         counterCollisionGroupNames.PushBack('RigidBody');
  588.                         counterCollisionGroupNames.PushBack('Dynamic');
  589.                         counterCollisionGroupNames.PushBack('Destructible');
  590.                 }
  591.                
  592.                
  593.                 ResetPadBacklightColor();
  594.                
  595.                 if( spawnData.restored )
  596.                 {
  597.                         if (IsCurrentlyUsingItemL())
  598.                         {
  599.                                 if (inv.HasItemById( currentlyEquipedItemL ))
  600.                                 {
  601.                                         OnUseSelectedItem();
  602.                                 }
  603.                                 else
  604.                                 {
  605.                                         HideUsableItem(true);
  606.                                 }
  607.                         }
  608.                         if ( GetCurrentMeleeWeaponType() == PW_Steel || GetCurrentMeleeWeaponType() == PW_Silver )
  609.                         {
  610.                                 OnEquipMeleeWeapon(GetCurrentMeleeWeaponType(), true, true);
  611.                         }
  612.                        
  613.                         AddTimer( 'UnmountCrossbowTimer', 0.01, true );
  614.                        
  615.                         ClearBlockedSlots();
  616.                 }
  617.                
  618.                 ((CR4PlayerStateSwimming)this.GetState('Swimming')).OnParentSpawned();
  619.                
  620.                
  621.                 SetImmortalityMode( AIM_None, AIC_SyncedAnim );
  622.                
  623.                
  624.                 theGame.GetDefinitionsManager().GetContainedAbilities('DwimeritiumBomb_3', atts);
  625.                 for(i=0; i<atts.Size(); i+=1)
  626.                 {
  627.                         skill = SkillNameToEnum(atts[i]);
  628.                         if(skill != S_SUndefined)
  629.                                 BlockSkill(skill, false);              
  630.                 }
  631.                
  632.                
  633.                 this.GetInventory().GetItemEquippedOnSlot( EES_SteelSword, item );
  634.                 if( this.GetInventory().ItemHasTag( item, 'PhantomWeapon' ) )
  635.                 {
  636.                         this.InitPhantomWeaponMgr();
  637.                 }
  638.  
  639.                
  640.                 if(FactsQuerySum("mq3036_fact_done") > 0)
  641.                         BlockAllActions('mq3036', false);
  642.                
  643.                 spawnedTime = theGame.GetEngineTimeAsSeconds();
  644.                
  645.                 if ( theGame.GetInGameConfigWrapper().GetVarValue('Gameplay', 'EnableUberMovement' ) == "1" )
  646.                         theGame.EnableUberMovement( true );
  647.                 else
  648.                         theGame.EnableUberMovement( false );
  649.                
  650.                
  651.                 if ( !FactsDoesExist("gwent_difficulty") )
  652.                         FactsAdd("gwent_difficulty", 2);
  653.                        
  654.                
  655.                 if(!newGamePlusInitialized && FactsQuerySum("NewGamePlus") > 0)
  656.                 {
  657.                         NewGamePlusInitialize();
  658.                 }
  659.                
  660.                
  661.                 if( lastInstantKillTime > theGame.GetGameTime() )
  662.                 {
  663.                         SetLastInstantKillTime( GameTimeCreate(0) );
  664.                 }
  665.         }
  666.        
  667.         public function NewGamePlusInitialize()
  668.         {
  669.                
  670.                 SetLastInstantKillTime( GameTimeCreate(0) );
  671.         }
  672.        
  673.         public function GetTimeSinceSpawned() : float
  674.         {
  675.                 return theGame.GetEngineTimeAsSeconds() - spawnedTime;
  676.         }
  677.        
  678.         timer function UnmountCrossbowTimer( dt : float, id : int )
  679.         {
  680.                 var itemId : SItemUniqueId;
  681.                
  682.                 itemId = this.inv.GetItemFromSlot( 'l_weapon' );
  683.                 if ( inv.IsIdValid( itemId ) && inv.IsItemCrossbow( itemId ) )
  684.                 {
  685.                         rangedWeapon = (Crossbow)( inv.GetItemEntityUnsafe( itemId ) );
  686.                        
  687.                         if (rangedWeapon)
  688.                         {       
  689.                                 rangedWeapon.Initialize( (CActor)( rangedWeapon.GetParentEntity() ) );
  690.                                 OnRangedForceHolster( true, true );
  691.                                 RemoveTimer( 'UnmountCrossbowTimer' );
  692.                         }
  693.                 }
  694.                 else
  695.                         RemoveTimer( 'UnmountCrossbowTimer' );
  696.         }
  697.        
  698.         event OnDestroyed()
  699.         {
  700.                 playerAiming.RemoveAimingSloMo();
  701.                
  702.                 if(rangedWeapon)
  703.                         rangedWeapon.ClearDeployedEntity(true);
  704.                        
  705.                 ResetPadBacklightColor();
  706.                
  707.                
  708.                 theGame.ReleaseNoSaveLock( noSaveLock );
  709.         }
  710.        
  711.        
  712.        
  713.        
  714.        
  715.         public function GetBlockedSlots () : array < SRadialSlotDef >
  716.         {
  717.                 return blockedRadialSlots;
  718.         }
  719.        
  720.         public function  ClearBlockedSlots()
  721.         {
  722.                 var i                            : int;
  723.                
  724.                
  725.                
  726.                 for ( i = 0; i < blockedRadialSlots.Size(); i+=1 )
  727.                 {
  728.                         if( !IsSwimming() )
  729.                         {
  730.                                 if ( EnableRadialSlot(blockedRadialSlots[i].slotName, 'swimming'))
  731.                                 {
  732.                                         i-=1;
  733.                                         continue;
  734.                                 }
  735.                         }
  736.                         if (!IsUsingVehicle())
  737.                         {
  738.                                 if ( EnableRadialSlot(blockedRadialSlots[i].slotName, 'useVehicle'))
  739.                                 {
  740.                                         i-=1;
  741.                                         continue;
  742.                                 }
  743.                         }
  744.                         if ( !IsCurrentlyUsingItemL() || !IsUsableItemLBlocked() )
  745.                         {
  746.                                 if ( EnableRadialSlot(blockedRadialSlots[i].slotName, 'usableItemL'))
  747.                                 {
  748.                                         i-=1;
  749.                                         continue;
  750.                                 }
  751.                         }
  752.                         if ( !IsThrowingItem() )
  753.                         {
  754.                                 if ( EnableRadialSlot(blockedRadialSlots[i].slotName, 'throwBomb'))
  755.                                 {
  756.                                         i-=1;
  757.                                         continue;
  758.                                 }
  759.                         }
  760.                 }
  761.                
  762.                        
  763.                
  764.         }
  765.        
  766.         public function RestoreBlockedSlots ()
  767.         {
  768.                 var i : int;
  769.                 var slotsToBlock : array<name>;
  770.                
  771.                 for ( i = 0; i < blockedRadialSlots.Size(); i+=1 )
  772.                 {
  773.                         slotsToBlock.PushBack ( blockedRadialSlots[i].slotName );
  774.                 }
  775.                 if ( slotsToBlock.Size() > 0 )
  776.                 {
  777.                         EnableRadialSlots ( false, slotsToBlock );
  778.                 }
  779.         }
  780.         private function DisableRadialSlot ( slotName : name, sourceName : name ) : bool
  781.         {
  782.                 var i : int;
  783.                 var k : int;
  784.                 var slotsToBlock : array<name>;
  785.                
  786.                 var blockedRadialSlotEntry : SRadialSlotDef;
  787.                
  788.                 slotsToBlock.PushBack ( slotName );
  789.                
  790.                 for ( i = 0; i < blockedRadialSlots.Size(); i+=1 )
  791.                 {
  792.                         if ( blockedRadialSlots[i].slotName == slotName )
  793.                         {
  794.                                 if ( sourceName != '' )
  795.                                 {
  796.                                         for ( k = 0; k < blockedRadialSlots[i].disabledBySources.Size(); k += 1 )
  797.                                         {
  798.                                                 if ( blockedRadialSlots[i].disabledBySources[k] == sourceName )
  799.                                                 {
  800.                                                         return false;
  801.                                                 }
  802.                                         }
  803.                                         blockedRadialSlots[i].disabledBySources.PushBack ( sourceName );
  804.                                         return false;
  805.                                 }
  806.                                
  807.                                 return false;
  808.                         }
  809.                 }
  810.                
  811.                 blockedRadialSlotEntry = InitBlockedRadialSlotEntry ( slotName );
  812.                
  813.                 if ( sourceName != '' )
  814.                 {
  815.                         blockedRadialSlotEntry.disabledBySources.PushBack ( sourceName );
  816.                 }
  817.                 blockedRadialSlots.PushBack ( blockedRadialSlotEntry );
  818.                 EnableRadialSlots ( false, slotsToBlock );
  819.                 return true;
  820.         }
  821.        
  822.         public function EnableRadialSlot ( slotName : name, sourceName : name ) : bool
  823.         {
  824.                 var i : int;
  825.                 var k : int;
  826.                
  827.                 var slotsToBlock : array<name>;
  828.                
  829.                 slotsToBlock.PushBack ( slotName );
  830.                
  831.                 for ( i = 0; i < blockedRadialSlots.Size(); i+=1 )
  832.                 {
  833.                         if ( blockedRadialSlots[i].slotName == slotName )
  834.                         {
  835.                        
  836.                                 if ( sourceName != '' )
  837.                                 {
  838.                                         for ( k = 0; k < blockedRadialSlots[i].disabledBySources.Size(); k += 1 )
  839.                                         {
  840.                                                 if ( blockedRadialSlots[i].disabledBySources[k] == sourceName  )
  841.                                                 {                                                      
  842.                                                         blockedRadialSlots[i].disabledBySources.Remove ( blockedRadialSlots[i].disabledBySources[k] );                                                 
  843.                                                 }
  844.                                         }
  845.                                 }
  846.                                 if ( blockedRadialSlots[i].disabledBySources.Size() <= 0  )
  847.                                 {
  848.                                         blockedRadialSlots.Remove( blockedRadialSlots[i] );
  849.                                         EnableRadialSlots ( true, slotsToBlock );
  850.                                         return true;
  851.                                 }
  852.                                 return false;
  853.                         }
  854.                 }
  855.                 return false;
  856.                
  857.         }
  858.        
  859.         private function InitBlockedRadialSlotEntry ( slotName : name ) : SRadialSlotDef
  860.         {
  861.                 var blockedRadialSlotEntry : SRadialSlotDef;
  862.                
  863.                 blockedRadialSlotEntry.slotName = slotName;
  864.                
  865.                 return blockedRadialSlotEntry;
  866.                
  867.         }
  868.        
  869.         public function EnableRadialSlotsWithSource ( enable : bool, slotsToBlock : array < name >, sourceName : name )
  870.         {
  871.                 var i : int;
  872.                
  873.                 for ( i = 0; i < slotsToBlock.Size(); i+=1 )
  874.                 {
  875.                         if ( enable )
  876.                         {
  877.                                 EnableRadialSlot ( slotsToBlock[i], sourceName );
  878.                         }
  879.                         else
  880.                         {
  881.                                 DisableRadialSlot ( slotsToBlock[i], sourceName );
  882.                         }
  883.                 }
  884.                 if ( blockedRadialSlots.Size() <= 0 )
  885.                 {
  886.                         blockedRadialSlots.Clear();
  887.                 }
  888.         }
  889.        
  890.         public function IsRadialSlotBlocked ( slotName : name ) : bool
  891.         {
  892.                 var i : int;
  893.                
  894.                 for ( i = 0; i < blockedRadialSlots.Size(); i+=1 )
  895.                 {
  896.                         if ( blockedRadialSlots[i].slotName == slotName )
  897.                         {
  898.                                 return true;
  899.                         }
  900.                 }
  901.                 return false;
  902.         }
  903.        
  904.        
  905.        
  906.        
  907.        
  908.        
  909.         public function RepairItem (  rapairKitId : SItemUniqueId, usedOnItem : SItemUniqueId );
  910.         public function HasRepairAbleGearEquiped () : bool;
  911.         public function HasRepairAbleWaponEquiped () : bool;
  912.         public function IsItemRepairAble ( item : SItemUniqueId ) : bool;
  913.        
  914.        
  915.        
  916.        
  917.        
  918.        
  919.         public final function ReduceAllOilsAmmo( id : SItemUniqueId )
  920.         {
  921.                 var i : int;
  922.                 var oils : array< W3Effect_Oil >;
  923.                
  924.                 oils = inv.GetOilsAppliedOnItem( id );
  925.                
  926.                 for( i=0; i<oils.Size(); i+=1 )
  927.                 {
  928.                         oils[ i ].ReduceAmmo();
  929.                 }
  930.         }
  931.        
  932.         public final function ResumeOilBuffs( steel : bool )
  933.         {
  934.                 var item : SItemUniqueId;
  935.                 var oils : array< CBaseGameplayEffect >;
  936.                 var buff, recentOil : W3Effect_Oil;
  937.                 var i : int;
  938.                
  939.                 item = GetEquippedSword( steel );
  940.                 oils = GetBuffs( EET_Oil );
  941.                
  942.                 if( oils.Size() > 1 )
  943.                 {
  944.                        
  945.                        
  946.                         recentOil = inv.GetNewestOilAppliedOnItem( item, false );
  947.                 }
  948.                
  949.                 for( i=0; i<oils.Size(); i+=1 )
  950.                 {
  951.                         buff = ( W3Effect_Oil ) oils[ i ];
  952.                        
  953.                         if( recentOil && recentOil == buff )
  954.                         {
  955.                                 continue;
  956.                         }
  957.                        
  958.                         if(buff && buff.GetSwordItemId() == item )
  959.                         {
  960.                                 buff.Resume( '' );
  961.                         }
  962.                 }
  963.                
  964.                 if( recentOil )
  965.                 {
  966.                         recentOil.Resume( '' );
  967.                 }
  968.         }
  969.        
  970.         protected final function PauseOilBuffs( isSteel : bool )
  971.         {
  972.                 var item : SItemUniqueId;
  973.                 var oils : array< CBaseGameplayEffect >;
  974.                 var buff : W3Effect_Oil;
  975.                 var i : int;
  976.                
  977.                 item = GetEquippedSword( isSteel );
  978.                 oils = GetBuffs( EET_Oil );
  979.                
  980.                 for( i=0; i<oils.Size(); i+=1 )
  981.                 {
  982.                         buff = ( W3Effect_Oil ) oils[ i ];
  983.                         if(buff && buff.GetSwordItemId() == item )
  984.                         {
  985.                                 buff.Pause( '', true );
  986.                         }
  987.                 }
  988.         }
  989.        
  990.         public final function ManageAerondightBuff( apply : bool )
  991.         {
  992.                 var aerondight          : W3Effect_Aerondight;
  993.                 var item                        : SItemUniqueId;
  994.                
  995.                 item = inv.GetCurrentlyHeldSword();
  996.                
  997.                 if( inv.ItemHasTag( item, 'Aerondight' ) )
  998.                 {
  999.                         aerondight = (W3Effect_Aerondight)GetBuff( EET_Aerondight );
  1000.                        
  1001.                         if( apply )
  1002.                         {
  1003.                                 if( !aerondight )
  1004.                                 {
  1005.                                         AddEffectDefault( EET_Aerondight, this, "Aerondight" );
  1006.                                 }
  1007.                                 else
  1008.                                 {
  1009.                                         aerondight.Resume( 'ManageAerondightBuff' );
  1010.                                 }
  1011.                         }
  1012.                         else
  1013.                         {
  1014.                                 aerondight.Pause( 'ManageAerondightBuff' );
  1015.                         }
  1016.                 }
  1017.         }
  1018.        
  1019.        
  1020.         public function ApplyOil( oilId : SItemUniqueId, usedOnItem : SItemUniqueId ) : bool
  1021.         {
  1022.                 var oilAbilities : array< name >;
  1023.                 var ammo, ammoBonus : float;
  1024.                 var dm : CDefinitionsManagerAccessor;          
  1025.                 var buffParams : SCustomEffectParams;
  1026.                 var oilParams : W3OilBuffParams;
  1027.                 var oilName : name;
  1028.                 var min, max : SAbilityAttributeValue;
  1029.                 var i : int;
  1030.                 var oils : array< W3Effect_Oil >;
  1031.                 var existingOil : W3Effect_Oil;
  1032.                                
  1033.                 if( !CanApplyOilOnItem( oilId, usedOnItem ) )
  1034.                 {
  1035.                         return false;
  1036.                 }
  1037.                
  1038.                 dm = theGame.GetDefinitionsManager();
  1039.                 inv.GetItemAbilitiesWithTag( oilId, theGame.params.OIL_ABILITY_TAG, oilAbilities );
  1040.                 oilName = inv.GetItemName( oilId );
  1041.                 oils = inv.GetOilsAppliedOnItem( usedOnItem );
  1042.                
  1043.                
  1044.                 for( i=0; i<oils.Size(); i+=1 )
  1045.                 {
  1046.                         if( oils[ i ].GetOilItemName() == oilName )
  1047.                         {
  1048.                                 existingOil = oils[ i ];
  1049.                                 break;
  1050.                         }
  1051.                 }
  1052.                
  1053.                
  1054.                 if( !existingOil )
  1055.                 {
  1056.                         if( !GetWitcherPlayer() || !GetWitcherPlayer().IsSetBonusActive( EISB_Wolf_1 ) )
  1057.                         {
  1058.                                 inv.RemoveAllOilsFromItem( usedOnItem );
  1059.                         }
  1060.                         else
  1061.                         {
  1062.                                 dm.GetAbilityAttributeValue( GetSetBonusAbility( EISB_Wolf_1 ), 'max_oils_count', min, max );
  1063.                                 if( inv.GetActiveOilsAppliedOnItemCount( usedOnItem ) >= CalculateAttributeValue( max ) )
  1064.                                 {
  1065.                                         inv.RemoveOldestOilFromItem( usedOnItem );
  1066.                                 }
  1067.                         }
  1068.                 }
  1069.                
  1070.                
  1071.                 ammo = CalculateAttributeValue(inv.GetItemAttributeValue(oilId, 'ammo'));
  1072.                 if(CanUseSkill(S_Alchemy_s06))
  1073.                 {
  1074.                         ammoBonus = CalculateAttributeValue(GetSkillAttributeValue(S_Alchemy_s06, 'ammo_bonus', false, false));
  1075.                         ammo *= 1 + ammoBonus * GetSkillLevel(S_Alchemy_s06);
  1076.                 }
  1077.                
  1078.                
  1079.                 if( existingOil )
  1080.                 {
  1081.                         existingOil.Reapply( RoundMath( ammo ) );
  1082.                 }
  1083.                 else
  1084.                 {
  1085.                         buffParams.effectType = EET_Oil;
  1086.                         buffParams.creator = this;
  1087.                         oilParams = new W3OilBuffParams in this;
  1088.                         oilParams.iconPath = dm.GetItemIconPath( oilName );
  1089.                         oilParams.localizedName = dm.GetItemLocalisationKeyName( oilName );
  1090.                         oilParams.localizedDescription = dm.GetItemLocalisationKeyName( oilName );
  1091.                         oilParams.sword = usedOnItem;
  1092.                         oilParams.maxCount = RoundMath( ammo );
  1093.                         oilParams.currCount = RoundMath( ammo );
  1094.                         oilParams.oilAbilityName = oilAbilities[ 0 ];
  1095.                         oilParams.oilItemName = oilName;
  1096.                         buffParams.buffSpecificParams = oilParams;
  1097.                        
  1098.                         AddEffectCustom( buffParams );
  1099.                        
  1100.                         delete oilParams;
  1101.                 }
  1102.                
  1103.                 LogOils("Added oil <<" + oilName + ">> to <<" + inv.GetItemName( usedOnItem ) + ">>");
  1104.                
  1105.                
  1106.                 SetFailedFundamentalsFirstAchievementCondition( true );        
  1107.                
  1108.                 theGame.GetGlobalEventsManager().OnScriptedEvent( SEC_OnOilApplied );
  1109.                
  1110.                 if( !inv.IsItemHeld( usedOnItem ) )
  1111.                 {
  1112.                         PauseOilBuffs( inv.IsItemSteelSwordUsableByPlayer( usedOnItem ) );
  1113.                 }
  1114.                
  1115.                 return true;
  1116.         }
  1117.        
  1118.        
  1119.         public final function IsEquippedSwordUpgradedWithOil(steel : bool, optional oilName : name) : bool
  1120.         {
  1121.                 var sword : SItemUniqueId;
  1122.                 var i : int;
  1123.                 var oils : array< W3Effect_Oil >;
  1124.        
  1125.                 sword = GetEquippedSword( steel );                             
  1126.                 if( !inv.IsIdValid( sword ) )
  1127.                 {
  1128.                         return false;
  1129.                 }
  1130.        
  1131.                 if( oilName == '' )
  1132.                 {
  1133.                         return inv.ItemHasAnyActiveOilApplied( sword );
  1134.                 }
  1135.                
  1136.                 oils = inv.GetOilsAppliedOnItem( sword );
  1137.                 for( i=0; i<oils.Size(); i+=1 )
  1138.                 {
  1139.                         if( oils[ i ].GetOilItemName() == oilName )
  1140.                         {
  1141.                                 return true;
  1142.                         }
  1143.                 }
  1144.                
  1145.                 return false;
  1146.         }
  1147.        
  1148.         public function CanApplyOilOnItem(oilId : SItemUniqueId, usedOnItem : SItemUniqueId) : bool
  1149.         {
  1150.                 if(inv.ItemHasTag(oilId, theGame.params.TAG_STEEL_OIL) && inv.IsItemSteelSwordUsableByPlayer(usedOnItem))
  1151.                         return true;
  1152.                        
  1153.                 if(inv.ItemHasTag(oilId, theGame.params.TAG_SILVER_OIL) && inv.IsItemSilverSwordUsableByPlayer(usedOnItem))
  1154.                         return true;
  1155.                        
  1156.                 return false;
  1157.         }
  1158.        
  1159.        
  1160.         public final function DidFailFundamentalsFirstAchievementCondition() : bool
  1161.         {
  1162.                 return failedFundamentalsFirstAchievementCondition;
  1163.         }
  1164.        
  1165.         public final function SetFailedFundamentalsFirstAchievementCondition(b : bool)
  1166.         {
  1167.                 var i : int;
  1168.                 var npc : CNewNPC;
  1169.                
  1170.                 failedFundamentalsFirstAchievementCondition = b;
  1171.                
  1172.                
  1173.                 if(failedFundamentalsFirstAchievementCondition)
  1174.                 {
  1175.                         for(i=0; i<hostileEnemies.Size(); i+=1)
  1176.                         {
  1177.                                 if(hostileEnemies[i].HasTag(theGame.params.MONSTER_HUNT_ACTOR_TAG))
  1178.                                 {
  1179.                                         npc = (CNewNPC)hostileEnemies[i];
  1180.                                         npc.AddTag('failedFundamentalsAchievement');
  1181.                                         npc.AddTimer('FundamentalsAchFailTimer', 30*60, , , , true, true);
  1182.                                 }
  1183.                         }
  1184.                 }
  1185.         }
  1186.        
  1187.         public function IsInCombatFist() : bool
  1188.         {
  1189.                 return this.GetCurrentStateName() == 'CombatFists';
  1190.         }
  1191.        
  1192.         public function IsInitialized() : bool;
  1193.        
  1194.         public function IsCiri() : bool
  1195.         {
  1196.                 return ((W3ReplacerCiri)this);
  1197.         }
  1198.        
  1199.         protected function WouldLikeToMove() : bool
  1200.         {
  1201.                 var speedVec : Vector;
  1202.                 var speed, speedMult : float;
  1203.  
  1204.                
  1205.                 speedVec.X = theInput.GetActionValue( 'GI_AxisLeftX' );
  1206.                 speedVec.Y = theInput.GetActionValue( 'GI_AxisLeftY' );
  1207.                 speed = VecLength2D( speedVec );
  1208.                
  1209.                 return speed > 0.1f;
  1210.         }
  1211.  
  1212.         function HandleMovement( deltaTime : float )
  1213.         {
  1214.                
  1215.                
  1216.                
  1217.                
  1218.                 if (WouldLikeToMove())
  1219.                         SetBehaviorVariable( 'playerWouldLikeToMove', 1.0f);
  1220.                 else
  1221.                         SetBehaviorVariable( 'playerWouldLikeToMove', 0.0f);
  1222.  
  1223.                 super.HandleMovement( deltaTime );
  1224.         }
  1225.        
  1226.         function BattleCryIsReady( ) : bool
  1227.         {
  1228.                 var l_currentTime : float;
  1229.                
  1230.                 l_currentTime = theGame.GetEngineTimeAsSeconds();
  1231.                
  1232.                 if( l_currentTime >= battlecry_timeForNext )
  1233.                 {
  1234.                         return true;
  1235.                 }              
  1236.                 return false;
  1237.         }
  1238.        
  1239.         function PlayBattleCry( _BattleCry : name , _Chance : float, optional _IgnoreDelay, ignoreRepeatCheck : bool )
  1240.         {       
  1241.                 var l_randValue                 : float;
  1242.                 var fact                                : int;
  1243.                
  1244.                 fact = FactsQuerySum("force_stance_normal");
  1245.                
  1246.                 if( IsSwimming()
  1247.                         || theGame.IsDialogOrCutscenePlaying()
  1248.                         || IsInNonGameplayCutscene()
  1249.                         || IsInGameplayScene()
  1250.                         || theGame.IsCurrentlyPlayingNonGameplayScene()
  1251.                         || theGame.IsFading()
  1252.                         || theGame.IsBlackscreen()
  1253.                         || FactsQuerySum("force_stance_normal") > 0 )
  1254.                 {
  1255.                         return;
  1256.                 }
  1257.                
  1258.                
  1259.                 if ( !ignoreRepeatCheck )
  1260.                 {
  1261.                         if( battlecry_lastTry == _BattleCry )
  1262.                                 return;
  1263.                 }
  1264.                
  1265.                 battlecry_lastTry = _BattleCry;
  1266.                
  1267.                 l_randValue = RandF();
  1268.                
  1269.                
  1270.                 if( l_randValue < _Chance && ( _IgnoreDelay || BattleCryIsReady() )  )
  1271.                 {
  1272.                         thePlayer.PlayVoiceset( 90, _BattleCry );                      
  1273.                        
  1274.                         battlecry_timeForNext = theGame.GetEngineTimeAsSeconds() + RandRangeF( battlecry_delayMax, battlecry_delayMin );
  1275.                 }
  1276.                
  1277.         }
  1278.        
  1279.         public final function OnWeatherChanged()
  1280.         {
  1281.                 if( IsInInterior()
  1282.                         || GetCurrentStateName() != 'Exploration'
  1283.                         || theGame.IsDialogOrCutscenePlaying()
  1284.                         || IsInNonGameplayCutscene()
  1285.                         || IsInGameplayScene()
  1286.                         || theGame.IsCurrentlyPlayingNonGameplayScene()
  1287.                         || theGame.IsFading()
  1288.                         || theGame.IsBlackscreen()
  1289.                         || GetTimeSinceSpawned() < 60 )
  1290.                 {
  1291.                         return;
  1292.                 }
  1293.                
  1294.                 AddTimer( 'CommentOnWeather', 1 );
  1295.         }
  1296.        
  1297.         public final timer function CommentOnWeather( _Delta : float, _Id : int )
  1298.         {
  1299.                 var l_weather                           : name;
  1300.                 var l_currentArea                       : EAreaName;
  1301.                 var l_rand                                      : float;
  1302.                
  1303.                 l_weather                       = GetWeatherConditionName();
  1304.                
  1305.                 l_currentArea = theGame.GetCommonMapManager().GetCurrentArea();
  1306.                
  1307.                 switch ( l_weather )
  1308.                 {
  1309.                         case 'WT_Clear':
  1310.                        
  1311.                                 l_rand = RandF();
  1312.                                
  1313.                                 if( l_rand > 0.66f && !AreaIsCold() && theGame.envMgr.IsDay() )
  1314.                                 {
  1315.                                         thePlayer.PlayVoiceset( 90, 'WeatherHot' );
  1316.                                 }
  1317.                                 else if ( l_rand > 0.33f )
  1318.                                 {
  1319.                                         thePlayer.PlayVoiceset( 90, 'WeatherClearingUp' );
  1320.                                 }                              
  1321.                         break;
  1322.                        
  1323.                         case 'WT_Rain_Storm':
  1324.                                 thePlayer.PlayVoiceset( 90, 'WeatherStormy' );
  1325.                         break;
  1326.                        
  1327.                         case 'WT_Light_Clouds':
  1328.                                 if( previousRainStrength < GetRainStrength() )
  1329.                                 {
  1330.                                         thePlayer.PlayVoiceset( 90, 'WeatherLooksLikeRain' );
  1331.                                 }
  1332.                                 else if( AreaIsCold() && previousWeather == 'WT_Clear' )
  1333.                                 {
  1334.                                         thePlayer.PlayVoiceset( 90, 'WeatherCold' );
  1335.                                 }
  1336.                         break;
  1337.                        
  1338.                         case 'WT_Mid_Clouds':
  1339.                                 if( previousRainStrength < GetRainStrength() )
  1340.                                 {
  1341.                                         thePlayer.PlayVoiceset( 90, 'WeatherRaining' );
  1342.                                 }
  1343.                                 else if( AreaIsCold() && previousWeather == 'WT_Clear' )
  1344.                                 {
  1345.                                         thePlayer.PlayVoiceset( 90, 'WeatherCold' );
  1346.                                 }
  1347.                         break;
  1348.                        
  1349.                         case 'WT_Mid_Clouds_Dark':
  1350.                                 if( previousWeather != 'WT_Heavy_Clouds' && previousWeather != 'WT_Heavy_Clouds_Dark' )
  1351.                                         thePlayer.PlayVoiceset( 90, 'WeatherWindy' );
  1352.                         break;
  1353.                        
  1354.                         case 'WT_Heavy_Clouds':
  1355.                                 if( previousWeather != 'WT_Mid_Clouds_Dark' && previousWeather != 'WT_Heavy_Clouds_Dark' )
  1356.                                         thePlayer.PlayVoiceset( 90, 'WeatherWindy' );
  1357.                         break;
  1358.                        
  1359.                         case 'WT_Heavy_Clouds_Dark':
  1360.                                 if( thePlayer.IsOnBoat() )
  1361.                                 {
  1362.                                         thePlayer.PlayVoiceset( 90, 'WeatherSeaWillStorm' );
  1363.                                 }
  1364.                                 else if( previousRainStrength < GetRainStrength() )
  1365.                                 {
  1366.                                         thePlayer.PlayVoiceset( 90, 'WeatherLooksLikeRain' );
  1367.                                 }
  1368.                                 else
  1369.                                 {
  1370.                                         thePlayer.PlayVoiceset( 90, 'WeatherWindy' );
  1371.                                 }
  1372.                         break;
  1373.                        
  1374.                         case 'WT_Snow':
  1375.                                 if( RandF() > 0.5f )
  1376.                                         thePlayer.PlayVoiceset( 90, 'WeatherSnowy' );
  1377.                                 else
  1378.                                         thePlayer.PlayVoiceset( 90, 'WeatherCold' );
  1379.                         break;
  1380.                 }       
  1381.                
  1382.                 previousRainStrength    = GetRainStrength();
  1383.                 previousWeather                 = l_weather;
  1384.         }
  1385.        
  1386.         function CanUpdateMovement() : bool
  1387.         {
  1388.                 if ( rangedWeapon
  1389.                         && GetBehaviorVariable( 'fullBodyAnimWeight' ) >= 1.f
  1390.                         && rangedWeapon.GetCurrentStateName() != 'State_WeaponWait' )
  1391.                         return false;
  1392.                        
  1393.                 return true;
  1394.         }
  1395.        
  1396.         public function SetDefaultLocomotionController()
  1397.         {
  1398.                 if( !defaultLocomotionController )
  1399.                 {
  1400.                         defaultLocomotionController     = new CR4LocomotionPlayerControllerScript in this;
  1401.                 }
  1402.                
  1403.                 ActionDirectControl( defaultLocomotionController );
  1404.         }
  1405.                
  1406.         event OnPlayerTickTimer( deltaTime : float )
  1407.         {
  1408.                 var focusModeController : CFocusModeController;
  1409.                 var cnt : int;
  1410.                
  1411.                 super.OnPlayerTickTimer( deltaTime );
  1412.                        
  1413.                 HandleMovement( deltaTime );
  1414.                
  1415.                 if ( playerAiming.GetCurrentStateName() == 'Aiming' )
  1416.                 {
  1417.                         FindTarget();
  1418.                         FindNonActorTarget( false );
  1419.                         UpdateDisplayTarget();
  1420.                         UpdateLookAtTarget();                  
  1421.                 }
  1422.                 else
  1423.                 {
  1424.                         if( playerTickTimerPhase == 0 )
  1425.                         {
  1426.                                 FindTarget();
  1427.                         }
  1428.                         else if( playerTickTimerPhase == 1 )
  1429.                         {
  1430.                                 FindNonActorTarget( false );
  1431.                         }
  1432.                         else if ( playerTickTimerPhase == 2 )
  1433.                         {
  1434.                                 UpdateDisplayTarget();
  1435.                                 UpdateLookAtTarget();
  1436.                         }
  1437.                 }
  1438.                
  1439.                
  1440.                
  1441.                 playerTickTimerPhase = ( playerTickTimerPhase + 1 ) % 3;
  1442.                
  1443.                 focusModeController = theGame.GetFocusModeController();
  1444.                 focusModeController.UpdateFocusInteractions( deltaTime );
  1445.                
  1446.                
  1447.                 cnt = (int)( effectManager.GetCriticalBuffsCount() > 0 );              
  1448.                 SetBehaviorVariable('hasCriticalBuff', cnt);
  1449.         }       
  1450.        
  1451.         event OnDeath( damageAction : W3DamageAction )
  1452.         {
  1453.                 super.OnDeath( damageAction );
  1454.                
  1455.                 RemoveTimer('RequestCriticalAnimStart');
  1456.                
  1457.                 EnableFindTarget( false );
  1458.                 BlockAllActions('Death', true);
  1459.                
  1460.                 EnableHardLock( false );
  1461.                
  1462.                 theGame.CreateNoSaveLock( 'player_death', deathNoSaveLock, false, false );
  1463.                 theGame.SetDeathSaveLockId( deathNoSaveLock );
  1464.                
  1465.                 ClearHostileEnemiesList();
  1466.                 RemoveReactions();
  1467.                 SetPlayerCombatTarget(NULL);
  1468.                 OnEnableAimingMode( false );   
  1469.                
  1470.                 theGame.EnableFreeCamera( false );
  1471.         }
  1472.        
  1473.        
  1474.         function OnRevived()
  1475.         {
  1476.                 super.OnRevived();
  1477.                 BlockAllActions('Death', false);
  1478.                
  1479.                 theGame.ReleaseNoSaveLock(deathNoSaveLock);
  1480.                
  1481.                 this.RestartReactionsIfNeeded();
  1482.         }
  1483.        
  1484.         public function CanStartTalk() : bool
  1485.         {
  1486.                 if ( beingWarnedBy.Size() > 0 )
  1487.                         return false;
  1488.                
  1489.                 return super.CanStartTalk();
  1490.         }
  1491.        
  1492.        
  1493.        
  1494.        
  1495.        
  1496.        
  1497.         public function AddCounterTimeStamp(time : EngineTime)          {counterTimestamps.PushBack(time);}     
  1498.        
  1499.        
  1500.         public function CheckCounterSpamming(attacker : CActor) : bool
  1501.         {
  1502.                 var counterWindowStartTime : EngineTime;               
  1503.                 var i, spamCounter : int;
  1504.                 var reflexAction : bool;
  1505.                 var testEngineTime : EngineTime;
  1506.                
  1507.                 if(!attacker)
  1508.                         return false;
  1509.                
  1510.                 counterWindowStartTime = ((CNewNPC)attacker).GetCounterWindowStartTime();
  1511.                 spamCounter = 0;
  1512.                 reflexAction = false;
  1513.                
  1514.                
  1515.                 if ( counterWindowStartTime == testEngineTime )
  1516.                 {
  1517.                         return false;
  1518.                 }
  1519.                
  1520.                 for(i = counterTimestamps.Size() - 1; i>=0; i-=1)
  1521.                 {
  1522.                        
  1523.                         if(counterTimestamps[i] >= (counterWindowStartTime - EngineTimeFromFloat(0.4)) )
  1524.                         {
  1525.                                 spamCounter += 1;
  1526.                         }
  1527.                        
  1528.                         else
  1529.                         {
  1530.                                 counterTimestamps.Remove(counterTimestamps[i]);
  1531.                                 continue;
  1532.                         }
  1533.                        
  1534.                        
  1535.                         if(!reflexAction && (counterTimestamps[i] >= counterWindowStartTime))
  1536.                                 reflexAction = true;
  1537.                 }
  1538.                
  1539.                
  1540.                 if(spamCounter == 1 && reflexAction)
  1541.                         return true;
  1542.                        
  1543.                 return false;
  1544.         }
  1545.        
  1546.         protected function PerformCounterCheck(parryInfo: SParryInfo) : bool
  1547.         {
  1548.                 var mult                                                : float;
  1549.                 var parryType                                   : EParryType;
  1550.                 var validCounter, useKnockdown  : bool;
  1551.                 var slideDistance, duration     : float;
  1552.                 var playerToTargetRot                   : EulerAngles;
  1553.                 var zDifference, mutation8TriggerHP : float;
  1554.                 var effectType                                  : EEffectType;
  1555.                 var repelType                                   : EPlayerRepelType = PRT_Random;
  1556.                 var params                                              : SCustomEffectParams;
  1557.                 var thisPos, attackerPos                : Vector;
  1558.                 var fistFightCheck, isMutation8 : bool;
  1559.                 var fistFightCounter                    : bool;
  1560.                 var attackerInventory                   : CInventoryComponent;
  1561.                 var weaponId                                    : SItemUniqueId;
  1562.                 var weaponTags                                  : array<name>;
  1563.                 var playerToAttackerVector              : Vector;
  1564.                 var tracePosStart                               : Vector;
  1565.                 var tracePosEnd                                 : Vector;
  1566.                 var hitPos                                              : Vector;
  1567.                 var hitNormal                                   : Vector;
  1568.                 var min, max                                    : SAbilityAttributeValue;
  1569.                 var npc                                                 : CNewNPC;
  1570.                
  1571.                 if(ShouldProcessTutorial('TutorialDodge') || ShouldProcessTutorial('TutorialCounter'))
  1572.                 {
  1573.                         theGame.RemoveTimeScale( theGame.GetTimescaleSource(ETS_TutorialFight) );
  1574.                         FactsRemove("tut_fight_slomo_ON");
  1575.                 }
  1576.                
  1577.                 if ( !parryInfo.canBeParried || parryInfo.attacker.HasAbility( 'CannotBeCountered' ) )
  1578.                         return false;
  1579.                
  1580.                 fistFightCheck = FistFightCheck( parryInfo.target, parryInfo.attacker, fistFightCounter );
  1581.                
  1582.                 if( ParryCounterCheck() && parryInfo.targetToAttackerAngleAbs < theGame.params.PARRY_HALF_ANGLE && fistFightCheck )
  1583.                 {
  1584.                        
  1585.                         validCounter = CheckCounterSpamming(parryInfo.attacker);
  1586.                        
  1587.                         if(validCounter)
  1588.                         {
  1589.                                 if ( IsInCombatActionFriendly() )
  1590.                                         RaiseEvent('CombatActionFriendlyEnd');
  1591.                                
  1592.                                 SetBehaviorVariable( 'parryType', ChooseParryTypeIndex( parryInfo ) );
  1593.                                 SetBehaviorVariable( 'counter', (float)validCounter);                  
  1594.                                
  1595.                                
  1596.                                
  1597.                                 SetBehaviorVariable( 'parryType', ChooseParryTypeIndex( parryInfo ) );
  1598.                                 SetBehaviorVariable( 'counter', (float)validCounter);                  
  1599.                                 this.SetBehaviorVariable( 'combatActionType', (int)CAT_Parry );
  1600.                                
  1601.                                
  1602.                                 if ( !fistFightCounter )
  1603.                                 {
  1604.                                         attackerInventory = parryInfo.attacker.GetInventory();
  1605.                                         weaponId = attackerInventory.GetItemFromSlot('r_weapon');
  1606.                                         attackerInventory.GetItemTags( weaponId , weaponTags );
  1607.                                        
  1608.                                         if( GetWitcherPlayer().IsMutationActive( EPMT_Mutation8 ) )
  1609.                                         {
  1610.                                                 isMutation8 = true;
  1611.                                                 theGame.GetDefinitionsManager().GetAbilityAttributeValue( 'Mutation8', 'hp_perc_trigger', min, max );
  1612.                                                 mutation8TriggerHP = min.valueMultiplicative;
  1613.                                         }
  1614.                                        
  1615.                                        
  1616.                                        
  1617.                                         npc = (CNewNPC)parryInfo.attacker;
  1618.                                        
  1619.                                        
  1620.                                         if ( parryInfo.attacker.HasAbility('mon_gravehag') )
  1621.                                         {
  1622.                                                 repelType = PRT_Slash;
  1623.                                                 parryInfo.attacker.AddEffectDefault(EET_CounterStrikeHit, this, 'ReflexParryPerformed');
  1624.                                                
  1625.                                         }
  1626.                                         else if ( npc && !npc.IsHuman() && !npc.HasTag( 'dettlaff_vampire' ) )
  1627.                                         {
  1628.                                                 repelType = PRT_SideStepSlash;
  1629.                                         }
  1630.                                         else if ( weaponTags.Contains('spear2h') )
  1631.                                         {
  1632.                                                 repelType = PRT_SideStepSlash;
  1633.                                                 parryInfo.attacker.AddEffectDefault(EET_CounterStrikeHit, this, "ReflexParryPerformed");
  1634.                                                 parryInfo.attacker.SignalGameplayEvent( 'SpearDestruction');
  1635.                                         }
  1636.                                         else if( isMutation8 && npc && !npc.IsImmuneToMutation8Finisher() )
  1637.                                         {
  1638.                                                 repelType = PRT_RepelToFinisher;
  1639.                                                 npc.AddEffectDefault( EET_CounterStrikeHit, this, "ReflexParryPerformed" );
  1640.                                                
  1641.                                                
  1642.                                                 SetTarget( npc, true );
  1643.                                                
  1644.                                                 PerformFinisher( 0.f, 0 );
  1645.                                         }
  1646.                                         else
  1647.                                         {
  1648.                                                
  1649.                                                 thisPos = this.GetWorldPosition();
  1650.                                                 attackerPos = parryInfo.attacker.GetWorldPosition();
  1651.                                                 playerToTargetRot = VecToRotation( thisPos - attackerPos );
  1652.                                                 zDifference = thisPos.Z - attackerPos.Z;
  1653.                                                
  1654.                                                 if ( playerToTargetRot.Pitch < -5.f && zDifference > 0.35 )
  1655.                                                 {
  1656.                                                         repelType = PRT_Kick;
  1657.                                                        
  1658.                                                         ragdollTarget = parryInfo.attacker;
  1659.                                                         AddTimer( 'ApplyCounterRagdollTimer', 0.3 );
  1660.                                                 }
  1661.                                                 else
  1662.                                                 {
  1663.                                                         useKnockdown = false;
  1664.                                                         if ( CanUseSkill(S_Sword_s11) )
  1665.                                                         {
  1666.                                                                 if( GetSkillLevel(S_Sword_s11) > 1 && RandRangeF(3,0) < GetWitcherPlayer().GetStat(BCS_Focus) )
  1667.                                                                 {
  1668.                                                                         duration = CalculateAttributeValue(GetSkillAttributeValue(S_Sword_s11, 'duration', false, true));
  1669.                                                                         useKnockdown = true;
  1670.                                                                 }
  1671.                                                         }
  1672.                                                         else if ( parryInfo.attacker.IsHuman() )
  1673.                                                         {
  1674.                                                                
  1675.                                                                 tracePosStart = parryInfo.attacker.GetWorldPosition();
  1676.                                                                 tracePosStart.Z += 1.f;
  1677.                                                                 playerToAttackerVector = VecNormalize( parryInfo.attacker.GetWorldPosition() -  parryInfo.target.GetWorldPosition() );
  1678.                                                                 tracePosEnd = ( playerToAttackerVector * 0.75f ) + ( playerToAttackerVector * parryInfo.attacker.GetRadius() ) + parryInfo.attacker.GetWorldPosition();
  1679.                                                                 tracePosEnd.Z += 1.f;
  1680.  
  1681.                                                                 if ( !theGame.GetWorld().StaticTrace( tracePosStart, tracePosEnd, hitPos, hitNormal, counterCollisionGroupNames ) )
  1682.                                                                 {
  1683.                                                                         tracePosStart = tracePosEnd;
  1684.                                                                         tracePosEnd -= 3.f;
  1685.                                                                        
  1686.                                                                         if ( !theGame.GetWorld().StaticTrace( tracePosStart, tracePosEnd, hitPos, hitNormal, counterCollisionGroupNames ) )
  1687.                                                                                 useKnockdown = true;
  1688.                                                                 }
  1689.                                                         }
  1690.                                                        
  1691.                                                         if(useKnockdown && (!parryInfo.attacker.IsImmuneToBuff(EET_HeavyKnockdown) || !parryInfo.attacker.IsImmuneToBuff(EET_Knockdown)))
  1692.                                                         {
  1693.                                                                 if(!parryInfo.attacker.IsImmuneToBuff(EET_HeavyKnockdown))
  1694.                                                                 {
  1695.                                                                         params.effectType = EET_HeavyKnockdown;
  1696.                                                                 }
  1697.                                                                 else
  1698.                                                                 {
  1699.                                                                         params.effectType = EET_Knockdown;
  1700.                                                                 }
  1701.                                                                
  1702.                                                                 repelType = PRT_Kick;
  1703.                                                                 params.creator = this;
  1704.                                                                 params.sourceName = "ReflexParryPerformed";
  1705.                                                                 params.duration = duration;
  1706.                                                                
  1707.                                                                 parryInfo.attacker.AddEffectCustom(params);
  1708.                                                         }
  1709.                                                         else
  1710.                                                         {
  1711.                                                                 parryInfo.attacker.AddEffectDefault(EET_CounterStrikeHit, this, "ReflexParryPerformed");
  1712.                                                         }
  1713.                                                 }
  1714.                                         }
  1715.                                        
  1716.                                         parryInfo.attacker.GetInventory().PlayItemEffect(parryInfo.attackerWeaponId, 'counterattack');
  1717.                                        
  1718.                                        
  1719.                                         if ( repelType == PRT_Random )
  1720.                                                 if ( RandRange(100) > 50 )
  1721.                                                         repelType = PRT_Bash;
  1722.                                                 else
  1723.                                                         repelType = PRT_Kick;
  1724.                                        
  1725.                                         this.SetBehaviorVariable( 'repelType', (int)repelType );
  1726.                                         parryInfo.attacker.SetBehaviorVariable( 'repelType', (int)repelType );
  1727.                                 }
  1728.                                 else
  1729.                                 {
  1730.                                         parryInfo.attacker.AddEffectDefault(EET_CounterStrikeHit, this, "ReflexParryPerformed");
  1731.                                 }
  1732.                                
  1733.                                
  1734.                                 SetParryTarget ( parryInfo.attacker );
  1735.                                 SetSlideTarget( parryInfo.attacker );
  1736.                                 if ( !IsActorLockedToTarget() )
  1737.                                         SetMoveTarget( parryInfo.attacker );
  1738.                                
  1739.                                 if ( RaiseForceEvent( 'PerformCounter' ) )
  1740.                                         OnCombatActionStart();
  1741.                                
  1742.                                 SetCustomRotation( 'Counter', VecHeading( parryInfo.attacker.GetWorldPosition() - this.GetWorldPosition() ), 0.0f, 0.2f, false );
  1743.                                 AddTimer( 'UpdateCounterRotation', 0.4f, true );
  1744.                                 AddTimer( 'SetCounterRotation', 0.2f );
  1745.                                
  1746.                                 IncreaseUninterruptedHitsCount();       
  1747.                                
  1748.                                
  1749.                                 if(IsHeavyAttack(parryInfo.attackActionName))
  1750.                                         mult = theGame.params.HEAVY_STRIKE_COST_MULTIPLIER;
  1751.                                        
  1752.                                 DrainStamina(ESAT_Counterattack, 0, 0, '', 0, mult);
  1753.                                
  1754.                                 theGame.GetGamerProfile().IncStat(ES_CounterattackChain);
  1755.                                
  1756.                         }
  1757.                         else
  1758.                         {
  1759.                                 ResetUninterruptedHitsCount();
  1760.                         }
  1761.                         return validCounter;
  1762.                 }                      
  1763.                
  1764.                 return false;
  1765.         }
  1766.        
  1767.         timer function UpdateCounterRotation( dt : float, id : int )
  1768.         {
  1769.                 UpdateCustomRotationHeading( 'Counter', VecHeading( parryTarget.GetWorldPosition() - this.GetWorldPosition() ) );
  1770.         }
  1771.        
  1772.         timer function SetCounterRotation( dt : float, id : int )
  1773.         {
  1774.                 SetCustomRotation( 'Counter', VecHeading( parryTarget.GetWorldPosition() - this.GetWorldPosition() ), 360.f, 0.2f, false );
  1775.         }       
  1776.        
  1777.         private var parryTarget : CActor;
  1778.         private function SetParryTarget( t : CActor )
  1779.         {
  1780.                 parryTarget = t;
  1781.         }
  1782.        
  1783.         private var ragdollTarget : CActor;
  1784.         timer function ApplyCounterRagdollTimer( time : float , id : int)
  1785.         {
  1786.                 var actor : CActor;
  1787.                                
  1788.                 actor = (CActor)ragdollTarget;
  1789.                
  1790.                 if(actor)
  1791.                 {
  1792.                         actor.AddEffectDefault(EET_HeavyKnockdown, this, 'ReflexParryPerformed');
  1793.                 }
  1794.         }
  1795.        
  1796.        
  1797.        
  1798.        
  1799.         public function EnableMode( mode : EPlayerMode, enable : bool )
  1800.         {
  1801.                 playerMode.EnableMode( mode, enable ); 
  1802.         }
  1803.        
  1804.         public function GetPlayerMode() : W3PlayerMode
  1805.         {
  1806.                 return playerMode;
  1807.         }
  1808.        
  1809.         private function GetClosestIncomingAttacker() : CActor
  1810.         {
  1811.                 var i, size                                     : int;
  1812.                 var attackerToPlayerDistances   : array< float >;
  1813.                 var closestAttackerIndex                : int;
  1814.                 var incomingAttackers                   : array<CActor>;
  1815.                        
  1816.                
  1817.                 if(playerMode && playerMode.combatDataComponent)
  1818.                 {
  1819.                         if ( incomingAttackers.Size() <= 0 )
  1820.                                 this.playerMode.combatDataComponent.GetTicketSourceOwners( incomingAttackers, 'TICKET_Charge' );
  1821.                        
  1822.                         if ( incomingAttackers.Size() <= 0 )
  1823.                                 this.playerMode.combatDataComponent.GetTicketSourceOwners( incomingAttackers, 'TICKET_Melee' );
  1824.                                
  1825.                         if ( incomingAttackers.Size() <= 0 )
  1826.                                 this.playerMode.combatDataComponent.GetTicketSourceOwners( incomingAttackers, 'TICKET_Range' );
  1827.                 }
  1828.                        
  1829.                 size = incomingAttackers.Size();
  1830.                 attackerToPlayerDistances.Resize( size );
  1831.  
  1832.                 if ( size > 0 )
  1833.                 {
  1834.                         for ( i = incomingAttackers.Size()-1; i >= 0; i -= 1)
  1835.                         {
  1836.                                 if ( !IsEnemyVisible( incomingAttackers[i] ) )
  1837.                                 {
  1838.                                         incomingAttackers.EraseFast( i );
  1839.                                 }
  1840.                         }                      
  1841.                 }
  1842.        
  1843.                 if ( size > 0 )
  1844.                 {
  1845.                         for ( i = 0; i < size; i += 1 )
  1846.                         {
  1847.                                 attackerToPlayerDistances[i] = VecDistance( incomingAttackers[i].GetWorldPosition(), this.GetWorldPosition() );
  1848.                         }
  1849.                         closestAttackerIndex = ArrayFindMinF( attackerToPlayerDistances );
  1850.                         return incomingAttackers[ closestAttackerIndex ];
  1851.                 }
  1852.                 else
  1853.                 {
  1854.                         return NULL;
  1855.                 }
  1856.         }
  1857.        
  1858.        
  1859.         timer function CombatCheck( time : float , id : int)
  1860.         {
  1861.                 var i : int;
  1862.                 var strLevel, temp : string;
  1863.                 var enemies : array<CActor>;
  1864.                                
  1865.                 UpdateFinishableEnemyList();
  1866.                 FindMoveTarget();
  1867.                 playerMode.UpdateCombatMode();
  1868.                
  1869.                 if( GetPlayerCombatStance() == PCS_Guarded )
  1870.                 {
  1871.                         if( GetTarget().GetHealthPercents() > 0.25f )
  1872.                         {
  1873.                                 PlayBattleCry( 'BattleCryTaunt', 0.2f );
  1874.                         }
  1875.                         else
  1876.                         {
  1877.                                 if( GetTarget().IsHuman() )
  1878.                                         PlayBattleCry( 'BattleCryHumansEnd', 0.3f );
  1879.                                 else
  1880.                                         PlayBattleCry( 'BattleCryMonstersEnd', 0.3f );
  1881.                         }
  1882.                 }
  1883.                
  1884.                 if(IsThreatened() && ShouldProcessTutorial('TutorialMonsterThreatLevels') && FactsQuerySum("q001_nightmare_ended") > 0)
  1885.                 {
  1886.                         GetEnemiesInRange(enemies);
  1887.                         for(i=0; i<enemies.Size(); i+=1)
  1888.                         {
  1889.                                 strLevel = ((CNewNPC)enemies[i]).GetExperienceDifferenceLevelName(temp);
  1890.                                 if(strLevel == "deadlyLevel" || strLevel == "highLevel")
  1891.                                 {
  1892.                                         FactsAdd("tut_high_threat_monster");
  1893.                                         break;
  1894.                                 }
  1895.                         }
  1896.                 }              
  1897.         }
  1898.        
  1899.         public function ReceivedDamageInCombat() : bool
  1900.         {
  1901.                 return receivedDamageInCombat;
  1902.         }
  1903.        
  1904.        
  1905.         event OnCombatStart()
  1906.         {
  1907.                 var weaponType : EPlayerWeapon;
  1908.                
  1909.                 theGame.CreateNoSaveLock( 'combat', noSaveLock );
  1910.                
  1911.                 theGame.GameplayFactsAdd( "in_combat" );
  1912.                
  1913.                
  1914.                 FactsRemove("statistics_cerberus_sign");
  1915.                 FactsRemove("statistics_cerberus_petard");
  1916.                 FactsRemove("statistics_cerberus_bolt");
  1917.                 FactsRemove("statistics_cerberus_fists");
  1918.                 FactsRemove("statistics_cerberus_melee");
  1919.                 FactsRemove("statistics_cerberus_environment");
  1920.                        
  1921.                 BlockAction(EIAB_OpenMeditation, 'InCombat');
  1922.                 BlockAction(EIAB_HighlightObjective, 'InCombat');
  1923.                
  1924.                 if ( !this.IsUsingBoat() && GetTarget().GetAttitude(this) == AIA_Hostile )
  1925.                 {
  1926.                         weaponType = GetMostConvenientMeleeWeapon( GetTarget() );
  1927.                        
  1928.                         if ( weaponType == PW_Steel || weaponType == PW_Silver )
  1929.                                 this.OnEquipMeleeWeapon( weaponType, false );
  1930.                 }
  1931.         }
  1932.                
  1933.        
  1934.         event OnCombatFinished()
  1935.         {
  1936.                 var cnt : int;
  1937.                
  1938.                 reevaluateCurrentWeapon = false;
  1939.                
  1940.                 thePlayer.HardLockToTarget( false );
  1941.        
  1942.                 receivedDamageInCombat = false;
  1943.                
  1944.                 theGame.GameplayFactsRemove( "in_combat" );
  1945.                        
  1946.                
  1947.                 cnt = 0;
  1948.                 if(FactsQuerySum("statistics_cerberus_sign") > 0)
  1949.                         cnt += 1;
  1950.                 if(FactsQuerySum("statistics_cerberus_petard") > 0)
  1951.                         cnt += 1;
  1952.                 if(FactsQuerySum("statistics_cerberus_bolt") > 0)
  1953.                         cnt += 1;
  1954.                 if(FactsQuerySum("statistics_cerberus_fists") > 0)
  1955.                         cnt += 1;
  1956.                 if(FactsQuerySum("statistics_cerberus_melee") > 0)
  1957.                         cnt += 1;
  1958.                 if(FactsQuerySum("statistics_cerberus_environment") > 0)
  1959.                         cnt += 1;
  1960.                
  1961.                
  1962.                 FactsRemove("statistics_cerberus_sign");
  1963.                 FactsRemove("statistics_cerberus_petard");
  1964.                 FactsRemove("statistics_cerberus_bolt");
  1965.                 FactsRemove("statistics_cerberus_fists");
  1966.                 FactsRemove("statistics_cerberus_melee");
  1967.                 FactsRemove("statistics_cerberus_environment");
  1968.                
  1969.                 if(cnt >= 3)
  1970.                         theGame.GetGamerProfile().AddAchievement(EA_Cerberus);
  1971.                
  1972.                
  1973.                 if(theGame.GetTutorialSystem() && FactsQuerySum("TutorialShowSilver") > 0)
  1974.                 {
  1975.                         FactsAdd("tut_show_silver_sword", 1);
  1976.                         FactsRemove("TutorialShowSilver");
  1977.                 }
  1978.                 this.SetBehaviorVariable('isInCombatForOverlay',0.f);
  1979.                 GoToExplorationIfNeeded();
  1980.                 theGame.ReleaseNoSaveLock( noSaveLock );
  1981.                 LogChannel( 'OnCombatFinished', "OnCombatFinished: ReleaseNoSaveLock" );
  1982.                
  1983.                 SetFailedFundamentalsFirstAchievementCondition(false);
  1984.                
  1985.                 UnblockAction(EIAB_OpenMeditation, 'InCombat');
  1986.                 UnblockAction(EIAB_HighlightObjective, 'InCombat');
  1987.         }
  1988.        
  1989.         event OnReactToBeingHit( damageAction : W3DamageAction )
  1990.         {
  1991.                 var weaponType : EPlayerWeapon;
  1992.                
  1993.                 super.OnReactToBeingHit(damageAction);
  1994.                 IncHitCounter();
  1995.                
  1996.                 if ( IsInCombat() && damageAction.attacker && damageAction.attacker == GetTarget() && !( this.IsUsingVehicle() && this.IsOnBoat() ) )
  1997.                 {
  1998.                         weaponType = GetMostConvenientMeleeWeapon( GetTarget() );
  1999.                         if ( weaponType != PW_Fists && weaponType != PW_None && weaponType != this.GetCurrentMeleeWeaponType() )
  2000.                                 OnEquipMeleeWeapon( weaponType, false );
  2001.                 }
  2002.         }
  2003.        
  2004.        
  2005.         public function ReceivedCombatDamage()
  2006.         {
  2007.                 receivedDamageInCombat = true;
  2008.         }
  2009.        
  2010.        
  2011.        
  2012.        
  2013.        
  2014.        
  2015.         timer function UninterruptedHitsResetOnIdle(dt : float, id : int)
  2016.         {
  2017.                 ResetUninterruptedHitsCount();
  2018.         }
  2019.        
  2020.         public function ResetUninterruptedHitsCount()
  2021.         {
  2022.                 uninterruptedHitsCount = 0;
  2023.                 LogUnitAtt("Uninterrupted attacks reset!!!!");
  2024.         }
  2025.        
  2026.         public function IncreaseUninterruptedHitsCount()
  2027.         {
  2028.                 uninterruptedHitsCount += 1;
  2029.                 LogUnitAtt("Uninterrupted attacks count increased to " + uninterruptedHitsCount);
  2030.                
  2031.                 if(uninterruptedHitsCount == 4)
  2032.                         AddTimer('StartUninterruptedBlurr', 1, false);
  2033.                
  2034.                
  2035.                 AddTimer('UninterruptedHitsResetOnIdle', 4.f, false);
  2036.         }
  2037.        
  2038.         timer function StartUninterruptedBlurr(dt : float, id : int)
  2039.         {
  2040.                 var changed : bool;
  2041.                 var movingAgent : CMovingPhysicalAgentComponent;
  2042.                 var target : CActor;
  2043.                
  2044.                
  2045.                 if(uninterruptedHitsCount < 4)
  2046.                 {
  2047.                         LogUnitAtt("Stopping camera effect");
  2048.                         thePlayer.StopEffect(uninterruptedHitsCurrentCameraEffect);
  2049.                         uninterruptedHitsCurrentCameraEffect = '';
  2050.                         uninterruptedHitsCameraStarted = false;                
  2051.                         RemoveTimer('StartUninterruptedBlurr');
  2052.                 }
  2053.                 else   
  2054.                 {
  2055.                         target = GetTarget();
  2056.                        
  2057.                         if( target )
  2058.                         {
  2059.                                 movingAgent = ( (CMovingPhysicalAgentComponent) (target.GetMovingAgentComponent()) );
  2060.                         }
  2061.                                
  2062.                         if(!uninterruptedHitsCameraStarted)
  2063.                         {
  2064.                                 LogUnitAtt("Starting camera effect");
  2065.                                 AddTimer('StartUninterruptedBlurr', 0.001, true);       
  2066.                                 if(movingAgent && movingAgent.GetCapsuleHeight() > 2)
  2067.                                         uninterruptedHitsCurrentCameraEffect = theGame.params.UNINTERRUPTED_HITS_CAMERA_EFFECT_BIG_ENEMY;
  2068.                                 else
  2069.                                         uninterruptedHitsCurrentCameraEffect = theGame.params.UNINTERRUPTED_HITS_CAMERA_EFFECT_REGULAR_ENEMY;
  2070.                                 thePlayer.PlayEffect(uninterruptedHitsCurrentCameraEffect);
  2071.                                 uninterruptedHitsCameraStarted = true;
  2072.                         }
  2073.                         else
  2074.                         {
  2075.                                 changed = false;
  2076.                                 if(movingAgent && movingAgent.GetCapsuleHeight() > 2 && uninterruptedHitsCurrentCameraEffect != theGame.params.UNINTERRUPTED_HITS_CAMERA_EFFECT_BIG_ENEMY)
  2077.                                         changed = true;
  2078.                                 else if(!movingAgent || ( movingAgent.GetCapsuleHeight() <= 2 && uninterruptedHitsCurrentCameraEffect != theGame.params.UNINTERRUPTED_HITS_CAMERA_EFFECT_REGULAR_ENEMY) )
  2079.                                         changed = true;
  2080.                                
  2081.                                
  2082.                                 if(changed)
  2083.                                 {
  2084.                                        
  2085.                                         thePlayer.StopEffect(uninterruptedHitsCurrentCameraEffect);
  2086.                                        
  2087.                                        
  2088.                                         if(uninterruptedHitsCurrentCameraEffect == theGame.params.UNINTERRUPTED_HITS_CAMERA_EFFECT_BIG_ENEMY)
  2089.                                                 uninterruptedHitsCurrentCameraEffect = theGame.params.UNINTERRUPTED_HITS_CAMERA_EFFECT_REGULAR_ENEMY;
  2090.                                         else
  2091.                                                 uninterruptedHitsCurrentCameraEffect = theGame.params.UNINTERRUPTED_HITS_CAMERA_EFFECT_BIG_ENEMY;
  2092.                                                
  2093.                                        
  2094.                                         thePlayer.PlayEffect(uninterruptedHitsCurrentCameraEffect);
  2095.                                 }
  2096.                         }
  2097.                 }
  2098.         }
  2099.        
  2100.        
  2101.        
  2102.        
  2103.        
  2104.         private var playerActionEventListeners                  : array<CGameplayEntity>;
  2105.         private var playerActionEventBlockingListeners  : array<CGameplayEntity>;
  2106.        
  2107.         private function PlayerActionBlockGameplayActions( sourceName : name, lock : bool, isFromPlace : bool )
  2108.         {
  2109.                 if ( lock )
  2110.                 {
  2111.                         thePlayer.BlockAction( EIAB_Signs, sourceName, false, false, isFromPlace );
  2112.                         thePlayer.BlockAction( EIAB_DrawWeapon, sourceName, false, false, isFromPlace );
  2113.                         thePlayer.BlockAction( EIAB_CallHorse, sourceName, false, false, isFromPlace );
  2114.                         thePlayer.BlockAction( EIAB_FastTravel, sourceName, false, false, isFromPlace );
  2115.                         thePlayer.BlockAction( EIAB_Fists, sourceName, false, false, isFromPlace );
  2116.                         thePlayer.BlockAction( EIAB_InteractionAction, sourceName, false, false, isFromPlace );
  2117.                         thePlayer.DisableCombatState();
  2118.                 }
  2119.                 else
  2120.                 {
  2121.                         thePlayer.UnblockAction( EIAB_Signs, sourceName );
  2122.                         thePlayer.UnblockAction( EIAB_DrawWeapon, sourceName );
  2123.                         thePlayer.UnblockAction( EIAB_CallHorse, sourceName );
  2124.                         thePlayer.UnblockAction( EIAB_FastTravel, sourceName );
  2125.                         thePlayer.UnblockAction( EIAB_Fists, sourceName );
  2126.                         thePlayer.UnblockAction( EIAB_InteractionAction, sourceName );
  2127.                 }
  2128.         }
  2129.        
  2130.         public function GetPlayerActionEventListeners() : array<CGameplayEntity>
  2131.         {
  2132.                 return playerActionEventListeners;
  2133.         }
  2134.        
  2135.        
  2136.         public function RegisterForPlayerAction( listener : CGameplayEntity, isLockedByPlace : bool )
  2137.         {
  2138.                 if ( !playerActionEventListeners.Contains( listener ) )
  2139.                 {
  2140.                         playerActionEventListeners.PushBack( listener );
  2141.                 }
  2142.                 if ( listener.ShouldBlockGameplayActionsOnInteraction() )
  2143.                 {
  2144.                         if ( !playerActionEventBlockingListeners.Contains( listener ) )
  2145.                         {
  2146.                                 playerActionEventBlockingListeners.PushBack( listener );
  2147.                         }
  2148.                         if ( playerActionEventBlockingListeners.Size() == 1 )
  2149.                         {
  2150.                                 PlayerActionBlockGameplayActions( 'PlayerAction', true, isLockedByPlace );
  2151.                         }
  2152.                 }
  2153.         }
  2154.        
  2155.        
  2156.         public function UnregisterForPlayerAction( listener : CGameplayEntity, isLockedByPlace : bool )
  2157.         {
  2158.                 playerActionEventListeners.Remove( listener );
  2159.                 playerActionEventBlockingListeners.Remove( listener );
  2160.                 if ( playerActionEventBlockingListeners.Size() == 0 )
  2161.                 {
  2162.                         PlayerActionBlockGameplayActions( 'PlayerAction', false, isLockedByPlace );
  2163.                 }       
  2164.         }
  2165.        
  2166.         event OnPlayerActionStart()
  2167.         {
  2168.                
  2169.                 thePlayer.SetBehaviorVariable( 'inJumpState', 1.f );
  2170.         }
  2171.        
  2172.         event OnPlayerActionEnd()
  2173.         {
  2174.                 var i : int;           
  2175.                 for ( i = playerActionEventListeners.Size() - 1; i >= 0; i-=1 )
  2176.                 {
  2177.                         playerActionEventListeners[i].OnPlayerActionEnd();
  2178.                 }
  2179.                 currentCustomAction = PEA_None;
  2180.                
  2181.                
  2182.                 thePlayer.SetBehaviorVariable( 'inJumpState', 0.f );
  2183.         }
  2184.        
  2185.         event OnPlayerActionStartFinished()
  2186.         {
  2187.                 var i : int;           
  2188.                 for ( i = playerActionEventListeners.Size() - 1; i >= 0; i-=1 )
  2189.                 {
  2190.                         playerActionEventListeners[i].OnPlayerActionStartFinished();
  2191.                 }
  2192.         }
  2193.        
  2194.         function PlayerStartAction( playerAction : EPlayerExplorationAction, optional animName : name ) : bool
  2195.         {
  2196.                 if ( playerAction == PEA_SlotAnimation && !IsNameValid(animName) )
  2197.                 {
  2198.                         return false;
  2199.                 }
  2200.                        
  2201.                 SetBehaviorVariable( 'playerStopAction', 0.0);
  2202.                 SetBehaviorVariable( 'playerExplorationAction', (float)(int)playerAction);
  2203.                
  2204.                
  2205.                
  2206.                 if ( RaiseForceEvent('playerActionStart') )
  2207.                 {
  2208.                         currentCustomAction = playerAction;
  2209.                         if ( playerAction == PEA_SlotAnimation )
  2210.                         {
  2211.                                 playerActionSlotAnimName = animName;
  2212.                                 AddTimer('PlayActionAnimWorkaround',0,false);
  2213.                         }
  2214.                         return true;
  2215.                 }
  2216.                 return false;
  2217.         }
  2218.        
  2219.         private var playerActionSlotAnimName : name;
  2220.        
  2221.         timer function PlayActionAnimWorkaround( dt : float , id : int)
  2222.         {
  2223.                 this.ActionPlaySlotAnimationAsync('PLAYER_ACTION_SLOT',playerActionSlotAnimName, 0.2, 0.2, true);
  2224.         }
  2225.        
  2226.         function PlayerStopAction( playerAction : EPlayerExplorationAction )
  2227.         {
  2228.                 SetBehaviorVariable( 'playerExplorationAction', (float)(int)playerAction);
  2229.                 SetBehaviorVariable( 'playerStopAction', 1.0);
  2230.                 currentCustomAction = PEA_None;
  2231.         }
  2232.        
  2233.         function GetPlayerAction() : EPlayerExplorationAction
  2234.         {
  2235.                 return currentCustomAction;
  2236.         }
  2237.        
  2238.         function MedallionPing()
  2239.         {
  2240.                 var currTime            : float = theGame.GetEngineTimeAsSeconds();
  2241.                
  2242.                 if ( lastMedallionEffect < currTime )
  2243.                 {
  2244.                         lastMedallionEffect = theGame.GetEngineTimeAsSeconds() + medallion.effectDuration;
  2245.                         medallion.TriggerMedallionFX();
  2246.                 }
  2247.         }
  2248.        
  2249.        
  2250.        
  2251.        
  2252.        
  2253.         public function CanPerformPlayerAction(optional alsoOutsideExplorationState : bool) : bool
  2254.         {
  2255.                
  2256.                 if(!alsoOutsideExplorationState && GetCurrentStateName() != 'Exploration')
  2257.                         return false;
  2258.                
  2259.                 if( isInAir || (substateManager && !substateManager.CanInteract()) || IsInCombatAction() || GetCriticalBuffsCount() > 0)
  2260.                         return false;
  2261.                        
  2262.                 return true;
  2263.         }
  2264.        
  2265.        
  2266.         event OnItemGiven(data : SItemChangedData)
  2267.         {
  2268.                 var keyName : name;
  2269.                 var i : int;
  2270.                 var hud : CR4ScriptedHud;
  2271.                 var message : string;
  2272.                 var inve : CInventoryComponent;
  2273.  
  2274.                 if(data.informGui)
  2275.                 {                      
  2276.                         hud = (CR4ScriptedHud)theGame.GetHud();
  2277.                         if(hud)
  2278.                         {
  2279.                                 message = GetLocStringByKeyExt("panel_common_item_received") + ": " + GetLocStringByKeyExt(inv.GetItemLocalizedNameByUniqueID(data.ids[0]));
  2280.                                 if(data.quantity > 1)
  2281.                                         message += " x" + data.quantity;
  2282.                                 hud.HudConsoleMsg(message);
  2283.                         }
  2284.                 }
  2285.                
  2286.                 inve = GetInventory(); 
  2287.                
  2288.                
  2289.                 if(inve.ItemHasTag(data.ids[0], 'key'))
  2290.                 {
  2291.                         keyName = inve.GetItemName(data.ids[0]);
  2292.                         for(i=nearbyLockedContainersNoKey.Size()-1; i>=0; i-=1)
  2293.                         {
  2294.                                 if(nearbyLockedContainersNoKey[i].GetKeyName() == keyName && nearbyLockedContainersNoKey[i].IsEnabled())
  2295.                                 {
  2296.                                         nearbyLockedContainersNoKey[i].UpdateComponents("Unlock");
  2297.                                         nearbyLockedContainersNoKey.Remove(nearbyLockedContainersNoKey[i]);
  2298.                                 }
  2299.                         }
  2300.                 }
  2301.  
  2302.                
  2303.                 if(inve.IsItemAlchemyItem(data.ids[0]))
  2304.                 {
  2305.                         UpgradeAlchemyItem(data.ids[0], CanUseSkill(S_Perk_08));                       
  2306.                 }
  2307.                
  2308.                 if(inve.ItemHasTag(data.ids[0], theGame.params.TAG_OFIR_SET))
  2309.                         CheckOfirSetAchievement();
  2310.         }
  2311.        
  2312.         private final function CheckOfirSetAchievement()
  2313.         {
  2314.                 var hasArmor, hasBoots, hasGloves, hasPants, hasSword, hasSaddle, hasBag, hasBlinders : bool;
  2315.                
  2316.                
  2317.                 CheckOfirItems(GetInventory(), hasArmor, hasBoots, hasGloves, hasPants, hasSword, hasSaddle, hasBag, hasBlinders);
  2318.  
  2319.                
  2320.                 CheckOfirItems(GetWitcherPlayer().GetHorseManager().GetInventoryComponent(), hasArmor, hasBoots, hasGloves, hasPants, hasSword, hasSaddle, hasBag, hasBlinders);
  2321.                
  2322.                 if(hasArmor && hasBoots && hasGloves && hasPants && hasSword && hasSaddle && hasBag && hasBlinders)
  2323.                         theGame.GetGamerProfile().AddAchievement(EA_LatestFashion);
  2324.         }
  2325.        
  2326.         private final function CheckOfirItems(inv : CInventoryComponent, out hasArmor : bool, out hasBoots : bool, out hasGloves : bool, out hasPants : bool, out hasSword : bool, out hasSaddle : bool, out hasBag : bool, out hasBlinders : bool)
  2327.         {
  2328.                 var ofirs : array<SItemUniqueId>;
  2329.                 var i : int;
  2330.                
  2331.                 ofirs = inv.GetItemsByTag(theGame.params.TAG_OFIR_SET);
  2332.                 for(i=0; i<ofirs.Size(); i+=1)
  2333.                 {
  2334.                         if(inv.IsItemChestArmor(ofirs[i]))
  2335.                         {
  2336.                                 hasArmor = true;
  2337.                                 continue;
  2338.                         }
  2339.                         else if(inv.IsItemBoots(ofirs[i]))
  2340.                         {
  2341.                                 hasBoots = true;
  2342.                                 continue;
  2343.                         }
  2344.                         else if(inv.IsItemGloves(ofirs[i]))
  2345.                         {
  2346.                                 hasGloves = true;
  2347.                                 continue;
  2348.                         }
  2349.                         else if(inv.IsItemPants(ofirs[i]))
  2350.                         {
  2351.                                 hasPants = true;
  2352.                                 continue;
  2353.                         }
  2354.                         else if(inv.IsItemSteelSwordUsableByPlayer(ofirs[i]))
  2355.                         {
  2356.                                 hasSword = true;
  2357.                                 continue;
  2358.                         }
  2359.                         else if(inv.IsItemSilverSwordUsableByPlayer(ofirs[i]))
  2360.                         {
  2361.                                 hasSword = true;
  2362.                                 continue;
  2363.                         }
  2364.                         else if(inv.IsItemSaddle(ofirs[i]))
  2365.                         {
  2366.                                 hasSaddle = true;
  2367.                                 continue;
  2368.                         }
  2369.                         else if(inv.IsItemHorseBag(ofirs[i]))
  2370.                         {
  2371.                                 hasBag = true;
  2372.                                 continue;
  2373.                         }
  2374.                         else if(inv.IsItemBlinders(ofirs[i]))
  2375.                         {
  2376.                                 hasBlinders = true;
  2377.                                 continue;
  2378.                         }
  2379.                 }
  2380.         }
  2381.        
  2382.        
  2383.         public function ChangeAlchemyItemsAbilities(upgrade : bool)
  2384.         {
  2385.                 var i : int;
  2386.                 var dm : CDefinitionsManagerAccessor;
  2387.                 var items : array<SItemUniqueId>;
  2388.        
  2389.                 inv.GetAllItems(items);
  2390.                 dm = theGame.GetDefinitionsManager();
  2391.                
  2392.                 for(i=0; i<items.Size(); i+=1)
  2393.                         if(inv.IsItemAlchemyItem(items[i]))
  2394.                                 UpgradeAlchemyItem(items[i], upgrade);
  2395.         }
  2396.        
  2397.        
  2398.         public function UpgradeAlchemyItem(itemID : SItemUniqueId, upgrade : bool)
  2399.         {
  2400.                 var j, currLevel, otherLevel : int;
  2401.                 var dm : CDefinitionsManagerAccessor;
  2402.                 var abs, currAbilities, otherAbilities : array<name>;
  2403.                 var min, max : SAbilityAttributeValue;
  2404.        
  2405.                 if(!inv.IsItemAlchemyItem(itemID))
  2406.                         return;
  2407.                        
  2408.                
  2409.                 currLevel = (int)CalculateAttributeValue(inv.GetItemAttributeValue(itemID, 'level'));
  2410.                
  2411.                
  2412.                 if(currLevel == 3 || currLevel == 2 || currLevel < 2 || currLevel > 3)
  2413.                         return;
  2414.        
  2415.                
  2416.                 currAbilities = inv.GetItemAbilitiesWithAttribute(itemID, 'level', currLevel);
  2417.                                        
  2418.                
  2419.                 inv.GetItemContainedAbilities(itemID, abs);
  2420.                 dm = theGame.GetDefinitionsManager();
  2421.                 for(j=0; j<abs.Size(); j+=1)
  2422.                 {
  2423.                         dm.GetAbilityAttributeValue(abs[j], 'level', min, max);
  2424.                         otherLevel = (int)CalculateAttributeValue(GetAttributeRandomizedValue(min, max));
  2425.                         if( (otherLevel == 2 || otherLevel == 3) && otherLevel != currLevel)
  2426.                                 otherAbilities.PushBack(abs[j]);
  2427.                 }
  2428.                
  2429.                
  2430.                 if(otherAbilities.Size() == 0)
  2431.                 {
  2432.                         LogAssert(false, "CR4Player.UpgradeAlchemyItem: cannot find ability to swap to from <<" + currAbilities[0] + ">> on item <<" + inv.GetItemName(itemID) + ">> !!!");
  2433.                 }
  2434.                 else
  2435.                 {
  2436.                         for(j=0; j<currAbilities.Size(); j+=1)
  2437.                                 inv.RemoveItemBaseAbility(itemID, currAbilities[j]);
  2438.                                
  2439.                         for(j=0; j<otherAbilities.Size(); j+=1)
  2440.                                 inv.AddItemBaseAbility(itemID, otherAbilities[j]);
  2441.                 }
  2442.         }
  2443.        
  2444.        
  2445.        
  2446.        
  2447.  
  2448.         public function MovAdjRotateToTarget( ticket : SMovementAdjustmentRequestTicket )
  2449.         {
  2450.                 var movementAdjustor : CMovementAdjustor = GetMovingAgentComponent().GetMovementAdjustor();
  2451.                 var localOrientationTarget : EOrientationTarget = GetOrientationTarget();
  2452.  
  2453.                 if ( localOrientationTarget == OT_CustomHeading )
  2454.                 {
  2455.                         movementAdjustor.RotateTo( ticket, GetOrientationTargetCustomHeading() );                                      
  2456.                 }
  2457.                 else if ( localOrientationTarget == OT_Actor )
  2458.                 {
  2459.                          if ( slideTarget )
  2460.                                 movementAdjustor.RotateTowards( ticket, slideTarget );
  2461.                         else if ( lAxisReleasedAfterCounter )
  2462.                                 movementAdjustor.RotateTo( ticket, GetHeading() );
  2463.                         else
  2464.                                 movementAdjustor.RotateTo( ticket, GetCombatActionHeading() );
  2465.                 }
  2466.                 else if ( localOrientationTarget == OT_Player )
  2467.                 {
  2468.                         if ( bLAxisReleased )
  2469.                                 movementAdjustor.RotateTo( ticket, GetHeading() );
  2470.                         else
  2471.                                 movementAdjustor.RotateTo( ticket, rawPlayerHeading );
  2472.                 }
  2473.                 else if ( localOrientationTarget == OT_CameraOffset )
  2474.                 {
  2475.                        
  2476.                         movementAdjustor.RotateTo( ticket, VecHeading( theCamera.GetCameraDirection() ) );
  2477.                 }              
  2478.                 else
  2479.                 {
  2480.                        
  2481.                         movementAdjustor.RotateTo( ticket, rawCameraHeading );
  2482.                 }
  2483.                
  2484.         }
  2485.  
  2486.        
  2487.        
  2488.        
  2489.        
  2490.         public function UpdateLookAtTarget()
  2491.         {
  2492.                 var localOrientationTarget      : EOrientationTarget;
  2493.                 var playerRot                   : EulerAngles;
  2494.                 var lookAtActive                : Float;
  2495.                 var lookAtTarget                : Vector;
  2496.                 var headBoneIdx                 : int;
  2497.                 var tempComponent               : CDrawableComponent;
  2498.                 var entityHeight                : float;
  2499.                 var useTorsoBone                : bool;
  2500.                
  2501.                 var angles                              : EulerAngles;
  2502.                 var dir                                 : Vector;
  2503.                 var camZ                                : float;
  2504.                
  2505.                 var target                              : CActor;
  2506.                
  2507.                 lookAtActive = 0.0f;
  2508.        
  2509.                 localOrientationTarget = GetOrientationTarget();
  2510.                
  2511.                 if ( localOrientationTarget == OT_Player || localOrientationTarget == OT_CustomHeading )
  2512.                 {
  2513.                                        
  2514.                        
  2515.                        
  2516.                        
  2517.                         if ( localOrientationTarget == OT_Player  )
  2518.                                 angles = VecToRotation( GetHeadingVector() );
  2519.                         else if ( customOrientationInfoStack.Size() > 0 )
  2520.                                 angles = VecToRotation( VecFromHeading( customOrientationInfoStack[ customOrientationInfoStack.Size() - 1 ].customHeading ) );
  2521.                         else
  2522.                                 angles = VecToRotation( GetHeadingVector() );
  2523.                        
  2524.                        
  2525.                         dir = RotForward( angles );
  2526.                         lookAtTarget = dir * 30.f + this.GetWorldPosition();
  2527.                         lookAtTarget.Z += 1.6f;
  2528.                         lookAtActive = 1.0f;           
  2529.                 }
  2530.                 else if ( localOrientationTarget == OT_Camera )
  2531.                 {
  2532.                         headBoneIdx = GetHeadBoneIndex();
  2533.                         if ( headBoneIdx >= 0 )
  2534.                         {
  2535.                                 lookAtTarget = MatrixGetTranslation( GetBoneWorldMatrixByIndex( headBoneIdx ) );
  2536.                         }
  2537.                         else
  2538.                         {
  2539.                                 lookAtTarget = GetWorldPosition();
  2540.                                 lookAtTarget.Z += 1.6f;
  2541.                         }
  2542.                         lookAtTarget += theCamera.GetCameraDirection() * 100.f;
  2543.                         lookAtActive = 1.0f;
  2544.                 }
  2545.                 else if ( localOrientationTarget == OT_CameraOffset )
  2546.                 {
  2547.                        
  2548.                                        
  2549.                         dir = theCamera.GetCameraDirection();
  2550.                         angles = VecToRotation( dir );
  2551.                         angles.Pitch = -angles.Pitch + oTCameraPitchOffset;
  2552.                         angles.Yaw -= oTCameraOffset;
  2553.                         dir = RotForward( angles );
  2554.        
  2555.                         lookAtTarget = dir * 30.f + this.GetWorldPosition();
  2556.                         lookAtTarget.Z += 1.6f;
  2557.                         lookAtActive = 1.0f;
  2558.                 }              
  2559.                 else if ( localOrientationTarget == OT_Actor )
  2560.                 {
  2561.                         if ( IsInCombatAction() )
  2562.                         {
  2563.                                 if ( ( ( ( W3PlayerWitcher )this ).GetCurrentlyCastSign() != ST_None && GetBehaviorVariable( 'combatActionType' ) == (int)CAT_CastSign )
  2564.                                         || GetBehaviorVariable( 'combatActionType' ) == (int)CAT_ItemThrow )
  2565.                                        
  2566.                                 useTorsoBone = true;
  2567.                         }
  2568.                
  2569.                         if ( rangedWeapon && rangedWeapon.GetCurrentStateName() != 'State_WeaponWait' )
  2570.                                 useTorsoBone = true;
  2571.                
  2572.                         if ( tempLookAtTarget && (CActor)(tempLookAtTarget) )
  2573.                         {
  2574.                                 lookAtTarget = ProcessLookAtTargetPosition( tempLookAtTarget, useTorsoBone );
  2575.                                 lookAtActive = 1.0f;
  2576.                         }
  2577.                        
  2578.                         if ( GetDisplayTarget() && IsDisplayTargetTargetable() )
  2579.                         {
  2580.                                 lookAtTarget = ProcessLookAtTargetPosition( GetDisplayTarget(), useTorsoBone );
  2581.                                 lookAtActive = 1.0f;
  2582.                         }
  2583.                         else
  2584.                         {
  2585.                                
  2586.                                
  2587.                                 if ( slideTarget )
  2588.                                 {
  2589.                                         lookAtTarget = ProcessLookAtTargetPosition( slideTarget, useTorsoBone );
  2590.                                 }
  2591.                                 else
  2592.                                 {
  2593.                                         target = GetTarget();
  2594.                                         if ( target )
  2595.                                         {
  2596.                                                 lookAtTarget = ProcessLookAtTargetPosition( target, useTorsoBone );
  2597.                                         }
  2598.                                 }
  2599.                                        
  2600.                                 lookAtActive = 1.0f;   
  2601.                         }
  2602.                        
  2603.                         if ( !slideTarget && !IsUsingVehicle() )
  2604.                         {
  2605.                                
  2606.                                 playerRot = GetWorldRotation();
  2607.                                 lookAtTarget = GetWorldPosition() + VecFromHeading( playerRot.Yaw ) * 100.0f;
  2608.                                 lookAtActive = 0.0f;
  2609.                         }
  2610.                        
  2611.                         if ( useTorsoBone )
  2612.                                 lookAtTarget.Z += 0.2f; 
  2613.                 }
  2614.                
  2615.                
  2616.                
  2617.                
  2618.                 GetVisualDebug().AddSphere('lookAtTarget', 1.f, lookAtTarget, true, Color(255,0,0), 3.0f );
  2619.                 SetLookAtPosition( lookAtTarget );
  2620.                 UpdateLookAtVariables( lookAtActive, lookAtTarget );
  2621.         }
  2622.  
  2623.         private function ProcessLookAtTargetPosition( ent : CGameplayEntity, useTorsoBone : bool ) : Vector
  2624.         {
  2625.                 var boneIdx             : int;
  2626.                 var actor                       : CActor;
  2627.                 var lookAtTarget        : Vector;
  2628.                 var tempComponent       : CDrawableComponent;
  2629.                 var box                         : Box;
  2630.                 var entityHeight        : float;
  2631.                 var entityPos           : Vector;
  2632.                 var predictedPos        : Vector;
  2633.                 var z                           : float;
  2634.                 var entMat                      : Matrix;
  2635.        
  2636.                 actor = (CActor)(ent);
  2637.                 entityPos = ent.GetWorldPosition();
  2638.                 lookAtTarget = entityPos;
  2639.                
  2640.                 if ( actor )
  2641.                 {
  2642.                         if ( useTorsoBone )
  2643.                                 boneIdx = actor.GetTorsoBoneIndex();
  2644.                         else                           
  2645.                                 boneIdx = actor.GetHeadBoneIndex();
  2646.                 }
  2647.                 else
  2648.                         boneIdx = -1;
  2649.        
  2650.                 if ( !( ent.aimVector.X == 0 && ent.aimVector.Y == 0 && ent.aimVector.Z == 0 ) )
  2651.                 {
  2652.                         entMat = ent.GetLocalToWorld();
  2653.                         lookAtTarget = VecTransform( entMat, ent.aimVector );
  2654.                 }       
  2655.                 else if ( boneIdx >= 0 )
  2656.                 {
  2657.                         lookAtTarget = MatrixGetTranslation( ent.GetBoneWorldMatrixByIndex( boneIdx ) );       
  2658.                 }       
  2659.                 else
  2660.                 {
  2661.                         if ( actor )
  2662.                                 lookAtTarget.Z += ( ((CMovingPhysicalAgentComponent)actor.GetMovingAgentComponent()).GetCapsuleHeight() * 0.5 );
  2663.                         else
  2664.                         {
  2665.                                 tempComponent = (CDrawableComponent)( ent.GetComponentByClassName('CDrawableComponent') );
  2666.                                 if ( tempComponent.GetObjectBoundingVolume( box ) )
  2667.                                 {
  2668.                                         entityHeight = box.Max.Z - box.Min.Z;
  2669.                                         lookAtTarget = lookAtTarget + Vector(0,0,entityHeight/2);
  2670.                                 }              
  2671.                         }
  2672.                 }
  2673.                 z = ((CMovingPhysicalAgentComponent)actor.GetMovingAgentComponent()).GetCapsuleHeight();
  2674.                 if ( actor )
  2675.                 {
  2676.                         if ( PredictLookAtTargetPosition( actor, lookAtTarget.Z - entityPos.Z, predictedPos ) )
  2677.                                 lookAtTarget = predictedPos;
  2678.                 }
  2679.                        
  2680.                 return lookAtTarget;
  2681.         }
  2682.        
  2683.        
  2684.         private function PredictLookAtTargetPosition( targetActor : CActor, zOffSet : float, out predictedPos : Vector ) : bool
  2685.         {
  2686.                 var virtualPos          : Vector;
  2687.                 var i                           : int;
  2688.                 var dist                        : float;
  2689.                 var deltaTime           : float;
  2690.                 var projSpeed           : float;
  2691.                 var projSpeedInt        : Vector;
  2692.                 var projAngle           : float;       
  2693.                
  2694.                 var e3Hack                              : bool;
  2695.                 var currentTimeInCurve : float;
  2696.                 e3Hack = false;        
  2697.                
  2698.                 if ( rangedWeapon
  2699.                         && rangedWeapon.GetDeployedEntity()
  2700.                         && ( rangedWeapon.GetCurrentStateName() == 'State_WeaponAim' || rangedWeapon.GetCurrentStateName() == 'State_WeaponShoot' ) )
  2701.                 {       
  2702.                         projSpeed = rangedWeapon.GetDeployedEntity().projSpeed;
  2703.  
  2704.                         virtualPos = targetActor.GetWorldPosition();
  2705.                        
  2706.                         if ( e3Hack && targetActor.HasTag( 'e3_griffin' ) )
  2707.                         {
  2708.                                 for ( i = 0; i < 10; i += 1 )
  2709.                                 {
  2710.                                         dist = VecDistance( rangedWeapon.GetDeployedEntity().GetWorldPosition(), virtualPos );
  2711.                                         deltaTime = dist/projSpeed;
  2712.                                         virtualPos = targetActor.PredictWorldPosition( deltaTime );
  2713.                                 }
  2714.                         }
  2715.                         else
  2716.                                 return false;
  2717.  
  2718.                         virtualPos.Z += zOffSet;
  2719.                         predictedPos = virtualPos;
  2720.                         GetVisualDebug().AddSphere('CrossbowPredictedPos', 1.0f, virtualPos , true, Color(255,50,50), 5.0f );
  2721.                         return true;
  2722.                 }
  2723.                 return false;
  2724.         }
  2725.        
  2726.         public function SetLookAtPosition( vec : Vector )
  2727.         {
  2728.                 lookAtPosition = vec;
  2729.         }
  2730.  
  2731.         public function GetLookAtPosition() : Vector
  2732.         {
  2733.                 return lookAtPosition;
  2734.         }
  2735.        
  2736.        
  2737.        
  2738.        
  2739.        
  2740.         event OnBlockingSceneEnded( optional output : CStorySceneOutput)
  2741.         {
  2742.                
  2743.                 SetImmortalityMode( AIM_None, AIC_SyncedAnim );
  2744.                 super.OnBlockingSceneEnded(output);
  2745.         }
  2746.        
  2747.        
  2748.        
  2749.        
  2750.        
  2751.         function GetCurrentMeleeWeaponName() : name
  2752.         {
  2753.                 return weaponHolster.GetCurrentMeleeWeaponName();
  2754.         }
  2755.        
  2756.         public function GetCurrentMeleeWeaponType() : EPlayerWeapon
  2757.         {
  2758.                 return weaponHolster.GetCurrentMeleeWeapon();
  2759.         }
  2760.        
  2761.         public function OnMeleeForceHolster(ignoreActionLock : bool)
  2762.         {
  2763.                 weaponHolster.HolsterWeapon(ignoreActionLock, true);
  2764.         }
  2765.        
  2766.         event OnForcedHolsterWeapon()
  2767.         {
  2768.                 weaponHolster.OnForcedHolsterWeapon();
  2769.         }
  2770.        
  2771.         event OnEquippedItem( category : name, slotName : name )
  2772.         {
  2773.                 var weaponType : EPlayerWeapon;
  2774.                
  2775.                 if ( slotName == 'r_weapon' )
  2776.                 {
  2777.                         switch ( category )
  2778.                         {
  2779.                                 case 'None' :
  2780.                                         weaponType = PW_None;
  2781.                                         break;
  2782.                                 case 'fist' :
  2783.                                         weaponType = PW_Fists;
  2784.                                         break;
  2785.                                 case 'steelsword' :
  2786.                                         weaponType = PW_Steel;
  2787.                                         break;
  2788.                                 case 'silversword' :
  2789.                                         weaponType = PW_Silver;
  2790.                                         break;
  2791.                                 default :
  2792.                                         return true;
  2793.                         }
  2794.                        
  2795.                         weaponHolster.OnEquippedMeleeWeapon( weaponType );
  2796.                 }
  2797.         }
  2798.        
  2799.         private var isHoldingDeadlySword : bool;
  2800.         public function ProcessIsHoldingDeadlySword()
  2801.         {
  2802.                 isHoldingDeadlySword = IsDeadlySwordHeld();
  2803.         }
  2804.        
  2805.         public function IsHoldingDeadlySword() : bool
  2806.         {
  2807.                 return isHoldingDeadlySword;
  2808.         }
  2809.        
  2810.         event OnHolsteredItem( category :  name, slotName : name )
  2811.         {
  2812.                 var weaponType : EPlayerWeapon;
  2813.                
  2814.                
  2815.                 if ( slotName == 'r_weapon' && (category == 'steelsword' || category == 'silversword') )
  2816.                 {
  2817.                         if( category == 'silversword' )
  2818.                         {
  2819.                                 ManageAerondightBuff( false );
  2820.                         }
  2821.                        
  2822.                         GetBuff( EET_LynxSetBonus ).Pause( 'drawing weapon' );
  2823.                        
  2824.                         PauseOilBuffs( category == 'steelsword' );
  2825.                 }
  2826.                
  2827.                 if ( slotName == 'r_weapon' )
  2828.                 {
  2829.                         weaponType = weaponHolster.GetCurrentMeleeWeapon();
  2830.                         switch ( category )
  2831.                         {
  2832.                                 case 'fist' :
  2833.                                         if ( weaponType == PW_Fists )
  2834.                                                 weaponHolster.OnEquippedMeleeWeapon( PW_None );
  2835.                                         return true;
  2836.                                 case 'steelsword' :
  2837.                                         if ( weaponType == PW_Steel )
  2838.                                                 weaponHolster.OnEquippedMeleeWeapon( PW_None );
  2839.                                         return true;
  2840.                                 case 'silversword' :
  2841.                                         if ( weaponType == PW_Silver )
  2842.                                                 weaponHolster.OnEquippedMeleeWeapon( PW_None );
  2843.                                         return true;
  2844.                                 default :
  2845.                                         return true;
  2846.                         }
  2847.                 }
  2848.         }
  2849.        
  2850.         event OnEquipMeleeWeapon( weaponType : EPlayerWeapon, ignoreActionLock : bool, optional sheatheIfAlreadyEquipped : bool )
  2851.         {       
  2852.                 RemoveTimer( 'DelayedSheathSword' );
  2853.                                
  2854.                 weaponHolster.OnEquipMeleeWeapon( weaponType, ignoreActionLock, sheatheIfAlreadyEquipped );
  2855.                
  2856.                
  2857.                
  2858.                 m_RefreshWeaponFXType = true;
  2859.         }
  2860.        
  2861.         event OnHolsterLeftHandItem()
  2862.         {
  2863.                 weaponHolster.OnHolsterLeftHandItem();
  2864.         }
  2865.        
  2866.         timer function DelayedTryToReequipWeapon( dt: float, id : int )
  2867.         {
  2868.                 var weaponType : EPlayerWeapon;
  2869.                
  2870.                 if( IsInCombat() && GetTarget() )
  2871.                 {
  2872.                         weaponType = GetMostConvenientMeleeWeapon( GetTarget() );
  2873.                        
  2874.                         if ( weaponType == PW_Steel || weaponType == PW_Silver )
  2875.                                 weaponHolster.OnEquipMeleeWeapon( weaponType, false );
  2876.                 }       
  2877.         }
  2878.        
  2879.         timer function DelayedSheathSword( dt: float, id : int )
  2880.         {
  2881.                 if ( !IsCombatMusicEnabled() )
  2882.                 {
  2883.                         if ( IsInCombatAction() || !IsActionAllowed( EIAB_DrawWeapon ) )
  2884.                         {
  2885.                                 LogChannel( 'OnCombatFinished', "DelayedSheathSword: Sheath pushed to buffer" );
  2886.                                 PushCombatActionOnBuffer(EBAT_Sheathe_Sword,BS_Pressed);
  2887.                         }
  2888.                         else
  2889.                         {
  2890.                                 LogChannel( 'OnCombatFinished', "DelayedSheathSword: Sheath successful" );
  2891.                                 OnEquipMeleeWeapon( PW_None, false );
  2892.                         }
  2893.                 }       
  2894.         }
  2895.        
  2896.         protected function ShouldAutoSheathSwordInstantly() : bool
  2897.         {
  2898.                 var enemies : array<CActor>;
  2899.                 var i : int;
  2900.                
  2901.                 GetEnemiesInRange( enemies );
  2902.                
  2903.                 for ( i = 0; i < enemies.Size(); i += 1 )
  2904.                 {
  2905.                         if ( IsThreat( enemies[i] ) &&
  2906.                                 VecDistance( enemies[i].GetWorldPosition(), this.GetWorldPosition() ) <= findMoveTargetDist )
  2907.                         {
  2908.                                 return false;
  2909.                         }
  2910.                 }
  2911.                
  2912.                 return true;
  2913.         }
  2914.        
  2915.         public function PrepareToAttack( optional target : CActor, optional action : EBufferActionType )
  2916.         {
  2917.                 var  weaponType                 : EPlayerWeapon;
  2918.                
  2919.                 if( IsInAir() || !GetBIsCombatActionAllowed() )
  2920.                 {
  2921.                         return ;
  2922.                 }
  2923.                
  2924.                 if( !target )
  2925.                 {
  2926.                         target  = (CActor)displayTarget;
  2927.                 }
  2928.                 if( !target && IsCombatMusicEnabled() )
  2929.                 {
  2930.                         target  = moveTarget;
  2931.                 }
  2932.                 if( !target )
  2933.                 {
  2934.                         if ( this.GetCurrentStateName() == 'Exploration' )
  2935.                         {
  2936.                                 SetCombatActionHeading( ProcessCombatActionHeading( action ) );
  2937.                                 thePlayer.CanAttackWhenNotInCombat( action, false, target );
  2938.                         }
  2939.                 }
  2940.                
  2941.                 weaponHolster.TryToPrepareMeleeWeaponToAttack();
  2942.                
  2943.                
  2944.                 {
  2945.                         weaponType = GetCurrentMeleeWeaponType();
  2946.                        
  2947.                         if ( weaponType == PW_None )
  2948.                         {
  2949.                                
  2950.                                 weaponType = GetMostConvenientMeleeWeapon( target );
  2951.                         }
  2952.                        
  2953.                        
  2954.                         if( !OnStateCanGoToCombat() )
  2955.                         {
  2956.                                 return;
  2957.                         }
  2958.                        
  2959.                         GoToCombat( weaponType );
  2960.                 }
  2961.         }
  2962.        
  2963.         public function DisplayCannotAttackMessage( actor : CActor ) : bool
  2964.         {
  2965.                 if ( actor && ( actor.GetMovingAgentComponent().GetName() == "child_base" || ((CNewNPC)actor).GetNPCType() == ENGT_Quest ) )
  2966.                 {
  2967.                         DisplayHudMessage(GetLocStringByKeyExt("panel_hud_message_cant_attack_this_target"));
  2968.                         return true;
  2969.                 }       
  2970.                
  2971.                 return false;
  2972.         }
  2973.        
  2974.         public function GetMostConvenientMeleeWeapon( targetToDrawAgainst : CActor, optional ignoreActionLock : bool ) : EPlayerWeapon
  2975.         {
  2976.                 return weaponHolster.GetMostConvenientMeleeWeapon( targetToDrawAgainst, ignoreActionLock );
  2977.         }
  2978.        
  2979.         private var reevaluateCurrentWeapon : bool;
  2980.        
  2981.         event OnTargetWeaponDrawn()
  2982.         {
  2983.                 var  weaponType : EPlayerWeapon = this.GetCurrentMeleeWeaponType();
  2984.                 if ( weaponType == PW_Fists )
  2985.                         reevaluateCurrentWeapon = true;
  2986.         }
  2987.        
  2988.         public function GoToCombatIfNeeded( optional enemy : CActor ) : bool
  2989.         {
  2990.                 var  weaponType : EPlayerWeapon;
  2991.                 var      target         : CActor;
  2992.                
  2993.                 if( !enemy && IsInCombat() )
  2994.                 {
  2995.                         target = GetTarget();
  2996.                        
  2997.                         if ( target )
  2998.                                 enemy = target;
  2999.                         else
  3000.                                 enemy = moveTarget;
  3001.                 }
  3002.                
  3003.                
  3004.                 if( !ShouldGoToCombat( enemy ) )
  3005.                 {
  3006.                         return false;
  3007.                 }
  3008.                
  3009.                 weaponType = this.GetCurrentMeleeWeaponType();
  3010.                
  3011.                 if ( weaponType == PW_None || ( reevaluateCurrentWeapon && weaponType == PW_Fists ) || ( !IsInCombat() && weaponHolster.IsOnTheMiddleOfHolstering() ) )
  3012.                 {
  3013.                        
  3014.                         weaponType = weaponHolster.GetMostConvenientMeleeWeapon( enemy );
  3015.                         reevaluateCurrentWeapon = false;
  3016.                 }
  3017.                
  3018.                
  3019.                 GoToCombat( weaponType );
  3020.                
  3021.                
  3022.                 return true;
  3023.         }
  3024.        
  3025.         public function GoToCombatIfWanted( ) : bool
  3026.         {
  3027.                 var weaponType  : EPlayerWeapon;
  3028.                 var     target          : CActor;
  3029.                 var     enemy           : CActor;
  3030.                
  3031.                
  3032.                 if( !IsInCombat() )
  3033.                 {
  3034.                         return false;
  3035.                 }
  3036.                
  3037.                 target = GetTarget();
  3038.                
  3039.                 if ( target )
  3040.                         enemy = target;
  3041.                 else
  3042.                         enemy = moveTarget;
  3043.                
  3044.                 weaponType = this.GetCurrentMeleeWeaponType();
  3045.                
  3046.                 if ( weaponType == PW_None || ( !IsInCombat() && weaponHolster.IsOnTheMiddleOfHolstering() ) )
  3047.                 {
  3048.                        
  3049.                         weaponType = weaponHolster.GetMostConvenientMeleeWeapon( enemy );
  3050.                 }
  3051.                
  3052.                
  3053.                 GoToCombat( weaponType );
  3054.                
  3055.                
  3056.                 return true;
  3057.         }
  3058.        
  3059.         public function GoToExplorationIfNeeded() : bool
  3060.         {
  3061.                
  3062.                
  3063.                 if( ! IsInCombatState() )
  3064.                 {
  3065.                         return false;
  3066.                 }
  3067.                
  3068.                 if( !ShouldGoToExploration() )
  3069.                 {
  3070.                         return false;
  3071.                 }
  3072.                
  3073.                
  3074.                 weaponHolster.EndedCombat();
  3075.                
  3076.                
  3077.                 GotoState( 'Exploration' );
  3078.                 return true;
  3079.         }
  3080.        
  3081.         event OnStateCanGoToCombat()
  3082.         {
  3083.                 return false;
  3084.         }
  3085.        
  3086.         event OnStateCanUpdateExplorationSubstates()
  3087.         {
  3088.                 return false;
  3089.         }
  3090.        
  3091.         private function ShouldGoToCombat( optional enemy : CActor ) : bool
  3092.         {
  3093.                 var currentStateName : name;
  3094.                
  3095.                
  3096.                 if( !OnStateCanGoToCombat() )
  3097.                 {
  3098.                         return false;
  3099.                 }
  3100.                
  3101.                 currentStateName = GetCurrentStateName();
  3102.                
  3103.                 if( currentStateName == 'AimThrow' )
  3104.                 {
  3105.                         return false;
  3106.                 }
  3107.                
  3108.                 if( currentStateName == 'Swimming' )
  3109.                 {
  3110.                         return false;
  3111.                 }
  3112.  
  3113.                 if( currentStateName == 'TraverseExploration' )
  3114.                 {
  3115.                         return false;
  3116.                 }
  3117.                
  3118.                
  3119.                
  3120.                
  3121.                
  3122.                
  3123.                 if ( !enemy )
  3124.                 {
  3125.                         return playerMode.combatMode;
  3126.                 }
  3127.                
  3128.                
  3129.                
  3130.                
  3131.                
  3132.                 return true;
  3133.         }
  3134.        
  3135.         private function ShouldGoToExploration() : bool
  3136.         {
  3137.                 if ( IsInCombat() )
  3138.                 {
  3139.                         return false;
  3140.                 }
  3141.                
  3142.                 if ( rangedWeapon && rangedWeapon.GetCurrentStateName() != 'State_WeaponWait' )
  3143.                 {
  3144.                         return false;
  3145.                 }
  3146.                 if( IsFistFightMinigameEnabled() )
  3147.                 {
  3148.                         return false;
  3149.                 }
  3150.                 if( IsKnockedUnconscious() )
  3151.                 {
  3152.                         return false;
  3153.                 }
  3154.                 if( IsInCombatAction() )
  3155.                 {
  3156.                         return false;
  3157.                 }
  3158.                 if( GetCriticalBuffsCount() > 0 )
  3159.                 {
  3160.                         return false;
  3161.                 }
  3162.                
  3163.                 return true;
  3164.         }
  3165.        
  3166.         private function GoToCombat( weaponType : EPlayerWeapon, optional initialAction : EInitialAction )
  3167.         {                      
  3168.                
  3169.                 switch( weaponType )
  3170.                 {
  3171.                         case PW_Silver:
  3172.                                 ((W3PlayerWitcherStateCombatSilver) GetState('CombatSilver')).SetupState( initialAction );
  3173.                                 GoToStateIfNew( 'CombatSilver' );
  3174.                                 break;
  3175.                         case PW_Steel:
  3176.                                 ((W3PlayerWitcherStateCombatSteel) GetState('CombatSteel')).SetupState( initialAction );
  3177.                                 GoToStateIfNew( 'CombatSteel' );
  3178.                                 break;
  3179.                         case PW_Fists:
  3180.                         case PW_None:
  3181.                         default :
  3182.                                 ((W3PlayerWitcherStateCombatFists) GetState('CombatFists')).SetupState( initialAction );
  3183.                                 GoToStateIfNew( 'CombatFists' );
  3184.                         break;
  3185.                 }       
  3186.         }
  3187.        
  3188.         public function GoToStateIfNew( newState : name, optional keepStack : bool, optional forceEvents : bool  )
  3189.         {
  3190.                 if( newState != GetCurrentStateName() )
  3191.                 {
  3192.                         GotoState( newState, keepStack, forceEvents );
  3193.                 }
  3194.         }
  3195.        
  3196.        
  3197.         public function GotoState( newState : name, optional keepStack : bool, optional forceEvents : bool  )
  3198.         {
  3199.                
  3200.                
  3201.                 super.GotoState( newState, keepStack, forceEvents );
  3202.                
  3203.         }
  3204.        
  3205.         public function IsThisACombatSuperState( stateName : name ) : bool
  3206.         {
  3207.                 return stateName == 'Combat' || stateName == 'CombatSteel' || stateName == 'CombatSilver' || stateName == 'CombatFists';
  3208.         }
  3209.        
  3210.         public function GetWeaponHolster() : WeaponHolster
  3211.         {
  3212.                 return weaponHolster;
  3213.         }
  3214.        
  3215.         public function AbortSign()
  3216.         {
  3217.                 var playerWitcher : W3PlayerWitcher;
  3218.                 var sign : W3SignEntity;
  3219.                
  3220.                 playerWitcher = (W3PlayerWitcher)this;
  3221.                
  3222.                 if(playerWitcher)
  3223.                 {
  3224.                         sign = (W3SignEntity)playerWitcher.GetCurrentSignEntity();
  3225.                         if (sign)
  3226.                         {
  3227.                                 sign.OnSignAborted();
  3228.                         }
  3229.                 }
  3230.         }
  3231.  
  3232.        
  3233.        
  3234.        
  3235.         protected var disableActionBlend : bool;
  3236.        
  3237.                
  3238.                
  3239.                
  3240.         event OnAnimEvent_DisallowHitAnim( animEventName : name, animEventType : EAnimationEventType, animInfo : SAnimationEventAnimInfo )
  3241.         {
  3242.                 if ( animEventType == AET_DurationEnd )
  3243.                 {       
  3244.                         if ( ( BufferCombatAction == EBAT_Dodge || BufferCombatAction == EBAT_Roll )
  3245.                                         &&  IsInCombatAction()
  3246.                                         && GetBehaviorVariable( 'combatActionType' ) == (int)CAT_Attack )
  3247.                         {
  3248.                                
  3249.                                 ( (CR4Player)this ).ProcessCombatActionBuffer();
  3250.                                 disableActionBlend = true;
  3251.                         }
  3252.                 }
  3253.                 else if ( IsInCombatAction() && GetBehaviorVariable( 'combatActionType' ) == (int)CAT_Dodge && animEventType == AET_DurationStart )
  3254.                 {
  3255.                         disableActionBlend = false;
  3256.                 }
  3257.                
  3258.                 super.OnAnimEvent_DisallowHitAnim( animEventName, animEventType, animInfo );
  3259.         }
  3260.        
  3261.        
  3262.         event OnAnimEvent_FadeOut( animEventName : name, animEventType : EAnimationEventType, animInfo : SAnimationEventAnimInfo )
  3263.         {
  3264.                 theGame.FadeOutAsync( 0.2, Color( 0, 0, 0, 1 ) );
  3265.         }
  3266.        
  3267.         event OnAnimEvent_FadeIn( animEventName : name, animEventType : EAnimationEventType, animInfo : SAnimationEventAnimInfo )
  3268.         {
  3269.                 theGame.FadeInAsync( 0.4 );
  3270.         }
  3271.        
  3272.         event OnAnimEvent_BloodTrailForced( animEventName : name, animEventType : EAnimationEventType, animInfo : SAnimationEventAnimInfo )
  3273.         {
  3274.                 var bloodTrailParam     : CBloodTrailEffect;
  3275.                 var weaponId                    : SItemUniqueId;
  3276.                
  3277.                 if ( isInFinisher )
  3278.                 {
  3279.                         bloodTrailParam = (CBloodTrailEffect)(GetFinisherVictim()).GetGameplayEntityParam( 'CBloodTrailEffect' );
  3280.                         weaponId = this.inv.GetItemFromSlot('r_weapon');
  3281.                         if ( bloodTrailParam )
  3282.                                 thePlayer.inv.PlayItemEffect( weaponId, bloodTrailParam.GetEffectName() );
  3283.                 }
  3284.         }
  3285.        
  3286.         event OnAnimEvent_SlowMo( animEventName : name, animEventType : EAnimationEventType, animInfo : SAnimationEventAnimInfo )
  3287.         {
  3288.                 if ( isInFinisher && DisableManualCameraControlStackHasSource( 'Finisher' ) )
  3289.                 {
  3290.                         if( animEventType != AET_DurationEnd  )
  3291.                                 theGame.SetTimeScale( 0.1f, 'AnimEventSlomoMo', 1000, true );
  3292.                         else
  3293.                                 theGame.RemoveTimeScale( 'AnimEventSlomoMo' ); 
  3294.                 }
  3295.         }
  3296.        
  3297.         event OnAnimEvent_PlayFinisherBlood( animEventName : name, animEventType : EAnimationEventType, animInfo : SAnimationEventAnimInfo )
  3298.         {
  3299.                 if ( isInFinisher )
  3300.                 {
  3301.                         SpawnFinisherBlood();
  3302.                 }
  3303.         }
  3304.        
  3305.         event OnAnimEvent_OnWeaponDrawReady( animEventName : name, animEventType : EAnimationEventType, animInfo : SAnimationEventAnimInfo )
  3306.         {
  3307.                 weaponHolster.OnWeaponDrawReady();
  3308.         }
  3309.        
  3310.         event OnAnimEvent_OnWeaponHolsterReady( animEventName : name, animEventType : EAnimationEventType, animInfo : SAnimationEventAnimInfo )
  3311.         {
  3312.                 weaponHolster.OnWeaponHolsterReady();
  3313.         }
  3314.        
  3315.         event OnAnimEvent_ThrowHoldTest( animEventName : name, animEventType : EAnimationEventType, animInfo : SAnimationEventAnimInfo )
  3316.         {
  3317.                 var thrownEntity                : CThrowable;
  3318.                
  3319.                 thrownEntity = (CThrowable)EntityHandleGet( thrownEntityHandle );
  3320.                
  3321.                 if( IsThrowHold() )
  3322.                 {
  3323.                         SetBehaviorVariable( 'throwStage', (int)TS_Loop );
  3324.                         PushState( 'AimThrow' );
  3325.                         thrownEntity.StartAiming();
  3326.                 }
  3327.                 else
  3328.                 {
  3329.                         BombThrowRelease();
  3330.                         SetCombatIdleStance( 1.f );
  3331.                 }
  3332.         }
  3333.        
  3334.         event OnAnimEvent_AllowTempLookAt( animEventName : name, animEventType : EAnimationEventType, animInfo : SAnimationEventAnimInfo )
  3335.         {
  3336.                 if( animEventType == AET_DurationStart )
  3337.                         SetTempLookAtTarget( slideTarget );
  3338.                 else if( animEventType == AET_DurationEnd )
  3339.                         SetTempLookAtTarget( NULL );
  3340.         }
  3341.        
  3342.         protected var slideNPC                  : CNewNPC;
  3343.         protected var minSlideDistance  : float;
  3344.         protected var maxSlideDistance  : float;
  3345.         protected var slideTicket               : SMovementAdjustmentRequestTicket;
  3346.        
  3347.         event OnAnimEvent_SlideToTarget( animEventName : name, animEventType : EAnimationEventType, animInfo : SAnimationEventAnimInfo )
  3348.         {
  3349.                 var movementAdjustor    : CMovementAdjustor;
  3350.                
  3351.                 if( animEventType == AET_DurationStart )
  3352.                 {
  3353.                         slideNPC = (CNewNPC)slideTarget;
  3354.                 }
  3355.                        
  3356.                 if( !slideNPC )
  3357.                 {
  3358.                         return false;
  3359.                 }
  3360.                        
  3361.                 if( animEventType == AET_DurationStart && slideNPC.GetGameplayVisibility() )
  3362.                 {
  3363.                         movementAdjustor = GetMovingAgentComponent().GetMovementAdjustor();
  3364.                         slideTicket = movementAdjustor.GetRequest( 'SlideToTarget' );
  3365.                         movementAdjustor.CancelByName( 'SlideToTarget' );
  3366.                         slideTicket = movementAdjustor.CreateNewRequest( 'SlideToTarget' );
  3367.                         movementAdjustor.BindToEventAnimInfo( slideTicket, animInfo );
  3368.                        
  3369.                         movementAdjustor.MaxLocationAdjustmentSpeed( slideTicket, 1000000 );
  3370.                         movementAdjustor.ScaleAnimation( slideTicket );
  3371.                         minSlideDistance = ((CMovingPhysicalAgentComponent)this.GetMovingAgentComponent()).GetCapsuleRadius()+((CMovingPhysicalAgentComponent)slideNPC.GetMovingAgentComponent()).GetCapsuleRadius();
  3372.                         if( IsInCombatFist() )
  3373.                         {
  3374.                                 maxSlideDistance = 1000.0f;     
  3375.                         }
  3376.                         else
  3377.                         {
  3378.                                 maxSlideDistance = minSlideDistance;
  3379.                         }
  3380.                         movementAdjustor.SlideTowards( slideTicket, slideTarget, minSlideDistance, maxSlideDistance ); 
  3381.                 }
  3382.                 else if( !slideNPC.GetGameplayVisibility() )
  3383.                 {
  3384.                         movementAdjustor = GetMovingAgentComponent().GetMovementAdjustor();
  3385.                         movementAdjustor.CancelByName( 'SlideToTarget' );
  3386.                         slideNPC = NULL;
  3387.                 }
  3388.                 else
  3389.                 {
  3390.                         movementAdjustor = GetMovingAgentComponent().GetMovementAdjustor();
  3391.                         movementAdjustor.SlideTowards( slideTicket, slideTarget, minSlideDistance, maxSlideDistance );                         
  3392.                 }
  3393.         }
  3394.        
  3395.         event OnAnimEvent_ActionBlend( animEventName : name, animEventType : EAnimationEventType, animInfo : SAnimationEventAnimInfo )
  3396.         {
  3397.         }
  3398.        
  3399.        
  3400.         event OnAnimEvent_SubstateManager( animEventName : name, animEventType : EAnimationEventType, animInfo : SAnimationEventAnimInfo )
  3401.         {
  3402.                
  3403.                 substateManager.OnAnimEvent( animEventName, animEventType, animInfo );
  3404.         }
  3405.        
  3406.         event OnAnimEvent_AllowFall( animEventName : name, animEventType : EAnimationEventType, animInfo : SAnimationEventAnimInfo )
  3407.         {
  3408.                 if ( !substateManager.m_OwnerMAC.IsOnGround() )
  3409.                 {
  3410.                         substateManager.m_SharedDataO.SetFallFromCritical( true );
  3411.                         substateManager.m_MoverO.SetVelocity( -6.0f * GetWorldForward() );
  3412.                         substateManager.QueueStateExternal( 'Jump' );
  3413.                         RemoveBuff( EET_Knockdown, true );
  3414.                         RemoveBuff( EET_HeavyKnockdown, true );
  3415.                         return true;
  3416.                 }
  3417.                 return false;
  3418.         }
  3419.        
  3420.         event OnAnimEvent_AllowFall2( animEventName : name, animEventType : EAnimationEventType, animInfo : SAnimationEventAnimInfo )
  3421.         {
  3422.                 if ( !substateManager.m_OwnerMAC.IsOnGround() )
  3423.                 {
  3424.                        
  3425.                        
  3426.                         substateManager.QueueStateExternal( 'Jump' );
  3427.                         RemoveBuff( EET_Knockdown, true );
  3428.                         RemoveBuff( EET_HeavyKnockdown, true );
  3429.                 }
  3430.                 if( substateManager.StateWantsAndCanEnter( 'Slide' ) )
  3431.                 {
  3432.                         substateManager.QueueStateExternal( 'Slide' );
  3433.                 }
  3434.         }
  3435.        
  3436.         event OnAnimEvent_DettachGround( animEventName : name, animEventType : EAnimationEventType, animInfo : SAnimationEventAnimInfo )
  3437.         {
  3438.                
  3439.         }
  3440.        
  3441.        
  3442.         event OnAnimEvent_pad_vibration( animEventName : name, animEventType : EAnimationEventType, animInfo : SAnimationEventAnimInfo )
  3443.         {
  3444.                 var witcher : W3PlayerWitcher;
  3445.                
  3446.                 theGame.VibrateControllerHard();
  3447.                
  3448.                
  3449.                 witcher = GetWitcherPlayer();
  3450.                 if(isInFinisher && witcher)
  3451.                 {
  3452.                         if(HasAbility('Runeword 10 _Stats', true) && !witcher.runeword10TriggerredOnFinisher && ((bool)theGame.GetInGameConfigWrapper().GetVarValue('Gameplay', 'AutomaticFinishersEnabled')) == true)
  3453.                         {                              
  3454.                                 witcher.Runeword10Triggerred();
  3455.                                 witcher.runeword10TriggerredOnFinisher = true;
  3456.                         }
  3457.                         else if(HasAbility('Runeword 12 _Stats', true) && !witcher.runeword12TriggerredOnFinisher)
  3458.                         {
  3459.                                 witcher.Runeword12Triggerred();
  3460.                                 witcher.runeword12TriggerredOnFinisher = true;
  3461.                         }
  3462.                 }
  3463.         }
  3464.        
  3465.        
  3466.         event OnAnimEvent_pad_vibration_light( animEventName : name, animEventType : EAnimationEventType, animInfo : SAnimationEventAnimInfo )
  3467.         {
  3468.                
  3469.         }
  3470.        
  3471.         event OnAnimEvent_KillWithRagdoll( animEventName : name, animEventType : EAnimationEventType, animInfo : SAnimationEventAnimInfo )
  3472.         {
  3473.                
  3474.                
  3475.         }
  3476.        
  3477.         event OnAnimEvent_RemoveBurning( animEventName : name, animEventType : EAnimationEventType, animInfo : SAnimationEventAnimInfo )
  3478.         {       
  3479.                 thePlayer.AddBuffImmunity(EET_Burning, 'AnimEvent_RemoveBurning', true);
  3480.         }
  3481.        
  3482.         event OnAnimEvent_RemoveTangled( animEventName : name, animEventType : EAnimationEventType, animInfo : SAnimationEventAnimInfo )
  3483.         {
  3484.                 if ( this.HasBuff( EET_Tangled ) )
  3485.                 {
  3486.                         this.StopEffect('black_spider_web');
  3487.                         this.PlayEffectSingle('black_spider_web_break');               
  3488.                 }
  3489.         }
  3490.        
  3491.        
  3492.         event OnAnimEvent_MoveNoise( animEventName : name, animEventType : EAnimationEventType, animInfo : SAnimationEventAnimInfo )
  3493.         {
  3494.                 theGame.GetBehTreeReactionManager().CreateReactionEventIfPossible( this, 'MoveNoise', -1, 30.0f, -1.f, -1, true );
  3495.         }
  3496.  
  3497.        
  3498.         event OnBehaviorGraphNotification( notificationName : name, stateName : name )
  3499.         {
  3500.                 substateManager.OnBehaviorGraphNotification( notificationName, stateName );
  3501.                
  3502.                 if( notificationName == 'PlayerRunActivate' )
  3503.                 {
  3504.                         isInRunAnimation = true;
  3505.                 }
  3506.                 else if( notificationName == 'PlayerRunDeactivate' )
  3507.                 {
  3508.                         isInRunAnimation = false;
  3509.                 }
  3510.         }
  3511.  
  3512.         event OnEnumAnimEvent( animEventName : name, variant : SEnumVariant, animEventType : EAnimationEventType, animEventDuration : float, animInfo : SAnimationEventAnimInfo )
  3513.         {
  3514.                 var movementAdjustor : CMovementAdjustor;
  3515.                 var ticket : SMovementAdjustmentRequestTicket;
  3516.                 var rotationRate : ERotationRate;
  3517.                
  3518.                 if ( animEventName == 'RotateToTarget' )
  3519.                 {
  3520.                        
  3521.                         rotationRate = GetRotationRateFromAnimEvent( variant.enumValue );
  3522.  
  3523.                         movementAdjustor = GetMovingAgentComponent().GetMovementAdjustor();
  3524.                         if ( animEventType == AET_DurationStart || animEventType == AET_DurationStartInTheMiddle )
  3525.                         {
  3526.                                
  3527.                                
  3528.                                 if (! movementAdjustor.IsRequestActive( movementAdjustor.GetRequest( 'RotateToTarget' ) ) )
  3529.                                 {
  3530.                                        
  3531.                                         ticket = movementAdjustor.CreateNewRequest( 'RotateToTarget' );
  3532.                                        
  3533.                                        
  3534.                                         if ((int)rotationRate == 0)
  3535.                                                 movementAdjustor.AdjustmentDuration( ticket, animEventDuration );
  3536.                                         else
  3537.                                         {
  3538.                                                 movementAdjustor.Continuous( ticket );
  3539.                                                 movementAdjustor.BindToEvent( ticket, 'RotateToTarget' );
  3540.                                         }       
  3541.                                        
  3542.                                         movementAdjustor.DontUseSourceAnimation( ticket );
  3543.                                         movementAdjustor.ReplaceRotation( ticket );
  3544.                                 }
  3545.                                 else
  3546.                                 {
  3547.                                        
  3548.                                         ticket = movementAdjustor.GetRequest( 'RotateToTarget' );
  3549.                                 }
  3550.                                 MovAdjRotateToTarget( ticket );
  3551.                                
  3552.                                 if ((int)rotationRate > 0)
  3553.                                 {
  3554.                                         movementAdjustor.MaxRotationAdjustmentSpeed( ticket, (float)((int)rotationRate) );
  3555.                                 }
  3556.                         }
  3557.                         else if ( animEventType == AET_DurationEnd )
  3558.                         {
  3559.                                
  3560.                                
  3561.                         }
  3562.                         else
  3563.                         {
  3564.                                
  3565.                                 ticket = movementAdjustor.GetRequest( 'RotateToTarget' );
  3566.                                 MovAdjRotateToTarget( ticket );
  3567.                         }
  3568.                 }
  3569.                 super.OnEnumAnimEvent(animEventName, variant, animEventType, animEventDuration, animInfo);
  3570.         }
  3571.                
  3572.         event OnTeleported()
  3573.         {
  3574.                 if( substateManager )
  3575.                 {
  3576.                         substateManager.OnTeleported();
  3577.                 }
  3578.         }
  3579.        
  3580.        
  3581.  
  3582.        
  3583.        
  3584.        
  3585.         event OnStartFistfightMinigame()
  3586.         {
  3587.                 super.OnStartFistfightMinigame();
  3588.                
  3589.                
  3590.                 SetFistFightMinigameEnabled( true );
  3591.                 FistFightHealthChange( true );
  3592.                 thePlayer.GetPlayerMode().ForceCombatMode( FCMR_QuestFunction );
  3593.                 SetImmortalityMode(AIM_Unconscious, AIC_Fistfight);
  3594.                 thePlayer.SetBehaviorVariable( 'playerWeaponLatent', (int)PW_Fists );
  3595.                 GotoCombatStateWithAction( IA_None );
  3596.                 ((CMovingAgentComponent)this.GetMovingAgentComponent()).SnapToNavigableSpace( true );
  3597.                 EquipGeraltFistfightWeapon( true );     
  3598.                 BlockAction( EIAB_RadialMenu,   'FistfightMinigame' ,,true);
  3599.                 BlockAction( EIAB_Signs,                'FistfightMinigame' ,,true);
  3600.                 BlockAction( EIAB_ThrowBomb,    'FistfightMinigame' ,,true);
  3601.                 BlockAction( EIAB_UsableItem,   'FistfightMinigame' ,,true);
  3602.                 BlockAction( EIAB_Crossbow,     'FistfightMinigame' ,,true);
  3603.                 BlockAction( EIAB_DrawWeapon,   'FistfightMinigame' ,,true);