9938 子 【BT0.1】【主干】装备升星修改 / 【BT0.1】【主干】装备升星修改

hch

2023-10-18 d56e0ca7cc8f85d09d16a526deb43a22654748e3

9938 子 【BT0.1】【主干】装备升星修改 / 【BT0.1】【主干】装备升星修改

 Core/GameEngine/Model/Config/EquipStarConfig.cs

@@ -1,256 +1,260 @@
//--------------------------------------------------------
//    [Author]:           Fish
//    [  Date ]:           Wednesday, July 17, 2019
//--------------------------------------------------------

using System.Collections.Generic;
using System.IO;
using System.Threading;
using System;
using UnityEngine;


public partial class EquipStarConfig
{

    public readonly int ID;
    public readonly int Level;
    public readonly int EquipPlace;
    public readonly int Star;
    public readonly int[] CostEquipPlace;
    public readonly int IsJobLimit;
    public readonly int[] CostEquipColor;
    public readonly int CostEquipCnt;
    public readonly int UnSuitRate;
    public readonly int SuitRate;
    public readonly Int2 CostItemDict;
    public readonly Int2[] StarAttrInfo;
    public readonly Int2[] BaseAttrInfo;

    public EquipStarConfig()
    {
    }

    public EquipStarConfig(string input)
    {
        try
        {
            var tables = input.Split('\t');

            int.TryParse(tables[0],out ID); 

            int.TryParse(tables[1],out Level); 

            int.TryParse(tables[2],out EquipPlace); 

            int.TryParse(tables[3],out Star); 

//--------------------------------------------------------

//    [Author]:           Fish

//    [  Date ]:           2023年10月18日

//--------------------------------------------------------



using System.Collections.Generic;

using System.IO;

using System.Threading;

using System;

using UnityEngine;



public partial class EquipStarConfig

{



    public readonly int ID;

    public readonly int Level;

    public readonly int EquipPlace;

    public readonly int Star;

    public readonly int[] CostEquipPlace;

    public readonly int IsJobLimit;

    public readonly int[] CostEquipColor;

    public readonly int CostEquipCnt;

    public readonly int UnSuitRate;

    public readonly int SuitRate;

    public readonly Int2[] CostItemDict;

    public readonly Int2[] StarAttrInfo;

    public readonly Int2[] BaseAttrInfo;



    public EquipStarConfig()

    {

    }



    public EquipStarConfig(string input)

    {

        try

        {

            var tables = input.Split('\t');



            int.TryParse(tables[0],out ID); 


            int.TryParse(tables[1],out Level); 


            int.TryParse(tables[2],out EquipPlace); 


            int.TryParse(tables[3],out Star); 


            string[] CostEquipPlaceStringArray = tables[4].Trim().Split(StringUtility.splitSeparator,StringSplitOptions.RemoveEmptyEntries);
            CostEquipPlace = new int[CostEquipPlaceStringArray.Length];
            for (int i=0;i<CostEquipPlaceStringArray.Length;i++)
            {
                 int.TryParse(CostEquipPlaceStringArray[i],out CostEquipPlace[i]);
            }

            int.TryParse(tables[5],out IsJobLimit); 

            }



            int.TryParse(tables[5],out IsJobLimit); 


            string[] CostEquipColorStringArray = tables[6].Trim().Split(StringUtility.splitSeparator,StringSplitOptions.RemoveEmptyEntries);
            CostEquipColor = new int[CostEquipColorStringArray.Length];
            for (int i=0;i<CostEquipColorStringArray.Length;i++)
            {
                 int.TryParse(CostEquipColorStringArray[i],out CostEquipColor[i]);
            }

            int.TryParse(tables[7],out CostEquipCnt); 

            int.TryParse(tables[8],out UnSuitRate); 

            int.TryParse(tables[9],out SuitRate); 

            Int2.TryParse(tables[10],out CostItemDict); 

            }



            int.TryParse(tables[7],out CostEquipCnt); 


            int.TryParse(tables[8],out UnSuitRate); 


            int.TryParse(tables[9],out SuitRate); 


            string[] CostItemDictStringArray = tables[10].Trim().Split(StringUtility.splitSeparator,StringSplitOptions.RemoveEmptyEntries);
            CostItemDict = new Int2[CostItemDictStringArray.Length];
            for (int i=0;i<CostItemDictStringArray.Length;i++)
            {
                 Int2.TryParse(CostItemDictStringArray[i],out CostItemDict[i]);
            }



            string[] StarAttrInfoStringArray = tables[11].Trim().Split(StringUtility.splitSeparator,StringSplitOptions.RemoveEmptyEntries);
            StarAttrInfo = new Int2[StarAttrInfoStringArray.Length];
            for (int i=0;i<StarAttrInfoStringArray.Length;i++)
            {
                 Int2.TryParse(StarAttrInfoStringArray[i],out StarAttrInfo[i]);
            }

            }



            string[] BaseAttrInfoStringArray = tables[12].Trim().Split(StringUtility.splitSeparator,StringSplitOptions.RemoveEmptyEntries);
            BaseAttrInfo = new Int2[BaseAttrInfoStringArray.Length];
            for (int i=0;i<BaseAttrInfoStringArray.Length;i++)
            {
                 Int2.TryParse(BaseAttrInfoStringArray[i],out BaseAttrInfo[i]);
            }
        }
        catch (Exception ex)
        {
            DebugEx.Log(ex);
        }
    }

    static Dictionary<string, EquipStarConfig> configs = new Dictionary<string, EquipStarConfig>();
    public static EquipStarConfig Get(string id)
    {   
        if (!inited)
        {
            Debug.Log("EquipStarConfig 还未完成初始化。");
            return null;
        }
		
        if (configs.ContainsKey(id))
        {
            return configs[id];
        }

        EquipStarConfig config = null;
        if (rawDatas.ContainsKey(id))
        {
            config = configs[id] = new EquipStarConfig(rawDatas[id]);
            rawDatas.Remove(id);
        }

        return config;
    }

    public static EquipStarConfig Get(int id)
    {
        return Get(id.ToString());
    }

    public static List<string> GetKeys()
    {
        var keys = new List<string>();
        keys.AddRange(configs.Keys);
        keys.AddRange(rawDatas.Keys);
        return keys;
    }

    public static List<EquipStarConfig> GetValues()
    {
        var values = new List<EquipStarConfig>();
        values.AddRange(configs.Values);

        var keys = new List<string>(rawDatas.Keys);
        foreach (var key in keys)
        {
            values.Add(Get(key));
        }

        return values;
    }

    public static bool Has(string id)
    {
        return configs.ContainsKey(id) || rawDatas.ContainsKey(id);
    }

    public static bool Has(int id)
    {
        return Has(id.ToString());
    }

    public static bool inited { get; private set; }
    protected static Dictionary<string, string> rawDatas = new Dictionary<string, string>();
    public static void Init(bool sync=false)
    {
        inited = false;
        var path = string.Empty;
        if (AssetSource.refdataFromEditor)
        {
            path = ResourcesPath.CONFIG_FODLER +"/EquipStar.txt";
        }
        else
        {
            path = AssetVersionUtility.GetAssetFilePath("config/EquipStar.txt");
        }

        configs.Clear();
        var tempConfig = new EquipStarConfig();
        var preParse = tempConfig is IConfigPostProcess;

        if (sync)
        {
            var lines = File.ReadAllLines(path);
            if (!preParse)
            {
                rawDatas = new Dictionary<string, string>(lines.Length - 3);
            }
            for (int i = 3; i < lines.Length; i++)
            {
                try 
                {
                    var line = lines[i];
                    var index = line.IndexOf("\t");
                    if (index == -1)
                    {
                        continue;
                    }
                    var id = line.Substring(0, index);

                    if (preParse)
                    {
                        var config = new EquipStarConfig(line);
                        configs[id] = config;
                        (config as IConfigPostProcess).OnConfigParseCompleted();
                    }
                    else
                    {
                        rawDatas[id] = line;
                    }
                }
                catch (System.Exception ex)
                {
                    Debug.LogError(ex);
                }
            }
            inited = true;
        }
        else
        {
            ThreadPool.QueueUserWorkItem((object _object) =>
            {
                var lines = File.ReadAllLines(path);
                if (!preParse)
                {
                    rawDatas = new Dictionary<string, string>(lines.Length - 3);
                }
                for (int i = 3; i < lines.Length; i++)
                {
                    try 
                    {
                       var line = lines[i];
                        var index = line.IndexOf("\t");
                        if (index == -1)
                        {
                            continue;
                        }
                        var id = line.Substring(0, index);

                        if (preParse)
                        {
                            var config = new EquipStarConfig(line);
                            configs[id] = config;
                            (config as IConfigPostProcess).OnConfigParseCompleted();
                        }
                        else
                        {
                            rawDatas[id] = line;
                        }
                    }
                    catch (System.Exception ex)
                    {
                        Debug.LogError(ex);
                    }
                }

                inited = true;
            });
        }
    }

}




            }

        }

        catch (Exception ex)

        {

            DebugEx.Log(ex);

        }

    }



    static Dictionary<string, EquipStarConfig> configs = new Dictionary<string, EquipStarConfig>();

    public static EquipStarConfig Get(string id)

    {   
        if (!inited)

        {

            Debug.Log("EquipStarConfig 还未完成初始化。");

            return null;

        }

		
        if (configs.ContainsKey(id))

        {

            return configs[id];

        }



        EquipStarConfig config = null;

        if (rawDatas.ContainsKey(id))

        {

            config = configs[id] = new EquipStarConfig(rawDatas[id]);

            rawDatas.Remove(id);

        }



        return config;

    }



    public static EquipStarConfig Get(int id)

    {

        return Get(id.ToString());

    }



    public static List<string> GetKeys()

    {

        var keys = new List<string>();

        keys.AddRange(configs.Keys);

        keys.AddRange(rawDatas.Keys);

        return keys;

    }



    public static List<EquipStarConfig> GetValues()

    {

        var values = new List<EquipStarConfig>();

        values.AddRange(configs.Values);



        var keys = new List<string>(rawDatas.Keys);

        for (int i = 0; i < keys.Count; i++)

        {

            values.Add(Get(keys[i]));

        }



        return values;

    }



    public static bool Has(string id)

    {

        return configs.ContainsKey(id) || rawDatas.ContainsKey(id);

    }



    public static bool Has(int id)

    {

        return Has(id.ToString());

    }



    public static bool inited { get; private set; }

    protected static Dictionary<string, string> rawDatas = new Dictionary<string, string>();

    public static void Init(bool sync=false)

    {

        inited = false;

        var path = string.Empty;

        if (AssetSource.refdataFromEditor)

        {

            path = ResourcesPath.CONFIG_FODLER +"/EquipStar.txt";

        }

        else

        {

            path = AssetVersionUtility.GetAssetFilePath("config/EquipStar.txt");

        }



        configs.Clear();

        var tempConfig = new EquipStarConfig();

        var preParse = tempConfig is IConfigPostProcess;



        if (sync)

        {

            var lines = File.ReadAllLines(path);

            if (!preParse)

            {

                rawDatas = new Dictionary<string, string>(lines.Length - 3);

            }

            for (int i = 3; i < lines.Length; i++)

            {

                try 
                {

                    var line = lines[i];

                    var index = line.IndexOf("\t");

                    if (index == -1)

                    {

                        continue;

                    }

                    var id = line.Substring(0, index);



                    if (preParse)

                    {

                        var config = new EquipStarConfig(line);

                        configs[id] = config;

                        (config as IConfigPostProcess).OnConfigParseCompleted();

                    }

                    else

                    {

                        rawDatas[id] = line;

                    }

                }

                catch (System.Exception ex)

                {

                    Debug.LogError(ex);

                }

            }

            inited = true;

        }

        else

        {

            ThreadPool.QueueUserWorkItem((object _object) =>

            {

                var lines = File.ReadAllLines(path);

                if (!preParse)

                {

                    rawDatas = new Dictionary<string, string>(lines.Length - 3);

                }

                for (int i = 3; i < lines.Length; i++)

                {

                    try 
                    {

                       var line = lines[i];

                        var index = line.IndexOf("\t");

                        if (index == -1)

                        {

                            continue;

                        }

                        var id = line.Substring(0, index);



                        if (preParse)

                        {

                            var config = new EquipStarConfig(line);

                            configs[id] = config;

                            (config as IConfigPostProcess).OnConfigParseCompleted();

                        }

                        else

                        {

                            rawDatas[id] = line;

                        }

                    }

                    catch (System.Exception ex)

                    {

                        Debug.LogError(ex);

                    }

                }



                inited = true;

            });

        }

    }



}










 Core/GameEngine/Model/Config/EquipStarConfig.cs.meta

@@ -1,8 +1,7 @@
fileFormatVersion: 2
guid: 1cb3a1eef8413e8449c98c1761d313d1
timeCreated: 1563348131
licenseType: Pro
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0

 System/Equip/EquipModel.cs

