BITFALL/Assets/Artists/Scripts/Equip/BITGunStates.cs

using System;
using System.Collections.Generic;
using System.Data.Odbc;
using System.Linq;
using Animancer;
using BITFALL.Player.Equip;
using BITFALL.Player.Movement;
using BITKit;
using BITKit.Animations;
using BITKit.Entities;
using BITKit.Selection;
using UnityEngine.InputSystem;
using BITKit.StateMachine;
using Cysharp.Threading.Tasks;
using UnityEngine;
// ReSharper disable UnassignedField.Local

namespace BITFALL.Guns.States
{
    [System.Serializable]
    public sealed class None:GunState
    {
    }
    [System.Serializable]
    public sealed class Movement : GunState
    {
        [SerializeField] private ExpectState<bool> _expectRun;
        [Inject] private ISelector _selector;
        private float requestBoltActionElapsedTime;
        private bool boltActionImmediately;

        private AnimancerState inspectState;
        
        private AnimancerState crouchState;
        public override void OnStateEntry(IState old)
        {
            switch (old)
            {
                case Movement:
                    break;
                default:
                    if (_entityMovement.CurrentState is IPlayerWalkState or IPlayerCrouchState or IPlayerKnockdownState)
                        PlayAnimation();
                    else
                        OnMovementStateChanged(null, _entityMovement.CurrentState);
                    break;
            }

            _selector.OnActive += OnActive;
            boltActionImmediately = root.RequireBolt;

            root.inputActionGroup.RegisterCallback(root.inspectAction, OnInspect);
        }

        private void OnInspect(InputAction.CallbackContext obj)
        {
            PlayAnimation(0,PlayAnimationVoid,nameof(BITConstant.Player.Inspect));
        }

        public override void OnStateExit(IState old, IState newState)
        {
            requestBoltActionElapsedTime = 0;
            base.OnStateExit(old, newState);
            _selector.OnActive -= OnActive;
            
            root.inputActionGroup.UnRegisterCallback(root.inspectAction, OnInspect);

            if (inspectState != null)
            {
                inspectState.Events.OnEnd = null;
                inspectState.Stop();
            }
              
        }

        public override void OnStateUpdate(float deltaTime)
        {
            if (root.RequireBolt)
                requestBoltActionElapsedTime += deltaTime;
            //if (root.animator[0].stateName is not BITConstant.Player.Movement) return;
            if (root.expectFiring.shouldBe && root.fireInterval.AllowUpdate)
            {
                root.Fire();
            }
            if (root.expectAiming.shouldBe && BITAppForUnity.AllowCursor == false)
            {
                root.TransitionState<Aim>();
                return;
            }
            if (_expectRun)
            {
                root.TransitionState<Run>();
                return;
            }

            switch (root.RequireBolt)
            {
                case var _ when boltActionImmediately:
                case var _ when requestBoltActionElapsedTime > 1f:
                //case var _ when root.animator[4].stateName == BITConstant.Player.Empty && requestBoltActionElapsedTime>0.32f:
                    root.TransitionState<Reload>();
                    break;
            }
        }

        public async void OnActive(ISelectable selectable)
        {
            await UniTask.DelayFrame(8);
            if (root.destroyCancellationToken.IsCancellationRequested) return;
            if (root.IsEntered && Enabled)
                await PlayAnimation(0, PlayAnimationVoid,BITConstant.Player.Interactive);
        }
    
