SubModule.cs

using HarmonyLib;
using MotionControlsOverhaul.Config;
using System.Collections.Generic;
using TaleWorlds.Core;
using TaleWorlds.InputSystem;
using TaleWorlds.Library;
using TaleWorlds.MountAndBlade;
using TaleWorlds.MountAndBlade.View.MissionViews;
using TaleWorlds.MountAndBlade.View.Screens;

namespace MotionControlsOverhaul
{
    public class SubModule : MBSubModuleBase
    {
        public static readonly string ModuleFolderName = "MotionControlsOverhaul";
        public static readonly string ModName = "MotionControlsOverhaul";

        protected override void OnGameStart(Game game, IGameStarter gameStarter)
        {
        }

        protected override void OnSubModuleLoad()
        {
            base.OnSubModuleLoad();
            Harmony harmony = new Harmony("MotionController");
            harmony.PatchAll();
        }

        protected override void OnSubModuleUnloaded()
        {
            base.OnSubModuleUnloaded();
        }

        protected override void OnBeforeInitialModuleScreenSetAsRoot()
        {
            base.OnBeforeInitialModuleScreenSetAsRoot();
        }

        public override void OnMissionBehaviorInitialize(Mission mission)
        {
            base.OnMissionBehaviorInitialize(mission);
            mission.AddMissionBehavior(new MotionControllerBehavior());
        }
    }

    public class MotionControllerBehavior : MissionLogic
    {
        private Agent _mainAgent => Mission.MainAgent;
        private GameKeyContext _gameAxisKey = HotKeyManager.GetCategory("Generic");
        private GameKeyContext _keyContextGeneric = HotKeyManager.GetCategory("Generic");
        private GameKeyContext _keyContext = HotKeyManager.GetCategory("CombatHotKeyCategory");

        private static bool _rStickBinded = true;
        private static bool _combatKeysBinded = true;
        private static InputKey _controllerCameraAxisX;
        private static InputKey _controllerCameraAxisY;
        private static InputKey _controllerAttackKey;
        private static InputKey _controllerDefendKey;
        private static MotionControllerBehavior _activeBehavior;

        private const int AttackGameKeyId = 9;
        private const int DefendGameKeyId = 10;
        private const int CrouchGameKeyId = 15;
        private const int CameraToggleGameKeyId = 27;
        private const string ControlModeToggleHotKeyId = "ControlModeToggle";
        private const string ControllerToggleCrouchHotKeyId = "ControllerToggleCrouch";
        private const float TriggerHoldThreshold = 0.2f;
        private const float RightStickDeadzone = 0.45f;
        private const float RightStickReleaseDeadzone = 0.2f;

        private AlternateCombatAction _selectedAlternateCombatAction = AlternateCombatAction.None;
        private AlternateCombatAction _alternateCombatAction = AlternateCombatAction.None;
        private InputKey _alternateCombatDirection = InputKey.Invalid;
        private bool _hasAlternateCombatFlags;
        private bool _wasAttackTriggerHeld;
        private bool _wasDefendTriggerHeld;
        private bool _ignoreAttackTriggerUntilRelease;
        private bool _ignoreDefendTriggerUntilRelease;
        private bool _attackTriggerReleasedThisTick;

        private enum AlternateCombatAction
        {
            None,
            Attack,
            Defend
        }

        public override void EarlyStart()
        {
            base.EarlyStart();
            _activeBehavior = this;
            _keyContext.GetGameKey(25).ControllerKey.ChangeKey(InputKey.Invalid);
            ApplyControllerButtonSwaps();
        }

        public override void OnMissionTick(float dt)
        {
            base.OnMissionTick(dt);
        }

        public override void OnMissionStateFinalized()
        {
            base.OnMissionStateFinalized();
            ResetAlternateCombatState();
            BindCameraRStick();
            BindCombatControllerKeys();

            if (_activeBehavior == this)
            {
                _activeBehavior = null;
            }
        }

        public static void ApplyActiveAlternateCombatFlags()
        {
            _activeBehavior?.ApplyAlternateCombatFlagsAfterVanillaInput();
        }

