SCR_PlayerController.c

Go to the documentation of this file.

class SCR_PlayerControllerClass : PlayerControllerClass
{
};
 
//------------------------------------------------------------------------------------------------
void OnControlledEntityChangedPlayerController(IEntity from, IEntity to);
typedef func OnControlledEntityChangedPlayerController;
typedef ScriptInvokerBase<OnControlledEntityChangedPlayerController> OnControlledEntityChangedPlayerControllerInvoker;
 
//------------------------------------------------------------------------------------------------
void OwnershipChangedDelegate(bool isChanging, bool becameOwner);
typedef func OwnershipChangedDelegate;
typedef ScriptInvokerBase<OwnershipChangedDelegate> OnOwnershipChangedInvoker;
 
//------------------------------------------------------------------------------------------------
void OnDestroyedPlayerController(Instigator killer, IEntity killerEntity);
typedef func OnDestroyedPlayerController;
typedef ScriptInvokerBase<OnDestroyedPlayerController> OnDestroyedPlayerControllerInvoker;
 
//------------------------------------------------------------------------------------------------
void OnPossessed(IEntity entity);
typedef func OnPossessed;
typedef ScriptInvokerBase<OnPossessed> OnPossessedInvoker;
 
//------------------------------------------------------------------------------------------------
void OnBeforePossessed(IEntity entity);
typedef func OnBeforePossessed;
typedef ScriptInvokerBase<OnBeforePossessed> OnBeforePossessedInvoker;
 
//------------------------------------------------------------------------------------------------
class SCR_PlayerController : PlayerController
{
    static PlayerController s_pLocalPlayerController;
    protected static const float WALK_SPEED = 0.5;
    protected static const float FOCUS_ACTIVATION = 0.1;
    protected static const float FOCUS_DEACTIVATION = 0.05;
    protected static const float FOCUS_TIMEOUT = 0.3;
    protected static const float FOCUS_TOLERANCE = 0.005;
    protected static float s_fADSFocus = 0.7;
    protected static float s_fFocusTimeout;
    protected static float s_fFocusAnalogue;
    protected static bool s_bWasADS;
 
    protected CharacterControllerComponent m_CharacterController;
    protected bool m_bIsLocalPlayerController;
    protected bool m_bIsPaused;
    bool m_bRetain3PV;
    protected bool m_bGadgetFocus;
    protected bool m_bFocusToggle;
    protected float m_fCharacterSpeed;
 
 
    [RplProp(onRplName: "OnRplMainEntityFromID")]
    protected RplId m_MainEntityID;
    protected IEntity m_MainEntity;
 
    [RplProp()]
    protected bool m_bIsPossessing;
 
    ref OnBeforePossessedInvoker m_OnBeforePossess = new OnBeforePossessedInvoker();        // Before an entity becomes possesed.
    ref OnPossessedInvoker m_OnPossessed = new OnPossessedInvoker();        // when entity becomes possessed or control returns to the main entity
    ref OnControlledEntityChangedPlayerControllerInvoker m_OnControlledEntityChanged = new OnControlledEntityChangedPlayerControllerInvoker();
    ref OnDestroyedPlayerControllerInvoker m_OnDestroyed = new OnDestroyedPlayerControllerInvoker();        // main entity is destroyed
    ref OnOwnershipChangedInvoker m_OnOwnershipChangedInvoker = new OnOwnershipChangedInvoker();
    //------------------------------------------------------------------------------------------------
    OnOwnershipChangedInvoker GetOnOwnershipChangedInvoker() 
    { 
        return m_OnOwnershipChangedInvoker; 
    }
 
    //------------------------------------------------------------------------------------------------
    protected override void OnOwnershipChanged(bool changing, bool becameOwner)
    {
        super.OnOwnershipChanged(changing, becameOwner);
        m_OnOwnershipChangedInvoker.Invoke(changing, becameOwner);
    }
 
    override void OnControlledEntityChanged(IEntity from, IEntity to)
    {
        // todo: react to change, inform fe. VONController
        m_OnControlledEntityChanged.Invoke(from, to);
    }
 
