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

using System.Collections;
using System.Collections.Generic;
using System.Linq;
using Animancer;
using BITFALL.Entities.Equipment.Melee;
using BITFALL.Entities.Equipment.Universal.States;
using BITFALL.Entities.Inventory;
using BITFALL.Player.Inventory;
using BITKit;
using BITKit.Entities;
using BITKit.StateMachine;
using Cysharp.Threading.Tasks;
using UnityEngine;
using Draw = BITFALL.Entities.Equipment.Universal.States.Draw;

namespace BITFALL.Entities.Equipment.Universal
{
    public interface IUseState : IState
    {
    }

    public abstract class UseState : IUseState
    {
        [SerializeField] protected UniversalUseController useController;
        [SerializeField] protected AnimancerComponent animancerComponent;
        [SerializeField] protected AnimationClip[] clips;
        public virtual bool Enabled { get; set; }

        public virtual void Initialize()
        {

        }
        public virtual void OnStateEntry(IState old)
        {
            if (clips?.Length is 0) return;
            var clip = clips.Random();
            animancerComponent.Play(clip).Events.OnEnd=OnPlayEnd;
        }

        public virtual void OnStateUpdate(float deltaTime)
        {
        }

        public virtual void OnStateExit(IState old, IState newState)
        {
        }
        protected virtual void OnPlayEnd()
        {
        }
    }

    public class UniversalUseController : BITEquipBase<IUseState>
    {
        [SerializeField] private AnimancerComponent animancerComponent;
        [Inject] internal IPlayerInventory _playerInventory;
        [Inject] internal IPlayerEquipSelector _playerEquipSelector;
        [Inject] internal IEntityEquipmentContainer _equipmentContainer;
        public bool IClosed { get; set; }
        public override void OnAwake()
        {
            base.OnAwake();
            animancerComponent.Animator.enabled = false;
        }
        public override void Entry()
        {
            animancerComponent.Animator.enabled = true;
            base.Entry();
            TransitionState<Draw>();
        }
        public override void Exit()
        {
            base.Exit();
            TransitionState<Exit>();
        }

        public override async UniTask ExitAsync()
        {
            while (destroyCancellationToken.IsCancellationRequested is false)
            {
                if (animancerComponent.IsPlaying() is false)
                {
                    break;
                }
                if (destroyCancellationToken.IsCancellationRequested)
                {
                    break;
                }
                await UniTask.NextFrame();
            }
            await base.ExitAsync();
        }

        public override void Exited()
        {
            base.Exited();
            animancerComponent.Animator.enabled = false;
        }

        public override void AnimationEvent(string eventName)
        {
            base.AnimationEvent(eventName);

            switch (eventName)
            {
                case BITConstant.Player.Use when CurrentState is Use:
                    if (item.TryGetProperty<EquipmentAsSlot>(out var asSlot))
                    {
                        _equipmentContainer.TryUseEquip(asSlot.slot);
                    }
                    else
                    {
                        _inventory.UseItem(Item);
                    }
                    break;
            }
        }
    }
}