        public static void ApplyActiveControllerButtonSwaps()
        {
            _activeBehavior?.ApplyControllerButtonSwaps();
        }

        public static void ApplyActiveAlternateFightingSetting()
        {
            _activeBehavior?.ApplyAlternateFightingSetting();
        }

        private void ApplyAlternateFightingSetting()
        {
            ResetAlternateCombatState();

            if (!MCOSettings.Instance.AlternateFighting)
            {
                if (!_rStickBinded) BindCameraRStick();
                BindCombatControllerKeys();
            }
        }

        private void ApplyControllerButtonSwaps()
        {
            if (MCOSettings.Instance.SwapCrouchCameraToggle)
            {
                SetControllerGameKey(CrouchGameKeyId, InputKey.ControllerLThumb);
                SetControllerGameKey(CameraToggleGameKeyId, InputKey.ControllerLDown);
                SetHotKey(ControlModeToggleHotKeyId, InputKey.ControllerLThumb);
                SetHotKey(ControllerToggleCrouchHotKeyId, InputKey.Invalid);
                return;
            }

            SetControllerGameKey(CrouchGameKeyId, InputKey.ControllerLDown);
            SetControllerGameKey(CameraToggleGameKeyId, InputKey.ControllerLThumb);
            SetHotKey(ControlModeToggleHotKeyId, InputKey.ControllerLDown);
            SetHotKey(ControllerToggleCrouchHotKeyId, InputKey.ControllerRDown);
        }

        private void SetControllerGameKey(int gameKeyId, InputKey inputKey)
        {
            GameKey gameKey = _keyContext.GetGameKey(gameKeyId);
            if (gameKey == null) return;

            if (gameKey.ControllerKey != null)
            {
                gameKey.ControllerKey.ChangeKey(inputKey);
            }

            if (gameKey.DefaultControllerKey != null)
            {
                gameKey.DefaultControllerKey.ChangeKey(inputKey);
            }
        }

        private void SetHotKey(string hotKeyId, InputKey inputKey)
        {
            HotKey hotKey = _keyContext.GetHotKey(hotKeyId);
            if (hotKey == null) return;

            SetHotKeyList(hotKey.Keys, inputKey);
            SetHotKeyList(hotKey.DefaultKeys, inputKey);
        }

        private void SetHotKeyList(List<Key> keys, InputKey inputKey)
        {
            if (keys == null) return;

            keys.Clear();
            keys.Add(new Key(inputKey));
        }

        public void UnbindCameraRStick()
        {
            foreach (var key in _gameAxisKey.RegisteredGameAxisKeys)
            {
                if (key.AxisKey.IsControllerInput && key.Id == "CameraAxisX")
                {
                    _controllerCameraAxisX = key.AxisKey.InputKey;
                    key.AxisKey.ChangeKey(InputKey.Invalid);
                }
                else if (key.AxisKey.IsControllerInput && key.Id == "CameraAxisY")
                {
                    _controllerCameraAxisY = key.AxisKey.InputKey;
                    key.AxisKey.ChangeKey(InputKey.Invalid);
                }
            }

            _rStickBinded = false;
        }

        public void BindCameraRStick()
        {
            foreach (var key in _gameAxisKey.RegisteredGameAxisKeys)
            {
                if (key.Id == "CameraAxisX" && key.AxisKey.InputKey == InputKey.Invalid) key.AxisKey.ChangeKey(_controllerCameraAxisX);
                if (key.Id == "CameraAxisY" && key.AxisKey.InputKey == InputKey.Invalid) key.AxisKey.ChangeKey(_controllerCameraAxisY);
            }

            _rStickBinded = true;
        }

        private void UnbindCombatControllerKeys()
        {
            if (!_combatKeysBinded) return;

            _controllerAttackKey = _keyContext.GetGameKey(AttackGameKeyId).ControllerKey.InputKey;
            _controllerDefendKey = _keyContext.GetGameKey(DefendGameKeyId).ControllerKey.InputKey;

            _keyContext.GetGameKey(AttackGameKeyId).ControllerKey.ChangeKey(InputKey.Invalid);
            _keyContext.GetGameKey(DefendGameKeyId).ControllerKey.ChangeKey(InputKey.Invalid);

            _combatKeysBinded = false;
        }