    //------------------------------------------------------------------------------------------------
    void SetGameUserSettings()
    {
        IEntity controlledEntity = GetControlledEntity();
        if (!controlledEntity)
        {
            return;
        }
        m_CharacterController = CharacterControllerComponent.Cast(controlledEntity.FindComponent(CharacterControllerComponent));
        if (!m_CharacterController)
        {
            return;
        }
 
        BaseContainer aimSensitivitySettings = GetGame().GetGameUserSettings().GetModule("SCR_AimSensitivitySettings");
 
        if (aimSensitivitySettings)
        {
            float aimSensitivityMouse;
            float aimSensitivityGamepad;
            float aimMultipADS;
 
            if (aimSensitivitySettings.Get("m_fMouseSensitivity", aimSensitivityMouse) &&
                aimSensitivitySettings.Get("m_fStickSensitivity", aimSensitivityGamepad) &&
                aimSensitivitySettings.Get("m_fAimADS", aimMultipADS))
            {
                m_CharacterController.SetAimingSensitivity(aimSensitivityMouse, aimSensitivityGamepad, aimMultipADS);
            }
 
 
        }
 
        BaseContainer gameplaySettings = GetGame().GetGameUserSettings().GetModule("SCR_GameplaySettings");
 
        if (gameplaySettings)
        {
            bool stickyADS = true;
            if (gameplaySettings.Get("m_bStickyADS", stickyADS))
                m_CharacterController.SetStickyADS(stickyADS);
 
            bool stickyGadgets = true;
            if (gameplaySettings.Get("m_bStickyGadgets", stickyGadgets))
                m_CharacterController.SetStickyGadget(stickyGadgets);
            
            bool mouseControlAircraft = true;
            if (gameplaySettings.Get("m_bMouseControlAircraft", mouseControlAircraft))
                m_CharacterController.SetMouseControlAircraft(mouseControlAircraft);
 
            EVehicleDrivingAssistanceMode drivingAssistance;
            if(GetGame().GetIsClientAuthority())
            {
                if (gameplaySettings.Get("m_eDrivingAssistance", drivingAssistance))
                    VehicleControllerComponent.SetDrivingAssistanceMode(drivingAssistance);
            }
            else
            {
                if (gameplaySettings.Get("m_eDrivingAssistance", drivingAssistance))
                    VehicleControllerComponent_SA.SetDrivingAssistanceMode(drivingAssistance);
            }
        }
 
        //TODO: we might want to set default focusInADS to 100 on XBOX and PSN ( default for mouse control should be 70 - see SCR_GameplaySettings )
        BaseContainer fovSettings = GetGame().GetGameUserSettings().GetModule("SCR_FieldOfViewSettings");
        if (fovSettings)
        {
            float focusInADS = 0.5;
            if (fovSettings.Get("m_fFocusInADS", focusInADS))
                s_fADSFocus = focusInADS;
        }
    }
 
