com.alicizax.unity.framework/Runtime/Procedure/ProcedureModule.cs

using System;
using System.Collections.Generic;
using UnityEngine;

namespace AlicizaX
{
    internal class ProcedureModule : IProcedureModule
    {
        private readonly Dictionary<Type, IProcedure> _procedures = new Dictionary<Type, IProcedure>();
        private IProcedure _currentProcedure;
        private IProcedure _defaultProcedure;


        public void InitializeProcedure(List<IProcedure> availableProcedures, Type defaultProcedureType)
        {
            _procedures.Clear();
            foreach (var procedure in availableProcedures)
            {
                var type = procedure.GetType();
                _procedures[type] = procedure;
                procedure.ProcedureModule = this;
                procedure.Init();
            }

            if (_procedures.ContainsKey(defaultProcedureType))
            {
                _defaultProcedure = _procedures[defaultProcedureType];
                SwitchProcedure(defaultProcedureType);
            }
            else
            {
                Log.Info($"默认流程 {defaultProcedureType.Name} 未注册!");
            }
        }


        /// <summary>
        /// <summary>
        /// 清除所有流程
        /// </summary>
        public void ClearAllProcedures()
        {
            if (_procedures != null)
            {
                foreach (var procedure in _procedures.Values)
                {
                    procedure.Destroy();
                }

                _procedures.Clear();
            }

            _currentProcedure = null;
            _defaultProcedure = null;
        }

        public bool SwitchProcedure<T>() where T : IProcedure
        {
            if (HasProcedure<T>())
            {
                return SwitchProcedure(typeof(T));
            }

            if (_defaultProcedure != null)
            {
                Debug.LogWarning($"流程 {typeof(T).Name} 不存在，切换到默认流程");
                return SwitchToDefault();
            }

            return false;
        }


        public bool SwitchProcedure(Type procedureType)
        {
            var nextProcedure = _procedures[procedureType];
            var lastProcedure = _currentProcedure;

            if (lastProcedure == nextProcedure)
                return true;

            if (lastProcedure != null)
            {
                lastProcedure.Leave();
            }

            nextProcedure.Enter();
            _currentProcedure = nextProcedure;

            return true;
        }


        /// <summary>
        /// 切换到默认流程
        /// </summary>
        private bool SwitchToDefault()
        {
            if (_defaultProcedure != null)
            {
                return SwitchProcedure(_defaultProcedure.GetType());
            }

            return false;
        }


        /// <summary>
        /// 检查是否存在指定类型的流程
        /// </summary>
        private bool HasProcedure<T>() where T : IProcedure
        {
            return _procedures.ContainsKey(typeof(T));
        }


        void IModule.Dispose()
        {
            ClearAllProcedures();
        }

        public int Priority { get; }

        void IModuleUpdate.Update(float elapseSeconds, float realElapseSeconds)
        {
            if (_currentProcedure != null)
            {
                _currentProcedure.Update();
            }
        }
    }
}