        public override void OnMovementStateChanged(IEntityMovementState old, IEntityMovementState newState)
        {
            _expectRun = newState is IPlayerRunState or IPlayerSprintState;
            if (newState is IPlayerSlideState)
            {
                if (root.CurrentState != this)
                    root.TransitionState<Movement>();
                PlayAnimation(BITConstant.Player.Slide);
                //root.animator.CrossFade(BITConstant.Player.Slide, 0.32f);
            }
            else if (newState is IPlayerDodgeState)
            {
                if (root.CurrentState != this)
                    root.TransitionState<Movement>();
                PlayAnimation(BITConstant.Player.Dodge);
            }
            else if (Enabled)
            {
                switch (newState)
                {
                    case IPlayerCrouchState:
                        PlayAnimation(root.SearchKey.Append(nameof(BITConstant.Player.Crouch)).ToArray());
                        break;
                    case IPlayerMovementState:
                        PlayAnimation();
                        break;
                }
            }
        }
    }
    [System.Serializable]
    public sealed class Run : GunState
    {
        private ExpectState<bool> _expectRun;
        private ExpectState<bool> _expectSprint;
        public override void OnStateEntry(IState old)
        {
            PlayAnimation(root.SearchKey.Append(nameof(BITConstant.Player.Run)).ToArray());

            root.inputActionGroup.RegisterCallback(root.aimAction, OnAim);
        }
        public override void OnStateExit(IState old, IState newState)
        {
            root.inputActionGroup.UnRegisterCallback(root.aimAction, OnAim);
        }
        public override void OnStateUpdate(float deltaTime)
        {
            // if (root.animator[0].stateName == BITConstant.Player.Movement)
            // {
            //     root.animator.CrossFade(BITConstant.Player.Run, 0.32f);
            //     PlayAnimation(SearchKey.Append(nameof(BITConstant.Player.Run)).ToArray());
            // }
            if(_expectSprint)
            {
                root.TransitionState<Sprint>();
            }
            else if(_expectRun == false)
            {
                root.TransitionState<Movement>();
            }
            else
            {
                currentState.Speed = _entityMovement.LocomotionBasedVelocity.GetLength() / _entityMovement.ReferenceSpeed;
            }
        }
        private void OnAim(InputAction.CallbackContext context)
        {
            if (context.started && BITAppForUnity.AllowCursor == false)
            {
                root.TransitionState<Aim>();
            }
        }

        public override void OnMovementStateChanged(IEntityMovementState old, IEntityMovementState newState)
        {
            _expectRun = newState is IPlayerRunState or IPlayerSprintState;
            _expectSprint = newState is IPlayerSprintState;
        }
    }
    [System.Serializable]
    public sealed class Sprint : GunState
    {
        private ExpectState<bool> _expectSprint;
        public override void OnStateEntry(IState old)
        {
            base.OnStateEntry(old);
            //root.animator.CrossFade(BITConstant.Player.Sprint, 0.32f);
            //PlayAnimation(root.SearchKey.Append(nameof(BITConstant.Player.Sprint)).ToArray());
            
            root.inputActionGroup.RegisterCallback(root.aimAction, OnAim);
        }
        public override void OnStateExit(IState old, IState newState)
        {
            root.inputActionGroup.UnRegisterCallback(root.aimAction, OnAim);
        }
        public override void OnStateUpdate(float deltaTime)
        {
            if(_expectSprint == false)
            {
                root.TransitionState<Movement>();
            }
            else
            {
                currentState.Speed = _entityMovement.LocomotionBasedVelocity.GetLength() / _entityMovement.ReferenceSpeed;
            }
        }
        private void OnAim(InputAction.CallbackContext context)
        {
            if (context.started && BITAppForUnity.AllowCursor == false)
            {
                root.TransitionState<Aim>();
            }
        }
        public override void OnMovementStateChanged(IEntityMovementState old, IEntityMovementState newState)
        {
            _expectSprint = newState is IPlayerSprintState;
        }
    }
    [System.Serializable]
    public sealed class Aim : GunState
    {
        public override void OnStateEntry(IState old)
        {
            // switch (old)
            // {
            //     case IPlayerRunState:
            //     case IPlayerSprintState:
            //         //root.animator.CrossFade(BITConstant.Player.Aim, 0.32f);
            //         PlayAnimation(root.SearchKey.Append(nameof(BITConstant.Player.Aim)).ToArray());
            //         break;
            //     default:
            //         PlayAnimation(root.SearchKey.Append(nameof(BITConstant.Player.Aim)).ToArray());
            //         break;
            // }
            base.OnStateEntry(old);
            
            _entityMovement.ExecuteCommand<PlayerPauseRunCommand>(new(this,true));
            
            _entityMovement.ExecuteCommand(new PlayerLimitMoveSpeedCommand()
            {
                Id = BITHash.Player.Aim,
                Limit =true,
                Speed = root._gun.InitialAimMovementSpeed,
            });
        }
        public override void OnStateExit(IState old, IState newState)
        {
            base.OnStateExit(old, newState);
            _entityMovement.ExecuteCommand<PlayerPauseRunCommand>(new(this,false));
            
            _entityMovement.ExecuteCommand(new PlayerLimitMoveSpeedCommand()
            {
                Id = BITHash.Player.Aim,
                Limit =false,
                Speed = root._gun.InitialAimMovementSpeed,
            });

            equipService.Aim = 0;
        }