    //------------------------------------------------------------------------------------------------
    void SetPossessedEntity(IEntity entity)
    {
        if (!m_bIsPossessing)
        {
            if (entity)
            {
                m_OnBeforePossess.Invoke(entity);
                //--- Start posessing
                m_bIsPossessing = true;
 
                //--- Remember previously controlled entity
                IEntity controlledEntity = GetControlledEntity();
                m_MainEntityID = RplId.Invalid();
                if (controlledEntity)
                {
                    RplComponent rpl = RplComponent.Cast(controlledEntity.FindComponent(RplComponent));
                    if (rpl)
                    {
                        rpl.GiveExt(RplIdentity.Local(), false);
                        m_MainEntityID = rpl.Id();
                    }
                }
 
                OnRplMainEntityFromID(); //--- ToDo: Remove? BumpMe should call it automatically.
                Replication.BumpMe();
 
                //-- Tell manager we're possessing an entity
                SCR_PossessingManagerComponent possessingManager = SCR_PossessingManagerComponent.GetInstance();
                if (possessingManager)
                    possessingManager.SetMainEntity(GetPlayerId(), entity, controlledEntity, m_bIsPossessing);
 
                //--- Switch control
                RplComponent rpl = RplComponent.Cast(entity.FindComponent(RplComponent));
                if (rpl)
                    rpl.GiveExt(GetRplIdentity(), false);
                SetAIActivation(entity, false);
                SetControlledEntity(entity);
                m_OnPossessed.Invoke(entity);
            }
        }
        else
        {
            if (!entity)
            {
                //--- Stop possessing
                m_bIsPossessing = false;
 
                //--- Forget main entity
                m_MainEntityID = RplId.Invalid();
                OnRplMainEntityFromID(); //--- ToDo: Remove?
                Replication.BumpMe();
 
                SCR_PossessingManagerComponent possessingManager = SCR_PossessingManagerComponent.GetInstance();
                if (possessingManager)
                    possessingManager.SetMainEntity(GetPlayerId(), GetControlledEntity(), m_MainEntity, m_bIsPossessing);
 
                //--- Switch control
                IEntity controlledEntity = GetControlledEntity();
                if (controlledEntity)
                {
                    RplComponent rpl = RplComponent.Cast(controlledEntity.FindComponent(RplComponent));
                    if (rpl)
                        rpl.GiveExt(RplIdentity.Local(), false);
 
                    SetAIActivation(controlledEntity, true);
                }
                
                //--- Switch control
                if (m_MainEntity)
                {
                    RplComponent rpl = RplComponent.Cast(m_MainEntity.FindComponent(RplComponent));
                    if (rpl)
                        rpl.GiveExt(GetRplIdentity(), false);
                }
                SetControlledEntity(m_MainEntity);
                m_OnPossessed.Invoke(m_MainEntity);
 
                //--- SetControlledEntity(null) doesn't work yet. ToDo: Remove this check once it's implemented
                if (GetControlledEntity() != m_MainEntity)
                    Print(string.Format("Error when switching control back to m_MainEntity = %1!", m_MainEntity), LogLevel.WARNING);
            }
            else
            {
                //--- Switch possessing
                SetPossessedEntity(null);
                SetPossessedEntity(entity);
                m_OnPossessed.Invoke(entity);
            }
        }
    }
 
    //------------------------------------------------------------------------------------------------
    void SetInitialMainEntity(notnull IEntity entity)
    {
        RplComponent rpl = RplComponent.Cast(entity.FindComponent(RplComponent));
        if (!rpl)
            return;
 
        m_MainEntityID = rpl.Id();
        OnRplMainEntityFromID();
        Replication.BumpMe();
 
        SCR_PossessingManagerComponent possessingManager = SCR_PossessingManagerComponent.GetInstance();
        if (possessingManager)
            possessingManager.SetMainEntity(GetPlayerId(), GetControlledEntity(), entity, m_bIsPossessing);
 
        rpl.GiveExt(GetRplIdentity(), false); // transfer ownership
        SetAIActivation(entity, false);
        SetControlledEntity(entity);
 
        m_OnPossessed.Invoke(entity);
    }
 
    //------------------------------------------------------------------------------------------------
    bool IsPossessing()
    {
        return m_bIsPossessing;
    }
    //------------------------------------------------------------------------------------------------
    IEntity GetMainEntity()
    {
        if (m_bIsPossessing)
            return m_MainEntity;
        else
            return GetControlledEntity();
    }
    //------------------------------------------------------------------------------------------------
    protected void OnRplMainEntityFromID()
    {
        //m_MainEntity = IEntity.Cast(Replication.FindItem(m_MainEntityID));
        RplComponent rpl = RplComponent.Cast(Replication.FindItem(m_MainEntityID));
        if (rpl)
            m_MainEntity = rpl.GetEntity();
    }
    //------------------------------------------------------------------------------------------------
    protected void SetAIActivation(IEntity entity, bool activate)
    {
        if (!entity)
            return;
 
        AIControlComponent aiControl = AIControlComponent.Cast(entity.FindComponent(AIControlComponent));
        if (!aiControl)
            return;
 
        if (activate)
            aiControl.ActivateAI();
        else
            aiControl.DeactivateAI();
    }
 