@@ -190,10 +190,9 @@

        public int GetSuitRepoindStar(int level)
        {
            var StarList = new List<int> { 0, 3, 6, 9 };
            var equipSet = GetEquipSet(level);
            int i = 0;
            foreach (int star in StarList)
            foreach (int star in EquipStarModel.StarList)
            {
                if (equipSet.suitRepoints[star].state == RedPointState.Simple)
                    return i;

 System/Equip/EquipSet.cs

@@ -37,10 +37,10 @@

            redpoint = new Redpoint(MainRedDot.RedPoint_BagFuncKey, 200100 + this.level);
            SuiteBtnRedpoint = new Redpoint(200100 + this.level, 6560 + this.level); //装备界面的 套装按钮
            suitRepoints[0] = new Redpoint(6560 + this.level, (200100 + this.level) * 100 + 0);
            suitRepoints[3] = new Redpoint(6560 + this.level, (200100 + this.level) * 100 + 3);
            suitRepoints[6] = new Redpoint(6560 + this.level, (200100 + this.level) * 100 + 6);
            suitRepoints[9] = new Redpoint(6560 + this.level, (200100 + this.level) * 100 + 9);
            foreach (var star in EquipStarModel.StarList)

            {

                suitRepoints[star] = new Redpoint(6560 + this.level, (200100 + this.level) * 100 + star);

            }
        }

        public void UpdateEquipSlot(int place, string equipGuid)

 System/Equip/EquipSuitPropertyWidget.cs

@@ -28,10 +28,7 @@
        [SerializeField] EquipSuitActiveHand m_SuitActive5;
        [SerializeField] EquipSuitActiveHand m_SuitActive8;

        [SerializeField] RedpointBehaviour redpoint0;
        [SerializeField] RedpointBehaviour redpoint3;
        [SerializeField] RedpointBehaviour redpoint6;
        [SerializeField] RedpointBehaviour redpoint9;
        [SerializeField] RedpointBehaviour[] redpointList;

        EquipModel model { get { return ModelCenter.Instance.GetModel<EquipModel>(); } }

@@ -41,17 +38,14 @@
        {
            this.level = level;

            redpoint0.redpointId = (200100 + this.level) * 100 + 0;
            redpoint3.redpointId = (200100 + this.level) * 100 + 3;
            redpoint6.redpointId = (200100 + this.level) * 100 + 6;
            redpoint9.redpointId = (200100 + this.level) * 100 + 9;
            var maxLevel = EquipStarModel.GetMaxStarLevel(level);
            for (int i = 0; i < m_StarToggles.Length; i++)
            {

                redpointList[i].redpointId = (200100 + this.level) * 100 + m_StarToggles[i].star;
                m_StarToggles[i].SetActive(maxLevel >= m_StarToggles[i].star);
            }

            m_SuitName.text = EquipSuitConfig.GetConfigs(PlayerDatas.Instance.baseData.Job, level, EquipSuitType.TwoSuit)[0].name;
            var maxLevel = EquipStarModel.GetMaxStarLevel(level);
            m_StarToggles[3].SetActive(maxLevel >= 9);
            m_StarToggles[2].SetActive(maxLevel >= 6);
            m_StarToggles[1].SetActive(maxLevel >= 3);
            m_StarToggles[0].SetActive(true);

            int selectIndex = model.GetSuitRepoindStar(level);
            if (selectIndex != -1)
@@ -60,21 +54,19 @@
                return;
            }

            if (eightSuitLevel >= 6 && maxLevel >= 9)
            {
                m_StarToggles[3].Select();
            int jumpIndex = eightSuitLevel / 3 + 1;
            if (eightSuitLevel < 0)

            {

                jumpIndex = 0;
            }
            else if (eightSuitLevel >= 3 && maxLevel >= 6)

            if (jumpIndex >= m_StarToggles.Length)
            {
                m_StarToggles[2].Select();
            }
            else if (eightSuitLevel >= 0 && maxLevel >= 3)
            {
                m_StarToggles[1].Select();
                m_StarToggles[0].Select();
            }
            else
            {
                m_StarToggles[0].Select();
                m_StarToggles[jumpIndex].Select();
            }

        }
@@ -177,7 +169,7 @@
            public void SetActive(bool active)
            {
                toggle.isOn = false;
                title.SetActive(active);
                toggle.SetActive(active);
                toggle.interactable = active;
                if (active)
                {

 System/EquipStar/EquipStarEffectTipModel.cs

@@ -42,7 +42,7 @@
                var effectInfos = new Dictionary<int, List<SuitEffectInfo>>();
                var configs = EquipSuitConfig.GetConfigs(PlayerDatas.Instance.baseData.Job, equipPosition.x, EquipSuitType.EightSuit);

                for (int i = 0; i < 10; i += 3)
                for (int i = 0; i < 19; i += 3)
                {
                    if (maxStarLevel >= i)
                    {
@@ -307,32 +307,8 @@
        }

        public static string GetStarNumberCHS(int star)
        {
            switch (star)
            {
                case 0:
                    return Language.Get("Num_CHS_0");
                case 1:
                    return Language.Get("Num_CHS_1");
                case 2:
                    return Language.Get("Num_CHS_2");
                case 3:
                    return Language.Get("Num_CHS_3");
                case 4:
                    return Language.Get("Num_CHS_4");
                case 5:
                    return Language.Get("Num_CHS_5");
                case 6:
                    return Language.Get("Num_CHS_6");
                case 7:
                    return Language.Get("Num_CHS_7");
                case 8:
                    return Language.Get("Num_CHS_8");
                case 9:
                    return Language.Get("Num_CHS_9");
                default:
                    return "";
            }
        {

            return Language.Get("Num_CHS_" + star);
        }

        public struct SuitEffectInfo

 System/EquipStar/EquipStarMaterialCandidate.cs

File was deleted

 System/EquipStar/EquipStarMaterialCandidate.cs.meta

File was deleted

 System/EquipStar/EquipStarMaterialCandidateCouple.cs

File was deleted

 System/EquipStar/EquipStarMaterialCandidateCouple.cs.meta

File was deleted

 System/EquipStar/EquipStarMaterialSelectButton.cs

File was deleted

 System/EquipStar/EquipStarMaterialSelectButton.cs.meta

File was deleted

 System/EquipStar/EquipStarMaterialSelectModel.cs

File was deleted

 System/EquipStar/EquipStarMaterialSelectModel.cs.meta

File was deleted

 System/EquipStar/EquipStarMaterialSelectWin.cs

File was deleted

 System/EquipStar/EquipStarMaterialSelectWin.cs.meta

File was deleted

 System/EquipStar/EquipStarModel.cs

@@ -1,861 +1,786 @@
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System;

namespace Snxxz.UI
{
    
    public class EquipStarModel : Model, IPlayerLoginOk, IBeforePlayerDataInitialize
    {
        public readonly LogicInt selectedLevel = new LogicInt();
        public readonly LogicInt selectedPlace = new LogicInt();
        public readonly LogicInt equipStarLevel = new LogicInt();
        public readonly LogicInt equipMaxStarLevel = new LogicInt();
        public readonly LogicInt starUpgradeProbability = new LogicInt();
        public readonly LogicList<EquipStarUpgradeCandidate> candidatePlaces = new LogicList<EquipStarUpgradeCandidate>();

        public readonly LogicList<Star> stars = new LogicList<Star>();

        public readonly LogicList<string> normalMaterials = new LogicList<string>(); //已选择用于升星的装备
        public readonly LogicInt specialMaterial = new LogicInt();
        public readonly LogicInt starResultEffect = new LogicInt();
        public readonly LogicInt autoBuy = new LogicInt();
        public Int2 jumpEquipPos = Int2.zero;
        public List<string> useStarMaterials = new List<string>();  //可用于升星的装备
        public string biggestRateMaterial = string.Empty;  //低境界非红装的最高概率一件

        Dictionary<int, EquipSetStar> equipStars = new Dictionary<int, EquipSetStar>();
        public Dictionary<int, EquipSetStar> EquipStars { get { return equipStars; } }

        Redpoint redpoint = new Redpoint(106, 1720000);
        bool redpointDirty = false;
        LogicUpdate logicUpdate = new LogicUpdate(1);

        PackModel packModel { get { return ModelCenter.Instance.GetModel<PackModel>(); } }
        EquipModel equipModel { get { return ModelCenter.Instance.GetModel<EquipModel>(); } }


        public override void Init()
        {
            ParseConfig();

            logicUpdate.Start(OnUpdate);
            packModel.refreshItemCountEvent += OnItemCountRefresh;
            DTC0721_tagMakeItemAnswer.MakeItemAnswerEvent += OnGetUpgradeStarResult;

            autoBuy.value = -1;
        }

        public override void UnInit()
        {
            packModel.refreshItemCountEvent -= OnItemCountRefresh;
            DTC0721_tagMakeItemAnswer.MakeItemAnswerEvent -= OnGetUpgradeStarResult;
        }

        public void OnBeforePlayerDataInitialize()
        {
            foreach (var equipStar in equipStars)
            {
                equipStar.Value.ResetStarLevel();
            }
        }

        public void OnPlayerLoginOk()
        {
        }

        public void UpdateStarLevels(HA3B1_tagMCEquipPartStarInfo info)
        {
            var selectedEquipOldStar = GetEquipStarLevel(new Int2(selectedLevel.value, selectedPlace.value));
            for (var i = 0; i < info.InfoList.Length; i++)
            {
                var equipPosition = EquipSet.ServerPlaceToClientPlace(info.InfoList[i].EquipPackIndex);
                var level = equipPosition.x;
                if (equipStars.ContainsKey(level))
                {
                    equipStars[level].UpdateEquipStarLevel(equipPosition.y, info.InfoList[i].Star);
                }
            }

            var starLevel = GetEquipStarLevel(new Int2(selectedLevel.value, selectedPlace.value));
            equipStarLevel.value = starLevel;
            selectedPlace.dirty = true;

            var maxStarLevel = GetMaxStarLevel(selectedLevel.value);
            UpdateSelelctedEquipStars(selectedEquipOldStar, starLevel, maxStarLevel);

            for (int i = 0; i < candidatePlaces.Count; i++)
            {
                var candidate = candidatePlaces[i];
                candidate.starLevel.value = GetEquipStarLevel(candidate.equipPosition);
            }

            redpointDirty = true;
        }



        void OnGetUpgradeStarResult(H0721_tagMakeItemAnswer info)
        {
            if (info.MakeType == (byte)MakeType.EquipStarUpgrade)
            {
                var equipPosition = new Int2(selectedLevel.value, selectedPlace.value);
                AutoAddMaterials(equipPosition);
                CalculateStarUpgradeProbability(equipPosition);

                if (info.Result == 1)
                {
                    var successModel = ModelCenter.Instance.GetModel<EquipStarSuccessModel>();
                    successModel.Show(equipPosition, GetStarLevel(equipPosition));
                    starResultEffect.value = 1;
                    
                }
                else
                {
                    EffectMgr.Instance.PlayUIEffect(7066, 2500, WindowCenter.Instance.uiRoot.tipsCanvas, false);
                    SysNotifyMgr.Instance.ShowTip("StarLevelUpFail");
                    starResultEffect.value = -1;
                }
            }
        }

        //查询自动购买状态
        public void QueryAutoBuy()
        {
            var placeValue = selectedPlace.value;
            if (placeValue == 0) return;

            var equipPosition = new Int2(selectedLevel.value, placeValue);
            var currentStarLevel = GetEquipStarLevel(equipPosition);
            if (starUpgradeProbability.value >= 100)
            {
                autoBuy.value = GetItemsMoney(equipPosition, currentStarLevel + 1);
                return;
            }

            DoStarUpgrade(equipPosition, currentStarLevel + 1, 2);

        }

        //装备已填充100%后，客户端自己计算升星石价格
        public int GetItemsMoney(Int2 equipPosition, int starLevel)
        {
            var config = EquipStarConfig.Get(equipPosition.x, equipPosition.y, starLevel);
            if (config == null)
            {
                return 0;
            }
            int itemID = config.CostItemDict.x;
            int count = config.CostItemDict.y;
            if (itemID <= 0 || count <= 0) return 0;
            var shopConfig = StoreConfig.GetStoreCfg(itemID, 2, 5);
            if (shopConfig == null) return 0;

            int hasCnt = packModel.GetItemCountByID(PackType.Item, config.CostItemDict.x);
            int needCnt = count >= hasCnt ? count - hasCnt : 0;
            return needCnt * shopConfig.MoneyNumber;
        }


        public void DoStarUpgrade(Int2 equipPosition, int starLevel, int auto=0)
        {
            if (!equipStars.ContainsKey(equipPosition.x))
            {
                return;
            }

            var equip = packModel.GetItemByGuid(equipModel.GetEquip(equipPosition));
            if (equip == null)
            {
                return;
            }

            if (equip.config.ItemColor < 4)
            {
                SysNotifyMgr.Instance.ShowTip("StarLevelUp4");
                return;
            }

            var maxLevel = GetMaxStarLevel(equipPosition.x);
            if (starLevel > maxLevel)
            {
                SysNotifyMgr.Instance.ShowTip("StarLevelUp1");
                return;
            }

            var config = EquipStarConfig.Get(equipPosition.x, equipPosition.y, starLevel);
            if (config == null)
            {
                return;
            }

            if (config.CostItemDict.x > 0 && specialMaterial.value == 0 && auto == 0)
            {
                SysNotifyMgr.Instance.ShowTip("StarLevelUp2", config.CostItemDict.x);
                return;
            }

            if (config.CostItemDict.x > 0 && packModel.GetItemCountByID(PackType.Item, config.CostItemDict.x) < config.CostItemDict.y && auto == 0)
            {
                SysNotifyMgr.Instance.ShowTip("StarLevelUp2", config.CostItemDict.x);
                return;
            }

            var materialIndexs = new List<ushort>();
            var materialItemIds = new List<uint>();
            for (var i = 0; i < normalMaterials.Count; i++)
            {
                var material = normalMaterials[i];
                if (!string.IsNullOrEmpty(material))
                {
                    var item = packModel.GetItemByGuid(material);
                    materialIndexs.Add((ushort)item.gridIndex);
                    materialItemIds.Add((uint)item.itemId);
                }
            }

            Action sendInfo = () =>
            {
                var info = new CA5C5_tagCMEquipPartStarUp();
                info.EquipPackIndex = (ushort)EquipSet.ClientPlaceToServerPlace(equipPosition);
                info.CostEquipIndex = materialIndexs.ToArray();
                info.CostEquipID = materialItemIds.ToArray();
                info.CostEquipCnt = (byte)materialIndexs.Count;
                info.AutoBuy = (byte)auto;
                GameNetSystem.Instance.SendInfo(info);
            };

            if (starUpgradeProbability.value < 50 && auto == 0)
            {
                ConfirmCancel.ShowPopConfirm(
                    Language.Get("Mail101"),
                    Language.Get("EquipStarUpgradePossibility"),
                    () => { }
                );
            }
            else
            {
                sendInfo();
            }
        }

        public void ResetOperateParams()
        {
            if (autoBuy.value == -2) autoBuy.value = -1;
            selectedLevel.value = 0;
            selectedPlace.value = 0;
            equipStarLevel.value = 0;
            equipMaxStarLevel.value = 0;
            starUpgradeProbability.value = -1;
            starResultEffect.value = 0;
            normalMaterials.Clear();
            stars.Clear();
        }

        public Int2 GetRecommendEquipPosition()
        {
            foreach (var starSet in equipStars.Values)
            {
                var level = starSet.level;
                for (var place = 1; place <= 12; place++)
                {
                    var isRedpoint = starSet.GetRedpointState(place) != RedPointState.None;
                    if (isRedpoint)
                    {
                        return new Int2(level, place);
                    }
                }
            }

            foreach (var starSet in equipStars.Values)
            {
                var level = starSet.level;
                for (var i = 1; i <= 12; i++)
                {
                    var equipPosition = new Int2(level, i);
                    var item = packModel.GetItemByGuid(equipModel.GetEquip(equipPosition));
                    if (item == null)
                    {
                        continue;
                    }

                    var starLevel = GetStarLevel(equipPosition);
                    var maxStarLevel = GetMaxStarLevel(item.config.ItemColor, item.config.LV);
                    if (starLevel >= maxStarLevel)
                    {
                        continue;
                    }
                }
            }

            return new Int2(1, 1);
        }

        public void SelectLevel(int level)
        {
            selectedLevel.value = level;
            candidatePlaces.Clear();

            if (level > 0)
            {
               // int equipCnt = level < 2 ? 8 : 12;
                for (var i = 1; i <= 12; i++)
                {
                    var place = i;
                    var equipPosition = new Int2(level, place);
                    var candidate = new EquipStarUpgradeCandidate(equipPosition);
                    candidate.starLevel.value = GetEquipStarLevel(equipPosition);
                    candidatePlaces.Add(candidate);
                }
                candidatePlaces.Sort(EquipStarUpgradeCandidateCompare);

                SelectPlace(candidatePlaces[0].equipPosition);
            }
            else
            {
                SelectPlace(Int2.zero);
            }
        }

        public void SelectPlace(Int2 equipPosition)
        {
            selectedPlace.value = equipPosition.y;
            selectedPlace.dirty = true;
            if (equipPosition.x > 0 && equipPosition.y >= 1 && equipPosition.y <= 12)
            {
                for (int i = 0; i < candidatePlaces.Count; i++)
                {
                    var candidate = candidatePlaces[i];
                    candidate.selected.value = candidate.equipPosition == equipPosition;
                }

                var starLevel = GetEquipStarLevel(equipPosition);
                var maxStarLevel = GetMaxStarLevel(equipPosition.x);
                equipStarLevel.value = starLevel;
                equipMaxStarLevel.value = maxStarLevel;

                UpdateSelelctedEquipStars(starLevel, starLevel, maxStarLevel);
                AutoAddMaterials(equipPosition);
                CalculateStarUpgradeProbability(equipPosition);
            }
        }

        public bool IsEquipPlaceUpgradable(string equipGuid)
        {
            if (string.IsNullOrEmpty(equipGuid))
            {
                return false;
            }

            var equip = packModel.GetItemByGuid(equipGuid);
            if (equip == null)
            {
                return false;
            }

            var maxStarLevel = GetMaxStarLevel(equip.config.ItemColor, equip.config.LV);
            var currentStarLevel = GetEquipStarLevel(new Int2(equip.config.LV, equip.config.EquipPlace));
            return currentStarLevel < maxStarLevel;
        }

        public static int GetMaxStarLevel(int quality, int level)
        {
            var max = 0;
            if (GeneralDefine.equipStarLimit.ContainsKey(quality))
            {
                var itemLevelStars = GeneralDefine.equipStarLimit[quality];
                if (itemLevelStars.ContainsKey(level))
                {
                    max = itemLevelStars[level];
                }
            }

            return max;
        }

        public static int GetMaxStarLevel(int level)
        {
            var max = 0;
            foreach (var itemLevelStars in GeneralDefine.equipStarLimit.Values)
            {
                if (itemLevelStars.ContainsKey(level))
                {
                    if (itemLevelStars[level] > max)
                    {
                        max = itemLevelStars[level];
                    }
                }
            }

            return max;
        }

        public int GetEquipPositionMaxStarLevel(Int2 equipPosition)
        {
            var equipGuid = equipModel.GetEquip(equipPosition);
            if (equipGuid == null)
            {
                return 0;
            }

            var equip = packModel.GetItemByGuid(equipGuid);
            if (equip == null)
            {
                return 0;
            }

            return GetMaxStarLevel(equip.config.ItemColor, equip.config.LV);
        }

        public int GetTotalStarLevel(int level)
        {
            if (!equipStars.ContainsKey(level))
            {
                return 0;
            }

            return equipStars[level].GetTotalStarLevel();
        }

        /// <summary>
        /// 这是指已经装备位置已经升级到的星级，不考虑当前穿戴的装备
        /// </summary>
        /// <param name="equipPosition"></param>
        /// <returns></returns>
        public int GetStarLevel(Int2 equipPosition)
        {
            if (!equipStars.ContainsKey(equipPosition.x))
            {
                return 0;
            }

            return equipStars[equipPosition.x].GetEquipStarLevel(equipPosition.y);
        }

        /// <summary>
        /// 这是指受当前装备限制的星级，比如当前装备位已经升级到了9星，但是穿戴的装备最高可升级到6星，那么返回的值是6
        /// </summary>
        /// <param name="equipPosition"></param>
        /// <returns></returns>
        public int GetEquipStarLevel(Int2 equipPosition)
        {
            var starLevel = GetStarLevel(equipPosition);
            var maxLevel = GetEquipPositionMaxStarLevel(equipPosition);

            return Mathf.Min(starLevel, maxLevel);
        }

        public List<int> GetMaterialGetWays(Int2 equipPosition, int starLevel)
        {
            var config = EquipStarConfig.Get(equipPosition.x, equipPosition.y, starLevel);
            if (config == null)
            {
                return null;
            }

            var getWays = new List<int>();
            foreach (int place in config.CostEquipPlace)
            {
                var equipControlConfig = EquipControlConfig.Get(equipPosition.x, place);
                foreach (int getWay in equipControlConfig.getWays)
                {
                    if (!getWays.Contains(getWay))
                    {
                        getWays.Add(getWay);
                    }
                }
            }

            return getWays;
        }

        //1、可提升战力装备不显示.
        //2、红装排最后
        //3、境界，小于等级自身的优先显示
        //4、特殊处理概率【最高】的一件低境界非红装显示在第一件

        //筛选可用于升星的装备材料
        public List<string> GetMaterials(Int2 equipPosition, int starLevel)
        {
            var config = EquipStarConfig.Get(equipPosition.x, equipPosition.y, starLevel);
            if (config == null)
            {
                return null;
            }

            var equipGuid = equipModel.GetEquip(equipPosition);
            var equip = packModel.GetItemByGuid(equipGuid);
            if (equip == null)
            {
                return null;
            }

            var expcetMaterials = packModel.GetItems(PackType.Item, new SinglePack.FilterParams()
            {
                qualitys = new List<int>(config.CostEquipColor),
                equipTypes = new List<int>(config.CostEquipPlace),
                jobs = config.IsJobLimit == 1 ? new List<int>() { PlayerDatas.Instance.baseData.Job } : null,
            });

            float rate = 0;
            var materialGuids = new List<string>();
            foreach (var item in expcetMaterials)
            {
                if (ItemLogicUtility.Instance.IsFightUpEx(item.itemId, item.score, item.config.RealmLimit) == -1)
                {
                    //4、特殊处理概率【最高】的一件低境界非红装显示在第一件
                    if (item.config.ItemColor <= 4 && item.config.RealmLimit <= PlayerDatas.Instance.baseData.realmLevel)
                    {
                        var tmpRate = GetMaterialSuccessRate(equipPosition, item.guid);
                        if (rate < tmpRate)
                        { 
                            biggestRateMaterial = item.guid;
                            rate = tmpRate;
                        }
                    }

                    //不显示更高战力的装备
                    materialGuids.Add(item.guid);
                }
            }

            materialGuids.Remove(biggestRateMaterial);
            return materialGuids;
        }

        public void AddMaterial(string guid)
        {
            if (!normalMaterials.Contains(guid))
            {
                normalMaterials.Add(guid);
                CalculateStarUpgradeProbability(new Int2(selectedLevel.value, selectedPlace.value));
            }
        }

        public void RemoveMaterial(string guid)
        {
            if (normalMaterials.Contains(guid))
            {
                normalMaterials.Remove(guid);
                CalculateStarUpgradeProbability(new Int2(selectedLevel.value, selectedPlace.value));
            }
        }

        private void AutoAddMaterials(Int2 equipPosition)
        {
            var equipGuid = equipModel.GetEquip(equipPosition);
            var upgradable = IsEquipPlaceUpgradable(equipGuid);

            if (upgradable)
            {
                normalMaterials.Clear();
                var config = EquipStarConfig.Get(equipPosition.x, equipPosition.y, GetEquipStarLevel(equipPosition) + 1);
                if (config.CostItemDict.x > 0)
                {
                    var itemId = config.CostItemDict.x;
                    specialMaterial.value = itemId;
                }
                else
                {
                    specialMaterial.value = 0;
                }
            }
            else
            {
                normalMaterials.Clear();
            }

            CalculateStarUpgradeProbability(new Int2(selectedLevel.value, selectedPlace.value));
        }

        public void CalculateStarUpgradeProbability(Int2 equipPosition)
        {
            var probability = 0f;
            var equipGuid = equipModel.GetEquip(equipPosition);
            var upgradable = IsEquipPlaceUpgradable(equipGuid);
            if (upgradable)
            {
                var currentStarLevel = GetEquipStarLevel(equipPosition);
                var config = EquipStarConfig.Get(equipPosition.x, equipPosition.y, currentStarLevel + 1);
                if (config != null && config.CostEquipCnt == 0)
                {
                    if (config.CostItemDict.x > 0)
                    {
                        var own = packModel.GetItemCountByID(PackType.Item, config.CostItemDict.x);
                        probability = own >= config.CostItemDict.y ? 1f : 0f;
                    }
                    else
                    {
                        probability = 0f;
                    }
                }
                else
                {
                    for (int i = 0; i < normalMaterials.Count; i++)
                    {
                        var material = normalMaterials[i];
                        probability += GetMaterialSuccessRate(equipPosition, material);
                    }
                }
                // 95%以上概率 则为100%
                int value = Mathf.RoundToInt(probability * 100);
                if (value >= 95 && value < 100)
                    value = 100;
                starUpgradeProbability.value = value;
                starUpgradeProbability.dirty = true;
            }
            else
            {
                starUpgradeProbability.value = -1;
            }
            
        }

        public float GetMaterialSuccessRate(Int2 equipPosition, string guid)
        {
            if (string.IsNullOrEmpty(guid))
            {
                return 0f;
            }

            var item = packModel.GetItemByGuid(guid);
            if (item == null)
            {
                return 0f;
            }

            var currentStarLevel = GetEquipStarLevel(equipPosition);
            var config = EquipStarConfig.Get(equipPosition.x, equipPosition.y, currentStarLevel + 1);
            if (config == null)
            {
                return 0f;
            }

            var amendLevel = item.config.LV - equipPosition.x;
            var amendRate = 1f;
            if (amendLevel > 0)
            {
                amendRate = 1 + amendLevel * GeneralDefine.equipStarUpAmendFactor * 0.01f;
            }
            else
            {
                amendRate = 1 + amendLevel * GeneralDefine.equipStarDownAmendFactor * 0.01f;
            }

            var successRate = 0.5f;
            var isSuit = item.config.SuiteiD > 0;
            if (isSuit)
            {
                successRate = Mathf.Clamp(Mathf.CeilToInt((float)Math.Round(config.SuitRate * amendRate, 2)), GeneralDefine.suitEquipStarUpgradeRateFloor, GeneralDefine.suitEquipStarUpgradeRateCeiling);
            }
            else
            {
                successRate = Mathf.Clamp(Mathf.CeilToInt((float)Math.Round(config.UnSuitRate * amendRate, 2)), GeneralDefine.normalEquipStarUpgradeRateFloor, GeneralDefine.normalEquipStarUpgradeRateCeiling);
            }

            return successRate * 0.01f;
        }

        private void UpdateSelelctedEquipStars(int oldStarLevel, int newStarLevel, int maxStarLevel)
        {
            stars.Clear();
            for (var i = 1; i <= maxStarLevel; i++)
            {
                stars.Add(new Star()
                {
                    actived = i <= newStarLevel,
                    newGet = i <= newStarLevel && i > oldStarLevel,
                });
            }
        }

        private void OnItemCountRefresh(PackType type, int index, int itemId)
        {
            switch (type)
            {
                case PackType.Item:
                    if (ItemLogicUtility.Instance.IsRealmEquip(itemId))
                    {
                        redpointDirty = true;
                    }

                    var itemConfig = ItemConfig.Get(itemId);
                    if (itemConfig.Type == 34)
                    {
                        redpointDirty = true;
                    }
                    break;
                case PackType.Equip:
                    var clientEquipPosition = EquipSet.ServerPlaceToClientPlace(index);
                    if (clientEquipPosition.x > 0)
                    {
                        redpointDirty = true;
                    }
                    break;
            }
        }

        private void UpdateStarRedpoint()
        {
            var targetEquipPosition = Int2.zero;
            var minStarLevel = 999;
            foreach (var trainSet in equipStars.Values)
            {
                var level = trainSet.level;
                for (var place = 1; place <= 12; place++)
                {
                    var equipPosition = new Int2(level, place);
                    var item = packModel.GetItemByGuid(equipModel.GetEquip(equipPosition));
                    if (item == null)
                    {
                        continue;
                    }

                    //达到最大星级
                    var maxStarLevel = GetMaxStarLevel(item.config.ItemColor, item.config.LV);
                    var starLevel = GetStarLevel(new Int2(level, place));
                    if (starLevel >= maxStarLevel)
                    {
                        continue;
                    }

                    //不是候选者中星级最小的
                    if (targetEquipPosition != Int2.zero && starLevel >= minStarLevel)
                    {
                        continue;
                    }

                    var config = EquipStarConfig.Get(level, place, starLevel + 1);
                    if (config == null)
                    {
                        continue;
                    }

                    //固定材料不足
                    if (config.CostItemDict.x > 0 && packModel.GetItemCountByID(PackType.Item, config.CostItemDict.x) < config.CostItemDict.y)
                    {
                        continue;
                    }

                    var materials = packModel.GetItems(PackType.Item, new SinglePack.FilterParams()
                    {
                        qualitys = new List<int>(config.CostEquipColor),
                        equipTypes = new List<int>(config.CostEquipPlace),
                        levels = new List<int>() { item.config.LV },
                        jobs = config.IsJobLimit == 1 ? new List<int>() { PlayerDatas.Instance.baseData.Job } : null,
                    });

                    for (int j = materials.Count - 1; j >= 0; j--)
                    {
                        var material = materials[j];
                        if (ItemLogicUtility.Instance.IsFightUp(material.itemId, material.score) == 1)
                        {
                            materials.RemoveAt(j);
                        }
                    }

                    var successRate = 0f;
                    foreach (var material in materials)
                    {
                        successRate += GetMaterialSuccessRate(equipPosition, material.guid);
                        if (successRate >= 0.5f)
                        {
                            break;
                        }
                    }

                    if (successRate < 0.5f)
                    {
                        continue;
                    }

                    minStarLevel = starLevel;
                    targetEquipPosition = new Int2(level, place);
                }
            }

            foreach (var starSet in equipStars.Values)
            {
                var level = starSet.level;
                if (!equipModel.IsLevelUnLocked(level))
                {
                    continue;
                }

                for (var place = 1; place <= 12; place++)
                {
                    var isRedpoint = level == targetEquipPosition.x && place == targetEquipPosition.y;
                    starSet.UpdateRedpoint(place, isRedpoint ? RedPointState.Simple : RedPointState.None);
                }
            }
        }

        private void OnUpdate()
        {
            if (redpointDirty && FuncOpen.Instance.IsFuncOpen(172))
            {
                redpointDirty = false;
                UpdateStarRedpoint();
            }
        }

        private int EquipStarUpgradeCandidateCompare(EquipStarUpgradeCandidate x, EquipStarUpgradeCandidate y)
        {
            var guidX = equipModel.GetEquip(x.equipPosition);
            var guidY = equipModel.GetEquip(y.equipPosition);
            if (!string.IsNullOrEmpty(guidX) && string.IsNullOrEmpty(guidY))
            {
                return -1;
            }

            if (string.IsNullOrEmpty(guidX) && !string.IsNullOrEmpty(guidY))
            {
                return 1;
            }
            return x.equipPosition.y.CompareTo(y.equipPosition.y);

            //var factorX = x.equipPosition.x * 100 + x.equipPosition.y;
            //var factorY = y.equipPosition.x * 100 + y.equipPosition.y;

            //if (string.IsNullOrEmpty(guidX) && string.IsNullOrEmpty(guidY))
            //{
            //    return factorX.CompareTo(factorY);
            //}

            //var equipX = packModel.GetItemByGuid(guidX);
            //var equipY = packModel.GetItemByGuid(guidY);

            //var canUpgradeStarLevelX = GetMaxStarLevel(equipX.config.ItemColor, equipX.config.LV) - GetStarLevel(x.equipPosition);
            //var canUpgradeStarLevelY = GetMaxStarLevel(equipY.config.ItemColor, equipY.config.LV) - GetStarLevel(y.equipPosition);

            //var compareResult = canUpgradeStarLevelX.CompareTo(canUpgradeStarLevelY);
            //if (compareResult != 0)
            //{
            //    return -compareResult;
            //}

            //return factorX.CompareTo(factorY);
        }

        private void ParseConfig()
        {
            var configs = EquipStarConfig.GetValues();
            foreach (var config in configs)
            {
                if (!equipStars.ContainsKey(config.Level))
                {
                    equipStars[config.Level] = new EquipSetStar(config.Level);
                }
            }
        }

        public struct Star
        {
            public bool actived;
            public bool newGet;
        }

    }
}

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

using System;



namespace Snxxz.UI

{

    
    public class EquipStarModel : Model, IPlayerLoginOk, IBeforePlayerDataInitialize

    {

        public readonly LogicInt selectedLevel = new LogicInt();

        public readonly LogicInt selectedPlace = new LogicInt();

        public readonly LogicInt equipStarLevel = new LogicInt();

        public readonly LogicInt equipMaxStarLevel = new LogicInt();

        public readonly LogicList<EquipStarUpgradeCandidate> candidatePlaces = new LogicList<EquipStarUpgradeCandidate>();



        public readonly LogicList<Star> stars = new LogicList<Star>();



        public readonly LogicInt specialMaterial = new LogicInt();

        public readonly LogicInt specialMaterial2 = new LogicInt();

        public readonly LogicInt starResultEffect = new LogicInt();

        public readonly LogicInt autoBuy = new LogicInt();

        public Int2 jumpEquipPos = Int2.zero;

        public List<string> useStarMaterials = new List<string>();  //可用于升星的装备

        public string biggestRateMaterial = string.Empty;  //低境界非红装的最高概率一件



        Dictionary<int, EquipSetStar> equipStars = new Dictionary<int, EquipSetStar>();

        public Dictionary<int, EquipSetStar> EquipStars { get { return equipStars; } }



        Redpoint redpoint = new Redpoint(106, 1720000);

        bool redpointDirty = false;

        LogicUpdate logicUpdate = new LogicUpdate(1);



        PackModel packModel { get { return ModelCenter.Instance.GetModel<PackModel>(); } }

        EquipModel equipModel { get { return ModelCenter.Instance.GetModel<EquipModel>(); } }





        public static List<int> StarList = new List<int> { 0, 3, 6, 9, 12, 15, 18 };



    public override void Init()

        {

            ParseConfig();



            logicUpdate.Start(OnUpdate);

            packModel.refreshItemCountEvent += OnItemCountRefresh;

            DTC0721_tagMakeItemAnswer.MakeItemAnswerEvent += OnGetUpgradeStarResult;



            autoBuy.value = -1;

        }



        public override void UnInit()

        {

            packModel.refreshItemCountEvent -= OnItemCountRefresh;

            DTC0721_tagMakeItemAnswer.MakeItemAnswerEvent -= OnGetUpgradeStarResult;

        }



        public void OnBeforePlayerDataInitialize()

        {

            foreach (var equipStar in equipStars)

            {

                equipStar.Value.ResetStarLevel();

            }

        }



        public void OnPlayerLoginOk()

        {

        }



        public void UpdateStarLevels(HA3B1_tagMCEquipPartStarInfo info)

        {

            var selectedEquipOldStar = GetEquipStarLevel(new Int2(selectedLevel.value, selectedPlace.value));

            for (var i = 0; i < info.InfoList.Length; i++)

            {

                var equipPosition = EquipSet.ServerPlaceToClientPlace(info.InfoList[i].EquipPackIndex);

                var level = equipPosition.x;

                if (equipStars.ContainsKey(level))

                {

                    equipStars[level].UpdateEquipStarLevel(equipPosition.y, info.InfoList[i].Star);

                }

            }



            var starLevel = GetEquipStarLevel(new Int2(selectedLevel.value, selectedPlace.value));

            equipStarLevel.value = starLevel;

            selectedPlace.dirty = true;



            var maxStarLevel = GetMaxStarLevel(selectedLevel.value);

            UpdateSelelctedEquipStars(selectedEquipOldStar, starLevel, maxStarLevel);



            for (int i = 0; i < candidatePlaces.Count; i++)

            {

                var candidate = candidatePlaces[i];

                candidate.starLevel.value = GetEquipStarLevel(candidate.equipPosition);

            }



            redpointDirty = true;

        }







        void OnGetUpgradeStarResult(H0721_tagMakeItemAnswer info)

        {

            if (info.MakeType == (byte)MakeType.EquipStarUpgrade)

            {

                var equipPosition = new Int2(selectedLevel.value, selectedPlace.value);

                AutoAddMaterials(equipPosition);



                if (info.Result == 1)

                {

                    var successModel = ModelCenter.Instance.GetModel<EquipStarSuccessModel>();

                    successModel.Show(equipPosition, GetStarLevel(equipPosition));

                    starResultEffect.value = 1;

                    
                }

                else

                {

                    EffectMgr.Instance.PlayUIEffect(7066, 2500, WindowCenter.Instance.uiRoot.tipsCanvas, false);

                    SysNotifyMgr.Instance.ShowTip("StarLevelUpFail");

                    starResultEffect.value = -1;

                }

            }

        }





        //装备已填充100%后，客户端自己计算升星石价格

        public int GetItemsMoney(Int2 equipPosition, int starLevel)

        {

            var config = EquipStarConfig.Get(equipPosition.x, equipPosition.y, starLevel);

            if (config == null)

            {

                return 0;

            }

            int itemID = config.CostItemDict[0].x;

            int count = config.CostItemDict[0].y;

            if (itemID <= 0 || count <= 0) return 0;

            var shopConfig = StoreConfig.GetStoreCfg(itemID, 2, 5);

            if (shopConfig == null) return 0;



            int hasCnt = packModel.GetItemCountByID(PackType.Item, config.CostItemDict[0].x);

            int needCnt = count >= hasCnt ? count - hasCnt : 0;

            return needCnt * shopConfig.MoneyNumber;

        }





        public void DoStarUpgrade(Int2 equipPosition, int starLevel, int auto=0)

        {

            if (!equipStars.ContainsKey(equipPosition.x))

            {

                return;

            }



            var equip = packModel.GetItemByGuid(equipModel.GetEquip(equipPosition));

            if (equip == null)

            {

                return;

            }



            if (equip.config.ItemColor < 4)

            {

                SysNotifyMgr.Instance.ShowTip("StarLevelUp4");

                return;

            }



            var maxLevel = GetMaxStarLevel(equipPosition.x);

            if (starLevel > maxLevel)

            {

                SysNotifyMgr.Instance.ShowTip("StarLevelUp1");

                return;

            }



            var config = EquipStarConfig.Get(equipPosition.x, equipPosition.y, starLevel);

            if (config == null)

            {

                return;

            }



            if (config.CostItemDict[0].x > 0 && specialMaterial.value == 0 && auto == 0)

            {

                SysNotifyMgr.Instance.ShowTip("StarLevelUp2", config.CostItemDict[0].x);

                return;

            }



            if (config.CostItemDict.Length > 1 && config.CostItemDict[1].x > 0 && specialMaterial2.value == 0 )

            {

                SysNotifyMgr.Instance.ShowTip("StarLevelUp2", config.CostItemDict[1].x);

                return;

            }



            if (config.CostItemDict[0].x > 0 && packModel.GetItemCountByID(PackType.Item, config.CostItemDict[0].x) < config.CostItemDict[0].y && auto == 0)

            {

                SysNotifyMgr.Instance.ShowTip("StarLevelUp2", config.CostItemDict[0].x);

                return;

            }



            if (config.CostItemDict.Length > 1 && config.CostItemDict[1].x > 0 && 
                packModel.GetItemCountByID(PackType.Item, config.CostItemDict[1].x) < config.CostItemDict[1].y)

            {

                SysNotifyMgr.Instance.ShowTip("StarLevelUp2", config.CostItemDict[1].x);

                return;

            }



            var materialIndexs = new List<ushort>();

            var materialItemIds = new List<uint>();





            Action sendInfo = () =>

            {

                var info = new CA5C5_tagCMEquipPartStarUp();

                info.EquipPackIndex = (ushort)EquipSet.ClientPlaceToServerPlace(equipPosition);

                info.CostEquipIndex = materialIndexs.ToArray();

                info.CostEquipID = materialItemIds.ToArray();

                info.CostEquipCnt = (byte)materialIndexs.Count;

                info.AutoBuy = (byte)auto;

                GameNetSystem.Instance.SendInfo(info);

            };



            sendInfo();

        }



        public void ResetOperateParams()

        {

            if (autoBuy.value == -2) autoBuy.value = -1;

            selectedLevel.value = 0;

            selectedPlace.value = 0;

            equipStarLevel.value = 0;

            equipMaxStarLevel.value = 0;

            starResultEffect.value = 0;

            stars.Clear();

        }



        public Int2 GetRecommendEquipPosition()

        {

            foreach (var starSet in equipStars.Values)

            {

                var level = starSet.level;

                for (var place = 1; place <= 12; place++)

                {

                    var isRedpoint = starSet.GetRedpointState(place) != RedPointState.None;

                    if (isRedpoint)

                    {

                        return new Int2(level, place);

                    }

                }

            }



            foreach (var starSet in equipStars.Values)

            {

                var level = starSet.level;

                for (var i = 1; i <= 12; i++)

                {

                    var equipPosition = new Int2(level, i);

                    var item = packModel.GetItemByGuid(equipModel.GetEquip(equipPosition));

                    if (item == null)

                    {

                        continue;

                    }



                    var starLevel = GetStarLevel(equipPosition);

                    var maxStarLevel = GetMaxStarLevel(item.config.ItemColor, item.config.LV);

                    if (starLevel >= maxStarLevel)

                    {

                        continue;

                    }

                }

            }



            return new Int2(1, 1);

        }



        public void SelectLevel(int level)

        {

            selectedLevel.value = level;

            candidatePlaces.Clear();



            if (level > 0)

            {

               // int equipCnt = level < 2 ? 8 : 12;

                for (var i = 1; i <= 12; i++)

                {

                    var place = i;

                    var equipPosition = new Int2(level, place);

                    var candidate = new EquipStarUpgradeCandidate(equipPosition);

                    candidate.starLevel.value = GetEquipStarLevel(equipPosition);

                    candidatePlaces.Add(candidate);

                }

                candidatePlaces.Sort(EquipStarUpgradeCandidateCompare);



                SelectPlace(candidatePlaces[0].equipPosition);

            }

            else

            {

                SelectPlace(Int2.zero);

            }

        }



        public void SelectPlace(Int2 equipPosition)

        {

            selectedPlace.value = equipPosition.y;

            selectedPlace.dirty = true;

            if (equipPosition.x > 0 && equipPosition.y >= 1 && equipPosition.y <= 12)

            {

                for (int i = 0; i < candidatePlaces.Count; i++)

                {

                    var candidate = candidatePlaces[i];

                    candidate.selected.value = candidate.equipPosition == equipPosition;

                }



                var starLevel = GetEquipStarLevel(equipPosition);

                var maxStarLevel = GetMaxStarLevel(equipPosition.x);

                equipStarLevel.value = starLevel;

                equipMaxStarLevel.value = maxStarLevel;



                UpdateSelelctedEquipStars(starLevel, starLevel, maxStarLevel);

                AutoAddMaterials(equipPosition);

            }

        }



        //是否可升星

        public bool IsEquipPlaceUpgradable(string equipGuid)

        {

            if (string.IsNullOrEmpty(equipGuid))

            {

                return false;

            }



            var equip = packModel.GetItemByGuid(equipGuid);

            if (equip == null)

            {

                return false;

            }



            var maxStarLevel = GetMaxStarLevel(equip.config.ItemColor, equip.config.LV);

            var currentStarLevel = GetEquipStarLevel(new Int2(equip.config.LV, equip.config.EquipPlace));

            return currentStarLevel < maxStarLevel;

        }



        public static int GetMaxStarLevel(int quality, int level)

        {

            var max = 0;

            if (GeneralDefine.equipStarLimit.ContainsKey(quality))

            {

                var itemLevelStars = GeneralDefine.equipStarLimit[quality];

                if (itemLevelStars.ContainsKey(level))

                {

                    max = itemLevelStars[level];

                }

            }



            return max;

        }



        public static int GetMaxStarLevel(int level)

        {

            var max = 0;

            foreach (var itemLevelStars in GeneralDefine.equipStarLimit.Values)

            {

                if (itemLevelStars.ContainsKey(level))

                {

                    if (itemLevelStars[level] > max)

                    {

                        max = itemLevelStars[level];

                    }

                }

            }



            return max;

        }



        public int GetEquipPositionMaxStarLevel(Int2 equipPosition)

        {

            var equipGuid = equipModel.GetEquip(equipPosition);

            if (equipGuid == null)

            {

                return 0;

            }



            var equip = packModel.GetItemByGuid(equipGuid);

            if (equip == null)

            {

                return 0;

            }



            return GetMaxStarLevel(equip.config.ItemColor, equip.config.LV);

        }



        public int GetTotalStarLevel(int level)

        {

            if (!equipStars.ContainsKey(level))

            {

                return 0;

            }



            return equipStars[level].GetTotalStarLevel();

        }



        /// <summary>

        /// 这是指已经装备位置已经升级到的星级，不考虑当前穿戴的装备

        /// </summary>

        /// <param name="equipPosition"></param>

        /// <returns></returns>

        public int GetStarLevel(Int2 equipPosition)

        {

            if (!equipStars.ContainsKey(equipPosition.x))

            {

                return 0;

            }



            return equipStars[equipPosition.x].GetEquipStarLevel(equipPosition.y);

        }



        /// <summary>

        /// 这是指受当前装备限制的星级，比如当前装备位已经升级到了9星，但是穿戴的装备最高可升级到6星，那么返回的值是6

        /// </summary>

        /// <param name="equipPosition"></param>

        /// <returns></returns>

        public int GetEquipStarLevel(Int2 equipPosition)

        {

            var starLevel = GetStarLevel(equipPosition);

            var maxLevel = GetEquipPositionMaxStarLevel(equipPosition);



            return Mathf.Min(starLevel, maxLevel);

        }



        public List<int> GetMaterialGetWays(Int2 equipPosition, int starLevel)

        {

            var config = EquipStarConfig.Get(equipPosition.x, equipPosition.y, starLevel);

            if (config == null)

            {

                return null;

            }



            var getWays = new List<int>();

            foreach (int place in config.CostEquipPlace)

            {

                var equipControlConfig = EquipControlConfig.Get(equipPosition.x, place);

                foreach (int getWay in equipControlConfig.getWays)

                {

                    if (!getWays.Contains(getWay))

                    {

                        getWays.Add(getWay);

                    }

                }

            }



            return getWays;

        }



        //1、可提升战力装备不显示.

        //2、红装排最后

        //3、境界，小于等级自身的优先显示

        //4、特殊处理概率【最高】的一件低境界非红装显示在第一件



        //筛选可用于升星的装备材料

        public List<string> GetMaterials(Int2 equipPosition, int starLevel)

        {

            var config = EquipStarConfig.Get(equipPosition.x, equipPosition.y, starLevel);

            if (config == null)

            {

                return null;

            }



            var equipGuid = equipModel.GetEquip(equipPosition);

            var equip = packModel.GetItemByGuid(equipGuid);

            if (equip == null)

            {

                return null;

            }



            var expcetMaterials = packModel.GetItems(PackType.Item, new SinglePack.FilterParams()

            {

                qualitys = new List<int>(config.CostEquipColor),

                equipTypes = new List<int>(config.CostEquipPlace),

                jobs = config.IsJobLimit == 1 ? new List<int>() { PlayerDatas.Instance.baseData.Job } : null,

            });



            float rate = 0;

            var materialGuids = new List<string>();

            foreach (var item in expcetMaterials)

            {

                if (ItemLogicUtility.Instance.IsFightUpEx(item.itemId, item.score, item.config.RealmLimit) == -1)

                {

                    //4、特殊处理概率【最高】的一件低境界非红装显示在第一件

                    if (item.config.ItemColor <= 4 && item.config.RealmLimit <= PlayerDatas.Instance.baseData.realmLevel)

                    {

                        var tmpRate = GetMaterialSuccessRate(equipPosition, item.guid);

                        if (rate < tmpRate)

                        { 
                            biggestRateMaterial = item.guid;

                            rate = tmpRate;

                        }

                    }



                    //不显示更高战力的装备

                    materialGuids.Add(item.guid);

                }

            }



            materialGuids.Remove(biggestRateMaterial);

            return materialGuids;

        }





        private void AutoAddMaterials(Int2 equipPosition)

        {

            var equipGuid = equipModel.GetEquip(equipPosition);

            var upgradable = IsEquipPlaceUpgradable(equipGuid);



            if (upgradable)

            {

                var config = EquipStarConfig.Get(equipPosition.x, equipPosition.y, GetEquipStarLevel(equipPosition) + 1);

                if (config.CostItemDict.Length > 0 && config.CostItemDict[0].x > 0)

                {

                    var itemId = config.CostItemDict[0].x;

                    specialMaterial.value = itemId;

                }

                else

                {

                    specialMaterial.value = 0;

                }

                if (config.CostItemDict.Length > 1)

                {

                    var itemId = config.CostItemDict[1].x;

                    specialMaterial2.value = itemId;

                }

                else

                {

                    specialMaterial2.value = 0;

                }

            }



        }



        


        public float GetMaterialSuccessRate(Int2 equipPosition, string guid)

        {

            if (string.IsNullOrEmpty(guid))

            {

                return 0f;

            }



            var item = packModel.GetItemByGuid(guid);

            if (item == null)

            {

                return 0f;

            }



            var currentStarLevel = GetEquipStarLevel(equipPosition);

            var config = EquipStarConfig.Get(equipPosition.x, equipPosition.y, currentStarLevel + 1);

            if (config == null)

            {

                return 0f;

            }



            var amendLevel = item.config.LV - equipPosition.x;

            var amendRate = 1f;

            if (amendLevel > 0)

            {

                amendRate = 1 + amendLevel * GeneralDefine.equipStarUpAmendFactor * 0.01f;

            }

            else

            {

                amendRate = 1 + amendLevel * GeneralDefine.equipStarDownAmendFactor * 0.01f;

            }



            var successRate = 0.5f;

            var isSuit = item.config.SuiteiD > 0;

            if (isSuit)

            {

                successRate = Mathf.Clamp(Mathf.CeilToInt((float)Math.Round(config.SuitRate * amendRate, 2)), GeneralDefine.suitEquipStarUpgradeRateFloor, GeneralDefine.suitEquipStarUpgradeRateCeiling);

            }

            else

            {

                successRate = Mathf.Clamp(Mathf.CeilToInt((float)Math.Round(config.UnSuitRate * amendRate, 2)), GeneralDefine.normalEquipStarUpgradeRateFloor, GeneralDefine.normalEquipStarUpgradeRateCeiling);

            }



            return successRate * 0.01f;

        }



        private void UpdateSelelctedEquipStars(int oldStarLevel, int newStarLevel, int maxStarLevel)

        {

            stars.Clear();

            for (var i = 1; i <= maxStarLevel; i++)

            {

                stars.Add(new Star()

                {

                    actived = i <= newStarLevel,

                    newGet = i <= newStarLevel && i > oldStarLevel,

                });

            }

        }



        private void OnItemCountRefresh(PackType type, int index, int itemId)

        {

            switch (type)

            {

                case PackType.Item:

                    if (ItemLogicUtility.Instance.IsRealmEquip(itemId))

                    {

                        redpointDirty = true;

                    }



                    var itemConfig = ItemConfig.Get(itemId);

                    if (itemConfig.Type == 34)

                    {

                        redpointDirty = true;

                    }

                    break;

                case PackType.Equip:

                    var clientEquipPosition = EquipSet.ServerPlaceToClientPlace(index);

                    if (clientEquipPosition.x > 0)

                    {

                        redpointDirty = true;

                    }

                    break;

            }

        }



        private void UpdateStarRedpoint()

        {

            var targetEquipPosition = Int2.zero;

            var minStarLevel = 999;

            foreach (var trainSet in equipStars.Values)

            {

                var level = trainSet.level;

                for (var place = 1; place <= 12; place++)

                {

                    var equipPosition = new Int2(level, place);

                    var item = packModel.GetItemByGuid(equipModel.GetEquip(equipPosition));

                    if (item == null)

                    {

                        continue;

                    }



                    //达到最大星级

                    var maxStarLevel = GetMaxStarLevel(item.config.ItemColor, item.config.LV);

                    var starLevel = GetStarLevel(new Int2(level, place));

                    if (starLevel >= maxStarLevel)

                    {

                        continue;

                    }



                    //不是候选者中星级最小的

                    if (targetEquipPosition != Int2.zero && starLevel >= minStarLevel)

                    {

                        continue;

                    }



                    var config = EquipStarConfig.Get(level, place, starLevel + 1);

                    if (config == null)

                    {

                        continue;

                    }



                    //固定材料不足

                    if (config.CostItemDict[0].x > 0 && packModel.GetItemCountByID(PackType.Item, config.CostItemDict[0].x) < config.CostItemDict[0].y)

                    {

                        continue;

                    }



                    if (config.CostItemDict.Length > 1 && config.CostItemDict[1].x > 0 && 
                        packModel.GetItemCountByID(PackType.Item, config.CostItemDict[1].x) < config.CostItemDict[1].y)

                    {

                        continue;

                    }



                    var materials = packModel.GetItems(PackType.Item, new SinglePack.FilterParams()

                    {

                        qualitys = new List<int>(config.CostEquipColor),

                        equipTypes = new List<int>(config.CostEquipPlace),

                        levels = new List<int>() { item.config.LV },

                        jobs = config.IsJobLimit == 1 ? new List<int>() { PlayerDatas.Instance.baseData.Job } : null,

                    });



                    for (int j = materials.Count - 1; j >= 0; j--)

                    {

                        var material = materials[j];

                        if (ItemLogicUtility.Instance.IsFightUp(material.itemId, material.score) == 1)

                        {

                            materials.RemoveAt(j);

                        }

                    }



                    var successRate = 0f;

                    foreach (var material in materials)

                    {

                        successRate += GetMaterialSuccessRate(equipPosition, material.guid);

                        if (successRate >= 0.5f)

                        {

                            break;

                        }

                    }



                    if (successRate < 0.5f)

                    {

                        continue;

                    }



                    minStarLevel = starLevel;

                    targetEquipPosition = new Int2(level, place);

                }

            }



            foreach (var starSet in equipStars.Values)

            {

                var level = starSet.level;

                if (!equipModel.IsLevelUnLocked(level))

                {

                    continue;

                }



                for (var place = 1; place <= 12; place++)

                {

                    var isRedpoint = level == targetEquipPosition.x && place == targetEquipPosition.y;

                    starSet.UpdateRedpoint(place, isRedpoint ? RedPointState.Simple : RedPointState.None);

                }

            }

        }



        private void OnUpdate()

        {

            if (redpointDirty && FuncOpen.Instance.IsFuncOpen(172))

            {

                redpointDirty = false;

                UpdateStarRedpoint();

            }

        }



        private int EquipStarUpgradeCandidateCompare(EquipStarUpgradeCandidate x, EquipStarUpgradeCandidate y)

        {

            var guidX = equipModel.GetEquip(x.equipPosition);

            var guidY = equipModel.GetEquip(y.equipPosition);

            if (!string.IsNullOrEmpty(guidX) && string.IsNullOrEmpty(guidY))

            {

                return -1;

            }



            if (string.IsNullOrEmpty(guidX) && !string.IsNullOrEmpty(guidY))

            {

                return 1;

            }

            return x.equipPosition.y.CompareTo(y.equipPosition.y);



            //var factorX = x.equipPosition.x * 100 + x.equipPosition.y;

            //var factorY = y.equipPosition.x * 100 + y.equipPosition.y;



            //if (string.IsNullOrEmpty(guidX) && string.IsNullOrEmpty(guidY))

            //{

            //    return factorX.CompareTo(factorY);

            //}



            //var equipX = packModel.GetItemByGuid(guidX);

            //var equipY = packModel.GetItemByGuid(guidY);



            //var canUpgradeStarLevelX = GetMaxStarLevel(equipX.config.ItemColor, equipX.config.LV) - GetStarLevel(x.equipPosition);

            //var canUpgradeStarLevelY = GetMaxStarLevel(equipY.config.ItemColor, equipY.config.LV) - GetStarLevel(y.equipPosition);



            //var compareResult = canUpgradeStarLevelX.CompareTo(canUpgradeStarLevelY);

            //if (compareResult != 0)

            //{

            //    return -compareResult;

            //}



            //return factorX.CompareTo(factorY);

        }



        private void ParseConfig()

        {

            var configs = EquipStarConfig.GetValues();

            foreach (var config in configs)

            {

                if (!equipStars.ContainsKey(config.Level))

                {

                    equipStars[config.Level] = new EquipSetStar(config.Level);

                }

            }

        }



        public struct Star

        {

            public bool actived;

            public bool newGet;

        }



    }

}




 System/EquipStar/EquipStarSuccessWin.cs

@@ -119,27 +119,29 @@
            var maxStarLevel = EquipStarModel.GetMaxStarLevel(model.equipPosition.x);
            var currentStar = model.star;

            for (int i = 0; i < m_Stars.Length; i++)
            var iconCnt = m_Stars.Length;
            for (int i = 0; i < iconCnt; i++)
            {
                var behaviour = m_Stars[i];
                if (i < maxStarLevel)
                {
                    if (i < currentStar)
                    {
                        behaviour.Display(true);
                        if (i == currentStar - 1)
                        var loopIndex = (currentStar / iconCnt * iconCnt + i < currentStar ? currentStar / iconCnt * iconCnt + i : i) / iconCnt;
                        behaviour.Display(true, loopIndex);
                        if (i == (currentStar - 1) % iconCnt)
                        {
                            behaviour.Display(false);
                            behaviour.Display(false, loopIndex);
                            Clock.AlarmAfter(1f, () =>
                            {
                                behaviour.Display(true);
                                behaviour.Display(true, loopIndex);
                                behaviour.PlayScaleAnimation();
                            });
                        }
                    }
                    else
                    {
                        behaviour.Display(false);
                        behaviour.Display(false, 0);
                    }
                }
                else
@@ -349,11 +351,12 @@
            public Image imageBase;
            public Image imageStar;

            public void Display(bool active)
            public void Display(bool active, int loopIndex)
            {
                container.SetActive(true);
                imageStar.SetActive(active);
                imageStar.transform.localScale = Vector3.one;
                imageStar.SetSprite("ImgStar_" + loopIndex);
            }

            public void Hide()

 System/EquipStar/EquipStarUpgradeSpecialMaterialBehaviour.cs

@@ -1,54 +1,56 @@
//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Tuesday, March 26, 2019
//--------------------------------------------------------
using UnityEngine;
using System.Collections;
using UnityEngine.UI;

namespace Snxxz.UI
{

    public class EquipStarUpgradeSpecialMaterialBehaviour : MonoBehaviour
    {
        [SerializeField] RectTransform m_Empty;
        [SerializeField] ItemBehaviour m_Item;
        [SerializeField] Text m_Count;
        [SerializeField] RectTransform m_Locked;

        PackModel packModel { get { return ModelCenter.Instance.GetModel<PackModel>(); } }

        bool isUnLocked = false;
        int itemId = 0;
        int itemNeed = 0;

        public void Display(bool isUnLocked, int itemId, int itemNeed)
        {
            this.isUnLocked = isUnLocked;
            this.itemId = itemId;
            this.itemNeed = itemNeed;

            DisplayBaseInfo();
        }

        private void DisplayBaseInfo()
        {
            m_Locked.SetActive(!isUnLocked);
            m_Empty.SetActive(!isUnLocked);
            m_Item.SetActive(isUnLocked);
            m_Count.SetActive(isUnLocked);

            if (isUnLocked)
            {
                var own = packModel.GetItemCountByID(PackType.Item, itemId);
                m_Item.SetItem(itemId, 1);
                m_Count.text = StringUtility.Contact(own, "/", itemNeed);
                m_Count.color = UIHelper.GetUIColor(own >= itemNeed ? TextColType.Green : TextColType.Red);
            }
        }
    }

}



//--------------------------------------------------------

//    [Author]:           第二世界

//    [  Date ]:           Tuesday, March 26, 2019

//--------------------------------------------------------

using UnityEngine;

using System.Collections;

using UnityEngine.UI;



namespace Snxxz.UI

{



    public class EquipStarUpgradeSpecialMaterialBehaviour : MonoBehaviour

    {

        [SerializeField] RectTransform m_Empty;

        [SerializeField] ItemCell m_Item;

        [SerializeField] RectTransform m_Locked;



        PackModel packModel { get { return ModelCenter.Instance.GetModel<PackModel>(); } }



        bool isUnLocked = false;

        int itemId = 0;

        int itemNeed = 0;



        public void Display(bool isUnLocked, int itemId, int itemNeed)

        {

            this.isUnLocked = isUnLocked;

            this.itemId = itemId;

            this.itemNeed = itemNeed;



            DisplayBaseInfo();

        }



        private void DisplayBaseInfo()

        {

            m_Locked.SetActive(!isUnLocked);

            m_Empty.SetActive(!isUnLocked);

            m_Item.SetActive(isUnLocked);



            if (isUnLocked)

            {

                var own = packModel.GetItemCountByID(PackType.Item, itemId);

                m_Item.Init(new ItemCellModel(itemId, false, 1));

                m_Item.button.AddListener(() => {

                    ItemTipUtility.Show(itemId);

                });

                m_Item.countText.SetActive(true);

                m_Item.countText.text = StringUtility.Contact(own, "/", itemNeed);

                m_Item.countText.color = UIHelper.GetUIColor(own >= itemNeed ? TextColType.Green : TextColType.Red);

            }

        }

    }



}








 System/EquipStar/EquipStarWin.cs

@@ -21,10 +21,9 @@
        [SerializeField] Star[] m_Stars;
        [SerializeField] ItemCell m_TargetEquip;
        [SerializeField] Text m_EquipStar;
        [SerializeField] EquipStarMaterialSelectButton m_MaterialSelect;
        [SerializeField] EquipStarUpgradeSpecialMaterialBehaviour m_SpecialMaterial;
        [SerializeField] EquipStarUpgradeSpecialMaterialBehaviour m_SpecialMaterial1;
        [SerializeField] EquipStarUpgradeSpecialMaterialBehaviour m_SpecialMaterial2;

        [SerializeField] Text m_SuccessRate;
        [SerializeField] RectTransform m_EmptyHint;
        [SerializeField] RectTransform m_PropertyDetails;
        [SerializeField] BaseProperty[] m_BasePropertys;
@@ -32,14 +31,9 @@
        [SerializeField] Button m_StarUpgrade;
        [SerializeField] RectTransform m_MaxStarLevelHint;
        [SerializeField] Button m_Preview;
        [SerializeField] UIEffect m_EffectStarFill;
        [SerializeField] UIEffect m_EffectSuccess;
        [SerializeField] UIEffect m_EffectFailed;

        [SerializeField] ToggleButton m_Auto;
        [SerializeField] Text m_AutoMoney;
        [SerializeField] RectTransform m_AutoTextContainer;
        [SerializeField] Text m_UnAutoText;
        [SerializeField] RectTransform m_AutoContainer;

        List<EquipStarLevelSelectBehaviour> levelBehaviours = new List<EquipStarLevelSelectBehaviour>();
@@ -72,22 +66,11 @@
        private void ShowAuto()
        {
            m_Auto.isOn = !m_Auto.isOn;
            if (m_Auto.isOn)
            {
                model.QueryAutoBuy();
            }
            else
            {
                model.autoBuy.value = -1;

                model.CalculateStarUpgradeProbability(new Int2(model.selectedLevel.value, model.selectedPlace.value));
            }
            model.autoBuy.value = -1;
        }

        public void ShowAutoText(int money)
        {
            //"8888自动提升至100%成功率（与全服拍卖同步）"
            //m_LevelLimit.colorType = 
            var color = PlayerDatas.Instance.baseData.bindDiamond >= money ? TextColType.Green : TextColType.Red;
            m_AutoMoney.text = Language.Get("StartUpAutoBuy", UIHelper.AppendColor(color, money.ToString(), true));

@@ -165,12 +148,6 @@

        private void OnItemCountRefresh(int index)
        {
            //var equipPosition = new Int2(model.selectedLevel.value, model.selectedPlace.value);
            //var currentStarLevel = model.GetEquipStarLevel(equipPosition);
            //model.normalMaterials.Fetch();
            //DisplayMaterialSlots(equipPosition, currentStarLevel);
            model.normalMaterials.dirty = true;
            model.CalculateStarUpgradeProbability(new Int2(model.selectedLevel.value, model.selectedPlace.value));

        }

@@ -179,35 +156,6 @@
        private void DisplayBaseInfo()
        {
            CreateLevelBehaviours();
        }

        private void DisplayerAutoBuy()
        {
            //特殊四件和满星不需要自动购买
            if (model.equipMaxStarLevel.value == model.equipStarLevel.value)
            {
                m_AutoContainer.SetActive(false);
                m_SuccessRate.text = string.Empty;
                return;
            }
            if (model.selectedPlace.value > 8 && model.selectedPlace.value <= 12)
            {
                m_AutoContainer.SetActive(false);
                model.autoBuy.value = -1;
                var equipPosition = new Int2(model.selectedLevel.value, model.selectedPlace.value);
                var equipGuid = equipModel.GetEquip(equipPosition);
                var equip = packModel.GetItemByGuid(equipGuid);
                if (equip == null)
                { 
                    m_SuccessRate.text = string.Empty;
                }
                return;
            }
            m_AutoContainer.SetActive(true);
            if (model.autoBuy.value != -1)
            {
                    model.QueryAutoBuy();
            }
        }


@@ -273,15 +221,6 @@
                DisplayStars(model.stars.Fetch());
            }

            if (force || model.starUpgradeProbability.dirty)
            {
                if (model.selectedPlace.value > 8 && model.selectedPlace.value <= 12)
                {
                    model.autoBuy.value = -1;
                }
                DisplaySuccessRate(model.starUpgradeProbability.Fetch());
                DisplayerAutoBuy();
            }

            if (force || model.starResultEffect.dirty)
            {
@@ -290,22 +229,12 @@
                PlayStarUpgradeEffect(result);
            }

            if (force || model.normalMaterials.dirty)
            {
                var equipPosition = new Int2(model.selectedLevel.value, model.selectedPlace.value);
                var currentStarLevel = model.GetEquipStarLevel(equipPosition);
                model.normalMaterials.Fetch();
                DisplayMaterialSlots(equipPosition, currentStarLevel);
            }


            if (force || model.autoBuy.dirty)
            {
                if (model.equipMaxStarLevel.value == model.equipStarLevel.value)
                {
                    m_AutoTextContainer.SetActive(false);
                    m_UnAutoText.SetActive(false);
                    m_SuccessRate.text = string.Empty;
                }
                else
                {
@@ -314,27 +243,12 @@
                    {
                        //不勾选自动购买
                        m_Auto.isOn = false;
                        m_AutoTextContainer.SetActive(false);
                        m_UnAutoText.SetActive(true);
                        m_UnAutoText.text = Language.Get("StarAutoBuy1");

                    }
                    else if (value == -2)
                    {
                        //勾选自动购买 但拍卖行装备不足
                        m_Auto.isOn = true;
                        m_AutoTextContainer.SetActive(false);
                        m_UnAutoText.SetActive(true);
                        m_UnAutoText.text = Language.Get("StarAutoBuy2");
                        DisplaySuccessRate(100);
                        ShowAutoText(value);
                    }
                    else
                    {
                        m_Auto.isOn = true;
                        m_AutoTextContainer.SetActive(true);
                        m_UnAutoText.SetActive(false);
                        ShowAutoText(value);
                        DisplaySuccessRate(100);
                    }
                }
                
@@ -410,31 +324,16 @@

            if (!upgradable || isMax )
            {
                m_MaterialSelect.Display(true, 0);
                m_SpecialMaterial.Display(false, 0, 0);
                m_SpecialMaterial1.Display(false, 0, 0);
                m_SpecialMaterial2.Display(false, 0, 0);
            }
            else
            {
                var starConfig = EquipStarConfig.Get(equipPosition.x, equipPosition.y, currentStarLevel + 1);
                var needEquip = starConfig.CostEquipCnt > 0;
                if (needEquip)
                {
                    if (model.normalMaterials.Count > 0)
                    {
                        var item = packModel.GetItemByGuid(model.normalMaterials[0]);
                        m_MaterialSelect.Display(false, item != null ? item.itemId : 0);
                    }
                    else
                    {
                        m_MaterialSelect.Display(false, 0);
                    }
                }
                else
                {
                    m_MaterialSelect.Display(true, 0);
                }

                m_SpecialMaterial.Display(starConfig.CostItemDict.x != 0, starConfig.CostItemDict.x, starConfig.CostItemDict.y);

                m_SpecialMaterial1.Display(starConfig.CostItemDict[0].x != 0, starConfig.CostItemDict[0].x, starConfig.CostItemDict[0].y);
                m_SpecialMaterial2.Display(starConfig.CostItemDict[1].x != 0, starConfig.CostItemDict[1].x, starConfig.CostItemDict[1].y);
            }
        }

@@ -509,32 +408,7 @@
            }
        }

        private void DisplaySuccessRate(int successRate)
        {
            if (model.autoBuy.value != -1) successRate = 100;   //有勾选即100%

            if (successRate >= 0)
            {
                m_SuccessRate.text = Language.Get("EquipStar13", successRate);

                if (successRate < 50)
                {
                    m_SuccessRate.color = UIHelper.GetUIColor(TextColType.Red, true);
                }
                else if (successRate < 80)
                {
                    m_SuccessRate.color = UIHelper.GetUIColor(TextColType.NavyBrown, true);
                }
                else
                {
                    m_SuccessRate.color = UIHelper.GetUIColor(TextColType.Green, true);
                }
            }
            else
            {
                m_SuccessRate.text = string.Empty;
            }
        }
        

        private void DisplayStarUpgradeButton(Int2 equipPosition, int currentStarLevel)
        {
@@ -621,19 +495,19 @@
            }
        }

        IEnumerator Co_PlaySuccessEffect()
        {
            m_EffectStarFill.Play();
            yield return WaitingForSecondConst.WaitMS700;
            m_EffectSuccess.Play();
        }
        //IEnumerator Co_PlaySuccessEffect()
        //{
        //    m_EffectStarFill.Play();
        //    yield return WaitingForSecondConst.WaitMS700;
        //    m_EffectSuccess.Play();
        //}

        IEnumerator Co_PlayFailedEffect()
        {
            m_EffectStarFill.Play();
            yield return WaitingForSecondConst.WaitMS700;
            m_EffectFailed.Play();
        }
        //IEnumerator Co_PlayFailedEffect()
        //{
        //    m_EffectStarFill.Play();
        //    yield return WaitingForSecondConst.WaitMS700;
        //    m_EffectFailed.Play();
        //}

        IEnumerator Co_DisplayStars(List<EquipStarModel.Star> stars)
        {

 System/FairyAu/ExchangeActiveTokenModel.cs

@@ -30,18 +30,18 @@
    {

        ChoseEquips = new HashSet<ItemModel>();

        ParseConfig();

        m_PackModel.refreshItemCountEvent += RefreshRealmEquIsAllMaxStarDicAndRedPoint;

        //m_PackModel.refreshItemCountEvent += RefreshRealmEquIsAllMaxStarDicAndRedPoint;

    }





    public override void UnInit()

    {

        m_PackModel.refreshItemCountEvent -= RefreshRealmEquIsAllMaxStarDicAndRedPoint;

        //m_PackModel.refreshItemCountEvent -= RefreshRealmEquIsAllMaxStarDicAndRedPoint;

    }



    public void OnPlayerLoginOk()

    {

        UpdateExchangeBtnRedPoint();

        //UpdateExchangeBtnRedPoint();

    }



    #region 交换活跃度按钮红点

@@ -71,14 +71,14 @@
        }

        int lv = ItemConfig.Get(itemId).LV;

        SetRealmEquIsAllMaxStar(lv);

        foreach (var value in m_RealmEquIsAllMaxStarDic.Values)

        {

            if (value)

            {

                UpdateExchangeBtnRedPoint();

                break;

            }

        }

        //foreach (var value in m_RealmEquIsAllMaxStarDic.Values)

        //{

        //    if (value)

        //    {

        //        UpdateExchangeBtnRedPoint();

        //        break;

        //    }

        //}

    }

    //某个境界的装备是否满级

    public void SetRealmEquIsAllMaxStar(int Lv)


 System/FairyAu/FairyBasicFunctionWin.cs

@@ -90,10 +90,10 @@


        private void OnExchangeBtnDown()

        {

            if (m_ExchangeActiveTokenModel.ExchangeBtnRedPoint.state != RedPointState.None)

            {

                m_ExchangeActiveTokenModel.ExchangeBtnRedPoint.state = RedPointState.None;

            }

            //if (m_ExchangeActiveTokenModel.ExchangeBtnRedPoint.state != RedPointState.None)

            //{

            //    m_ExchangeActiveTokenModel.ExchangeBtnRedPoint.state = RedPointState.None;

            //}

            WindowCenter.Instance.Open<ExchangeActiveTokenWin>();

        }




 System/ItemTip/ItemTipUtility.cs

@@ -1446,39 +1446,31 @@
            var eightSuits = new Dictionary<int, bool>();
            var eightSuitLevel = equiped ? equipModel.GetSuitLevel(config.LV, EquipSuitType.EightSuit) : -1;

            var twoSuitProperties0 = equipModel.GetEquipSuitEntry(config.LV, 0, EquipSuitType.TwoSuit);
            var fiveSuitProperties0 = equipModel.GetEquipSuitEntry(config.LV, 0, EquipSuitType.FiveSuit);

            if (!equiped)
            {
                twoSuitProperties0.actived = false;
                fiveSuitProperties0.actived = false;
            if (!equiped)

            {

                var suit2 = equipModel.GetEquipSuitEntry(config.LV, 0, EquipSuitType.TwoSuit);

                suit2.actived = false;

                var suit5 = equipModel.GetEquipSuitEntry(config.LV, 0, EquipSuitType.FiveSuit);

                suit5.actived = false;

                twoSuitProperties[0] = suit2;

                fiveSuitProperties[0] = suit5;

                eightSuits[0] = eightSuitLevel >= 0;

            }
            else

            {

                foreach (var star in EquipStarModel.StarList)

                {

                    if (maxSuitLevel >= star)

                    {

                        twoSuitProperties[star] = equipModel.GetEquipSuitEntry(config.LV, star, EquipSuitType.TwoSuit);

                        fiveSuitProperties[star] = equipModel.GetEquipSuitEntry(config.LV, star, EquipSuitType.FiveSuit);

                        eightSuits[star] = eightSuitLevel >= star;

                    }

                }
            }

            twoSuitProperties[0] = twoSuitProperties0;
            fiveSuitProperties[0] = fiveSuitProperties0;
            eightSuits[0] = eightSuitLevel >= 0;

            if (maxSuitLevel >= 3)
            {
                twoSuitProperties[3] = equipModel.GetEquipSuitEntry(config.LV, 3, EquipSuitType.TwoSuit);
                fiveSuitProperties[3] = equipModel.GetEquipSuitEntry(config.LV, 3, EquipSuitType.FiveSuit);
                eightSuits[3] = eightSuitLevel >= 3;
            }

            if (maxSuitLevel >= 6)
            {
                twoSuitProperties[6] = equipModel.GetEquipSuitEntry(config.LV, 6, EquipSuitType.TwoSuit);
                fiveSuitProperties[6] = equipModel.GetEquipSuitEntry(config.LV, 6, EquipSuitType.FiveSuit);
                eightSuits[6] = eightSuitLevel >= 3;
            }

            if (maxSuitLevel >= 9)
            {
                twoSuitProperties[9] = equipModel.GetEquipSuitEntry(config.LV, 9, EquipSuitType.TwoSuit);
                fiveSuitProperties[9] = equipModel.GetEquipSuitEntry(config.LV, 9, EquipSuitType.FiveSuit);
                eightSuits[9] = eightSuitLevel >= 9;
            }

            var suitInfo = new SuitInfo()
            {

 System/ItemTip/TipSuitPropertyWidget.cs

@@ -42,13 +42,9 @@
            m_StarsContainer.SetActive(maxLevel >= 0);
            if (maxLevel >= 0)
            {
                m_StarToggles[0].SetActive(true, DisplaySuitInfo);
                m_StarToggles[1].SetActive(maxLevel >= 3, DisplaySuitInfo);
                m_StarToggles[2].SetActive(maxLevel >= 6, DisplaySuitInfo);
                m_StarToggles[3].SetActive(maxLevel >= 9, DisplaySuitInfo);

                for (int i = 0; i < m_StarToggles.Length; i++)
                {
                    m_StarToggles[i].SetActive(m_StarToggles[i].star <= maxLevel, DisplaySuitInfo);
                    m_StarToggles[i].toggle.isOn = i == highestEightSuitLevel / 3;
                }
            }

 System/KnapSack/Logic/EquipDevourWin.cs

@@ -34,6 +34,7 @@
        [SerializeField] Image getMatBgImg;

        [SerializeField] Image getMatIcon;

        [SerializeField] Text getMatProgressText;

        [SerializeField] ButtonEx gotoShenfj;



        [SerializeField] int singleLineNum = 5;

        [SerializeField] int sumGridNum = 100;

@@ -54,6 +55,10 @@
            equipColorSelectBtn.AddListener(ClickColorSelectBtn);

            devourBtn.AddListener(ClickEquipDecomBtn);

            colorSpaceClick.AddListener(ClickColorSelectBtn);

            gotoShenfj.AddListener(() =>

            {

                WindowCenter.Instance.Open("EquipShenDecomposeWin");

            });

        }



        protected override void OnPreOpen()

@@ -419,10 +424,11 @@
            var count = 0;

            foreach (var item in itemModels)

            {

                if (ItemLogicUtility.Instance.IsFightUp(item.itemId, item.score) == 1)

                if (item.isAuction || ItemLogicUtility.Instance.IsFightUp(item.itemId, item.score) == 1)

                {

                    count += item.count;

                }

                
            }

            return count;

        }


 System/KnapSack/Logic/PackModel.cs

@@ -1,1793 +1,1793 @@
using System;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
using LitJson;
using System.Text.RegularExpressions;
using System.Collections;

namespace Snxxz.UI
{
    
    public class PackModel : Model, IBeforePlayerDataInitialize, IAfterPlayerDataInitialize, IPlayerLoginOk
    {
        public static string StrengthAttrShift_RecordKey = "";
        public const string RecordKnapsackTitle = "RecordKnapsackTitle";

        Dictionary<int, int> DrugToDungeonDict { get; set; }   //key 丹药ID,value副本ID
        Dictionary<int, int[]> DungeonToDrugDict { get; set; }  //key 副本ID,value丹药ID列表
        public List<AttrFruitConfig> makeDruglist { get; private set; }
        Dictionary<int, Dictionary<int, int>> decomposeAttrDict = new Dictionary<int, Dictionary<int, int>>();
        string RoleEquipLocalSave = "";
        List<int> LocalSavePlaceArray { get; set; }
        Dictionary<int, List<int>> sharedUseCountItemDict { get; set; }
        bool isUpdatePlayerLv = false;

        AlchemyModel alchemyModel { get { return ModelCenter.Instance.GetModel<AlchemyModel>(); } }
        ItemTipsModel itemTipsModel { get { return ModelCenter.Instance.GetModel<ItemTipsModel>(); } }

        public int lsItemID = 150; //可兑换的灵石物品ID
        int lsItemCnt = int.Parse(FuncConfigConfig.Get("LingshiShowCount").Numerical1);

        public int[] autoUseItemIDs;
        UIEffect lingshiEffect;  //灵石特效
        public override void Init()
        {
            ParseConfig();
            SysNotifyMgr.Instance.sysNotifyEvent += RefreshSysInfo;
            List<DungeonOpenTimeConfig> dungeonlist = DungeonOpenTimeConfig.GetValues();
            if (dungeonlist != null)
            {
                //DrugToDungeonDict = new Dictionary<int, int>();
                DungeonToDrugDict = new Dictionary<int, int[]>();

                for (int i = 0; i < dungeonlist.Count; i++)
                {
                    int[] drugIdlist = dungeonlist[i].ElixirHint;
                    if (drugIdlist != null && drugIdlist.Length > 0)
                    {
                        DungeonToDrugDict.Add(dungeonlist[i].DataMapID, drugIdlist);
                        //for (int j = 0; j < drugIdlist.Length; j++)
                        //{
                        //    DrugToDungeonDict.Add(drugIdlist[j], dungeonlist[i].DataMapID);
                        //}
                    }
                }
            }

            makeDruglist = new List<AttrFruitConfig>();
            List<AttrFruitConfig> fruitlist = AttrFruitConfig.GetValues();
            for (int i = 0; i < fruitlist.Count; i++)
            {
                if (fruitlist[i].FuncID == 2)
                {
                    makeDruglist.Add(fruitlist[i]);
                }
            }
            StageLoad.Instance.onStageLoadFinish += OnStageLoadFinish;

            SetDevourEquipPlace();

            decomposeAttrDict.Clear();
            List<EquipDeComposeConfig> decomlist = EquipDeComposeConfig.GetValues();
            for (int i = 0; i < decomlist.Count; i++)
            {
                JsonData attrData = JsonMapper.ToObject(decomlist[i].Attr);
                Dictionary<int, int> attrDict = new Dictionary<int, int>();
                decomposeAttrDict.Add(decomlist[i].LV, attrDict);
                foreach (var id in attrData.Keys)
                {
                    attrDict.Add(int.Parse(id), int.Parse(attrData[id].ToString()));
                }
            }

            FuncConfigConfig equipDecompose = FuncConfigConfig.Get("EquipDevourCount");
            minDecomposeNum = int.Parse(equipDecompose.Numerical1);
            defaultUnSelectlist = ConfigParse.GetMultipleStr<int>(equipDecompose.Numerical2);

            FuncConfigConfig ShareUseCntItem = FuncConfigConfig.Get("ShareUseCntItem");
            sharedUseCountItemDict = new Dictionary<int, List<int>>();
            JsonData shareUseJson = JsonMapper.ToObject(ShareUseCntItem.Numerical1);
            if (shareUseJson.IsArray)
            {
                for (int i = 0; i < shareUseJson.Count; i++)
                {
                    var idListJson = shareUseJson[i];
                    var idlist = new List<int>();
                    sharedUseCountItemDict.Add(i, idlist);
                    foreach (var id in idListJson)
                    {
                        idlist.Add(int.Parse(id.ToString()));
                    }
                }
            }

            ParseItemCount();

            autoUseItemIDs = JsonMapper.ToObject<int[]>(FuncConfigConfig.Get("ItemTipsNum").Numerical2);
        }

        public Dictionary<int, string> textCountShow = new Dictionary<int, string>();
        public int[] textCountShow2;

        public void ParseItemCount()
        {
            var textConfig = FuncConfigConfig.Get("ItemCountShow");
            var json = JsonMapper.ToObject(textConfig.Numerical1);
            foreach (var key in json.Keys)
            {
                var itemID = int.Parse(key);
                textCountShow[itemID] = json[key].ToString();
            }

            textCountShow2 = JsonMapper.ToObject<int[]>(textConfig.Numerical2);
        }


        private void OnFuncStateChangeEvent(int id)
        {
            if (id == (int)FuncOpenEnum.EquipDecompose)
            {
                EquipDecomRedCtrl();
            }
        }
        public void OnBeforePlayerDataInitialize()
        {
            GlobalTimeEvent.Instance.secondEvent -= UpdateSecond;
            PlayerDatas.Instance.playerDataRefreshEvent -= UpdatePlayerLv;
            LocalSave.DeleteKey(RecordKnapsackTitle);
            cacheMapId = 0;
            playerPackDict.Clear();
            itemDayUseCntDict.Clear();
            itemSumUseCntDict.Clear();
            itemGUIDDict.Clear();
            isPlayBetterEquipEffect = false;
            colorType = EquipColorType.Purple;
            decomposeLv = 1;
            decomposeExp = 0;
            decomposeProgress = 0;
            isAutoDecompose = false;
        }

        public void OnAfterPlayerDataInitialize()
        {

        }

        public void OnPlayerLoginOk()
        {
            ItemOperateUtility.Instance.RequestWarehouseData();
            EquipDecomRedCtrl();
            RoleEquipLocalSave = StringUtility.Contact("RoleEquipLocalSave", PlayerDatas.Instance.baseData.PlayerID);
            StrengthAttrShift_RecordKey = StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID, "StrengthAttrShift");
            if (LocalSave.GetIntArray(RoleEquipLocalSave) != null)
            {
                LocalSavePlaceArray = LocalSave.GetIntArray(RoleEquipLocalSave).ToList();
            }
            else
            {
                LocalSavePlaceArray = null;
            }
            GlobalTimeEvent.Instance.secondEvent += UpdateSecond;
            PlayerDatas.Instance.playerDataRefreshEvent += UpdatePlayerLv;
            isUpdatePlayerLv = true;
            FuncOpen.Instance.OnFuncStateChangeEvent += OnFuncStateChangeEvent;
        }

        private void RefreshSysInfo(string key, ArrayList infolist)
        {
            if (key != "GetMoney") return;

            if (WindowCenter.Instance.IsOpen("GodKingRandomGiftWin"))
            {
                return;
            }

            var type = 0;
            int.TryParse(infolist[0].ToString(), out type);
            if (type != 2) return;
            Vector3 pos = new Vector3(-100, 0, 0);
            Vector3 rot = new Vector3(0, 0, 0);
            if (!WindowCenter.Instance.IsOpen<MainInterfaceWin>())
            {
                pos = new Vector3(150, 50, 0);
                rot = new Vector3(180, 180, 0);
            }
            lingshiEffect = EffectMgr.Instance.PlayUIEffect(1158, 2500, WindowCenter.Instance.uiRoot.tipsCanvas, pos, rot, false);


        }
        public override void UnInit()
        {
            FuncOpen.Instance.OnFuncStateChangeEvent -= OnFuncStateChangeEvent;
            SysNotifyMgr.Instance.sysNotifyEvent -= RefreshSysInfo;
        }

        public event Action<PackType> refrechPackEvent; //刷新整个背包数据
        public event Action<PackType, int, int> refreshItemCountEvent; //（单个）最新物品数量刷新(旧的弃用)在得到新物品、物品数量的改变，清理该物品时均会触发 int 位置索引 int物品id
        public event Action<PackType> gridRefreshEvent; //背包空格刷新
        public event Action<PackType, int, int> itemCntAddEvent; //物品数量增加 int 位置索引 int物品id
        public event Action<PackType, int, int> itemCntReduceEvent; //物品数量减少的改变 int 位置索引 int物品id
        public event Action<int, int> useItemSuccessEvent; //物品使用成功 int 位置索引 int物品id

        public event Action<int> refreshItemDayUseCountEvent;  //刷新物品每日使用数量
        public event Action<int> refreshItemSumUseCountEvent;  //刷新物品总使用数量

        public bool isPlayBetterEquipEffect { get; set; }  //整理背包时是否播放特效

        #region 接收服务端数据
        private Dictionary<PackType, SinglePack> playerPackDict = new Dictionary<PackType, SinglePack>();
        private Dictionary<string, ItemModel> itemGUIDDict = new Dictionary<string, ItemModel>();

        public void UpdatePack(H0725_tagRolePackRefreshEx packInfo)
        {
            SetLookIndex(null);
            var packType = (PackType)packInfo.PackType;
            if (!playerPackDict.ContainsKey(packType))
            {
                playerPackDict.Add(packType, new SinglePack(packType));
            }

            if (isPlayBetterEquipEffect)
            {
                ItemLogicUtility.Instance.ClearSortedBetterEquip();
            }

            for (int i = 0; i < packInfo.ItemCount; i++)
            {
                var itemInfo = new ItemInfo(packInfo.ItemInfo[i]);
                var item = playerPackDict[packType].UpdateItem(itemInfo);
                AddItemGUIDDict(item, false);

                if (isPlayBetterEquipEffect)
                {
                    ItemLogicUtility.Instance.SetBagSortBetterEquipList(GetItemByGuid(itemInfo.guid));
                }
            }

            if (refrechPackEvent != null)
            {
                refrechPackEvent(packType);
            }

            UpdatePackRedpoint(packType);
        }

        public void UpdateItem(H0704_tagRolePackRefresh serverItem)
        {
            isPlayBetterEquipEffect = false;
            SetLookIndex(null);
            PackType type = (PackType)serverItem.PackType;
            if (!playerPackDict.ContainsKey(type))
            {
                playerPackDict.Add(type, new SinglePack(type));
            }

            var showNewItem = false;
            if (itemGUIDDict.ContainsKey(serverItem.ItemGUID))
            {
                var prePack = itemGUIDDict[serverItem.ItemGUID].packType;
                var preAuction = itemGUIDDict[serverItem.ItemGUID].isAuction;
                var nowPackType = type;
                var nowAcution = serverItem.IsBind == 1;
                showNewItem = preAuction != nowAcution || prePack != nowPackType;
            }
            else
            {
                showNewItem = true;
            }

            var itemInfo = new ItemInfo(serverItem);
            var item = playerPackDict[type].UpdateItem(itemInfo);
            AddItemGUIDDict(item, showNewItem);

            if (refreshItemCountEvent != null)
            {
                refreshItemCountEvent(type, itemInfo.index, itemInfo.itemId);
            }

            if (itemCntAddEvent != null)
            {
                itemCntAddEvent(type, itemInfo.index, itemInfo.itemId);
            }

            if (type == PackType.Equip)
            {
                if (ItemLogicUtility.Instance.IsRealmEquip(itemInfo.itemId))
                {
                    ItemOperateUtility.Instance.ShowPutOnNewEquipRemind(itemInfo.itemId);
                }
            }

            UpdatePackRedpoint(type);
            EquipDecomRedCtrl();
            AutoUseItem(itemInfo.itemId, serverItem.ItemGUID);
        }

        public void UpdateUnlockedGridCount(H0724_tagRolePackCanUseCount useCount)
        {
            PackType type = (PackType)useCount.PackType;
            if (!playerPackDict.ContainsKey(type))
            {
                playerPackDict.Add(type, new SinglePack(type));
            }

            playerPackDict[type].SetOpenGridCount(useCount.CanUseCount);

            if (gridRefreshEvent != null)
            {
                gridRefreshEvent(type);
            }

            UpdatePackRedpoint(type);
        }

        public void RefreshItemCount(H0707_tagItemCountRefresh refresh)
        {
            SetLookIndex(null);
            isPlayBetterEquipEffect = false;
            PackType type = (PackType)refresh.PackType;
            SinglePack singlePack = null;
            playerPackDict.TryGetValue(type, out singlePack);

            if (singlePack != null)
            {
                ItemModel itemModel = singlePack.GetItemByIndex(refresh.ItemIndex);
                if (itemModel != null)
                {
                    bool isAddItemCount = false;
                    if (refresh.ItemCount > itemModel.count)
                    {
                        isAddItemCount = true;
                    }
                    itemModel.RefreshCount(refresh.ItemCount);

                    if (isAddItemCount)
                    {
                        if (itemCntAddEvent != null)
                        {
                            itemCntAddEvent(type, itemModel.gridIndex, itemModel.itemId);
                        }
                        ItemLogicUtility.Instance.RecommendItem(itemModel);
                        ItemLogicUtility.Instance.RefreshPickItem(type, itemModel.itemId.ToString());
                    }
                    else
                    {
                        if (itemCntReduceEvent != null)
                        {
                            itemCntReduceEvent(type, itemModel.gridIndex, itemModel.itemId);
                        }
                    }

                    if (refreshItemCountEvent != null)
                    {
                        refreshItemCountEvent(type, itemModel.gridIndex, itemModel.itemId);
                    }

                    UpdateLSRedpoint(type, itemModel.itemId);
                }
            }

        }

        public void ClearPack(H0711_tagClearItemPack clearPack)
        {
            PackType type = (PackType)clearPack.PackIndex;
            SinglePack singlePack = null;
            playerPackDict.TryGetValue(type, out singlePack);
            if (singlePack != null)
            {
                singlePack.Clear();
            }
        }

        public void RemoveItem(H0709_tagClearItem clearItem)
        {
            isPlayBetterEquipEffect = false;
            SetLookIndex(null);
            PackType type = (PackType)clearItem.PackType;

            SinglePack singlePack = null;
            playerPackDict.TryGetValue(type, out singlePack);
            string guid = "";
            if (singlePack != null)
            {
                ItemModel itemModel = singlePack.GetItemByIndex(clearItem.ItemIndex);
                guid = itemModel.guid;
                int itemId = itemModel.itemId;

                DeleteItemDictByGUID(type, itemModel.guid);

                singlePack.RemoveItem(clearItem.ItemIndex);
                if (refreshItemCountEvent != null)
                {
                    refreshItemCountEvent(type, clearItem.ItemIndex, itemId);
                }

                if (itemCntReduceEvent != null)
                {
                    itemCntReduceEvent(type, clearItem.ItemIndex, itemId);
                }
            }

            UpdatePackRedpoint(type);
            EquipDecomRedCtrl();

            if (GetItemByGuid(guid) == null)
            {
                KnapsackTimeCDMgr.Instance.UnRegister(guid);
            }

        }

        public void PackResetOk(H0316_tagPackResetOK packreset)
        {
            ItemLogicUtility.Instance.isPackResetOk = true;
        }

        public void UseItemSuccess(H0706_tagUseItemSuccess success)
        {
            isPlayBetterEquipEffect = false;
            SetLookIndex(null);
            if (success.PlayerID != PlayerDatas.Instance.baseData.PlayerID)
            {
                return;
            }

            MakeUseItemSuccess(success.ItemIndex, (int)success.ItemID);
            switch (success.ItemID)
            {
                case 221:
                    if (WindowCenter.Instance.IsOpen<KnapSackWin>())
                    {
                        WindowCenter.Instance.Close<KnapSackWin>();
                    }
                    break;
            }

            if (useItemSuccessEvent != null)
            {
                useItemSuccessEvent(success.ItemIndex, (int)success.ItemID);
            }
        }

        void AutoUseItem(int itemID, string guid)
        {
            if (autoUseItemIDs.Contains(itemID))
            {
                ItemOperateUtility.Instance.GotoUseItem(guid);
            }
        }

        private void MakeUseItemSuccess(int index, int id)
        {
            ItemConfig itemConfig = ItemConfig.Get(id);
            if (itemConfig.CDType != 0)
            {
                float configCdTime = (float)Math.Round((double)itemConfig.CDTime / 1000, 1);
                var items = GetItems(PackType.Item, new SinglePack.FilterParams()
                {
                    itemTypes = new List<int>() { (int)ItemType.Buff }
                });

                for (int i = 0; i < items.Count; i++)
                {
                    if (items[i].itemId == 901
                        || items[i].itemId == 902
                        || items[i].itemId == 903
                        || items[i].itemId == 904)
                    {
                        KnapsackTimeCDMgr.Instance.Register(items[i].guid, items[i].itemId, configCdTime);
                        break;
                    }
                }

            }
        }

        void AddItemGUIDDict(ItemModel itemModel, bool showNewItem)
        {
            itemGUIDDict[itemModel.guid] = itemModel;
            GetItemEventCtrl(itemModel, showNewItem);
        }

        void DeleteItemDictByGUID(PackType type, string guid)
        {
            if (itemGUIDDict.ContainsKey(guid))
            {
                if (itemGUIDDict[guid].packType == type)
                {
                    itemGUIDDict.Remove(guid);
                }
            }
        }

        /// <summary>
        /// 物品每日使用的次数
        /// </summary>
        private Dictionary<int, int> itemDayUseCntDict = new Dictionary<int, int>();
        public void UpdateItemUseCnt(HA809_tagMCItemDayUseCntInfo useCntInfo)
        {
            for (int i = 0; i < useCntInfo.Count; i++)
            {
                int itemId = (int)useCntInfo.ItemUseCntList[i].ItemID;
                int cnt = useCntInfo.ItemUseCntList[i].UseCnt;
                if (!itemDayUseCntDict.ContainsKey(itemId))
                {
                    itemDayUseCntDict.Add(itemId, cnt);
                }
                else
                {
                    itemDayUseCntDict[itemId] = cnt;
                }

                if (refreshItemDayUseCountEvent != null)
                {
                    refreshItemDayUseCountEvent(itemId);
                }

            }
        }

        private Dictionary<int, int> itemSumUseCntDict = new Dictionary<int, int>();
        public void UpdateItemSumUseCnt(HA339_tagMCAttrFruitEatCntList useCntInfo)
        {
            for (int i = 0; i < useCntInfo.count; i++)
            {
                int itemId = (int)useCntInfo.EatCntList[i].ItemID;
                int cnt = useCntInfo.EatCntList[i].EatCnt;
                if (!itemSumUseCntDict.ContainsKey(itemId))
                {
                    itemSumUseCntDict.Add(itemId, cnt);
                }
                else
                {
                    itemSumUseCntDict[itemId] = cnt;
                }

                if (refreshItemSumUseCountEvent != null)
                {
                    refreshItemSumUseCountEvent(itemId);
                }
            }
        }

        #endregion

        #region 玩家装备特殊逻辑
        public Dictionary<int, Dictionary<int, int>> spiritWeaponPathIds { get; private set; }
        public Dictionary<int, int> wingsGetPathIdDict { get; private set; }
        public Dictionary<int, List<int>> dungeonUseDict { get; private set; }
        void ParseConfig()
        {
            FuncConfigConfig funcConfig = FuncConfigConfig.Get("WingYuPeiHQTJ");
            spiritWeaponPathIds = new Dictionary<int, Dictionary<int, int>>();
            var splits = funcConfig.Numerical3.Split('|');
            for (int i = 0; i < splits.Length; i++)
            {
                var tempString = splits[i];
                var matches = Regex.Matches(tempString.Trim(), "\\d+");
                var equipPlace = int.Parse(matches[0].Value);
                var job = int.Parse(matches[1].Value);
                var itemId = int.Parse(matches[2].Value);

                if (!spiritWeaponPathIds.ContainsKey(equipPlace))
                {
                    spiritWeaponPathIds[equipPlace] = new Dictionary<int, int>();
                }

                spiritWeaponPathIds[equipPlace][job] = itemId;
            }

            FuncConfigConfig copyItemBulletWindow = FuncConfigConfig.Get("CopyItemBulletWindow");
            JsonData copyWinData = JsonMapper.ToObject(copyItemBulletWindow.Numerical1);
            dungeonUseDict = new Dictionary<int, List<int>>();
            foreach (var dungeonId in copyWinData.Keys)
            {
                List<int> idlist = new List<int>();
                dungeonUseDict.Add(int.Parse(dungeonId), idlist);
                if (copyWinData[dungeonId].IsArray)
                {
                    JsonData useData = copyWinData[dungeonId];
                    for (int i = 0; i < useData.Count; i++)
                    {
                        idlist.Add(int.Parse(useData[i].ToString()));
                    }
                }
            }
        }

        public int GetRoleEquipPathId(int equipPlace)
        {
            int playerJob = PlayerDatas.Instance.baseData.Job;
            switch ((RoleEquipType)equipPlace)
            {
                case RoleEquipType.Guard:
                case RoleEquipType.PeerlessWeapon1:
                case RoleEquipType.PeerlessWeapon2:
                case RoleEquipType.Wing:
                    return spiritWeaponPathIds[equipPlace][playerJob];
                default:
                    return 0;
            }
        }

        private void UpdateSecond()
        {
            if (isUpdatePlayerLv)
            {
                isUpdatePlayerLv = false;
            }
        }

        private void UpdatePlayerLv(PlayerDataType type)
        {
            if (type != PlayerDataType.LV) return;

            isUpdatePlayerLv = true;
        }

        #endregion
        private void GetItemEventCtrl(ItemModel itemModel, bool showNewItem)
        {
            if (showNewItem)
            {
                bool isOverdue = false;
                if (itemModel.config.ExpireTime > 0)
                {
                    ItemCDCool cool = KnapsackTimeCDMgr.Instance.GetItemCoolById(itemModel.guid);
                    switch ((ItemTimeType)itemModel.config.EndureReduceType)
                    {
                        case ItemTimeType.EquipedTime:
                            List<int> itemEffectTime = itemModel.GetUseData((int)ItemUseDataKey.createTime);
                            if (itemEffectTime != null && itemEffectTime[0] != 0)
                            {
                                if (cool == null || cool.GetRemainTime() <= 0)
                                {
                                    isOverdue = true;
                                }
                            }
                            break;

                        case ItemTimeType.RealityTime:
                            if (cool == null || cool.GetRemainTime() <= 0)
                            {
                                isOverdue = true;
                            }
                            break;

                    }
                }

                if (!isOverdue)
                {
                    ItemLogicUtility.Instance.RecommendItem(itemModel);
                    ItemLogicUtility.Instance.OnGetEquip(itemModel);
                    ItemLogicUtility.Instance.RefreshPickItem(itemModel.packType, itemModel.itemId.ToString());
                }
            }

        }

        /// <summary>
        /// 得到某个包裹的所有数据
        /// </summary>
        /// <param name="type"></param>
        /// <returns></returns>
        public SinglePack GetSinglePack(PackType type)
        {
            SinglePack singlePack = null;
            playerPackDict.TryGetValue(type, out singlePack);
            return singlePack;
        }

        public void UnLockPackGrid(int chooseGridCount, PackType type)
        {
            var singlePack = GetSinglePack(type);
            int openCount = chooseGridCount - singlePack.unlockedGridCount;
            int index = 0;
            switch (type)
            {
                case PackType.Item:
                    index = chooseGridCount - GeneralDefine.initBagGridCount;
                    break;
                case PackType.Warehouse:
                    index = chooseGridCount - GeneralDefine.initDepotGridCount;
                    break;
            }

            itemTipsModel.SetExtendGirdModel(openCount, index, type);
            WindowCenter.Instance.Open<ExtendWin>();
        }

        public ItemModel GetItemByGuid(string guid)
        {
            if (string.IsNullOrEmpty(guid))
            {
                return null;
            }

            ItemModel itemModel = null;
            itemGUIDDict.TryGetValue(guid, out itemModel);
            return itemModel;
        }

        public ItemModel GetItemByIndex(PackType type, int index)
        {
            ItemModel itemModel = null;
            if (playerPackDict.ContainsKey(type))
            {
                itemModel = playerPackDict[type].GetItemByIndex(index);
            }
            return itemModel;
        }

        /// <summary>
        /// 获取指定背包内 指定ID的所有物品
        /// </summary>
        /// <param name="type"></param>
        /// <param name="id"></param>
        /// <param name="includeAuction"></param>
        /// <returns></returns>
        public List<ItemModel> GetItemsById(PackType type, int id, bool includeAuction = true)
        {
            if (playerPackDict.ContainsKey(type))
            {
                var singlePack = playerPackDict[type];
                return singlePack.GetItemsById(id, includeAuction);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        /// 获取指定背包内指定ID的一个物品
        /// </summary>
        /// <param name="type"></param>
        /// <param name="id"></param>
        /// <param name="includeAuction"></param>
        /// <returns></returns>
        public ItemModel GetItemByID(PackType type, int id, bool includeAuction = true)
        {
            if (playerPackDict.ContainsKey(type))
            {
                var singlePack = playerPackDict[type];
                return singlePack.GetItemByID(id, includeAuction);
            }
            else
            {
                return null;
            }
        }
        
        public List<ItemModel> GetItems(PackType packType, SinglePack.FilterParams param)
        {
            if (playerPackDict.ContainsKey(packType))
            {
                return playerPackDict[packType].GetItems(param);
            }
            else
            {
                return null;
            }
        }

        public string GetItemGUIDByID(int itemId, bool includeAuction = true)
        {
            string guid = string.Empty;
            foreach (var key in itemGUIDDict.Keys)
            {
                if (!includeAuction && itemGUIDDict[key].isAuction)
                {
                    continue;
                }

                if (itemGUIDDict[key].itemId == itemId)
                {
                    guid = key;
                    return guid;
                }
            }

            return guid;
        }

        /// <summary>
        /// 得到ID相同的物品数量
        /// </summary>
        /// <param name="type"></param>
        /// <param name="id"></param>
        /// <returns></returns>
        public int GetItemCountByID(PackType type, int id, bool includeAuction = true)
        {
            int count = 0;
            var singlePack = GetSinglePack(type);
            if (singlePack != null)
            {
                count = singlePack.GetCountById(id, includeAuction);
            }

            return count;
        }

        public int GetEmptyGridCount(PackType type)
        {
            int count = 0;
            SinglePack singlePack = GetSinglePack(type);
            if (singlePack != null)
            {
                count = singlePack.GetEmptyGridCount();
            }

            return count;
        }

        public bool TryGetShareNumItem(int itemId, out List<int> idlist)
        {
            idlist = new List<int>();
            foreach (var list in sharedUseCountItemDict.Values)
            {
                if (list.Contains(itemId))
                {
                    idlist = list;
                    return true;
                }
            }
            return false;
        }

        /// <summary>
        /// 得到物品今日使用次数
        /// </summary>
        /// <param name="itemId"></param>
        /// <returns></returns>
        public int GetItemUsedTimesToday(int itemId)
        {
            int useCnt = 0;
            List<int> shareIdlist = null;
            bool isShare = TryGetShareNumItem(itemId, out shareIdlist);
            if (isShare)
            {
                foreach (var id in shareIdlist)
                {
                    int singleUseCnt = 0;
                    itemDayUseCntDict.TryGetValue(id, out singleUseCnt);
                    useCnt += singleUseCnt;
                }
            }
            else
            {
                itemDayUseCntDict.TryGetValue(itemId, out useCnt);
            }
            return useCnt;
        }

        /// <summary>
        /// 得到物品总使用次数
        /// </summary>
        /// <param name="itemId"></param>
        /// <returns></returns>
        public int GetItemTotalUsedTimes(int itemId)
        {
            int useCnt = 0;
            List<int> shareIdlist = null;
            bool isShare = TryGetShareNumItem(itemId, out shareIdlist);
            if (isShare)
            {
                foreach (var id in shareIdlist)
                {
                    int singleUseCnt = 0;
                    itemDayUseCntDict.TryGetValue(id, out singleUseCnt);
                    useCnt += singleUseCnt;
                }
            }
            else
            {
                itemSumUseCntDict.TryGetValue(itemId, out useCnt);
            }
            return useCnt;
        }

        public void GotoWashAttributePoint(string guid)
        {
            ItemModel itemModel = GetItemByGuid(guid);
            if (itemModel == null) return;

            WashAttrPointWin.itemModel = itemModel;
            WindowCenter.Instance.Open<WashAttrPointWin>();
        }

        #region 红点逻辑判断

        const int ITEMPACK_REDKEY = 102011003;
        Redpoint redpointItemPack = new Redpoint(MainRedDot.RedPoint_BagFuncKey, ITEMPACK_REDKEY);

        const int LS_REDKEY = 102011015;
        Redpoint redpointLS = new Redpoint(MainRedDot.RedPoint_BagFuncKey, LS_REDKEY);

        private void UpdateLSRedpoint(PackType type, int itemID)
        {
            var singlePack = GetSinglePack(type);
            if (singlePack == null)
            {
                return;
            }
            if (type != PackType.Item) return;
            if (itemID != lsItemID) return;


            if (GetItemCountByID(PackType.Item, lsItemID) < lsItemCnt)
            {
                redpointLS.state = RedPointState.None;
            }
            else
            {
                redpointLS.state = RedPointState.Simple;
            }

        }

        private void UpdatePackRedpoint(PackType type)
        {
            var singlePack = GetSinglePack(type);
            if (singlePack == null)
            {
                return;
            }

            switch (type)
            {
                case PackType.Item:
                    if (singlePack.GetEmptyGridCount() <= 0)
                    {
                        redpointItemPack.state = RedPointState.Full;
                        SysNotifyMgr.Instance.ShowTip("BagFull");
                    }
                    else
                    {
                        redpointItemPack.state = RedPointState.None;
                    }
                    if (GetItemCountByID(PackType.Item, lsItemID) < lsItemCnt)
                    {
                        redpointLS.state = RedPointState.None;
                    }
                    else
                    {
                        redpointLS.state = RedPointState.Simple;
                    }
                    break;
                case PackType.Warehouse:
                    if (singlePack.GetEmptyGridCount() <= 0)
                    {
                        MainRedDot.Instance.redPointDepotFunc.state = RedPointState.Full;
                    }
                    else
                    {
                        MainRedDot.Instance.redPointDepotFunc.state = RedPointState.None;
                    }
                    break;
            }
        }

        const int PLAYERSUMSTAR_REDKEY = 102011002;
        Redpoint redpointSTAR = new Redpoint(MainRedDot.RedPoint_BagFuncKey, PLAYERSUMSTAR_REDKEY);

        public const int EquipDecompose_RedKey = 10205;
        public Redpoint redpointEquipDecom = new Redpoint(MainRedDot.RedPoint_MainPackKey, EquipDecompose_RedKey);
        public void EquipDecomRedCtrl()
        {
            if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.EquipDecompose))
            {
                return;
            }

            if (PlayerDatas.Instance.baseData.LV < devourRedpointLevel)
            {
                redpointEquipDecom.state = RedPointState.None;
                return;
            }

            var canDevourItems = GetCanDevourModellist();
            if (canDevourItems != null && canDevourItems.Count >= minDevourEquipNum)
            {
                redpointEquipDecom.state = RedPointState.Simple;
            }
            else
            {
                redpointEquipDecom.state = RedPointState.None;
            }
        }
        #endregion

        #region 查看某个位置的物品
        public event Action lookEquipEvent;
        private int _lookLineIndex = -1;
        public int lookLineIndex { get { return _lookLineIndex; } private set { _lookLineIndex = value; } }

        public string lookItemGUID { get; private set; }

        public void SetLookIndex(string guid, int singleRowCount = 5)
        {
            if (string.IsNullOrEmpty(guid) || guid == "")
            {
                lookLineIndex = -1;
                lookItemGUID = "";
            }
            else
            {
                int index = GetItemByGuid(guid).gridIndex;
                lookLineIndex = index / singleRowCount;
                lookItemGUID = guid;
            }

            if (lookEquipEvent != null)
            {
                lookEquipEvent();
            }
        }

        public event Action RefreshBagEvent;
        public void RefreshBagInfo()
        {
            if (RefreshBagEvent != null)
            {
                RefreshBagEvent();
            }
        }
        #endregion

        public void SetJumpToOneKeySell(Transform parent)
        {
            var goEffect = AchievementGuideEffectPool.Require(1);
            goEffect.transform.SetParentEx(parent, Vector3.zero, Quaternion.identity, Vector3.one);
            AchievementGoto.guideAchievementId = 0;
        }

        #region 物品使用快捷提示

        private int cacheMapId = 0;
        public event Action<PackType, string> itemUseAct;
        private Dictionary<int, int> itemUseTypeDict = new Dictionary<int, int>(); //key SkillTypeID,value 使用物品的ID
        private void OnStageLoadFinish()
        {
            itemUseTypeDict.Clear();
            if (PlayerDatas.Instance.baseData.MapID == cacheMapId)
            {
                return;
            }

            cacheMapId = PlayerDatas.Instance.baseData.MapID;
            UpdateDungeonDanUse();
            UpdateDungeonUse();
            SinglePack singlePack = GetSinglePack(PackType.Item);
            foreach (int itemId in itemUseTypeDict.Values)
            {
                var modellist = singlePack.GetItemsById(itemId);
                if (modellist.Count > 0)
                {
                    ItemModel itemModel = modellist[0];
                    bool isExist = StatusMgr.Instance.IsExist(PlayerDatas.Instance.hero.ServerInstID, itemModel.config.AddSkill1);
                    DebugEx.Log("Buff是否存在" + isExist);
                    if (itemUseAct != null && !isExist)
                    {
                        itemUseAct(PackType.Item, itemModel.guid);
                    }
                }
            }
        }

        private void AddItemUseTypeDict(int id)
        {
            SkillConfig skillConfig = GetSkillConfig(id);
            int itemCount = GetItemCountByID(PackType.Item, id);
            if (skillConfig != null && itemCount > 0)
            {
                if (!itemUseTypeDict.ContainsKey(skillConfig.SkillTypeID))
                {
                    itemUseTypeDict.Add(skillConfig.SkillTypeID, id);
                }
                else
                {
                    SkillConfig preSkillConfig = GetSkillConfig(itemUseTypeDict[skillConfig.SkillTypeID]);
                    if (skillConfig.SkillLV > preSkillConfig.SkillLV)
                    {
                        itemUseTypeDict[skillConfig.SkillTypeID] = id;
                    }
                }
            }
        }

        private void UpdateDungeonDanUse()
        {
            int mapId = PlayerDatas.Instance.baseData.MapID;
            int[] useDrugs = GetDrugIDListByDungeonID(mapId);
            if (useDrugs == null) return;

            for (int i = 0; i < useDrugs.Length; i++)
            {
                int id = useDrugs[i];
                AddItemUseTypeDict(id);
            }
        }

        private void UpdateDungeonUse()
        {
            int mapId = PlayerDatas.Instance.baseData.MapID;
            if (!dungeonUseDict.ContainsKey(mapId)) return;

            List<int> useIdlist = dungeonUseDict[mapId];
            for (int i = 0; i < useIdlist.Count; i++)
            {
                int id = useIdlist[i];
                AddItemUseTypeDict(id);
            }
        }

        public SkillConfig GetSkillConfig(int itemId)
        {
            ItemConfig itemConfig = ItemConfig.Get(itemId);
            SkillConfig skillConfig = SkillConfig.Get(itemConfig.AddSkill1);
            return skillConfig;
        }

        public int GetDungeonIDByDrugID(int drugID)
        {
            int dungeonID = 0;
            //DrugToDungeonDict.TryGetValue(drugID, out dungeonID);
            return dungeonID;
        }

        public int[] GetDrugIDListByDungeonID(int dungeonID)
        {
            int[] drugIDlist = null;
            DungeonToDrugDict.TryGetValue(dungeonID, out drugIDlist);
            return drugIDlist;
        }
        #endregion

        #region 判断物品是否达到使用上限
        public bool IsReachUseLimit(string guid, out ulong count)
        {
            count = 0;
            ItemModel itemModel = GetItemByGuid(guid);
            if (itemModel == null) return false;

            AttrFruitConfig fruitConfig = AttrFruitConfig.Get(itemModel.itemId);
            int haveUseCnt = GetItemUsedTimesToday(itemModel.itemId);
            int sumHaveUseCnt = GetItemTotalUsedTimes(itemModel.itemId);
            count = (ulong)itemModel.count;
            bool isReach = false;
            int remainDayCnt = 0;
            if (itemModel.config.MaxSkillCnt > 0)
            {
                remainDayCnt = itemModel.config.MaxSkillCnt - haveUseCnt;
                if (itemModel.count > remainDayCnt)
                {
                    count = (ulong)remainDayCnt;
                }
            }

            int remainSumCnt = 0;
            if (fruitConfig != null)
            {
                remainSumCnt = fruitConfig.basicUseLimit - sumHaveUseCnt;
                if (remainSumCnt <= remainDayCnt && itemModel.count > remainSumCnt)
                {
                    count = (ulong)remainSumCnt;
                }
            }

            if (count < (ulong)itemModel.count)
            {
                isReach = true;
            }

            return isReach;
        }
        #endregion

        #region 物品吞噬逻辑处理
        public EquipColorType colorType { get; private set; }
        public event Action<EquipColorType> RefreshColorSelectAct;
        public event Action RefreshEquipDecomNumAct;
        public int[] defaultUnSelectlist { get; private set; }

        public int GetBetterEquipCount(List<ItemModel> itemModels)
        {
            if (itemModels.IsNullOrEmpty())
            {
                return 0;
            }

            var count = 0;
            foreach (var item in itemModels)
            {
                if (ItemLogicUtility.Instance.IsFightUp(item.itemId, item.score) == 1)
                {
                    count += item.count;
                }
            }
            return count;
        }

        public void SetColorSelect(EquipColorType type)
        {
            colorType = type;

            if (RefreshColorSelectAct != null)
            {
                RefreshColorSelectAct(type);
            }
            SendEquipDevourRecordQuest();
            EquipDecomRedCtrl();
        }

        public List<int> devourPlacelist { get; private set; }
        public int devourRedpointLevel { get; private set; }
        public int minDevourEquipNum { get; private set; }
        public void SetDevourEquipPlace()
        {
            devourPlacelist = new List<int>();
            FuncConfigConfig funcConfig = FuncConfigConfig.Get("PetAbsorbType");
            int[] placeArray = ConfigParse.GetMultipleStr<int>(funcConfig.Numerical1);
            for (int i = 0; i < placeArray.Length; i++)
            {
                devourPlacelist.Add(placeArray[i]);
            }
            devourRedpointLevel = int.Parse(funcConfig.Numerical2);
            minDevourEquipNum = int.Parse(funcConfig.Numerical3);
        }

        List<ItemModel> devourModellist = new List<ItemModel>();
        List<ItemModel> orderDevourModellist = new List<ItemModel>();
        public List<ItemModel> GetDevourModellist()
        {
            SinglePack singlePack = GetSinglePack(PackType.Item);
            if (singlePack == null) return null;

            devourModellist.Clear();
            orderDevourModellist.Clear();
            foreach (var model in singlePack.GetAllItems().Values)
            {
                if (model.config.Type == 29)
                {
                    devourModellist.Add(model);
                }
                else
                {
                    if (devourPlacelist.Contains(model.config.EquipPlace))
                    {
                        if (GeneralDefine.equipDecomposeScreen.Contains(model.config.ItemColor))
                        {
                            devourModellist.Add(model);
                        }
                    }
                }

            }
            orderDevourModellist.AddRange(devourModellist);
            orderDevourModellist.Sort(CompareByColor);
            return orderDevourModellist;
        }

        public int CompareByColor(ItemModel start, ItemModel next)
        {
            bool typeX = start.config.Type == 29 ? true : false;
            bool typeY = next.config.Type == 29 ? true : false;

            if (typeX.CompareTo(typeY) != 0) return -typeX.CompareTo(typeY);

            int colorX = start.config.ItemColor;
            int colorY = next.config.ItemColor;
            if (colorX.CompareTo(colorY) != 0) return colorX.CompareTo(colorY);

            int startIndex = devourModellist.IndexOf(start);
            int nextIndex = devourModellist.IndexOf(next);
            if (startIndex.CompareTo(nextIndex) != 0) return startIndex.CompareTo(nextIndex);

            return 0;
        }

        public List<ItemModel> GetCanDevourModellist()
        {
            List<ItemModel> canDevourModellist = new List<ItemModel>();
            SinglePack singlePack = GetSinglePack(PackType.Item);
            if (singlePack == null || colorType == EquipColorType.None)
            {
                if (RefreshEquipDecomNumAct != null)
                {
                    RefreshEquipDecomNumAct();
                }
                return null;
            }

            foreach (var model in singlePack.GetAllItems().Values)
            {
                if (model.config.Type == 29)
                {
                    if (!defaultUnSelectlist.Contains(model.itemId))
                    {
                        canDevourModellist.Add(model);
                    }
                }
                else
                {
                    if (IsCanDevour(model))
                    {
                        canDevourModellist.Add(model);
                    }
                }
            }

            if (RefreshEquipDecomNumAct != null)
            {
                RefreshEquipDecomNumAct();
            }

            return canDevourModellist;
        }

        public bool IsCanDevour(ItemModel model)
        {
            if (devourPlacelist.Contains(model.config.EquipPlace))
            {
                if (GeneralDefine.equipDecomposeScreen.Contains(model.config.ItemColor))
                {
                    var eatEquipConfig = PetEatEquipConfig.GetEquipColorAndEquipClass(model.config.ItemColor, model.config.LV);
                    if (eatEquipConfig == null) return false;

                    if (ItemLogicUtility.Instance.IsFightUp(model.itemId, model.score) != 1)
                    {
                        if (model.config.ItemColor <= (int)colorType)
                        {
                            return true;
                        }
                    }
                }
            }

            return false;
        }

        public bool IsMaxDecomLv(int decomLv, out int realLv)
        {
            realLv = decomLv;
            var decomlist = EquipDeComposeConfig.GetValues();
            if (decomLv > decomlist[decomlist.Count - 1].LV)
            {
                realLv = decomlist[decomlist.Count - 1].LV;
                return true;
            }

            return false;
        }

        public List<ItemModel> selectDevourlist = new List<ItemModel>();
        public void GetSelectDevourList()
        {
            selectDevourlist.Clear();
            List<ItemModel> itemModels = GetCanDevourModellist();
            if (itemModels != null)
            {
                selectDevourlist.AddRange(itemModels);
            }
        }

        public void RefreshGetNewItem(ItemModel model)
        {
            if (model == null) return;

            if (CheckIsReachDevourCondi(model))
            {
                selectDevourlist.Add(model);
                if (RefreshEquipDecomNumAct != null)
                {
                    RefreshEquipDecomNumAct();
                }
            }
        }

        public void AddSelectDevourModellist(ItemModel model)
        {
            selectDevourlist.Add(model);
            if (RefreshEquipDecomNumAct != null)
            {
                RefreshEquipDecomNumAct();
            }
        }

        public bool CheckIsReachDevourCondi(ItemModel model)
        {
            if (model.config.Type == 29)
            {
                if (!defaultUnSelectlist.Contains(model.itemId))
                {
                    return true;
                }
                return false;
            }
            else
            {
                if (IsCanDevour(model))
                {
                    return true;
                }

            }
            return false;
        }

        public void RemoveSelectDevourModellist(ItemModel model)
        {
            if (selectDevourlist.Contains(model))
            {
                selectDevourlist.Remove(model);
            }
            if (RefreshEquipDecomNumAct != null)
            {
                RefreshEquipDecomNumAct();
            }
        }

        public Dictionary<int, int> GetDecomAttrDictByLv(int decomLv)
        {
            if (decomposeAttrDict.ContainsKey(decomLv))
            {
                return decomposeAttrDict[decomLv];
            }

            return null;
        }

        public bool IsReachMinDecomposeNum()
        {
            List<ItemModel> itemModels = GetCanDevourModellist();
            if (itemModels != null && itemModels.Count >= minDecomposeNum)
            {
                return true;
            }
            return false;
        }

        public void SendEquipdevourQuest(bool auto)
        {
            List<ItemModel> items = null;
            if (auto)
            {
                items = GetCanDevourModellist();
            }
            else
            {
                items = selectDevourlist;
            }

            if (items == null || items.Count < minDecomposeNum || !ItemLogicUtility.Instance.isPackResetOk || SettingEffectMgr.Instance.isStartDecompose) return;

            SettingEffectMgr.Instance.isStartDecompose = true;
            isAutoDecompose = auto;
            recordAutoDecomNum = Math.Min(items.Count, 100);
            var package = new CA32C_tagCMEquipDecompose();
            var indexLists = new ushort[recordAutoDecomNum];
            var idlist = new uint[recordAutoDecomNum];
            for (int i = 0; i < recordAutoDecomNum; i++)
            {
                indexLists[i] = (ushort)items[i].gridIndex;
                idlist[i] = (uint)items[i].itemId;
                if ((items[i].config.EquipPlace == 0 && items[i].config.Type != 29))
                {
                    return;
                }
            }
            package.Count = (byte)indexLists.Length;
            package.IndexList = indexLists;
            package.ItemIDList = idlist;
            package.IsAuto = (byte)(auto ? 1 : 0);
            GameNetSystem.Instance.SendInfo(package);
        }

        public void SendEquipDevourRecordQuest()
        {
            var record = StringUtility.Contact((int)colorType + 1, 1, 1);
            var decomSet = new CA32D_tagCMDecomposeSeting();
            decomSet.Seting = uint.Parse(record);
            GameNetSystem.Instance.SendInfo(decomSet);
        }

        public int decomposeLv { get; private set; }
        public int decomposeExp { get; private set; }
        public int decomposeProgress { get; private set; }
        public int addDecomposeExp { get; private set; }
        public int minDecomposeNum { get; private set; }
        public bool isAutoDecompose { get; set; }
        public int recordAutoDecomNum { get; private set; }
        public DecomposeGetMatInfo[] getItems { get; private set; }

        public event Action RefreshDecomAttrAct;
        public void GetServerDecomposeSet(HA31C_tagMCEquipDecomposeInfo info)
        {
            addDecomposeExp = 0;
            int realLv = info.LV + 1;
            bool isMax = IsMaxDecomLv(realLv, out realLv);
            if (realLv == decomposeLv)
            {
                addDecomposeExp = (int)info.Exp - decomposeExp;
            }
            else
            {
                for (int i = decomposeLv; i <= realLv; i++)
                {
                    var deComposeConfig = EquipDeComposeConfig.Get(i);
                    if (i == decomposeLv)
                    {
                        addDecomposeExp = deComposeConfig.UpNeedExp - decomposeExp;
                    }
                    else if (i == realLv)
                    {
                        addDecomposeExp += (int)info.Exp;
                    }
                    else
                    {
                        addDecomposeExp += deComposeConfig.UpNeedExp;
                    }
                }
            }

            decomposeLv = realLv;
            decomposeExp = (int)info.Exp;
            decomposeProgress = info.DecomposeCnt;
            getItems = JsonMapper.ToObject<DecomposeGetMatInfo[]>(info.GetItemData);

            if (info.Seting != 0)
            {
                string decomSetStr = info.Seting.ToString();
                string colorStr = decomSetStr.Substring(0, 1);
                colorType = (EquipColorType)(int.Parse(colorStr) - 1);
                string lvStr = decomSetStr.Substring(1, decomSetStr.Length - 2);
            }
            if (RefreshDecomAttrAct != null)
            {
                RefreshDecomAttrAct();
            }
        }
        /// <summary>
        /// 设置获得炼丹材料的展示数据
        /// </summary>
        /// <param name="getMatInfos"></param>
        /// <returns></returns>
        private List<DecomposeGetMatInfo> getMatInfos = new List<DecomposeGetMatInfo>();
        public List<DecomposeGetMatInfo> SetShowMatInfo()
        {
            getMatInfos.Clear();
            int sumMatCnt = 0;
            if (getItems != null)
            {
                for (int i = 0; i < getItems.Length; i++)
                {
                    if (getItems[i].Count > 0)
                    {
                        sumMatCnt += getItems[i].Count;
                    }
                    else
                    {
                        sumMatCnt += 1;
                    }
                }
            }

            if (sumMatCnt > 5)
            {
                for (int i = 0; i < getItems.Length; i++)
                {
                    getMatInfos.Add(getItems[i]);
                }
            }
            else
            {
                if (getItems != null)
                {
                    for (int i = 0; i < getItems.Length; i++)
                    {
                        if (getItems[i].Count > 0)
                        {
                            for (int j = 0; j < getItems[i].Count; j++)
                            {
                                DecomposeGetMatInfo matInfo = new DecomposeGetMatInfo();
                                matInfo.ItemID = getItems[i].ItemID;
                                matInfo.Count = 1;
                                matInfo.IsSuite = getItems[i].IsSuite;
                                matInfo.UserData = getItems[i].UserData;
                                getMatInfos.Add(matInfo);
                            }
                        }
                        else
                        {
                            getMatInfos.Add(getItems[i]);
                        }
                    }
                }
            }
            return getMatInfos;
        }

        public enum EquipColorType
        {
            None = 0,
            White = 1,
            Blue = 2,
            Purple = 3,
            Orange = 4,
            Red = 5,
            //后续IL开发添加预设
            default1,
            default2,
            default3,
            default4,
            All = 10,
        }

        public class DecomposeGetMatInfo
        {
            public int ItemID;
            public int Count;
            public int IsSuite;
            public string UserData;
        }
        #endregion

        #region 丹药逻辑处理

        private int CompareMakeDrug(AttrFruitConfig start, AttrFruitConfig end)
        {
            ItemConfig configS = ItemConfig.Get(start.ID);
            ItemConfig configE = ItemConfig.Get(end.ID);
            if (configS.RealmLimit.CompareTo(configE.RealmLimit) != 0)
            {
                return configS.RealmLimit.CompareTo(configE.RealmLimit);
            }
            if (configS.LV.CompareTo(configE.LV) != 0)
            {
                return configS.LV.CompareTo(configE.LV);
            }

            int x = makeDruglist.IndexOf(start);
            int y = makeDruglist.IndexOf(end);
            if (x.CompareTo(y) != 0) x.CompareTo(y);

            return 0;
        }

        List<AttrFruitConfig> drugOrderlist = new List<AttrFruitConfig>();
        List<AttrFruitConfig> haveDruglist = new List<AttrFruitConfig>();
        public List<AttrFruitConfig> GetDrugOrderByCnt()
        {
            drugOrderlist.Clear();
            haveDruglist.Clear();
            drugOrderlist.AddRange(makeDruglist);
            drugOrderlist.Sort(CompareByIsHave);
            for (int i = 0; i < drugOrderlist.Count; i++)
            {
                if (IsHaveDrugUse(drugOrderlist[i]))
                {
                    haveDruglist.Add(drugOrderlist[i]);
                }
            }
            haveDruglist.Sort(CompareMakeDrug);
            for (int i = 0; i < haveDruglist.Count; i++)
            {
                drugOrderlist[i] = haveDruglist[i];
            }

            return drugOrderlist;
        }

        public bool CheckIsDrugById(int itemId)
        {
            for (int i = 0; i < makeDruglist.Count; i++)
            {
                if (makeDruglist[i].ID == itemId)
                {
                    return true;
                }
            }
            return false;
        }

        public int CompareByIsHave(AttrFruitConfig start, AttrFruitConfig end)
        {
            bool isHaveStart = IsHaveDrugUse(start);
            bool isHaveEnd = IsHaveDrugUse(end);
            if (isHaveStart.CompareTo(isHaveEnd) != 0) return -isHaveStart.CompareTo(isHaveEnd);

            //isHaveStart = IsHaveDrugRecycle(start);
            //isHaveEnd = IsHaveDrugRecycle(end);
            //if (isHaveStart.CompareTo(isHaveEnd) != 0) return -isHaveStart.CompareTo(isHaveEnd);

            isHaveStart = GetItemCountByID(PackType.Item, start.ID) > 0 ? true : false;
            isHaveEnd = GetItemCountByID(PackType.Item, end.ID) > 0 ? true : false;
            if (isHaveStart.CompareTo(isHaveEnd) != 0) return isHaveStart.CompareTo(isHaveEnd);

            isHaveStart = IsReachMaxUseDrug(start);
            isHaveEnd = IsReachMaxUseDrug(end);
            if (isHaveStart.CompareTo(isHaveEnd) != 0) return isHaveStart.CompareTo(isHaveEnd);

            int x = makeDruglist.IndexOf(start);
            int y = makeDruglist.IndexOf(end);
            if (x.CompareTo(y) != 0) return x.CompareTo(y);
            return 0;
        }

        public bool IsHaveDrugUse(AttrFruitConfig fruitConfig)
        {
            if (!IsReachMaxUseDrug(fruitConfig))
            {
                return GetItemCountByID(PackType.Item, fruitConfig.ID) > 0 ? true : false;
            }

            return false;
        }

        public bool IsHaveDrugRecycle(AttrFruitConfig fruitConfig)
        {
            if (IsReachMaxUseDrug(fruitConfig))
            {
                return GetItemCountByID(PackType.Item, fruitConfig.ID) > 0 ? true : false;
            }
            return false;
        }

        public bool IsReachMaxUseDrug(AttrFruitConfig fruitConfig)
        {
            if (fruitConfig == null)
            {
                return false;
            }

            if (fruitConfig.FuncID == 2)
            {
                AlchemyDrugUseLimit drugUseLimit;
                if (alchemyModel.TryGetAlchemyUseLimit(fruitConfig.ID, out drugUseLimit))
                {
                    return drugUseLimit.IsReachLimit();
                }
            }

            int useNum = GetItemTotalUsedTimes(fruitConfig.ID);
            if (useNum >= fruitConfig.basicUseLimit)
            {
                return true;
            }
            return false;
        }
        #endregion

        //获取背包中的一件可拍卖物品 优先其他职业
        public string GetAuctionEquip()
        {
            var itemPackage = GetSinglePack(PackType.Item);
            var allItems = itemPackage.GetAllItems();

            var guid = string.Empty;
            List<string> guidList = new List<string>();
            foreach (var item in allItems.Values)
            {
                var isAuction = item.isAuction;
                if (isAuction && ItemLogicUtility.Instance.IsRealmEquip(item.itemId))
                {
                    if (!ItemLogicUtility.Instance.IsJobCompatibleItem(item.itemId))
                    {
                        return item.guid;
                    }
                    else
                    {
                        if (guid != string.Empty)
                            continue;
                        guid = item.guid;
                    }
                }
            }
            return guid;
        }
    }
}
using System;

using System.Collections.Generic;

using System.Linq;

using UnityEngine;

using LitJson;

using System.Text.RegularExpressions;

using System.Collections;



namespace Snxxz.UI

{

    
    public class PackModel : Model, IBeforePlayerDataInitialize, IAfterPlayerDataInitialize, IPlayerLoginOk

    {

        public static string StrengthAttrShift_RecordKey = "";

        public const string RecordKnapsackTitle = "RecordKnapsackTitle";



        Dictionary<int, int> DrugToDungeonDict { get; set; }   //key 丹药ID,value副本ID

        Dictionary<int, int[]> DungeonToDrugDict { get; set; }  //key 副本ID,value丹药ID列表

        public List<AttrFruitConfig> makeDruglist { get; private set; }

        Dictionary<int, Dictionary<int, int>> decomposeAttrDict = new Dictionary<int, Dictionary<int, int>>();

        string RoleEquipLocalSave = "";

        List<int> LocalSavePlaceArray { get; set; }

        Dictionary<int, List<int>> sharedUseCountItemDict { get; set; }

        bool isUpdatePlayerLv = false;



        AlchemyModel alchemyModel { get { return ModelCenter.Instance.GetModel<AlchemyModel>(); } }

        ItemTipsModel itemTipsModel { get { return ModelCenter.Instance.GetModel<ItemTipsModel>(); } }



        public int lsItemID = 150; //可兑换的灵石物品ID

        int lsItemCnt = int.Parse(FuncConfigConfig.Get("LingshiShowCount").Numerical1);



        public int[] autoUseItemIDs;

        UIEffect lingshiEffect;  //灵石特效

        public override void Init()

        {

            ParseConfig();

            SysNotifyMgr.Instance.sysNotifyEvent += RefreshSysInfo;

            List<DungeonOpenTimeConfig> dungeonlist = DungeonOpenTimeConfig.GetValues();

            if (dungeonlist != null)

            {

                //DrugToDungeonDict = new Dictionary<int, int>();

                DungeonToDrugDict = new Dictionary<int, int[]>();



                for (int i = 0; i < dungeonlist.Count; i++)

                {

                    int[] drugIdlist = dungeonlist[i].ElixirHint;

                    if (drugIdlist != null && drugIdlist.Length > 0)

                    {

                        DungeonToDrugDict.Add(dungeonlist[i].DataMapID, drugIdlist);

                        //for (int j = 0; j < drugIdlist.Length; j++)

                        //{

                        //    DrugToDungeonDict.Add(drugIdlist[j], dungeonlist[i].DataMapID);

                        //}

                    }

                }

            }



            makeDruglist = new List<AttrFruitConfig>();

            List<AttrFruitConfig> fruitlist = AttrFruitConfig.GetValues();

            for (int i = 0; i < fruitlist.Count; i++)

            {

                if (fruitlist[i].FuncID == 2)

                {

                    makeDruglist.Add(fruitlist[i]);

                }

            }

            StageLoad.Instance.onStageLoadFinish += OnStageLoadFinish;



            SetDevourEquipPlace();



            decomposeAttrDict.Clear();

            List<EquipDeComposeConfig> decomlist = EquipDeComposeConfig.GetValues();

            for (int i = 0; i < decomlist.Count; i++)

            {

                JsonData attrData = JsonMapper.ToObject(decomlist[i].Attr);

                Dictionary<int, int> attrDict = new Dictionary<int, int>();

                decomposeAttrDict.Add(decomlist[i].LV, attrDict);

                foreach (var id in attrData.Keys)

                {

                    attrDict.Add(int.Parse(id), int.Parse(attrData[id].ToString()));

                }

            }



            FuncConfigConfig equipDecompose = FuncConfigConfig.Get("EquipDevourCount");

            minDecomposeNum = int.Parse(equipDecompose.Numerical1);

            defaultUnSelectlist = ConfigParse.GetMultipleStr<int>(equipDecompose.Numerical2);



            FuncConfigConfig ShareUseCntItem = FuncConfigConfig.Get("ShareUseCntItem");

            sharedUseCountItemDict = new Dictionary<int, List<int>>();

            JsonData shareUseJson = JsonMapper.ToObject(ShareUseCntItem.Numerical1);

            if (shareUseJson.IsArray)

            {

                for (int i = 0; i < shareUseJson.Count; i++)

                {

                    var idListJson = shareUseJson[i];

                    var idlist = new List<int>();

                    sharedUseCountItemDict.Add(i, idlist);

                    foreach (var id in idListJson)

                    {

                        idlist.Add(int.Parse(id.ToString()));

                    }

                }

            }



            ParseItemCount();



            autoUseItemIDs = JsonMapper.ToObject<int[]>(FuncConfigConfig.Get("ItemTipsNum").Numerical2);

        }



        public Dictionary<int, string> textCountShow = new Dictionary<int, string>();

        public int[] textCountShow2;



        public void ParseItemCount()

        {

            var textConfig = FuncConfigConfig.Get("ItemCountShow");

            var json = JsonMapper.ToObject(textConfig.Numerical1);

            foreach (var key in json.Keys)

            {

                var itemID = int.Parse(key);

                textCountShow[itemID] = json[key].ToString();

            }



            textCountShow2 = JsonMapper.ToObject<int[]>(textConfig.Numerical2);

        }





        private void OnFuncStateChangeEvent(int id)

        {

            if (id == (int)FuncOpenEnum.EquipDecompose)

            {

                EquipDecomRedCtrl();

            }

        }

        public void OnBeforePlayerDataInitialize()

        {

            GlobalTimeEvent.Instance.secondEvent -= UpdateSecond;

            PlayerDatas.Instance.playerDataRefreshEvent -= UpdatePlayerLv;

            LocalSave.DeleteKey(RecordKnapsackTitle);

            cacheMapId = 0;

            playerPackDict.Clear();

            itemDayUseCntDict.Clear();

            itemSumUseCntDict.Clear();

            itemGUIDDict.Clear();

            isPlayBetterEquipEffect = false;

            colorType = EquipColorType.Purple;

            decomposeLv = 1;

            decomposeExp = 0;

            decomposeProgress = 0;

            isAutoDecompose = false;

        }



        public void OnAfterPlayerDataInitialize()

        {



        }



        public void OnPlayerLoginOk()

        {

            ItemOperateUtility.Instance.RequestWarehouseData();

            EquipDecomRedCtrl();

            RoleEquipLocalSave = StringUtility.Contact("RoleEquipLocalSave", PlayerDatas.Instance.baseData.PlayerID);

            StrengthAttrShift_RecordKey = StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID, "StrengthAttrShift");

            if (LocalSave.GetIntArray(RoleEquipLocalSave) != null)

            {

                LocalSavePlaceArray = LocalSave.GetIntArray(RoleEquipLocalSave).ToList();

            }

            else

            {

                LocalSavePlaceArray = null;

            }

            GlobalTimeEvent.Instance.secondEvent += UpdateSecond;

            PlayerDatas.Instance.playerDataRefreshEvent += UpdatePlayerLv;

            isUpdatePlayerLv = true;

            FuncOpen.Instance.OnFuncStateChangeEvent += OnFuncStateChangeEvent;

        }



        private void RefreshSysInfo(string key, ArrayList infolist)

        {

            if (key != "GetMoney") return;



            if (WindowCenter.Instance.IsOpen("GodKingRandomGiftWin"))

            {

                return;

            }



            var type = 0;

            int.TryParse(infolist[0].ToString(), out type);

            if (type != 2) return;

            Vector3 pos = new Vector3(-100, 0, 0);

            Vector3 rot = new Vector3(0, 0, 0);

            if (!WindowCenter.Instance.IsOpen<MainInterfaceWin>())

            {

                pos = new Vector3(150, 50, 0);

                rot = new Vector3(180, 180, 0);

            }

            lingshiEffect = EffectMgr.Instance.PlayUIEffect(1158, 2500, WindowCenter.Instance.uiRoot.tipsCanvas, pos, rot, false);





        }

        public override void UnInit()

        {

            FuncOpen.Instance.OnFuncStateChangeEvent -= OnFuncStateChangeEvent;

            SysNotifyMgr.Instance.sysNotifyEvent -= RefreshSysInfo;

        }



        public event Action<PackType> refrechPackEvent; //刷新整个背包数据

        public event Action<PackType, int, int> refreshItemCountEvent; //（单个）最新物品数量刷新(旧的弃用)在得到新物品、物品数量的改变，清理该物品时均会触发 int 位置索引 int物品id

        public event Action<PackType> gridRefreshEvent; //背包空格刷新

        public event Action<PackType, int, int> itemCntAddEvent; //物品数量增加 int 位置索引 int物品id

        public event Action<PackType, int, int> itemCntReduceEvent; //物品数量减少的改变 int 位置索引 int物品id

        public event Action<int, int> useItemSuccessEvent; //物品使用成功 int 位置索引 int物品id



        public event Action<int> refreshItemDayUseCountEvent;  //刷新物品每日使用数量

        public event Action<int> refreshItemSumUseCountEvent;  //刷新物品总使用数量



        public bool isPlayBetterEquipEffect { get; set; }  //整理背包时是否播放特效



        #region 接收服务端数据

        private Dictionary<PackType, SinglePack> playerPackDict = new Dictionary<PackType, SinglePack>();

        private Dictionary<string, ItemModel> itemGUIDDict = new Dictionary<string, ItemModel>();



        public void UpdatePack(H0725_tagRolePackRefreshEx packInfo)

        {

            SetLookIndex(null);

            var packType = (PackType)packInfo.PackType;

            if (!playerPackDict.ContainsKey(packType))

            {

                playerPackDict.Add(packType, new SinglePack(packType));

            }



            if (isPlayBetterEquipEffect)

            {

                ItemLogicUtility.Instance.ClearSortedBetterEquip();

            }



            for (int i = 0; i < packInfo.ItemCount; i++)

            {

                var itemInfo = new ItemInfo(packInfo.ItemInfo[i]);

                var item = playerPackDict[packType].UpdateItem(itemInfo);

                AddItemGUIDDict(item, false);



                if (isPlayBetterEquipEffect)

                {

                    ItemLogicUtility.Instance.SetBagSortBetterEquipList(GetItemByGuid(itemInfo.guid));

                }

            }



            if (refrechPackEvent != null)

            {

                refrechPackEvent(packType);

            }



            UpdatePackRedpoint(packType);

        }



        public void UpdateItem(H0704_tagRolePackRefresh serverItem)

        {

            isPlayBetterEquipEffect = false;

            SetLookIndex(null);

            PackType type = (PackType)serverItem.PackType;

            if (!playerPackDict.ContainsKey(type))

            {

                playerPackDict.Add(type, new SinglePack(type));

            }



            var showNewItem = false;

            if (itemGUIDDict.ContainsKey(serverItem.ItemGUID))

            {

                var prePack = itemGUIDDict[serverItem.ItemGUID].packType;

                var preAuction = itemGUIDDict[serverItem.ItemGUID].isAuction;

                var nowPackType = type;

                var nowAcution = serverItem.IsBind == 1;

                showNewItem = preAuction != nowAcution || prePack != nowPackType;

            }

            else

            {

                showNewItem = true;

            }



            var itemInfo = new ItemInfo(serverItem);

            var item = playerPackDict[type].UpdateItem(itemInfo);

            AddItemGUIDDict(item, showNewItem);



            if (refreshItemCountEvent != null)

            {

                refreshItemCountEvent(type, itemInfo.index, itemInfo.itemId);

            }



            if (itemCntAddEvent != null)

            {

                itemCntAddEvent(type, itemInfo.index, itemInfo.itemId);

            }



            if (type == PackType.Equip)

            {

                if (ItemLogicUtility.Instance.IsRealmEquip(itemInfo.itemId))

                {

                    ItemOperateUtility.Instance.ShowPutOnNewEquipRemind(itemInfo.itemId);

                }

            }



            UpdatePackRedpoint(type);

            EquipDecomRedCtrl();

            AutoUseItem(itemInfo.itemId, serverItem.ItemGUID);

        }



        public void UpdateUnlockedGridCount(H0724_tagRolePackCanUseCount useCount)

        {

            PackType type = (PackType)useCount.PackType;

            if (!playerPackDict.ContainsKey(type))

            {

                playerPackDict.Add(type, new SinglePack(type));

            }



            playerPackDict[type].SetOpenGridCount(useCount.CanUseCount);



            if (gridRefreshEvent != null)

            {

                gridRefreshEvent(type);

            }



            UpdatePackRedpoint(type);

        }



        public void RefreshItemCount(H0707_tagItemCountRefresh refresh)

        {

            SetLookIndex(null);

            isPlayBetterEquipEffect = false;

            PackType type = (PackType)refresh.PackType;

            SinglePack singlePack = null;

            playerPackDict.TryGetValue(type, out singlePack);



            if (singlePack != null)

            {

                ItemModel itemModel = singlePack.GetItemByIndex(refresh.ItemIndex);

                if (itemModel != null)

                {

                    bool isAddItemCount = false;

                    if (refresh.ItemCount > itemModel.count)

                    {

                        isAddItemCount = true;

                    }

                    itemModel.RefreshCount(refresh.ItemCount);



                    if (isAddItemCount)

                    {

                        if (itemCntAddEvent != null)

                        {

                            itemCntAddEvent(type, itemModel.gridIndex, itemModel.itemId);

                        }

                        ItemLogicUtility.Instance.RecommendItem(itemModel);

                        ItemLogicUtility.Instance.RefreshPickItem(type, itemModel.itemId.ToString());

                    }

                    else

                    {

                        if (itemCntReduceEvent != null)

                        {

                            itemCntReduceEvent(type, itemModel.gridIndex, itemModel.itemId);

                        }

                    }



                    if (refreshItemCountEvent != null)

                    {

                        refreshItemCountEvent(type, itemModel.gridIndex, itemModel.itemId);

                    }



                    UpdateLSRedpoint(type, itemModel.itemId);

                }

            }



        }



        public void ClearPack(H0711_tagClearItemPack clearPack)

        {

            PackType type = (PackType)clearPack.PackIndex;

            SinglePack singlePack = null;

            playerPackDict.TryGetValue(type, out singlePack);

            if (singlePack != null)

            {

                singlePack.Clear();

            }

        }



        public void RemoveItem(H0709_tagClearItem clearItem)

        {

            isPlayBetterEquipEffect = false;

            SetLookIndex(null);

            PackType type = (PackType)clearItem.PackType;



            SinglePack singlePack = null;

            playerPackDict.TryGetValue(type, out singlePack);

            string guid = "";

            if (singlePack != null)

            {

                ItemModel itemModel = singlePack.GetItemByIndex(clearItem.ItemIndex);

                guid = itemModel.guid;

                int itemId = itemModel.itemId;



                DeleteItemDictByGUID(type, itemModel.guid);



                singlePack.RemoveItem(clearItem.ItemIndex);

                if (refreshItemCountEvent != null)

                {

                    refreshItemCountEvent(type, clearItem.ItemIndex, itemId);

                }



                if (itemCntReduceEvent != null)

                {

                    itemCntReduceEvent(type, clearItem.ItemIndex, itemId);

                }

            }



            UpdatePackRedpoint(type);

            EquipDecomRedCtrl();



            if (GetItemByGuid(guid) == null)

            {

                KnapsackTimeCDMgr.Instance.UnRegister(guid);

            }



        }



        public void PackResetOk(H0316_tagPackResetOK packreset)

        {

            ItemLogicUtility.Instance.isPackResetOk = true;

        }



        public void UseItemSuccess(H0706_tagUseItemSuccess success)

        {

            isPlayBetterEquipEffect = false;

            SetLookIndex(null);

            if (success.PlayerID != PlayerDatas.Instance.baseData.PlayerID)

            {

                return;

            }



            MakeUseItemSuccess(success.ItemIndex, (int)success.ItemID);

            switch (success.ItemID)

            {

                case 221:

                    if (WindowCenter.Instance.IsOpen<KnapSackWin>())

                    {

                        WindowCenter.Instance.Close<KnapSackWin>();

                    }

                    break;

            }



            if (useItemSuccessEvent != null)

            {

                useItemSuccessEvent(success.ItemIndex, (int)success.ItemID);

            }

        }



        void AutoUseItem(int itemID, string guid)

        {

            if (autoUseItemIDs.Contains(itemID))

            {

                ItemOperateUtility.Instance.GotoUseItem(guid);

            }

        }



        private void MakeUseItemSuccess(int index, int id)

        {

            ItemConfig itemConfig = ItemConfig.Get(id);

            if (itemConfig.CDType != 0)

            {

                float configCdTime = (float)Math.Round((double)itemConfig.CDTime / 1000, 1);

                var items = GetItems(PackType.Item, new SinglePack.FilterParams()

                {

                    itemTypes = new List<int>() { (int)ItemType.Buff }

                });



                for (int i = 0; i < items.Count; i++)

                {

                    if (items[i].itemId == 901

                        || items[i].itemId == 902

                        || items[i].itemId == 903

                        || items[i].itemId == 904)

                    {

                        KnapsackTimeCDMgr.Instance.Register(items[i].guid, items[i].itemId, configCdTime);

                        break;

                    }

                }



            }

        }



        void AddItemGUIDDict(ItemModel itemModel, bool showNewItem)

        {

            itemGUIDDict[itemModel.guid] = itemModel;

            GetItemEventCtrl(itemModel, showNewItem);

        }



        void DeleteItemDictByGUID(PackType type, string guid)

        {

            if (itemGUIDDict.ContainsKey(guid))

            {

                if (itemGUIDDict[guid].packType == type)

                {

                    itemGUIDDict.Remove(guid);

                }

            }

        }



        /// <summary>

        /// 物品每日使用的次数

        /// </summary>

        private Dictionary<int, int> itemDayUseCntDict = new Dictionary<int, int>();

        public void UpdateItemUseCnt(HA809_tagMCItemDayUseCntInfo useCntInfo)

        {

            for (int i = 0; i < useCntInfo.Count; i++)

            {

                int itemId = (int)useCntInfo.ItemUseCntList[i].ItemID;

                int cnt = useCntInfo.ItemUseCntList[i].UseCnt;

                if (!itemDayUseCntDict.ContainsKey(itemId))

                {

                    itemDayUseCntDict.Add(itemId, cnt);

                }

                else

                {

                    itemDayUseCntDict[itemId] = cnt;

                }



                if (refreshItemDayUseCountEvent != null)

                {

                    refreshItemDayUseCountEvent(itemId);

                }



            }

        }



        private Dictionary<int, int> itemSumUseCntDict = new Dictionary<int, int>();

        public void UpdateItemSumUseCnt(HA339_tagMCAttrFruitEatCntList useCntInfo)

        {

            for (int i = 0; i < useCntInfo.count; i++)

            {

                int itemId = (int)useCntInfo.EatCntList[i].ItemID;

                int cnt = useCntInfo.EatCntList[i].EatCnt;

                if (!itemSumUseCntDict.ContainsKey(itemId))

                {

                    itemSumUseCntDict.Add(itemId, cnt);

                }

                else

                {

                    itemSumUseCntDict[itemId] = cnt;

                }



                if (refreshItemSumUseCountEvent != null)

                {

                    refreshItemSumUseCountEvent(itemId);

                }

            }

        }



        #endregion



        #region 玩家装备特殊逻辑

        public Dictionary<int, Dictionary<int, int>> spiritWeaponPathIds { get; private set; }

        public Dictionary<int, int> wingsGetPathIdDict { get; private set; }

        public Dictionary<int, List<int>> dungeonUseDict { get; private set; }

        void ParseConfig()

        {

            FuncConfigConfig funcConfig = FuncConfigConfig.Get("WingYuPeiHQTJ");

            spiritWeaponPathIds = new Dictionary<int, Dictionary<int, int>>();

            var splits = funcConfig.Numerical3.Split('|');

            for (int i = 0; i < splits.Length; i++)

            {

                var tempString = splits[i];

                var matches = Regex.Matches(tempString.Trim(), "\\d+");

                var equipPlace = int.Parse(matches[0].Value);

                var job = int.Parse(matches[1].Value);

                var itemId = int.Parse(matches[2].Value);



                if (!spiritWeaponPathIds.ContainsKey(equipPlace))

                {

                    spiritWeaponPathIds[equipPlace] = new Dictionary<int, int>();

                }



                spiritWeaponPathIds[equipPlace][job] = itemId;

            }



            FuncConfigConfig copyItemBulletWindow = FuncConfigConfig.Get("CopyItemBulletWindow");

            JsonData copyWinData = JsonMapper.ToObject(copyItemBulletWindow.Numerical1);

            dungeonUseDict = new Dictionary<int, List<int>>();

            foreach (var dungeonId in copyWinData.Keys)

            {

                List<int> idlist = new List<int>();

                dungeonUseDict.Add(int.Parse(dungeonId), idlist);

                if (copyWinData[dungeonId].IsArray)

                {

                    JsonData useData = copyWinData[dungeonId];

                    for (int i = 0; i < useData.Count; i++)

                    {

                        idlist.Add(int.Parse(useData[i].ToString()));

                    }

                }

            }

        }



        public int GetRoleEquipPathId(int equipPlace)

        {

            int playerJob = PlayerDatas.Instance.baseData.Job;

            switch ((RoleEquipType)equipPlace)

            {

                case RoleEquipType.Guard:

                case RoleEquipType.PeerlessWeapon1:

                case RoleEquipType.PeerlessWeapon2:

                case RoleEquipType.Wing:

                    return spiritWeaponPathIds[equipPlace][playerJob];

                default:

                    return 0;

            }

        }



        private void UpdateSecond()

        {

            if (isUpdatePlayerLv)

            {

                isUpdatePlayerLv = false;

            }

        }



        private void UpdatePlayerLv(PlayerDataType type)

        {

            if (type != PlayerDataType.LV) return;



            isUpdatePlayerLv = true;

        }



        #endregion

        private void GetItemEventCtrl(ItemModel itemModel, bool showNewItem)

        {

            if (showNewItem)

            {

                bool isOverdue = false;

                if (itemModel.config.ExpireTime > 0)

                {

                    ItemCDCool cool = KnapsackTimeCDMgr.Instance.GetItemCoolById(itemModel.guid);

                    switch ((ItemTimeType)itemModel.config.EndureReduceType)

                    {

                        case ItemTimeType.EquipedTime:

                            List<int> itemEffectTime = itemModel.GetUseData((int)ItemUseDataKey.createTime);

                            if (itemEffectTime != null && itemEffectTime[0] != 0)

                            {

                                if (cool == null || cool.GetRemainTime() <= 0)

                                {

                                    isOverdue = true;

                                }

                            }

                            break;



                        case ItemTimeType.RealityTime:

                            if (cool == null || cool.GetRemainTime() <= 0)

                            {

                                isOverdue = true;

                            }

                            break;



                    }

                }



                if (!isOverdue)

                {

                    ItemLogicUtility.Instance.RecommendItem(itemModel);

                    ItemLogicUtility.Instance.OnGetEquip(itemModel);

                    ItemLogicUtility.Instance.RefreshPickItem(itemModel.packType, itemModel.itemId.ToString());

                }

            }



        }



        /// <summary>

        /// 得到某个包裹的所有数据

        /// </summary>

        /// <param name="type"></param>

        /// <returns></returns>

        public SinglePack GetSinglePack(PackType type)

        {

            SinglePack singlePack = null;

            playerPackDict.TryGetValue(type, out singlePack);

            return singlePack;

        }



        public void UnLockPackGrid(int chooseGridCount, PackType type)

        {

            var singlePack = GetSinglePack(type);

            int openCount = chooseGridCount - singlePack.unlockedGridCount;

            int index = 0;

            switch (type)

            {

                case PackType.Item:

                    index = chooseGridCount - GeneralDefine.initBagGridCount;

                    break;

                case PackType.Warehouse:

                    index = chooseGridCount - GeneralDefine.initDepotGridCount;

                    break;

            }



            itemTipsModel.SetExtendGirdModel(openCount, index, type);

            WindowCenter.Instance.Open<ExtendWin>();

        }



        public ItemModel GetItemByGuid(string guid)

        {

            if (string.IsNullOrEmpty(guid))

            {

                return null;

            }



            ItemModel itemModel = null;

            itemGUIDDict.TryGetValue(guid, out itemModel);

            return itemModel;

        }



        public ItemModel GetItemByIndex(PackType type, int index)

        {

            ItemModel itemModel = null;

            if (playerPackDict.ContainsKey(type))

            {

                itemModel = playerPackDict[type].GetItemByIndex(index);

            }

            return itemModel;

        }



        /// <summary>

        /// 获取指定背包内 指定ID的所有物品

        /// </summary>

        /// <param name="type"></param>

        /// <param name="id"></param>

        /// <param name="includeAuction"></param>

        /// <returns></returns>

        public List<ItemModel> GetItemsById(PackType type, int id, bool includeAuction = true)

        {

            if (playerPackDict.ContainsKey(type))

            {

                var singlePack = playerPackDict[type];

                return singlePack.GetItemsById(id, includeAuction);

            }

            else

            {

                return null;

            }

        }



        /// <summary>

        /// 获取指定背包内指定ID的一个物品

        /// </summary>

        /// <param name="type"></param>

        /// <param name="id"></param>

        /// <param name="includeAuction"></param>

        /// <returns></returns>

        public ItemModel GetItemByID(PackType type, int id, bool includeAuction = true)

        {

            if (playerPackDict.ContainsKey(type))

            {

                var singlePack = playerPackDict[type];

                return singlePack.GetItemByID(id, includeAuction);

            }

            else

            {

                return null;

            }

        }

        
        public List<ItemModel> GetItems(PackType packType, SinglePack.FilterParams param)

        {

            if (playerPackDict.ContainsKey(packType))

            {

                return playerPackDict[packType].GetItems(param);

            }

            else

            {

                return null;

            }

        }



        public string GetItemGUIDByID(int itemId, bool includeAuction = true)

        {

            string guid = string.Empty;

            foreach (var key in itemGUIDDict.Keys)

            {

                if (!includeAuction && itemGUIDDict[key].isAuction)

                {

                    continue;

                }



                if (itemGUIDDict[key].itemId == itemId)

                {

                    guid = key;

                    return guid;

                }

            }



            return guid;

        }



        /// <summary>

        /// 得到ID相同的物品数量

        /// </summary>

        /// <param name="type"></param>

        /// <param name="id"></param>

        /// <returns></returns>

        public int GetItemCountByID(PackType type, int id, bool includeAuction = true)

        {

            int count = 0;

            var singlePack = GetSinglePack(type);

            if (singlePack != null)

            {

                count = singlePack.GetCountById(id, includeAuction);

            }



            return count;

        }



        public int GetEmptyGridCount(PackType type)

        {

            int count = 0;

            SinglePack singlePack = GetSinglePack(type);

            if (singlePack != null)

            {

                count = singlePack.GetEmptyGridCount();

            }



            return count;

        }



        public bool TryGetShareNumItem(int itemId, out List<int> idlist)

        {

            idlist = new List<int>();

            foreach (var list in sharedUseCountItemDict.Values)

            {

                if (list.Contains(itemId))

                {

                    idlist = list;

                    return true;

                }

            }

            return false;

        }



        /// <summary>

        /// 得到物品今日使用次数

        /// </summary>

        /// <param name="itemId"></param>

        /// <returns></returns>

        public int GetItemUsedTimesToday(int itemId)

        {

            int useCnt = 0;

            List<int> shareIdlist = null;

            bool isShare = TryGetShareNumItem(itemId, out shareIdlist);

            if (isShare)

            {

                foreach (var id in shareIdlist)

                {

                    int singleUseCnt = 0;

                    itemDayUseCntDict.TryGetValue(id, out singleUseCnt);

                    useCnt += singleUseCnt;

                }

            }

            else

            {

                itemDayUseCntDict.TryGetValue(itemId, out useCnt);

            }

            return useCnt;

        }



        /// <summary>

        /// 得到物品总使用次数

        /// </summary>

        /// <param name="itemId"></param>

        /// <returns></returns>

        public int GetItemTotalUsedTimes(int itemId)

        {

            int useCnt = 0;

            List<int> shareIdlist = null;

            bool isShare = TryGetShareNumItem(itemId, out shareIdlist);

            if (isShare)

            {

                foreach (var id in shareIdlist)

                {

                    int singleUseCnt = 0;

                    itemDayUseCntDict.TryGetValue(id, out singleUseCnt);

                    useCnt += singleUseCnt;

                }

            }

            else

            {

                itemSumUseCntDict.TryGetValue(itemId, out useCnt);

            }

            return useCnt;

        }



        public void GotoWashAttributePoint(string guid)

        {

            ItemModel itemModel = GetItemByGuid(guid);

            if (itemModel == null) return;



            WashAttrPointWin.itemModel = itemModel;

            WindowCenter.Instance.Open<WashAttrPointWin>();

        }



        #region 红点逻辑判断



        const int ITEMPACK_REDKEY = 102011003;

        Redpoint redpointItemPack = new Redpoint(MainRedDot.RedPoint_BagFuncKey, ITEMPACK_REDKEY);



        const int LS_REDKEY = 102011015;

        Redpoint redpointLS = new Redpoint(MainRedDot.RedPoint_BagFuncKey, LS_REDKEY);



        private void UpdateLSRedpoint(PackType type, int itemID)

        {

            var singlePack = GetSinglePack(type);

            if (singlePack == null)

            {

                return;

            }

            if (type != PackType.Item) return;

            if (itemID != lsItemID) return;





            if (GetItemCountByID(PackType.Item, lsItemID) < lsItemCnt)

            {

                redpointLS.state = RedPointState.None;

            }

            else

            {

                redpointLS.state = RedPointState.Simple;

            }



        }



        private void UpdatePackRedpoint(PackType type)

        {

            var singlePack = GetSinglePack(type);

            if (singlePack == null)

            {

                return;

            }



            switch (type)

            {

                case PackType.Item:

                    if (singlePack.GetEmptyGridCount() <= 0)

                    {

                        redpointItemPack.state = RedPointState.Full;

                        SysNotifyMgr.Instance.ShowTip("BagFull");

                    }

                    else

                    {

                        redpointItemPack.state = RedPointState.None;

                    }

                    if (GetItemCountByID(PackType.Item, lsItemID) < lsItemCnt)

                    {

                        redpointLS.state = RedPointState.None;

                    }

                    else

                    {

                        redpointLS.state = RedPointState.Simple;

                    }

                    break;

                case PackType.Warehouse:

                    if (singlePack.GetEmptyGridCount() <= 0)

                    {

                        MainRedDot.Instance.redPointDepotFunc.state = RedPointState.Full;

                    }

                    else

                    {

                        MainRedDot.Instance.redPointDepotFunc.state = RedPointState.None;

                    }

                    break;

            }

        }



        const int PLAYERSUMSTAR_REDKEY = 102011002;

        Redpoint redpointSTAR = new Redpoint(MainRedDot.RedPoint_BagFuncKey, PLAYERSUMSTAR_REDKEY);



        public const int EquipDecompose_RedKey = 10205;

        public Redpoint redpointEquipDecom = new Redpoint(MainRedDot.RedPoint_MainPackKey, EquipDecompose_RedKey);

        public void EquipDecomRedCtrl()

        {

            if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.EquipDecompose))

            {

                return;

            }



            if (PlayerDatas.Instance.baseData.LV < devourRedpointLevel)

            {

                redpointEquipDecom.state = RedPointState.None;

                return;

            }



            var canDevourItems = GetCanDevourModellist();

            if (canDevourItems != null && canDevourItems.Count >= minDevourEquipNum)

            {

                redpointEquipDecom.state = RedPointState.Simple;

            }

            else

            {

                redpointEquipDecom.state = RedPointState.None;

            }

        }

        #endregion



        #region 查看某个位置的物品

        public event Action lookEquipEvent;

        private int _lookLineIndex = -1;

        public int lookLineIndex { get { return _lookLineIndex; } private set { _lookLineIndex = value; } }



        public string lookItemGUID { get; private set; }



        public void SetLookIndex(string guid, int singleRowCount = 5)

        {

            if (string.IsNullOrEmpty(guid) || guid == "")

            {

                lookLineIndex = -1;

                lookItemGUID = "";

            }

            else

            {

                int index = GetItemByGuid(guid).gridIndex;

                lookLineIndex = index / singleRowCount;

                lookItemGUID = guid;

            }



            if (lookEquipEvent != null)

            {

                lookEquipEvent();

            }

        }



        public event Action RefreshBagEvent;

        public void RefreshBagInfo()

        {

            if (RefreshBagEvent != null)

            {

                RefreshBagEvent();

            }

        }

        #endregion



        public void SetJumpToOneKeySell(Transform parent)

        {

            var goEffect = AchievementGuideEffectPool.Require(1);

            goEffect.transform.SetParentEx(parent, Vector3.zero, Quaternion.identity, Vector3.one);

            AchievementGoto.guideAchievementId = 0;

        }



        #region 物品使用快捷提示



        private int cacheMapId = 0;

        public event Action<PackType, string> itemUseAct;

        private Dictionary<int, int> itemUseTypeDict = new Dictionary<int, int>(); //key SkillTypeID,value 使用物品的ID

        private void OnStageLoadFinish()

        {

            itemUseTypeDict.Clear();

            if (PlayerDatas.Instance.baseData.MapID == cacheMapId)

            {

                return;

            }



            cacheMapId = PlayerDatas.Instance.baseData.MapID;

            UpdateDungeonDanUse();

            UpdateDungeonUse();

            SinglePack singlePack = GetSinglePack(PackType.Item);

            foreach (int itemId in itemUseTypeDict.Values)

            {

                var modellist = singlePack.GetItemsById(itemId);

                if (modellist.Count > 0)

                {

                    ItemModel itemModel = modellist[0];

                    bool isExist = StatusMgr.Instance.IsExist(PlayerDatas.Instance.hero.ServerInstID, itemModel.config.AddSkill1);

                    DebugEx.Log("Buff是否存在" + isExist);

                    if (itemUseAct != null && !isExist)

                    {

                        itemUseAct(PackType.Item, itemModel.guid);

                    }

                }

            }

        }



        private void AddItemUseTypeDict(int id)

        {

            SkillConfig skillConfig = GetSkillConfig(id);

            int itemCount = GetItemCountByID(PackType.Item, id);

            if (skillConfig != null && itemCount > 0)

            {

                if (!itemUseTypeDict.ContainsKey(skillConfig.SkillTypeID))

                {

                    itemUseTypeDict.Add(skillConfig.SkillTypeID, id);

                }

                else

                {

                    SkillConfig preSkillConfig = GetSkillConfig(itemUseTypeDict[skillConfig.SkillTypeID]);

                    if (skillConfig.SkillLV > preSkillConfig.SkillLV)

                    {

                        itemUseTypeDict[skillConfig.SkillTypeID] = id;

                    }

                }

            }

        }



        private void UpdateDungeonDanUse()

        {

            int mapId = PlayerDatas.Instance.baseData.MapID;

            int[] useDrugs = GetDrugIDListByDungeonID(mapId);

            if (useDrugs == null) return;



            for (int i = 0; i < useDrugs.Length; i++)

            {

                int id = useDrugs[i];

                AddItemUseTypeDict(id);

            }

        }



        private void UpdateDungeonUse()

        {

            int mapId = PlayerDatas.Instance.baseData.MapID;

            if (!dungeonUseDict.ContainsKey(mapId)) return;



            List<int> useIdlist = dungeonUseDict[mapId];

            for (int i = 0; i < useIdlist.Count; i++)

            {

                int id = useIdlist[i];

                AddItemUseTypeDict(id);

            }

        }



        public SkillConfig GetSkillConfig(int itemId)

        {

            ItemConfig itemConfig = ItemConfig.Get(itemId);

            SkillConfig skillConfig = SkillConfig.Get(itemConfig.AddSkill1);

            return skillConfig;

        }



        public int GetDungeonIDByDrugID(int drugID)

        {

            int dungeonID = 0;

            //DrugToDungeonDict.TryGetValue(drugID, out dungeonID);

            return dungeonID;

        }



        public int[] GetDrugIDListByDungeonID(int dungeonID)

        {

            int[] drugIDlist = null;

            DungeonToDrugDict.TryGetValue(dungeonID, out drugIDlist);

            return drugIDlist;

        }

        #endregion



        #region 判断物品是否达到使用上限

        public bool IsReachUseLimit(string guid, out ulong count)

        {

            count = 0;

            ItemModel itemModel = GetItemByGuid(guid);

            if (itemModel == null) return false;



            AttrFruitConfig fruitConfig = AttrFruitConfig.Get(itemModel.itemId);

            int haveUseCnt = GetItemUsedTimesToday(itemModel.itemId);

            int sumHaveUseCnt = GetItemTotalUsedTimes(itemModel.itemId);

            count = (ulong)itemModel.count;

            bool isReach = false;

            int remainDayCnt = 0;

            if (itemModel.config.MaxSkillCnt > 0)

            {

                remainDayCnt = itemModel.config.MaxSkillCnt - haveUseCnt;

                if (itemModel.count > remainDayCnt)

                {

                    count = (ulong)remainDayCnt;

                }

            }



            int remainSumCnt = 0;

            if (fruitConfig != null)

            {

                remainSumCnt = fruitConfig.basicUseLimit - sumHaveUseCnt;

                if (remainSumCnt <= remainDayCnt && itemModel.count > remainSumCnt)

                {

                    count = (ulong)remainSumCnt;

                }

            }



            if (count < (ulong)itemModel.count)

            {

                isReach = true;

            }



            return isReach;

        }

        #endregion



        #region 物品吞噬逻辑处理

        public EquipColorType colorType { get; private set; }

        public event Action<EquipColorType> RefreshColorSelectAct;

        public event Action RefreshEquipDecomNumAct;

        public int[] defaultUnSelectlist { get; private set; }



        public int GetBetterEquipCount(List<ItemModel> itemModels)

        {

            if (itemModels.IsNullOrEmpty())

            {

                return 0;

            }



            var count = 0;

            foreach (var item in itemModels)

            {

                if (ItemLogicUtility.Instance.IsFightUp(item.itemId, item.score) == 1)

                {

                    count += item.count;

                }

            }

            return count;

        }



        public void SetColorSelect(EquipColorType type)

        {

            colorType = type;



            if (RefreshColorSelectAct != null)

            {

                RefreshColorSelectAct(type);

            }

            SendEquipDevourRecordQuest();

            EquipDecomRedCtrl();

        }



        public List<int> devourPlacelist { get; private set; }

        public int devourRedpointLevel { get; private set; }

        public int minDevourEquipNum { get; private set; }

        public void SetDevourEquipPlace()

        {

            devourPlacelist = new List<int>();

            FuncConfigConfig funcConfig = FuncConfigConfig.Get("PetAbsorbType");

            int[] placeArray = ConfigParse.GetMultipleStr<int>(funcConfig.Numerical1);

            for (int i = 0; i < placeArray.Length; i++)

            {

                devourPlacelist.Add(placeArray[i]);

            }

            devourRedpointLevel = int.Parse(funcConfig.Numerical2);

            minDevourEquipNum = int.Parse(funcConfig.Numerical3);

        }



        List<ItemModel> devourModellist = new List<ItemModel>();

        List<ItemModel> orderDevourModellist = new List<ItemModel>();

        public List<ItemModel> GetDevourModellist()

        {

            SinglePack singlePack = GetSinglePack(PackType.Item);

            if (singlePack == null) return null;



            devourModellist.Clear();

            orderDevourModellist.Clear();

            foreach (var model in singlePack.GetAllItems().Values)

            {

                if (model.config.Type == 29)

                {

                    devourModellist.Add(model);

                }

                else

                {

                    if (devourPlacelist.Contains(model.config.EquipPlace))

                    {

                        if (GeneralDefine.equipDecomposeScreen.Contains(model.config.ItemColor))

                        {

                            devourModellist.Add(model);

                        }

                    }

                }



            }

            orderDevourModellist.AddRange(devourModellist);

            orderDevourModellist.Sort(CompareByColor);

            return orderDevourModellist;

        }



        public int CompareByColor(ItemModel start, ItemModel next)

        {

            bool typeX = start.config.Type == 29 ? true : false;

            bool typeY = next.config.Type == 29 ? true : false;



            if (typeX.CompareTo(typeY) != 0) return -typeX.CompareTo(typeY);



            int colorX = start.config.ItemColor;

            int colorY = next.config.ItemColor;

            if (colorX.CompareTo(colorY) != 0) return colorX.CompareTo(colorY);



            int startIndex = devourModellist.IndexOf(start);

            int nextIndex = devourModellist.IndexOf(next);

            if (startIndex.CompareTo(nextIndex) != 0) return startIndex.CompareTo(nextIndex);



            return 0;

        }



        public List<ItemModel> GetCanDevourModellist()

        {

            List<ItemModel> canDevourModellist = new List<ItemModel>();

            SinglePack singlePack = GetSinglePack(PackType.Item);

            if (singlePack == null || colorType == EquipColorType.None)

            {

                if (RefreshEquipDecomNumAct != null)

                {

                    RefreshEquipDecomNumAct();

                }

                return null;

            }



            foreach (var model in singlePack.GetAllItems().Values)

            {

                if (model.config.Type == 29)

                {

                    if (!defaultUnSelectlist.Contains(model.itemId))

                    {

                        canDevourModellist.Add(model);

                    }

                }

                else

                {

                    if (IsCanDevour(model))

                    {

                        canDevourModellist.Add(model);

                    }

                }

            }



            if (RefreshEquipDecomNumAct != null)

            {

                RefreshEquipDecomNumAct();

            }



            return canDevourModellist;

        }



        public bool IsCanDevour(ItemModel model)

        {

            if (devourPlacelist.Contains(model.config.EquipPlace))

            {

                if (GeneralDefine.equipDecomposeScreen.Contains(model.config.ItemColor))

                {

                    var eatEquipConfig = PetEatEquipConfig.GetEquipColorAndEquipClass(model.config.ItemColor, model.config.LV);

                    if (eatEquipConfig == null) return false;



                    if (ItemLogicUtility.Instance.IsFightUp(model.itemId, model.score) != 1 && !model.isAuction)

                    {

                        if (model.config.ItemColor <= (int)colorType)

                        {

                            return true;

                        }

                    }

                }

            }



            return false;

        }



        public bool IsMaxDecomLv(int decomLv, out int realLv)

        {

            realLv = decomLv;

            var decomlist = EquipDeComposeConfig.GetValues();

            if (decomLv > decomlist[decomlist.Count - 1].LV)

            {

                realLv = decomlist[decomlist.Count - 1].LV;

                return true;

            }



            return false;

        }



        public List<ItemModel> selectDevourlist = new List<ItemModel>();

        public void GetSelectDevourList()

        {

            selectDevourlist.Clear();

            List<ItemModel> itemModels = GetCanDevourModellist();

            if (itemModels != null)

            {

                selectDevourlist.AddRange(itemModels);

            }

        }



        public void RefreshGetNewItem(ItemModel model)

        {

            if (model == null) return;



            if (CheckIsReachDevourCondi(model))

            {

                selectDevourlist.Add(model);

                if (RefreshEquipDecomNumAct != null)

                {

                    RefreshEquipDecomNumAct();

                }

            }

        }



        public void AddSelectDevourModellist(ItemModel model)

        {

            selectDevourlist.Add(model);

            if (RefreshEquipDecomNumAct != null)

            {

                RefreshEquipDecomNumAct();

            }

        }



        public bool CheckIsReachDevourCondi(ItemModel model)

        {

            if (model.config.Type == 29)

            {

                if (!defaultUnSelectlist.Contains(model.itemId))

                {

                    return true;

                }

                return false;

            }

            else

            {

                if (IsCanDevour(model))

                {

                    return true;

                }



            }

            return false;

        }



        public void RemoveSelectDevourModellist(ItemModel model)

        {

            if (selectDevourlist.Contains(model))

            {

                selectDevourlist.Remove(model);

            }

            if (RefreshEquipDecomNumAct != null)

            {

                RefreshEquipDecomNumAct();

            }

        }



        public Dictionary<int, int> GetDecomAttrDictByLv(int decomLv)

        {

            if (decomposeAttrDict.ContainsKey(decomLv))

            {

                return decomposeAttrDict[decomLv];

            }



            return null;

        }



        public bool IsReachMinDecomposeNum()

        {

            List<ItemModel> itemModels = GetCanDevourModellist();

            if (itemModels != null && itemModels.Count >= minDecomposeNum)

            {

                return true;

            }

            return false;

        }



        public void SendEquipdevourQuest(bool auto)

        {

            List<ItemModel> items = null;

            if (auto)

            {

                items = GetCanDevourModellist();

            }

            else

            {

                items = selectDevourlist;

            }



            if (items == null || items.Count < minDecomposeNum || !ItemLogicUtility.Instance.isPackResetOk || SettingEffectMgr.Instance.isStartDecompose) return;



            SettingEffectMgr.Instance.isStartDecompose = true;

            isAutoDecompose = auto;

            recordAutoDecomNum = Math.Min(items.Count, 100);

            var package = new CA32C_tagCMEquipDecompose();

            var indexLists = new ushort[recordAutoDecomNum];

            var idlist = new uint[recordAutoDecomNum];

            for (int i = 0; i < recordAutoDecomNum; i++)

            {

                indexLists[i] = (ushort)items[i].gridIndex;

                idlist[i] = (uint)items[i].itemId;

                if ((items[i].config.EquipPlace == 0 && items[i].config.Type != 29))

                {

                    return;

                }

            }

            package.Count = (byte)indexLists.Length;

            package.IndexList = indexLists;

            package.ItemIDList = idlist;

            package.IsAuto = (byte)(auto ? 1 : 0);

            GameNetSystem.Instance.SendInfo(package);

        }



        public void SendEquipDevourRecordQuest()

        {

            var record = StringUtility.Contact((int)colorType + 1, 1, 1);

            var decomSet = new CA32D_tagCMDecomposeSeting();

            decomSet.Seting = uint.Parse(record);

            GameNetSystem.Instance.SendInfo(decomSet);

        }



        public int decomposeLv { get; private set; }

        public int decomposeExp { get; private set; }

        public int decomposeProgress { get; private set; }

        public int addDecomposeExp { get; private set; }

        public int minDecomposeNum { get; private set; }

        public bool isAutoDecompose { get; set; }

        public int recordAutoDecomNum { get; private set; }

        public DecomposeGetMatInfo[] getItems { get; private set; }



        public event Action RefreshDecomAttrAct;

        public void GetServerDecomposeSet(HA31C_tagMCEquipDecomposeInfo info)

        {

            addDecomposeExp = 0;

            int realLv = info.LV + 1;

            bool isMax = IsMaxDecomLv(realLv, out realLv);

            if (realLv == decomposeLv)

            {

                addDecomposeExp = (int)info.Exp - decomposeExp;

            }

            else

            {

                for (int i = decomposeLv; i <= realLv; i++)

                {

                    var deComposeConfig = EquipDeComposeConfig.Get(i);

                    if (i == decomposeLv)

                    {

                        addDecomposeExp = deComposeConfig.UpNeedExp - decomposeExp;

                    }

                    else if (i == realLv)

                    {

                        addDecomposeExp += (int)info.Exp;

                    }

                    else

                    {

                        addDecomposeExp += deComposeConfig.UpNeedExp;

                    }

                }

            }



            decomposeLv = realLv;

            decomposeExp = (int)info.Exp;

            decomposeProgress = info.DecomposeCnt;

            getItems = JsonMapper.ToObject<DecomposeGetMatInfo[]>(info.GetItemData);



            if (info.Seting != 0)

            {

                string decomSetStr = info.Seting.ToString();

                string colorStr = decomSetStr.Substring(0, 1);

                colorType = (EquipColorType)(int.Parse(colorStr) - 1);

                string lvStr = decomSetStr.Substring(1, decomSetStr.Length - 2);

            }

            if (RefreshDecomAttrAct != null)

            {

                RefreshDecomAttrAct();

            }

        }

        /// <summary>

        /// 设置获得炼丹材料的展示数据

        /// </summary>

        /// <param name="getMatInfos"></param>

        /// <returns></returns>

        private List<DecomposeGetMatInfo> getMatInfos = new List<DecomposeGetMatInfo>();

        public List<DecomposeGetMatInfo> SetShowMatInfo()

        {

            getMatInfos.Clear();

            int sumMatCnt = 0;

            if (getItems != null)

            {

                for (int i = 0; i < getItems.Length; i++)

                {

                    if (getItems[i].Count > 0)

                    {

                        sumMatCnt += getItems[i].Count;

                    }

                    else

                    {

                        sumMatCnt += 1;

                    }

                }

            }



            if (sumMatCnt > 5)

            {

                for (int i = 0; i < getItems.Length; i++)

                {

                    getMatInfos.Add(getItems[i]);

                }

            }

            else

            {

                if (getItems != null)

                {

                    for (int i = 0; i < getItems.Length; i++)

                    {

                        //if (getItems[i].Count > 0)

                        //{

                        //    for (int j = 0; j < getItems[i].Count; j++)

                        //    {

                        //        DecomposeGetMatInfo matInfo = new DecomposeGetMatInfo();

                        //        matInfo.ItemID = getItems[i].ItemID;

                        //        matInfo.Count = 1;

                        //        matInfo.IsSuite = getItems[i].IsSuite;

                        //        matInfo.UserData = getItems[i].UserData;

                        //        getMatInfos.Add(matInfo);

                        //    }

                        //}

                        //else

                        {

                            getMatInfos.Add(getItems[i]);

                        }

                    }

                }

            }

            return getMatInfos;

        }



        public enum EquipColorType

        {

            None = 0,

            White = 1,

            Blue = 2,

            Purple = 3,

            Orange = 4,

            Red = 5,

            //后续IL开发添加预设

            default1,

            default2,

            default3,

            default4,

            All = 10,

        }



        public class DecomposeGetMatInfo

        {

            public int ItemID;

            public int Count;

            public int IsSuite;

            public string UserData;

        }

        #endregion



        #region 丹药逻辑处理



        private int CompareMakeDrug(AttrFruitConfig start, AttrFruitConfig end)

        {

            ItemConfig configS = ItemConfig.Get(start.ID);

            ItemConfig configE = ItemConfig.Get(end.ID);

            if (configS.RealmLimit.CompareTo(configE.RealmLimit) != 0)

            {

                return configS.RealmLimit.CompareTo(configE.RealmLimit);

            }

            if (configS.LV.CompareTo(configE.LV) != 0)

            {

                return configS.LV.CompareTo(configE.LV);

            }



            int x = makeDruglist.IndexOf(start);

            int y = makeDruglist.IndexOf(end);

            if (x.CompareTo(y) != 0) x.CompareTo(y);



            return 0;

        }



        List<AttrFruitConfig> drugOrderlist = new List<AttrFruitConfig>();

        List<AttrFruitConfig> haveDruglist = new List<AttrFruitConfig>();

        public List<AttrFruitConfig> GetDrugOrderByCnt()

        {

            drugOrderlist.Clear();

            haveDruglist.Clear();

            drugOrderlist.AddRange(makeDruglist);

            drugOrderlist.Sort(CompareByIsHave);

            for (int i = 0; i < drugOrderlist.Count; i++)

            {

                if (IsHaveDrugUse(drugOrderlist[i]))

                {

                    haveDruglist.Add(drugOrderlist[i]);

                }

            }

            haveDruglist.Sort(CompareMakeDrug);

            for (int i = 0; i < haveDruglist.Count; i++)

            {

                drugOrderlist[i] = haveDruglist[i];

            }



            return drugOrderlist;

        }



        public bool CheckIsDrugById(int itemId)

        {

            for (int i = 0; i < makeDruglist.Count; i++)

            {

                if (makeDruglist[i].ID == itemId)

                {

                    return true;

                }

            }

            return false;

        }



        public int CompareByIsHave(AttrFruitConfig start, AttrFruitConfig end)

        {

            bool isHaveStart = IsHaveDrugUse(start);

            bool isHaveEnd = IsHaveDrugUse(end);

            if (isHaveStart.CompareTo(isHaveEnd) != 0) return -isHaveStart.CompareTo(isHaveEnd);



            //isHaveStart = IsHaveDrugRecycle(start);

            //isHaveEnd = IsHaveDrugRecycle(end);

            //if (isHaveStart.CompareTo(isHaveEnd) != 0) return -isHaveStart.CompareTo(isHaveEnd);



            isHaveStart = GetItemCountByID(PackType.Item, start.ID) > 0 ? true : false;

            isHaveEnd = GetItemCountByID(PackType.Item, end.ID) > 0 ? true : false;

            if (isHaveStart.CompareTo(isHaveEnd) != 0) return isHaveStart.CompareTo(isHaveEnd);



            isHaveStart = IsReachMaxUseDrug(start);

            isHaveEnd = IsReachMaxUseDrug(end);

            if (isHaveStart.CompareTo(isHaveEnd) != 0) return isHaveStart.CompareTo(isHaveEnd);



            int x = makeDruglist.IndexOf(start);

            int y = makeDruglist.IndexOf(end);

            if (x.CompareTo(y) != 0) return x.CompareTo(y);

            return 0;

        }



        public bool IsHaveDrugUse(AttrFruitConfig fruitConfig)

        {

            if (!IsReachMaxUseDrug(fruitConfig))

            {

                return GetItemCountByID(PackType.Item, fruitConfig.ID) > 0 ? true : false;

            }



            return false;

        }



        public bool IsHaveDrugRecycle(AttrFruitConfig fruitConfig)

        {

            if (IsReachMaxUseDrug(fruitConfig))

            {

                return GetItemCountByID(PackType.Item, fruitConfig.ID) > 0 ? true : false;

            }

            return false;

        }



        public bool IsReachMaxUseDrug(AttrFruitConfig fruitConfig)

        {

            if (fruitConfig == null)

            {

                return false;

            }



            if (fruitConfig.FuncID == 2)

            {

                AlchemyDrugUseLimit drugUseLimit;

                if (alchemyModel.TryGetAlchemyUseLimit(fruitConfig.ID, out drugUseLimit))

                {

                    return drugUseLimit.IsReachLimit();

                }

            }



            int useNum = GetItemTotalUsedTimes(fruitConfig.ID);

            if (useNum >= fruitConfig.basicUseLimit)

            {

                return true;

            }

            return false;

        }

        #endregion



        //获取背包中的一件可拍卖物品 优先其他职业

        public string GetAuctionEquip()

        {

            var itemPackage = GetSinglePack(PackType.Item);

            var allItems = itemPackage.GetAllItems();



            var guid = string.Empty;

            List<string> guidList = new List<string>();

            foreach (var item in allItems.Values)

            {

                var isAuction = item.isAuction;

                if (isAuction && ItemLogicUtility.Instance.IsRealmEquip(item.itemId))

                {

                    if (!ItemLogicUtility.Instance.IsJobCompatibleItem(item.itemId))

                    {

                        return item.guid;

                    }

                    else

                    {

                        if (guid != string.Empty)

                            continue;

                        guid = item.guid;

                    }

                }

            }

            return guid;

        }

    }

}


 System/TreasureFindHost/ReciveConditionCell.cs

@@ -142,7 +142,7 @@
                        {

                            List<int> adviceIdlist = findHosts.findRecommandItems[PlayerDatas.Instance.baseData.Job];

                            hostModel.SetAdviceIdlist(adviceIdlist);

                            ItemTipUtility.Show(adviceIdlist[0]);

                            ItemTipUtility.Show(adviceIdlist[0]);  
                        }

                        else

                        {