        private void BindCombatControllerKeys()
        {
            if (_combatKeysBinded) return;

            _keyContext.GetGameKey(AttackGameKeyId).ControllerKey.ChangeKey(_controllerAttackKey);
            _keyContext.GetGameKey(DefendGameKeyId).ControllerKey.ChangeKey(_controllerDefendKey);

            _combatKeysBinded = true;
        }

        public void AlternateFighting()
        {
            Agent mainAgent = _mainAgent;
            if (!MCOSettings.Instance.AlternateFighting)
            {
                ResetAlternateCombatState();
                if (!_rStickBinded) BindCameraRStick();
                BindCombatControllerKeys();
                return;
            }

            if (mainAgent == null || IsUsingRangedWeapon(mainAgent))
            {
                ResetAlternateCombatState(mainAgent);
                if (!_rStickBinded) BindCameraRStick();
                BindCombatControllerKeys();
                return;
            }

            if (_combatKeysBinded) UnbindCombatControllerKeys();

            AlternateCombatAction requestedAction = GetRequestedCombatAction();
            InputKey stickDirection = GetHeldRightStickDirection();

            if (stickDirection == InputKey.Invalid)
            {
                ResetAlternateCombatState(mainAgent);
                if (requestedAction == AlternateCombatAction.None && !_rStickBinded) BindCameraRStick();
                if (requestedAction != AlternateCombatAction.None && _rStickBinded) UnbindCameraRStick();
                return;
            }

            if (_attackTriggerReleasedThisTick && requestedAction == AlternateCombatAction.None && _alternateCombatAction == AlternateCombatAction.Attack)
            {
                if (_rStickBinded) UnbindCameraRStick();
                ApplyDefendCancelPulse(mainAgent, stickDirection);
                ClearAlternateCombatState();
                return;
            }

            AlternateCombatAction actionToApply = requestedAction != AlternateCombatAction.None ? requestedAction : _alternateCombatAction;
            if (actionToApply == AlternateCombatAction.None)
            {
                if (!_rStickBinded) BindCameraRStick();
                return;
            }

            if (_rStickBinded) UnbindCameraRStick();
            HandleAlternateCombatInput(mainAgent, actionToApply, stickDirection);
        }

        private void ApplyAlternateCombatFlagsAfterVanillaInput()
        {
            AlternateFighting();
        }

        private void HandleAlternateCombatInput(Agent mainAgent, AlternateCombatAction action, InputKey stickDirection)
        {
            AlternateCombatAction previousAction = _alternateCombatAction;
            bool isChangingHeldCombat =
                _hasAlternateCombatFlags &&
                (_alternateCombatAction != action || _alternateCombatDirection != stickDirection);

            _alternateCombatAction = action;
            _alternateCombatDirection = stickDirection;

            if (isChangingHeldCombat)
            {
                if (previousAction == AlternateCombatAction.Defend)
                {
                    ClearAlternateCombatFlags(mainAgent);
                }
                else
                {
                    ApplyDefendCancelPulse(mainAgent, stickDirection);
                }

                return;
            }

            ApplyAlternateCombatFlags(mainAgent, action, stickDirection);
        }

        private static bool IsUsingRangedWeapon(Agent mainAgent)
        {
            WeaponComponentData currentUsageItem = mainAgent.WieldedWeapon.CurrentUsageItem;
            return currentUsageItem != null && currentUsageItem.IsRangedWeapon;
        }