    //------------------------------------------------------------------------------------------------
    static int GetLocalPlayerId()
    {
        PlayerController pPlayerController = GetGame().GetPlayerController();
        if (!pPlayerController)
            return 0;
 
        return pPlayerController.GetPlayerId();
    }
 
    //------------------------------------------------------------------------------------------------
    static IEntity GetLocalControlledEntity()
    {
        PlayerController pPlayerController = GetGame().GetPlayerController();
        if (pPlayerController)
            return pPlayerController.GetControlledEntity();
 
        return null;
    }
    static IEntity GetLocalMainEntity()
    {
        SCR_PlayerController playerController = SCR_PlayerController.Cast(GetGame().GetPlayerController());
        if (playerController)
            return playerController.GetMainEntity();
        else
            return null;
    }
 
    //------------------------------------------------------------------------------------------------
    static Faction GetLocalControlledEntityFaction()
    {
        PlayerController playerController = GetGame().GetPlayerController();
        if (!playerController)
            return null;
 
        IEntity controlledEntity = playerController.GetControlledEntity();
        if (!controlledEntity)
            return null;
 
        FactionAffiliationComponent factionAffiliation = FactionAffiliationComponent.Cast(controlledEntity.FindComponent(FactionAffiliationComponent));
        if (factionAffiliation)
            return factionAffiliation.GetAffiliatedFaction();
        else
            return null;
    }
    static Faction GetLocalMainEntityFaction()
    {
        SCR_PlayerController playerController = SCR_PlayerController.Cast(GetGame().GetPlayerController());
        if (!playerController)
            return null;
 
        IEntity controlledEntity = playerController.GetMainEntity();
        if (!controlledEntity)
            return null;
 
        FactionAffiliationComponent factionAffiliation = FactionAffiliationComponent.Cast(controlledEntity.FindComponent(FactionAffiliationComponent));
        if (factionAffiliation)
            return factionAffiliation.GetAffiliatedFaction();
        else
            return null;
    }
 
    //------------------------------------------------------------------------------------------------
    override void OnDestroyed(notnull Instigator killer)
    {
        super.OnDestroyed(killer);
        IEntity killerEntity = killer.GetInstigatorEntity();
        m_OnDestroyed.Invoke(killer, killerEntity);
    }
 
    //------------------------------------------------------------------------------------------------
    override void OnUpdate(float timeSlice)
    {
        if (!s_pLocalPlayerController)
            UpdateLocalPlayerController();
 
        if (m_bIsLocalPlayerController)
        {
            UpdateControls();
            //UpdateUI();
        }
    }
 
    protected void UpdateLocalPlayerController()
    {
        m_bIsLocalPlayerController = this == GetGame().GetPlayerController();
        if (!m_bIsLocalPlayerController)
            return;
 
        s_pLocalPlayerController = this;
        InputManager inputManager = GetGame().GetInputManager();
        if (!inputManager)
            return;
 
        inputManager.AddActionListener("WeaponChangeMagnification", EActionTrigger.VALUE, ChangeMagnification);
        inputManager.AddActionListener("CharacterWalk", EActionTrigger.DOWN, OnWalk);
        inputManager.AddActionListener("CharacterWalk", EActionTrigger.UP, OnEndWalk);
        inputManager.AddActionListener("FocusToggle", EActionTrigger.DOWN, ActionFocusToggle);
        inputManager.AddActionListener("FocusToggleUnarmed", EActionTrigger.DOWN, ActionFocusToggleUnarmed);
        inputManager.AddActionListener("Inventory", EActionTrigger.DOWN, ActionOpenInventory );
        inputManager.AddActionListener("TacticalPing", EActionTrigger.DOWN, ActionGesturePing );
        inputManager.AddActionListener("TacticalPingHold", EActionTrigger.DOWN, ActionGesturePingHold );
        inputManager.AddActionListener("TacticalPingHold", EActionTrigger.UP, ActionGesturePingHold );
        inputManager.AddActionListener("WeaponSwitchOptics", EActionTrigger.UP, ChangeWeaponOptics);
    }
 