        public override void OnStateUpdate(float deltaTime)
        {
            if (root.expectFiring.shouldBe && root.fireInterval.AllowUpdate)
            {
                root.Fire();
            }

            equipService.Aim = currentState.Weight;

            if (BITAppForUnity.AllowCursor)
            {
                root.TransitionState<Movement>();
            }
            else if (root.expectAiming.shouldBe)
            {

            }
            else
            {
                root.TransitionState<Movement>();
            }
        }

        public override void OnMovementStateChanged(IEntityMovementState old, IEntityMovementState newState)
        {
            if (Enabled is false) return;
            if (newState is not (IPlayerRunState or IPlayerSprintState)) return;
            root.expectAiming.Reset();
            root.TransitionState<Movement>();
        }
    }
    [System.Serializable]
    public sealed class Draw : GunState
    {
        [Inject]
        private IPlayerEquipSelector _equipSelector;
        
        public override void Initialize()
        {
            base.Initialize();
            _equipSelector.OnUpdateEquip += OnUpdateEquip;
        }
        private readonly List<int> _drawed = new();
        private void OnUpdateEquip(IDictionary<int, IBasicItem> obj)
        {
            foreach (var x in _drawed.ToArray())
            {
                if (obj.Any(pair => _drawed.Contains(pair.Value.Id)) is false)
                {
                    _drawed.Remove(x);
                }
            }
        }

        protected override void OnEnd()
        {
            root.TransitionState<Movement>();
        }

        public override void OnStateEntry(IState old)
        {
            base.OnStateEntry(old);
            if (_drawed.TryAdd(root.Item.Id))
            {
                PlayAnimation(nameof(BITConstant.Player.Draw));
                root.UnityEntity.Invoke(Constant.Animation.Play, BITConstant.Player.Draw);
            }
            else
            {
                PlayAnimation(nameof(BITConstant.Player.QuickDraw));
                root.UnityEntity.Invoke(Constant.Animation.Play, BITConstant.Player.QuickDraw);
            }
            _entityMovement.ExecuteCommand<PlayerPauseRunCommand>(new(this,true));
        }
        public override void OnStateExit(IState old, IState newState)
        {
            base.OnStateExit(old, newState);
            _entityMovement.ExecuteCommand<PlayerPauseRunCommand>(new(this,false));
        }
    }

    [System.Serializable]
    public sealed class Reload:GunState
    {
        [SerializeField] private GameObject reserveMagazine;
        public override void Initialize()
        {
            base.Initialize();
            if(reserveMagazine)
            reserveMagazine.SetActive(false);
        }

        protected override void OnEnd()
        {
            root.TransitionState<Movement>();
        }
        public override void OnStateEntry(IState old)
        {
            if(reserveMagazine)
            reserveMagazine.SetActive(true);
            base.OnStateEntry(old);
            
            _entityMovement.ExecuteCommand<PlayerPauseRunCommand>(new(this,true));

            if (root.RequireBolt)
            {
                root.UnityEntity.Invoke(Constant.Animation.Play, BITConstant.Player.BoltAction);
            }
            else
            {
                root.UnityEntity.Invoke(Constant.Animation.Play, BITConstant.Player.Reload);
            }
         
        }
        public override void OnMovementStateChanged(IEntityMovementState old, IEntityMovementState newState)
        {
            if (Enabled is false) return;
            if (newState is IPlayerRunState or IPlayerSprintState)
            {
                root.TransitionState<Movement>();
            }
        }

        public override void OnStateExit(IState old, IState newState)
        {
            root.RequireBolt = false;
            base.OnStateExit(old, newState);
            _entityMovement.ExecuteCommand<PlayerPauseRunCommand>(new(this,false));
            if(reserveMagazine)
            reserveMagazine.SetActive(false);
        }
    }
    [System.Serializable]
    public sealed class Melee : GunState
    {
        [SerializeField] private GameObject knife;
        private bool isKnife;

