using System; 
 | 
using System.Collections; 
 | 
using System.Collections.Generic; 
 | 
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) 
 | 
        { 
 | 
            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(); 
 | 
} 
 |