        private AlternateCombatAction GetRequestedCombatAction()
        {
            bool attackTriggerHeld = IsTriggerHeld(InputKey.ControllerRTrigger);
            bool defendTriggerHeld = IsTriggerHeld(InputKey.ControllerLTrigger);
            bool attackTriggerPressed = attackTriggerHeld && !_wasAttackTriggerHeld;
            bool defendTriggerPressed = defendTriggerHeld && !_wasDefendTriggerHeld;
            _attackTriggerReleasedThisTick = !attackTriggerHeld && _wasAttackTriggerHeld;

            if (!attackTriggerHeld)
            {
                _ignoreAttackTriggerUntilRelease = false;
            }

            if (!defendTriggerHeld)
            {
                _ignoreDefendTriggerUntilRelease = false;
            }

            if (attackTriggerPressed)
            {
                _selectedAlternateCombatAction = AlternateCombatAction.Attack;
                if (defendTriggerHeld)
                {
                    _ignoreDefendTriggerUntilRelease = true;
                }
            }

            if (defendTriggerPressed)
            {
                _selectedAlternateCombatAction = AlternateCombatAction.Defend;
                if (attackTriggerHeld)
                {
                    _ignoreAttackTriggerUntilRelease = true;
                }
            }

            bool effectiveAttackTriggerHeld = attackTriggerHeld && !_ignoreAttackTriggerUntilRelease;
            bool effectiveDefendTriggerHeld = defendTriggerHeld && !_ignoreDefendTriggerUntilRelease;

            if (!effectiveAttackTriggerHeld && _selectedAlternateCombatAction == AlternateCombatAction.Attack)
            {
                _selectedAlternateCombatAction = effectiveDefendTriggerHeld ? AlternateCombatAction.Defend : AlternateCombatAction.None;
            }

            if (!effectiveDefendTriggerHeld && _selectedAlternateCombatAction == AlternateCombatAction.Defend)
            {
                _selectedAlternateCombatAction = effectiveAttackTriggerHeld ? AlternateCombatAction.Attack : AlternateCombatAction.None;
            }

            if (_selectedAlternateCombatAction == AlternateCombatAction.None)
            {
                if (effectiveAttackTriggerHeld && !effectiveDefendTriggerHeld) _selectedAlternateCombatAction = AlternateCombatAction.Attack;
                if (effectiveDefendTriggerHeld && !effectiveAttackTriggerHeld) _selectedAlternateCombatAction = AlternateCombatAction.Defend;
                if (effectiveAttackTriggerHeld && effectiveDefendTriggerHeld) _selectedAlternateCombatAction = AlternateCombatAction.Attack;
            }

            _wasAttackTriggerHeld = attackTriggerHeld;
            _wasDefendTriggerHeld = defendTriggerHeld;

            return _selectedAlternateCombatAction;
        }

        private void ClearAlternateCombatState()
        {
            _selectedAlternateCombatAction = AlternateCombatAction.None;
            _alternateCombatAction = AlternateCombatAction.None;
            _alternateCombatDirection = InputKey.Invalid;
            _hasAlternateCombatFlags = false;
            _wasAttackTriggerHeld = false;
            _wasDefendTriggerHeld = false;
            _ignoreAttackTriggerUntilRelease = false;
            _ignoreDefendTriggerUntilRelease = false;
            _attackTriggerReleasedThisTick = false;
        }

        private static bool IsTriggerHeld(InputKey trigger)
        {
            return Input.GetKeyState(trigger).x > TriggerHoldThreshold || Input.IsKeyDown(trigger);
        }

        private InputKey GetHeldRightStickDirection()
        {
            Vec2 rightStick = Input.GetKeyState(InputKey.ControllerRStick);
            float absoluteX = MathF.Abs(rightStick.x);
            float absoluteY = MathF.Abs(rightStick.y);

            if (absoluteX >= RightStickDeadzone || absoluteY >= RightStickDeadzone)
            {
                if (absoluteX > absoluteY)
                {
                    return rightStick.x > 0f ? InputKey.ControllerRStickRight : InputKey.ControllerRStickLeft;
                }

                return rightStick.y > 0f ? InputKey.ControllerRStickUp : InputKey.ControllerRStickDown;
            }

            if (absoluteX < RightStickReleaseDeadzone && absoluteY < RightStickReleaseDeadzone)
            {
                return InputKey.Invalid;
            }

            InputKey directionFromButton = GetRightStickButtonDirection();
            if (directionFromButton != InputKey.Invalid)
            {
                return directionFromButton;
            }

            return _alternateCombatDirection;
        }

        private static InputKey GetRightStickButtonDirection()
        {
            int key = Input.GetFirstKeyDownInRange((int)InputKey.ControllerRStickUp);

            if (key >= (int)InputKey.ControllerRStickUp && key <= (int)InputKey.ControllerRStickRight)
            {
                return (InputKey)key;
            }

            return InputKey.Invalid;
        }

