BITFALL/Assets/BITKit/Unity/Scripts/Animator/UnityAnimator.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using UnityEngine;
using System.Threading;
using System.Threading.Tasks;
using Unity.Mathematics;

namespace BITKit.Animations
{
    public static class UnityAnimatorExtensions
    {
        public static AnimatorOverrideController CopyAndFillMissingContent(
            this AnimatorOverrideController originalOverrideController, AnimatorOverrideController runtimeController)
        {
            var newOverrideController = new AnimatorOverrideController(runtimeController)
            {
                runtimeAnimatorController = originalOverrideController.runtimeAnimatorController,
            };

            Dictionary<AnimationClip, AnimationClip> clips = new();
            List<KeyValuePair<AnimationClip, AnimationClip>> sourceClips = new();
            List<KeyValuePair<AnimationClip, AnimationClip>> destinationClips = new();
            
            originalOverrideController.GetOverrides(sourceClips);
            runtimeController.GetOverrides(destinationClips);

            List<KeyValuePair<AnimationClip, AnimationClip>> newClips = new();
            foreach (var VARIABLE in sourceClips)
            {
                if (VARIABLE.Key is not null && VARIABLE.Value is not null)
                    clips.TryAdd(VARIABLE.Key, VARIABLE.Value);
            }
            foreach (var VARIABLE in destinationClips)
            {
                if (VARIABLE.Key is not null)
                    clips.TryAdd(VARIABLE.Key, VARIABLE.Value);
            }
            
         

            // foreach (var VARIABLE in sourceClips)
            // {
            //     if (clips.TryGetValue(VARIABLE.Key, out var clip))
            //     {
            //         newClips.Add(new KeyValuePair<AnimationClip, AnimationClip>(clip, VARIABLE.Value));
            //     }
            // }

            newOverrideController.name = $"{originalOverrideController.name} Combine";
            newOverrideController.ApplyOverrides(
                clips.Select(x=>new KeyValuePair<AnimationClip,AnimationClip>(x.Key,x.Value)).ToList()
                );
            return newOverrideController;
        }
    }

    public class UnityAnimator : MonoBehaviour, IAnimator
    {
   


        [Serializable]
        public class AnimatorLayerInfo
        {
            public string LayerName;
            public string stateName;
            public string fullStateName;
            internal string entryName;
            public AnimatorStateInfo currentState = new();
            public event Action<string> onStateEnter;
            public event Action<string> onStateExit;
            public void OnStateEnter(string name)
            {
                onStateEnter?.Invoke(name);
            }
            public void OnStateExit(string name)
            {
                onStateExit?.Invoke(name);
            }
        }

        [Header(Constant.Header.Settings)]
        [SerializeField] private bool debug;
         
        [Header(Constant.Header.Components)]
        public Animator animator;
        public AnimatorLayerInfo this[int index]
        {
            get
            {
                if (layerInfos.Count <= index)
                {
                    for (int i = layerInfos.Count - 1; i < index; i++)
                    {
                        var newLayer = new AnimatorLayerInfo
                        {
                            LayerName = animator.GetLayerName(i+1)
                        };
                        layerInfos.Add(newLayer);
                    }
                }

                if (index > layerInfos.Count - 1)
                {
                    throw new Exception("Index out of range");
                }
                return layerInfos[index];
            }
        }
        [SerializeField] private List<AnimatorLayerInfo> layerInfos = new();
        [Header(Constant.Header.InternalVariables)]
        private readonly Dictionary<string,UnityAnimatorStateInfo> _registryStates=new ();

        private void OnEnable()
        {
            animator.enabled = true;
        }
        private void OnDisable()
        {
            animator.enabled = false;
            foreach (var x in layerInfos)
            {
                x.entryName = null;
            }
        }
        public void CrossFade(string animationName, float duration, int index = 0, float normalizedTimeOffset = 0)
        {
            animator.CrossFade(GetVariableName(animationName), duration, index, normalizedTimeOffset);
        }

        public void Play(string animationName, int index = -1, float normalizedTimeOffset = 0)
        {
            if (debug)
            {
                BIT4Log.Log<UnityAnimator>( $"{gameObject.name} Play:" + animationName);
            }
            animator.Play(GetVariableName(animationName), index, normalizedTimeOffset);
        }

        public void OnStateEnter(int index, string name)
        {
            if (debug)
            {
                BIT4Log.Log<UnityAnimator>($"OnEntry:{name}");
            }
            this[index].fullStateName = name;
            foreach (var item in name.Split("."))
            {
                name = item;
                break;
            }
            this[index].stateName = this[index].entryName = name;
            this[index].OnStateEnter(name);
        }
        public void OnStateExit(int index, string name)
        {
            if (string.IsNullOrEmpty(this[index].entryName))
            {
                return;
            }
            if (debug)
            {
                BIT4Log.Log<UnityAnimator>($"OnExit:{name}");
            }
            this[index].OnStateExit(name);
        }
        public float3 GetRootVelocity()
        {
            return animator.velocity;
        }

        private void Start()
        {
            foreach (var x in animator.GetBehaviours<UnityAnimatorStateInfo>())
            {
                try
                {
                    _registryStates.TryAdd(x.StateName, x);
                    foreach (var v in x.VariableNames)
                    {
                        _registryStates.TryAdd(v, x);
                    }
                }
                catch (Exception e)
                {
                    BIT4Log.Warning<UnityAnimator>(gameObject.name);
                    throw;
                }
              
            }
        }

        private void Update()
        {
            for (var i = 0; i < animator.layerCount; i++)
            {
                this[i].currentState = animator.GetCurrentAnimatorStateInfo(i);
            }
        }

        [ContextMenu(nameof(Diagnosis))]
        private void Diagnosis()
        {
          
        }

        private string GetVariableName(string animationName)
        {
            animationName = animationName.Replace(".", "_");

            if (!_registryStates.TryGetValue(animationName, out var stateInfo)) return animationName;
            
            animationName = stateInfo.StateName;
            if (stateInfo.VariableAnimationNames.Length > 0)
            {
                animationName = stateInfo.VariableAnimationNames.Random();
            }

            return animationName;
        }
    }
}