    protected void UpdateControls()
    {
        bool disableControls = GetGame().GetMenuManager().IsAnyMenuOpen();
        if (m_bIsPaused != disableControls)
        {
            m_bIsPaused = disableControls;
            SetDisableControls(disableControls);
        }
    }
 
    protected void UpdateUI()
    {
        ChimeraCharacter char = ChimeraCharacter.Cast(GetControlledEntity());
        if (!char)
            return;
        CharacterAnimationComponent animComp = char.GetAnimationComponent();
        if (!animComp)
            return;
        // Command ladder is present only when character is using ladder
        CharacterCommandLadder ladderCMD = animComp.GetCommandHandler().GetCommandLadder();
        if (!ladderCMD)
            return;
        int lrExitState = ladderCMD.CanExitLR();
        if (lrExitState & 0x1)
        {
            Print("Can exit right");
        }
        if (lrExitState & 0x2)
        {
            Print("Can exit left");
        }
    }
 
    protected void ChangeMagnification(float value)
    {
        SCR_CharacterControllerComponent characterController = GetCharacterController();
        if (characterController)
            characterController.SetNextSightsFOVInfo(value);
    }
 
    protected void ChangeWeaponOptics()
    {
        SCR_CharacterControllerComponent characterController = GetCharacterController();
        if (characterController)
            characterController.SetNextSights();
    }
 
    protected SCR_CharacterControllerComponent GetCharacterController()
    {
        ChimeraCharacter char = ChimeraCharacter.Cast(GetControlledEntity());
        if (!char)
            return null;
 
        return SCR_CharacterControllerComponent.Cast(char.GetCharacterController());
    }
 
    // Parameter value:
    // TRUE:  Disables the controls
    // FALSE: Enables the controls
    private void SetDisableControls(bool value)
    {
        SCR_CharacterControllerComponent characterController = GetCharacterController();
        if (!characterController)
            return;
 
        characterController.SetDisableViewControls(value);
        characterController.SetDisableWeaponControls(value);
        characterController.SetDisableMovementControls(value)
    }
 