        public override void Initialize()
        {
            base.Initialize();
            if (knife)
                knife.gameObject.SetActive(false);
        }

        protected override void OnEnd()
        {
            root.TransitionState<Movement>();
        }

        public override void OnStateEntry(IState old)
        {
            if (root._equipmentContainer.Equipment.TryGetValue(new EquipmentAsThrow(), out var throwItem))
            {
                isKnife = throwItem.GetAssetable().TryGetProperty<AllowQuickKnife>(out _);
            }
            else
            {
                isKnife = false;
            }

            if (isKnife)
            {
                PlayAnimation("QuickKnife");
            }
            else
            {
                PlayAnimation();
            }

            if (knife && isKnife)
                knife.gameObject.SetActive(true);
            //base.OnStateEntry(old);


            root.UnityEntity.Invoke(Constant.Animation.Play, BITConstant.Player.Melee);
            _entityMovement.ExecuteCommand<PlayerPauseRunCommand>(new(this, true));

            _entityMovement.ExecuteCommand(new PlayerFocusCommand()
            {
                Focus = true,
                Sender = this
            });

            root.inputActionGroup.RegisterCallback(root.meleeAction, OnMelee);
        }

        public override void OnStateExit(IState old, IState newState)
        {
            base.OnStateExit(old, newState);
            _entityMovement.ExecuteCommand<PlayerPauseRunCommand>(new(this, false));

            root.inputActionGroup.UnRegisterCallback(root.meleeAction, OnMelee);

            _entityMovement.ExecuteCommand(new PlayerFocusCommand()
            {
                Focus = false,
                Sender = this
            });
            if (knife)
                knife.gameObject.SetActive(false);
        }

        private void OnMelee(InputAction.CallbackContext obj)
        {
            if (obj.performed is false) return;
            if (!(currentState.NormalizedTime > 0.5f)) return;
            currentState.Events.OnEnd = null;
            currentState.Stop();
            PlayAnimation();
        }
        public override void OnMovementStateChanged(IEntityMovementState old, IEntityMovementState newState)
        {
            if (Enabled is false) return;
            if (newState is IPlayerRunState or IPlayerSprintState)
            {
                root.TransitionState<Movement>();
            }
        }
    }

    [System.Serializable]
    public sealed class Climb:GunState
    {
        public override void OnStateEntry(IState old)
        {
            base.OnStateEntry(old);
            _entityMovement.ExecuteCommand<PlayerPauseRunCommand>(new(this,true));
        }
        public override void OnStateExit(IState old, IState newState)
        {
            base.OnStateExit(old, newState);
            _entityMovement.ExecuteCommand<PlayerPauseRunCommand>(new(this,false));
            currentState = null;
        }

        public override void OnMovementStateChanged(IEntityMovementState old, IEntityMovementState newState)
        {
            switch (newState)
            {
                case IPlayerClimbState:
                case IPlayerLinkState { LinkArea: 44 }:
                case IPlayerVaultState:
                    if (Enabled || currentState is not null)
                    {
                        currentState.Time = 0;
                        //currentState.Stop();
                        //PlayAnimation();
                    }
                    else
                    {
                        root.TransitionState<Climb>();
                    }
                    break;
                default:
                    if (Enabled)
                    {
                        root.TransitionState<Movement>();
                    }

                    break;

            }
        }
    }

    [System.Serializable]
    public sealed class Holster : GunState
    {
        protected override void OnEnd()
        {
            animancerComponent.Stop();
        }
    }
    [Serializable]
    public sealed class Tactics : GunState
    {
        public override void OnStateEntry(IState old)
        {
            base.OnStateEntry(old);
            _entityMovement.ExecuteCommand<PlayerPauseRunCommand>(new(this,true));
        }
        public override void OnStateExit(IState old, IState newState)
        {
            base.OnStateExit(old, newState);
            _entityMovement.ExecuteCommand<PlayerPauseRunCommand>(new(this,false));
        }
        protected override void OnEnd()
        {
            base.OnEnd();
            root.TransitionState<Movement>();
        }
    }
}