NLDClient-yudde/ProjectNLD/Assets/Code/Scripts/Framework/Condition/ConditionManager.cs

using System;
using System.Collections.Generic;
using System.Reflection;
using cfg;
using cfg.ActorCfg;
using PhxhSDK;
using Utils;
using static Framework.EventManager;

namespace Framework.Condition
{
    public interface ICondition
    {
        public EventName SignalName { get; }

        bool Check(List<float> args);
    }


    public sealed class ConditionManager : Singlenton<ConditionManager>, IInitable
    {
        private const string CONDITION_PREFIX = "Condition";
        private const string CONDITION_DESC_PREFIX = "condition_desc_";

        //避免GC
        private List<float> _tempConditionArgs = new();

        private ICondition[] m_conditions;

        #region MainLife

        public void Init()
        {
            m_conditions = new ICondition[(int)ConditionType.Max];
            for (int i = 1; i < (int)ConditionType.Max; i++)
            {
                if (Enum.IsDefined(typeof(ConditionType), i))
                {
                    var conditionType = ((ConditionType)i).ToString();
                    var typeName = CONDITION_PREFIX + conditionType;
                    var type = CommonUtilsFramework.GamePlayAssembly.GetType(typeName);
                    if (type == null)
                    {
                        DebugUtil.LogError("Cant find Type,name:{0}", typeName);
                        continue;
                    }

                    if (Activator.CreateInstance(type) is ICondition condition)
                    {
                        m_conditions[i] = condition;
                    }
                    else
                    {
                        DebugUtil.LogError($"cant construct condition,type:{type},please check if your type is correctly implement ICondition");
                    }
                }
            }
        }

        public void Release()
        {
            m_conditions = null;
            _tempConditionArgs = null;
        }

        #endregion

        #region API

        public bool CheckCondition(int conditionID)
        {
            var conditionCfg = GetConditionCfg(conditionID);
            GetConditionCfgArgs(conditionCfg, ref _tempConditionArgs);
            return CheckCondition(conditionCfg.Type, _tempConditionArgs);
        }

        public bool CheckCondition(int[] conditionGroup, bool useAnd = true)
        {
            foreach (var conditionID in conditionGroup)
            {
                var isSuccess = CheckCondition(conditionID);
                if (useAnd)
                {
                    if (!isSuccess)
                    {
                        return false;
                    }
                }
                else
                {
                    if (isSuccess)
                        return true;
                }
            }

            return useAnd;
        }

        public bool CheckCondition(ConditionType conditionType, List<float> conditionArg)
        {
            if (m_conditions[(int)conditionType] == null)
            {
                throw new Exception(
                    $"condition type is outside of range!condition type:{(int)conditionType}");
            }

            return m_conditions[(int)conditionType].Check(conditionArg);
        }

        public EventName GetConditionSignal(int conditionID)
        {
            var conditionCfg = GetConditionCfg(conditionID);
            if (conditionCfg != null)
            {
                return GetConditionSignal(conditionCfg.Type);
            }

            DebugUtil.LogError($"cant find condition!conditionID:{conditionID}");
            return EventName.None;
        }

        public EventName GetConditionSignal(ConditionType conditionType)
        {
            var condition = GetConditionByType(conditionType);
            if (condition != null)
            {
                return condition.SignalName;
            }

            DebugUtil.LogError($"cant find condition!conditionType:{conditionType}");
            return EventName.None;
        }

        public string GetConditionLocalization(int conditionID)
        {
            var conditionCfg = GetConditionCfg(conditionID);
            if (conditionCfg != null)
            {
                GetConditionCfgArgs(conditionCfg, ref _tempConditionArgs);
                return GetConditionLocalization(conditionCfg.Type, _tempConditionArgs);
            }

            DebugUtil.LogError($"cant find condition!conditionID:{conditionID}");
            return null;
        }

        public string GetConditionLocalization(ConditionType conditionType, List<float> args)
        {
            var key = CONDITION_DESC_PREFIX + conditionType;
            return StringManager.Instance.GetLocalizeTextByKeyAndList(key, args);
        }

        #endregion

        #region InnerFunction

        private DataCondition GetConditionCfg(int conditionID)
        {
            return TableManager.Instance.Tables.ConditionConfig.Get((int)conditionID);
        }

        private ICondition GetConditionByType(ConditionType conditionType)
        {
            var index = (int)conditionType;
            if (index < 0 || index >= m_conditions.Length)
            {
                DebugUtil.LogError("cant find condition!");
                return null;
            }

            return m_conditions[index];
        }

        private void GetConditionCfgArgs(DataCondition conditionCfg, ref List<float> _args)
        {
            _args.Clear();
            _args.Add(conditionCfg.Param1);
            _args.Add(conditionCfg.Param2);
            _args.Add(conditionCfg.Param3);
        }

        #endregion
    }
}