    //------------------------------------------------------------------------------------------------
    float GetFocusValue(float adsProgress = 0, float dt = -1)
    {
        if (!m_CharacterController)
            return 0;
 
        float focus;
 
        // Autofocus
        if (adsProgress > 0)
            focus = s_fADSFocus * Math.Min(adsProgress, 1);
 
        InputManager inputManager = GetGame().GetInputManager();
 
        // Cancel toggled focus when focus is held
        bool inputDigital = inputManager.GetActionTriggered("Focus");
        if (inputDigital && m_bFocusToggle)
            m_bFocusToggle = false;
 
        // Conditions must be consistent with ActionFocusToggle and ActionFocusToggleUnarmed
        ChimeraCharacter character = m_CharacterController.GetCharacter();
        if (m_bFocusToggle && character)
        {
            if (character.IsInVehicle())
            {
                // Cancel toggle focus when in vehicle and aiming through gadget (binocular, compass)
                if (m_bGadgetFocus)
                    m_bFocusToggle = false;
 
                // Cancel toggle focus when in vehicle and not in forced freelook
                if (!m_CharacterController.IsFreeLookEnabled() && !m_CharacterController.GetFreeLookInput())
                    m_bFocusToggle = false;
            }
            else
            {
                // Cancel toggle focus when not in vehicle and holding item in hands
                if (m_CharacterController.GetCurrentItemInHands())
                    m_bFocusToggle = false;
 
                // Cancel toggle focus when not in vehicle and holding gadget
                if (m_CharacterController.IsGadgetInHands())
                    m_bFocusToggle = false;
            }
        }
 
        // Ground vehicles have different focus action to prevent conflict with brakes
        float inputAnalogue;
        if (!inputManager.IsContextActive("CarContext") && !inputManager.IsContextActive("HelicopterContext"))
        {
            // Square root input to focus mapping results in linear change of picture area
            float focusAnalogue = Math.Sqrt(inputManager.GetActionValue("FocusAnalog"));
 
            // Tolerance to prevent jittering
            if (focusAnalogue < FOCUS_DEACTIVATION)
                s_fFocusAnalogue = 0;
            else if (!float.AlmostEqual(s_fFocusAnalogue, focusAnalogue, FOCUS_TOLERANCE))
                s_fFocusAnalogue = focusAnalogue;
 
            inputAnalogue = s_fFocusAnalogue;
        }
 
        bool isADS = m_CharacterController.GetWeaponADSInput();
 
        // Check gadget ADS
        if (!isADS && m_CharacterController.IsGadgetInHands())
            isADS = m_CharacterController.IsGadgetRaisedModeWanted();
 
        // Verify turrets
        if (!isADS && character)
        {
            CompartmentAccessComponent compartmentAccess = character.GetCompartmentAccessComponent();
 
            BaseCompartmentSlot compartment;
            if (compartmentAccess)
                compartment = compartmentAccess.GetCompartment();
 
            TurretControllerComponent turretController;
            if (compartment)
                turretController = TurretControllerComponent.Cast(compartment.GetController());
 
            if (turretController)
                isADS = turretController.IsWeaponADS();
        }
 
        // Prevent focus warping back while toggling ADS on controller
        // analogue: track timeout as we have no input filter that has thresholds or delays and returns axis value yet
        if (inputAnalogue < FOCUS_DEACTIVATION)
            s_fFocusTimeout = FOCUS_TIMEOUT; // Below deactivation threshold
        else if (s_bWasADS != isADS && s_fFocusTimeout > 0)
            s_fFocusTimeout = FOCUS_TIMEOUT; // ADS toggled
        else if (inputAnalogue < FOCUS_ACTIVATION && s_fFocusTimeout > 0)
            s_fFocusTimeout = FOCUS_TIMEOUT;  // Below activation threshold and not active
        else if (s_fFocusTimeout > dt)
            s_fFocusTimeout -= dt; // Not yet active, decrementing
        else
            s_fFocusTimeout = 0; // Activated
 
        // Cancel toggle focus with analogue input
        if (m_bFocusToggle && s_fFocusTimeout == 0)
            m_bFocusToggle = false;
 
        s_bWasADS = isADS;
 
        // Combine all valid input sources
        float input;
        if (m_bFocusToggle || inputDigital)
            input = 1;
        else if (s_fFocusTimeout == 0)
            input = inputAnalogue;
 
        if (input > 0)
            focus = Math.Max(focus, input);
 
        // Ensure return value always within 0-1
        focus = Math.Clamp(focus, 0, 1);
        return focus;
    }
 
    //------------------------------------------------------------------------------------------------
    void SetGadgetFocus(bool gadgetFocus)
    {
        m_bGadgetFocus = gadgetFocus;
    }
 
    //------------------------------------------------------------------------------------------------
    bool GetGadgetFocus()
    {
        return m_bGadgetFocus;
    }
 
    //------------------------------------------------------------------------------------------------
    void ActionFocusToggle(float value = 0.0, EActionTrigger reason = 0)
    {
        if (!m_CharacterController)
            return;
 
        // Conditions must be consistent with GetFocusValue logic
        ChimeraCharacter character = m_CharacterController.GetCharacter();
        if (character && !character.IsInVehicle())
            return;
 
        // Cancel toggle focus when in vehicle and aiming through gadget (binocular, compass)
        if (m_bGadgetFocus)
            return;
 
        // Cancel toggle focus when in vehicle and not in forced freelook
        if (!m_CharacterController.IsFreeLookEnabled() && !m_CharacterController.GetFreeLookInput())
            return;
 
        m_bFocusToggle = !m_bFocusToggle;
    }
 