        private void ApplyAlternateCombatFlags(Agent mainAgent, AlternateCombatAction action, InputKey direction)
        {
            Agent.MovementControlFlag combatFlag = GetCombatDirectionFlag(action, direction);
            if (combatFlag == Agent.MovementControlFlag.None) return;

            if (action == AlternateCombatAction.Defend)
            {
                combatFlag |= Agent.MovementControlFlag.DefendBlock;
            }

            Agent.MovementControlFlag movementFlags = mainAgent.MovementFlags;
            movementFlags &= ~Agent.MovementControlFlag.AttackMask;
            movementFlags &= ~Agent.MovementControlFlag.DefendMask;
            movementFlags |= combatFlag;

            SetMovementFlags(mainAgent, movementFlags);
            _hasAlternateCombatFlags = true;
        }

        private void ApplyDefendCancelPulse(Agent mainAgent, InputKey direction)
        {
            Agent.MovementControlFlag defendFlag = GetCombatDirectionFlag(AlternateCombatAction.Defend, direction);
            if (defendFlag == Agent.MovementControlFlag.None) return;

            Agent.MovementControlFlag movementFlags = mainAgent.MovementFlags;
            movementFlags &= ~Agent.MovementControlFlag.AttackMask;
            movementFlags &= ~Agent.MovementControlFlag.DefendMask;
            movementFlags |= defendFlag;
            movementFlags |= Agent.MovementControlFlag.DefendBlock;

            SetMovementFlags(mainAgent, movementFlags);
            _hasAlternateCombatFlags = false;
        }

        private static Agent.MovementControlFlag GetCombatDirectionFlag(AlternateCombatAction action, InputKey direction)
        {
            switch (direction)
            {
                case InputKey.ControllerRStickUp:
                    return action == AlternateCombatAction.Attack ? Agent.MovementControlFlag.AttackUp : Agent.MovementControlFlag.DefendUp;
                case InputKey.ControllerRStickDown:
                    return action == AlternateCombatAction.Attack ? Agent.MovementControlFlag.AttackDown : Agent.MovementControlFlag.DefendDown;
                case InputKey.ControllerRStickLeft:
                    return action == AlternateCombatAction.Attack ? Agent.MovementControlFlag.AttackLeft : Agent.MovementControlFlag.DefendLeft;
                case InputKey.ControllerRStickRight:
                    return action == AlternateCombatAction.Attack ? Agent.MovementControlFlag.AttackRight : Agent.MovementControlFlag.DefendRight;
                default:
                    return Agent.MovementControlFlag.None;
            }
        }

        private void ResetAlternateCombatState()
        {
            ResetAlternateCombatState(_mainAgent);
        }

        private void ResetAlternateCombatState(Agent mainAgent)
        {
            if (mainAgent == null)
            {
                _hasAlternateCombatFlags = false;
            }
            else
            {
                ClearAlternateCombatFlags(mainAgent);
            }

            ClearAlternateCombatState();
        }

        private void ClearAlternateCombatFlags(Agent mainAgent)
        {
            if (!_hasAlternateCombatFlags || mainAgent == null) return;

            Agent.MovementControlFlag movementFlags = mainAgent.MovementFlags;
            movementFlags &= ~Agent.MovementControlFlag.AttackMask;
            movementFlags &= ~Agent.MovementControlFlag.DefendMask;

            SetMovementFlags(mainAgent, movementFlags);
            _hasAlternateCombatFlags = false;
        }

        private static void SetMovementFlags(Agent mainAgent, Agent.MovementControlFlag movementFlags)
        {
            if (mainAgent.MovementFlags == movementFlags) return;

            mainAgent.MovementFlags = movementFlags;
        }
    }

    [HarmonyPatch(typeof(MissionMainAgentController))]
    [HarmonyPatch("ControlTick")]
    internal static class MissionMainAgentControllerAlternateCombatPatch
    {
        private static void Postfix()
        {
            MotionControllerBehavior.ApplyActiveAlternateCombatFlags();
        }
    }
}