0312 修复随机说话显示

hch

2025-10-15 582cb3b6723a130f6029d3e7143ca8112c0d2c80

 Main/Component/UI/Common/FuncOpen.cs

@@ -4,250 +4,311 @@
using UnityEngine;
using LitJson;

    public class FuncOpen
    {
        private static FuncOpen _inst = null;
        public static FuncOpen Instance {
            get {
                if (_inst == null)
                {
                    _inst = new FuncOpen();
                }
                return _inst;
            }
        }

        protected FuncOpen()
        {
            if (Application.isEditor)
public class FuncOpen
{
    private static FuncOpen _inst = null;
    public static FuncOpen Instance {
        get {
            if (_inst == null)
            {
                if (!Application.isPlaying) return;
                _inst = new FuncOpen();
            }

            var allKeys = new List<int>(FuncOpenLVConfig.dic.Keys);//GetKeys();
            funcArray = new int[allKeys.Count];
            int _index = 0;
            foreach (var key in allKeys)
            {
                int func = key;
                funcOpenState[func] = false;
                funcArray[_index] = func;
                _index++;
            }

            DTC0102_tagCDBPlayer.beforePlayerDataInitializeEvent += BeforePlayerDataInitializeEvent;
            DTC0102_tagCDBPlayer.switchAccountEvent += SwitchAccountEvent;

            funcClientLVLimitDict.Clear();
            var jsonConfig = JsonMapper.ToObject(FuncConfigConfig.Get("FuncLevelLimitClient").Numerical1);
            foreach (var key in jsonConfig.Keys)
            {
                funcClientLVLimitDict[int.Parse(key)] = int.Parse(jsonConfig[key].ToString());
            }
        }

        private void BeforePlayerDataInitializeEvent()
        {
            for (int i = 0; i < funcArray.Length; i++)
            {
                funcOpenState[funcArray[i]] = false;
            }
        }

        private void SwitchAccountEvent()
        {
            for (int i = 0; i < funcArray.Length; i++)
            {
                funcOpenState[funcArray[i]] = false;
                if (OnFuncStateChangeEvent != null)
                {
                    OnFuncStateChangeEvent(funcArray[i]);
                }
            }
        }

        // TaskModel m_TaskModel;
        // TaskModel taskmodel { get { return m_TaskModel ?? (m_TaskModel = ModelCenter.Instance.GetModel<TaskModel>()); } }
        private static Dictionary<int, bool> funcOpenState = new Dictionary<int, bool>();
        private int[] funcArray;

        public event Action<int> OnFuncStateChangeEvent;

        //纯客户端的功能等级限制, key 以功能配置表的FuncLevelLimitClient为准
        //1. 精彩活动-全服红包显示等级
        public Dictionary<int, int> funcClientLVLimitDict = new Dictionary<int, int>();
        public bool IsClientLVLimit(int key)
        {
            if (!funcClientLVLimitDict.ContainsKey(key))
                return true;

            if (PlayerDatas.Instance.baseData.LV >= funcClientLVLimitDict[key])
                return true;

            return false;
        }


        public void UpdateFuncState(HA302_tagMCFuncOpenStateList vNetData)
        {
            for (int i = 0; i < vNetData.FuncCount; i++)
            {
                
                var funcState = vNetData.FuncStateList[i];

                bool bPerFuncIsOpen = false;
                bool bAfterFuncIsOpen = false;

                if (!funcOpenState.ContainsKey(funcState.FuncID))
                {
                    funcOpenState.Add(funcState.FuncID, funcState.State == 1);
                    bAfterFuncIsOpen = true;
                }
                else
                {
                    bPerFuncIsOpen = funcOpenState[funcState.FuncID];
                    funcOpenState[funcState.FuncID] = funcState.State == 1;
                    bAfterFuncIsOpen = funcOpenState[funcState.FuncID];
                }
                if (OnFuncStateChangeEvent != null)
                {
                    OnFuncStateChangeEvent(funcState.FuncID);
                }
            }
        }

        private bool IsFuncOpen(int key, out int errorCode)
        {
            
            errorCode = 0;
            var config = FuncOpenLVConfig.Get(key);
            if (config == null)
            {
                return false;
            }
            // if (config.LimitMagicWeapon > 0)
            // {
            //     Treasure treasure = null;
            //     var _stage = config.LimitMagicWeapon % 100;
            //     ModelCenter.Instance.GetModel<TreasureModel>().TryGetTreasure(config.LimitMagicWeapon / 100, out treasure);
            //     if (treasure == null || treasure.state != TreasureState.Collected || treasure.level < _stage)
            //     {
            //         errorCode = 2;
            //         return false;
            //     }
            // }
            // if (config.LimitMissionID > 0)
            // {
                // MissionDetailDates missionDetailDates = null;
                // taskmodel.allMissionDict.TryGetValue(config.LimitMissionID, out missionDetailDates);
                // if (missionDetailDates == null || missionDetailDates.MissionState != 3)
                // {
                    // errorCode = 4;
                    // return false;
                // }
            // }
            // if (config.LimiRealmLV > 0 && PlayerDatas.Instance.baseData.realmLevel < config.LimiRealmLV)
            // {
            //     errorCode = 3;
            //     return false;
            // }
            if (config.LimitLV > 0 && PlayerDatas.Instance.baseData.LV < config.LimitLV)
            {
                errorCode = 1;
                return false;
            }
            return true;
            // return false;
        }

        public bool IsFuncOpen(int key, bool tip = false)
        {
            bool isOpen = false;
            if (funcOpenState.ContainsKey(key))
                isOpen = funcOpenState[key];
            if (!isOpen && tip)
                ProcessorFuncErrorTip(key);
            return isOpen;
        }

        public void ProcessorFuncErrorTip(int key)
        {
            var config = FuncOpenLVConfig.Get(key);
            if (config != null)
            {
                SoundPlayer.Instance.PlayUIAudio(SoundPlayer.defaultClickNegativeAudio);
                if (config.Tip.Equals("FuncLimit_Level"))
                {
                    SysNotifyMgr.Instance.ShowTip(config.Tip);
                    return;
                }
                var errorCode = 0;
                if (!IsFuncOpen(key, out errorCode))
                {
                    switch (errorCode)
                    {
                        case 1:
                            SysNotifyMgr.Instance.ShowTip(config.Tip, Language.Get("OpenFunc4", config.LimitLV));
                            break;
                        //  TODO YYL
                        // case 2:
                        //     var treasureConfig = TreasureConfig.Get(config.LimitMagicWeapon / 100);
                        //     SysNotifyMgr.Instance.ShowTip(config.Tip, Language.Get("OpenFunc1", treasureConfig != null ? treasureConfig.Name : string.Empty));
                        //     break;
                        // case 3:
                        //     SysNotifyMgr.Instance.ShowTip(config.Tip, UIHelper.GetRealmName(config.LimiRealmLV, true));
                        //     break;
                        case 4:
                            if (config.LimitLV > 0)
                            {
                                SysNotifyMgr.Instance.ShowTip(config.Tip, Language.Get("OpenFunc2", config.LimitLV));
                            }
                            else
                            {
                                SysNotifyMgr.Instance.ShowTip(config.Tip, Language.Get("OpenFunc3"));
                            }
                            break;
                    }
                }
            }
        }

        public int GetLimitLv(int key)
        {
            // FuncOpenLVConfig tagFuncOpenLVModel = FuncOpenLVConfig.Get(key);
            // if (tagFuncOpenLVModel.LimitLV != 0)
            // {
            //     return tagFuncOpenLVModel.LimitLV;
            // }
            // if (tagFuncOpenLVModel.LimitMissionID != 0)
            // {
            //     var TaskConfig = PyTaskConfig.Get(tagFuncOpenLVModel.LimitMissionID);
            //     return TaskConfig.lv;
            // }

            return 1;
        }

        Dictionary<int, ICheckFuncOpen> m_CheckFuncDict = new Dictionary<int, ICheckFuncOpen>();
        public void Register(int _key, ICheckFuncOpen _check)
        {
            if (!m_CheckFuncDict.ContainsKey(_key))
            {
                m_CheckFuncDict.Add(_key, _check);
            }
        }

        public bool CheckFuncOpen(int _key)
        {
            if (m_CheckFuncDict.ContainsKey(_key))
            {
                return m_CheckFuncDict[_key].CheckFunc();
            }
            return true;
            return _inst;
        }
    }

    public interface ICheckFuncOpen
    protected FuncOpen()
    {
        bool CheckFunc();
    }
        if (Application.isEditor)
        {
            if (!Application.isPlaying) return;
        }

        var allKeys = new List<int>(FuncOpenLVConfig.dic.Keys);//GetKeys();
        funcArray = new int[allKeys.Count];
        int _index = 0;
        foreach (var key in allKeys)
        {
            int func = key;
            funcOpenState[func] = false;
            funcArray[_index] = func;
            _index++;
        }

        DTC0102_tagCDBPlayer.beforePlayerDataInitializeEvent += BeforePlayerDataInitializeEvent;
        DTC0102_tagCDBPlayer.switchAccountEvent += SwitchAccountEvent;

        funcClientLVLimitDict.Clear();
        var jsonConfig = JsonMapper.ToObject(FuncConfigConfig.Get("FuncLevelLimitClient").Numerical1);
        foreach (var key in jsonConfig.Keys)
        {
            funcClientLVLimitDict[int.Parse(key)] = int.Parse(jsonConfig[key].ToString());
        }
    }

    private void BeforePlayerDataInitializeEvent()
    {
        for (int i = 0; i < funcArray.Length; i++)
        {
            funcOpenState[funcArray[i]] = false;
        }
    }

    private void SwitchAccountEvent()
    {
        for (int i = 0; i < funcArray.Length; i++)
        {
            funcOpenState[funcArray[i]] = false;
            if (OnFuncStateChangeEvent != null)
            {
                OnFuncStateChangeEvent(funcArray[i]);
            }
        }
    }

    // TaskModel m_TaskModel;
    // TaskModel taskmodel { get { return m_TaskModel ?? (m_TaskModel = ModelCenter.Instance.GetModel<TaskModel>()); } }
    private static Dictionary<int, bool> funcOpenState = new Dictionary<int, bool>();
    private int[] funcArray;

    public event Action<int> OnFuncStateChangeEvent;

    //纯客户端的功能等级限制, key 以功能配置表的FuncLevelLimitClient为准
    //1. 精彩活动-全服红包显示等级
    public Dictionary<int, int> funcClientLVLimitDict = new Dictionary<int, int>();
    public bool IsClientLVLimit(int key)
    {
        if (!funcClientLVLimitDict.ContainsKey(key))
            return true;

        if (PlayerDatas.Instance.baseData.LV >= funcClientLVLimitDict[key])
            return true;

        return false;
    }


    public void UpdateFuncState(HA302_tagMCFuncOpenStateList vNetData)
    {
        for (int i = 0; i < vNetData.FuncCount; i++)
        {
            
            var funcState = vNetData.FuncStateList[i];

            bool bPerFuncIsOpen = false;
            bool bAfterFuncIsOpen = false;

            if (!funcOpenState.ContainsKey(funcState.FuncID))
            {
                funcOpenState.Add(funcState.FuncID, funcState.State == 1);
                bAfterFuncIsOpen = true;
            }
            else
            {
                bPerFuncIsOpen = funcOpenState[funcState.FuncID];
                funcOpenState[funcState.FuncID] = funcState.State == 1;
                bAfterFuncIsOpen = funcOpenState[funcState.FuncID];
            }
            if (OnFuncStateChangeEvent != null)
            {
                OnFuncStateChangeEvent(funcState.FuncID);
            }
        }
    }

    private bool IsFuncOpen(int key, out int errorCode)
    {
        
        errorCode = 0;
        var config = FuncOpenLVConfig.Get(key);
        if (config == null)
        {
            return false;
        }

        if (config.OpenDay > 0)
        {
            if (config.OpenDay > TimeUtility.OpenDay + 1)
            { 
                errorCode = 2;
                return false;
            }
        }

        if (config.LimitMissionID > 0)
        {

            if (TaskManager.Instance.GetNeedFinishTaskCount(config.LimitMissionID) > 0)
            {
                errorCode = 4;
                return false;
            }
        }
        if (config.LimiRealmLV > 0 && PlayerDatas.Instance.baseData.realmLevel < config.LimiRealmLV)
        {
            errorCode = 3;
            return false;
        }
        if (config.LimitLV > 0 && PlayerDatas.Instance.baseData.LV < config.LimitLV)
        {
            errorCode = 1;
            return false;
        }
        return true;
        // return false;
    }

    public bool IsFuncOpen(int key, bool tip = false)
    {
        bool isOpen = false;
        if (funcOpenState.ContainsKey(key))
            isOpen = funcOpenState[key];
        if (!isOpen && tip)
            ProcessorFuncErrorTip(key);
        return isOpen;
    }

    public void ProcessorFuncErrorTip(int key)
    {
        var config = FuncOpenLVConfig.Get(key);
        if (config != null)
        {
            SoundPlayer.Instance.PlayUIAudio(SoundPlayer.defaultClickNegativeAudio);

            var errorCode = 0;
            if (!IsFuncOpen(key, out errorCode))
            {
                switch (errorCode)
                {
                    case 1:
                        SysNotifyMgr.Instance.ShowStringTip(Language.Get("FuncLimit_Level", config.LimitLV)
                        + Language.Get("FuncLimitOpen1"));
                        break;
                    case 2:
                        //开服多少天 一般是组合
                        if (config.LimitLV != 0)
                        {
                            SysNotifyMgr.Instance.ShowStringTip(Language.Get("FuncLimit_OpenDay", config.OpenDay)
                             + Language.Get("FuncLimitOpen2")
                             + Language.Get("FuncLimit_Level", config.LimitLV)
                             + Language.Get("FuncLimitOpen1"));

                        }
                        else if (config.LimitMissionID != 0)
                        { 
                            SysNotifyMgr.Instance.ShowStringTip(Language.Get("FuncLimit_OpenDay", config.OpenDay)
                             + Language.Get("FuncLimitOpen2")
                             + Language.Get("FuncLimit_Mission", TaskManager.Instance.GetNeedFinishTaskCount(config.LimitMissionID))
                             + Language.Get("FuncLimitOpen1"));
                        }
                        else
                        {
                            SysNotifyMgr.Instance.ShowStringTip(Language.Get("FuncLimit_OpenDay", config.OpenDay)
                             + Language.Get("FuncLimitOpen1"));
                        }
                        break;
                    case 3:
                        SysNotifyMgr.Instance.ShowStringTip(Language.Get("FuncLimit_Realm", RealmConfig.Get(config.LimiRealmLV).Name)
                         + Language.Get("FuncLimitOpen1"));
                        break;
                    case 4:
                        SysNotifyMgr.Instance.ShowStringTip(Language.Get("FuncLimit_Mission", TaskManager.Instance.GetNeedFinishTaskCount(config.LimitMissionID))
                         + Language.Get("FuncLimitOpen1"));
                        break;
                }
            }
        }
    }


    public string GetErrorTip(int key)
    {
        if (!FuncOpenLVConfig.HasKey(key))
            return string.Empty;
        FuncOpenLVConfig config = FuncOpenLVConfig.Get(key);
        if (!IsFuncOpen(key, out int errorCode))
        {
            switch (errorCode)
            {
                case 1:
                    return StringUtility.Contact(
                        Language.Get("FuncLimit_Level", config.LimitLV),
                        Language.Get("FuncLimitOpen1"));
                case 2:
                    //开服多少天 一般是组合
                    if (config.LimitLV != 0)
                    {
                        return StringUtility.Contact(
                            Language.Get("FuncLimit_OpenDay", config.OpenDay),
                            Language.Get("FuncLimitOpen2"),
                        Language.Get("FuncLimit_Level", config.LimitLV),
                        Language.Get("FuncLimitOpen1"));

                    }
                    else if (config.LimitMissionID != 0)
                    {
                        return StringUtility.Contact(
                            Language.Get("FuncLimit_OpenDay", config.OpenDay),
                            Language.Get("FuncLimitOpen2"),
                        Language.Get("FuncLimit_Mission",
                        TaskManager.Instance.GetNeedFinishTaskCount(config.LimitMissionID)),
                        Language.Get("FuncLimitOpen1"));
                    }
                    else
                    {
                        return StringUtility.Contact(
                            Language.Get("FuncLimit_OpenDay", config.OpenDay),
                            Language.Get("FuncLimitOpen1"));
                    }
                case 3:
                    return StringUtility.Contact(
                            Language.Get("FuncLimit_Realm", RealmConfig.Get(config.LimiRealmLV).Name),
                            Language.Get("FuncLimitOpen1"));
                case 4:
                    return StringUtility.Contact(
                            Language.Get("FuncLimit_Mission", TaskManager.Instance.GetNeedFinishTaskCount(config.LimitMissionID)),
                            Language.Get("FuncLimitOpen1"));
            }
        }
        return string.Empty;
    }

    public int GetLimitLv(int key)
    {
        // FuncOpenLVConfig tagFuncOpenLVModel = FuncOpenLVConfig.Get(key);
        // if (tagFuncOpenLVModel.LimitLV != 0)
        // {
        //     return tagFuncOpenLVModel.LimitLV;
        // }
        // if (tagFuncOpenLVModel.LimitMissionID != 0)
        // {
        //     var TaskConfig = PyTaskConfig.Get(tagFuncOpenLVModel.LimitMissionID);
        //     return TaskConfig.lv;
        // }

        return 1;
    }

    Dictionary<int, ICheckFuncOpen> m_CheckFuncDict = new Dictionary<int, ICheckFuncOpen>();
    public void Register(int _key, ICheckFuncOpen _check)
    {
        if (!m_CheckFuncDict.ContainsKey(_key))
        {
            m_CheckFuncDict.Add(_key, _check);
        }
    }

    public bool CheckFuncOpen(int _key)
    {
        if (m_CheckFuncDict.ContainsKey(_key))
        {
            return m_CheckFuncDict[_key].CheckFunc();
        }
        return true;
    }
}

public interface ICheckFuncOpen
{
    bool CheckFunc();
}