    //------------------------------------------------------------------------------------------------
    void ActionFocusToggleUnarmed(float value = 0.0, EActionTrigger reason = 0)
    {
        if (!m_CharacterController)
            return;
 
        // Conditions must be consistent with GetFocusValue logic
        ChimeraCharacter character = m_CharacterController.GetCharacter();
        if (character && character.IsInVehicle())
            return;
 
        // Cancel toggle focus when not in vehicle and holding item in hands
        if (m_CharacterController.GetCurrentItemInHands())
            return;
 
        // Cancel toggle focus when not in vehicle and holding gadget
        if (m_CharacterController.IsGadgetInHands())
            return;
 
        // Allow cancelling unarmed focus while picking up items
        // Disallow enabling unarmed focus while picking up items, as it may become irreleant quickly
        // Reason is player may want to enter ADS before ready, while intent is unclear
        if (!m_bFocusToggle && m_CharacterController.IsPlayingItemGesture())
            return;
 
        m_bFocusToggle = !m_bFocusToggle;
    }
 
    //------------------------------------------------------------------------------------------------
    void OnWalk()
    {
        if (!m_CharacterController || m_CharacterController.GetDynamicSpeed() == WALK_SPEED)
            return;
 
        m_fCharacterSpeed = m_CharacterController.GetDynamicSpeed();
        m_CharacterController.SetDynamicSpeed(WALK_SPEED);
        m_CharacterController.SetShouldApplyDynamicSpeedOverride(true);
    }
 
    //------------------------------------------------------------------------------------------------
    void OnEndWalk()
    {
        if (!m_CharacterController || m_CharacterController.GetDynamicSpeed() == m_fCharacterSpeed)
            return;
 
        m_CharacterController.SetDynamicSpeed(m_fCharacterSpeed);
        m_CharacterController.SetShouldApplyDynamicSpeedOverride(false);
    }
 
    //------------------------------------------------------------------------------------------------
    void ActionOpenInventory()
    {
        IEntity entity = s_pLocalPlayerController.GetControlledEntity();
        if (!entity)
            return;
 
        SCR_InventoryStorageManagerComponent inventory = SCR_InventoryStorageManagerComponent.Cast(entity.FindComponent(SCR_InventoryStorageManagerComponent));
        if (inventory)
            inventory.Action_OpenInventory();
    }
 
    //------------------------------------------------------------------------------------------------
    void ActionGesturePing(float value = 0.0, EActionTrigger reason = 0)
    {
        if (!m_CharacterController)
            return;
 
        // Press and forget variant... eg press comma once - character will point with it's finger for 1 second (including blending time from animation graph ~300ms)
        m_CharacterController.TryStartCharacterGesture(ECharacterGestures.POINT_WITH_FINGER, 1500);
    }
 
    //------------------------------------------------------------------------------------------------
    void ActionGesturePingHold(float value = 0.0, EActionTrigger reason = 0)
    {
        if (!m_CharacterController)
            return;
 
        // Hold key variant... hold period - character will point with it's finger until period key is released
        if (reason == EActionTrigger.DOWN)
        {
            m_CharacterController.TryStartCharacterGesture(ECharacterGestures.POINT_WITH_FINGER);
        } else if ( reason == EActionTrigger.UP)
        {
            m_CharacterController.StopCharacterGesture();
        }
    }
 
    //------------------------------------------------------------------------------------------------
    override void EOnInit(IEntity owner)
    {
        super.EOnInit(owner);
 
        //HACK: SCR_PlayerController must insert SCR_InteractionHandlerComponent OnControlledEntityChanged into script invoker due to fact that the latter calls its OnInit only for the host
        SCR_InteractionHandlerComponent handler = SCR_InteractionHandlerComponent.Cast(owner.FindComponent(SCR_InteractionHandlerComponent));
        if (!handler)
            return;
 
        m_OnControlledEntityChanged.Insert(handler.OnControlledEntityChanged);
    }
}