Cielonos/Assets/Scripts/MainGame/Items/Base/ItemBase.cs

using System;
using System.Collections.Generic;
using Cielonos.MainGame.Characters;
using Cielonos.MainGame.FunctionalAnimation;
using Sirenix.OdinInspector;
using SLSFramework.WwiseAssistance;
using SLSUtilities.FunctionalAnimation;
using UnityEngine;
using UnityEngine.Serialization;

namespace Cielonos.MainGame.Inventory
{
    public abstract partial class ItemBase : SerializedMonoBehaviour
    {
        public Player player => MainGameManager.Instance.player;
        protected PlayerAnimationSubcontroller animationSc => player.animationSc;
        protected FunctionalAnimationSubmodule fullBodyFuncAnimSm => animationSc.fullBodyFuncAnimSm;
        
        [Title("Data")]
        public List<FuncAnimData> fullBodyFuncAnims = new List<FuncAnimData>();
        [HideInInspector]
        private List<string> registeredFunctionNames = new List<string>();
        
        [FormerlySerializedAs("objectData")] 
        public ViewObjectData viewObjectData;
        public VFXData vfxData;
        public ComboData comboData;
        public AttackData attackData;
        public FunctionData functionData;
        public AmmoData ammoData;
        public BlockData blockData;
        
        [Title("Audio")]
        public AudioContainer audioContainer;
        
        [Title("Submodules")]
        public ComboSubmodule comboSm;
        public FunctionSubmodule functionSm;
        public AmmoSubmodule ammoSm;
        
        [Title("Subcontrollers")]
        public FeedbackSubcontroller feedbackSc;
        
        [Title("View Objects")]
        public Dictionary<string, ItemViewObject> viewObjects = new Dictionary<string, ItemViewObject>();
        
        protected virtual void Update()
        {
            functionSm?.Update(player.selfTimeSm.DeltaTime);
        }
    }

    public partial class ItemBase
    {
        public virtual void Initialize()
        {
            vfxData.Initialize(player);
            comboSm = new ComboSubmodule(this, comboData);
            functionSm = new FunctionSubmodule(this, functionData);
            ammoSm = new AmmoSubmodule(this, ammoData);
        }
    }

    public partial class ItemBase
    {
        protected RuntimeFuncAnim PlayTargetedAnimation(string animationName, CharacterBase target = null,
            float adsorptionMinDistance = 1f, bool autoRotate = true, 
            FunctionalAnimationSubmodule funcAnimSm = null,
            float animationSpeedMultiplier = 1f, float transitionDuration = 0.1f, bool isNormalizedTransition = false)
        {
            
            funcAnimSm ??= fullBodyFuncAnimSm;

            if (funcAnimSm.Play(animationName, animationSpeedMultiplier, transitionDuration, isNormalizedTransition))
            {
                float actionCoolDownTime = fullBodyFuncAnimSm.currentData.Interval(IntervalType.ActionDisruption).StartTime /
                                           fullBodyFuncAnimSm.currentPlaySpeedMultiplier;
                comboSm?.SuspendThenSetup(actionCoolDownTime);
                //GameManager.Player.eventController.GeneralAttackEvents.InvokeAllEvents();
                
                if (target != null)
                {
                    if(autoRotate) player.landMovementSc.TurnToTarget(target);
                    funcAnimSm.currentRuntimeFuncAnim.AddUpdateUntilEvent(new SetRootAdsorptionAdjustment(target, adsorptionMinDistance));
                }
                
                return funcAnimSm.currentRuntimeFuncAnim;
            }

            return null;
        }
    }

    public partial class ItemBase
    {
        public void RegisterFullBodyFuncAnims()
        {
            foreach (FuncAnimData funcAnim in fullBodyFuncAnims)
            {
                player.animationSc.fullBodyFuncAnimSm.Add(funcAnim);
            }
        }
        
        protected virtual void RegisterFunctionsToAnimSc(params Action[] functions)
        {
            foreach (Action function in functions)
            {
                string functionName = function.Method.Name;
                if (!player.animationSc.registeredFunctions.TryAdd(functionName, anim => function()))
                {
                    Debug.LogWarning($"Function {functionName} is already registered.");
                }
                else
                {
                    registeredFunctionNames.Add(functionName);
                }
            }
        }
        
        protected virtual void RegisterFunctionsToAnimSc(params Action<RuntimeFuncAnim>[] functions)
        {
            foreach (Action<RuntimeFuncAnim> function in functions)
            {
                string functionName = function.Method.Name;
                if (!player.animationSc.registeredFunctions.TryAdd(functionName, function))
                {
                    Debug.LogWarning($"Function {functionName} is already registered.");
                }
                else
                {
                    registeredFunctionNames.Add(functionName);
                }
            }
        }
        
        protected void RemoveAllRegisteredFunctions()
        {
            foreach (string functionName in registeredFunctionNames)
            {
                if (!player.animationSc.registeredFunctions.Remove(functionName))
                {
                    Debug.LogWarning($"Function {functionName} is not found.");
                }
            }
            registeredFunctionNames.Clear();
        }
        
        protected virtual void RemoveFunctionsFromAnimSc(params Action[] functions)
        {
            foreach (Action function in functions)
            {
                string functionName = function.Method.Name;
                if (!player.animationSc.registeredFunctions.Remove(functionName))
                {
                    Debug.LogWarning($"Function {functionName} is not found.");
                }
            }
        }
    }
}