130 战斗修改回合样式

lcy

2025-11-05 3b2a6bb9047cfce9f501593b3669a9c1af6c5df4

 Main/System/KnapSack/PackManager.cs

@@ -3,1028 +3,1140 @@
using System.Linq;
using UnityEngine;
using LitJson;
using System.Text.RegularExpressions;
using System.Collections;
using System.IO;

    public class PackManager : GameSystemManager<PackManager>
    //public class PackModel : Model, IBeforePlayerDataInitialize, IAfterPlayerDataInitialize, IPlayerLoginOk
    {
        public static string StrengthAttrShift_RecordKey = "";
        public const string RecordKnapsackTitle = "RecordKnapsackTitle";
public class PackManager : GameSystemManager<PackManager>
{
    public event Action<PackType> refrechPackEvent; //刷新整个背包数据

        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;
    //物品（创建）刷新，可能批量创建注意效率; bool：true代表创建 false 刷新; 注意0707物品数量刷新不包含在此事件
    public event Action<PackType, string, bool> ChangeItemEvent; // 背包类型，GUID，是否创建

        //AlchemyModel alchemyModel { get { return ModelCenter.Instance.GetModel<AlchemyModel>(); } }
        //ItemTipsModel itemTipsModel { get { return ModelCenter.Instance.GetModel<ItemTipsModel>(); } }
    //删除物品，可能批量删除注意效率
    public event Action<PackType, string, int, int, int> DeleteItemEvent; // 背包类型，GUID, 物品ID，索引, 删除原因

        List<string> commonShowAwardEvents = new List<string>();
    // 单物品刷新 在得到新物品、物品数量的改变，清理该物品时均会触发 ; 但0725整个背包刷新不触发，如果有需要单独数量刷新事件另外处理
    // 触发比较频繁，界面使用时可以做个汇总后延迟刷新
    public event Action<PackType, int, int> RefreshItemEvent; //背包类型，位置索引，物品id
    public event Action<PackType> gridRefreshEvent; //背包可用格子数刷新
    public event Action<int, int> useItemSuccessEvent; //物品使用成功 int 位置索引 int物品id

        public int[] autoUseItemIDs;
        public override void Init()
        {
            DTC0102_tagCDBPlayer.beforePlayerDataInitializeEvent += OnBeforePlayerDataInitialize;
            DTC0102_tagCDBPlayer.afterPlayerDataInitializeEvent += OnAfterPlayerDataInitialize;
            DTC0403_tagPlayerLoginLoadOK.playerLoginOkEvent += OnPlayerLoginOk;
            ParseConfig();
            //SysNotifyMgr.Instance.sysNotifyEvent += RefreshSysInfo;
          
    public event Action<int> refreshItemDayUseCountEvent;  //刷新物品每日使用数量
    public event Action<int> refreshItemSumUseCountEvent;  //刷新物品总使用数量
    public event Action<PackType, string, bool> RefreshItemLockEvent; //物品锁定刷新 背包类型，guid，锁定状态


            // 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 override void Release()
        {
            DTC0102_tagCDBPlayer.beforePlayerDataInitializeEvent -= OnBeforePlayerDataInitialize;
            DTC0102_tagCDBPlayer.afterPlayerDataInitializeEvent -= OnAfterPlayerDataInitialize;
            DTC0403_tagPlayerLoginLoadOK.playerLoginOkEvent -= OnPlayerLoginOk;
FuncOpen.Instance.OnFuncStateChangeEvent -= OnFuncStateChangeEvent;
           // SysNotifyMgr.Instance.sysNotifyEvent -= RefreshSysInfo;
        }

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

        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);
            gameCashShow = JsonMapper.ToObject<List<int>>(textConfig.Numerical3);
        }


        private void OnFuncStateChangeEvent(int id)
        {

        }
        public void OnBeforePlayerDataInitialize()
        {
            GlobalTimeEvent.Instance.secondEvent -= UpdateSecond;
            PlayerDatas.Instance.playerDataRefreshEvent -= UpdatePlayerLv;
            LocalSave.DeleteKey(RecordKnapsackTitle);
            playerPackDict.Clear();
            itemDayUseCntDict.Clear();
            itemSumUseCntDict.Clear();
            itemGUIDDict.Clear();
            isPlayBetterEquipEffect = false;
        }

        public void OnAfterPlayerDataInitialize()
        {

        }

        public void OnPlayerLoginOk()
        {
            //ItemOperateUtility.Instance.RequestWarehouseData();
            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 (ItemLogicUtility.Instance.hidePickItem)
            //     return;

            // if (PlayerDatas.Instance.baseData.LV < 3)
            //     return;

            // var type = 0;
            // int.TryParse(infolist[0].ToString(), out type);
            // if (type == 1)
            // {
            //     Vector3 pos = new Vector3(-100, 0, 0);
            //     Vector3 rot = new Vector3(0, 0, 0);
            //     if (!WindowCenter.Instance.IsOpen<MainInterfaceWin>())
            //     {
            //         pos = new Vector3(0, 50, 0);
            //         rot = new Vector3(180, 180, 0);
            //     }
            //     EffectMgr.Instance.PlayUIEffect(1204, 3000, WindowCenter.Instance.uiRoot.tipsCanvas, pos, rot, false);
            // }
            // else if (type == 2)
            // {
            //     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, 3000, WindowCenter.Instance.uiRoot.tipsCanvas, pos, rot, false);
            // }
        }
    
        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
    private Dictionary<PackType, SinglePack> playerPackDict = new Dictionary<PackType, SinglePack>();
    private Dictionary<string, ItemModel> itemGUIDDict = new Dictionary<string, ItemModel>();

        public event Action<int> refreshItemDayUseCountEvent;  //刷新物品每日使用数量
        public event Action<int> refreshItemSumUseCountEvent;  //刷新物品总使用数量
    private Dictionary<int, int> PackGirdServerBuyCountDict = new Dictionary<int, int>(); //背包类型：购买格子的次数

        public bool isPlayBetterEquipEffect { get; set; }  //整理背包时是否播放特效
    //读表数据
    public Dictionary<int, int> PackMaxCountDict = new Dictionary<int, int>(); //背包类型：背包格子最大数量
    public int initBagGridCount { get; private set; } //初始物品背包格子数
    public int[] itemPackSortTyps { get; private set; }    //背包物品的按类型排序
    public List<int> composeItemIDList = new List<int>();  //合成列表物品ID
    List<int> canComposeItemIDList = new List<int>(); //数量足够合成列表物品ID 排序判断用

        #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 Dictionary<int, int> openGirdMoneyDict = new Dictionary<int, int>(); //背包类型：消耗货币类型
    public Dictionary<int, int[]> openGirdMoneyValueDict = new Dictionary<int, int[]>(); //背包类型：消耗货币值(按次数定价)
    public Dictionary<int, int[]> openGirdCountDict = new Dictionary<int, int[]>(); //背包类型：每次开的格子数量
    public static string StrengthAttrShift_RecordKey = "";
    public const string RecordKnapsackTitle = "RecordKnapsackTitle";


    string RoleEquipLocalSave = "";
    List<int> LocalSavePlaceArray { get; set; }
    Dictionary<int, List<int>> sharedUseCountItemDict { get; set; }
    // bool isUpdatePlayerLv = false;
    bool isItemChange = false;  //延迟处理物品变化

    public int[] gameCashShow;  //代金券特殊显示 除以100
    public int[] autoUseItemIDs;
    public override void Init()
    {
        DTC0102_tagCDBPlayer.beforePlayerDataInitializeEvent += OnBeforePlayerDataInitialize;
        DTC0403_tagPlayerLoginLoadOK.playerLoginOkEvent += OnPlayerLoginOk;
        ParseConfig();
        //SysNotifyMgr.Instance.sysNotifyEvent += RefreshSysInfo;
        


        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.RefreshPickItem(type, itemModel.itemId.ToString());
                    }
                    else
                    {
                        if (itemCntReduceEvent != null)
                        {
                            itemCntReduceEvent(type, itemModel.gridIndex, itemModel.itemId);
                        }
                    }

                    if (refreshItemCountEvent != null)
                    {
                        refreshItemCountEvent(type, itemModel.gridIndex, 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);

            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;
            }


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

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


        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)
        // 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 < useCntInfo.count; i++)
        //     for (int i = 0; i < shareUseJson.Count; i++)
        //     {
        //         int itemId = (int)useCntInfo.EatCntList[i].ItemID;
        //         int cnt = (int)useCntInfo.EatCntList[i].EatCnt;
        //         if (!itemSumUseCntDict.ContainsKey(itemId))
        //         var idListJson = shareUseJson[i];
        //         var idlist = new List<int>();
        //         sharedUseCountItemDict.Add(i, idlist);
        //         foreach (var id in idListJson)
        //         {
        //             itemSumUseCntDict.Add(itemId, cnt);
        //         }
        //         else
        //         {
        //             itemSumUseCntDict[itemId] = cnt;
        //         }

        //         if (refreshItemSumUseCountEvent != null)
        //         {
        //             refreshItemSumUseCountEvent(itemId);
        //             idlist.Add(int.Parse(id.ToString()));
        //         }
        //     }
        // }

        #endregion

        #region 玩家装备特殊逻辑
        void ParseConfig()
        {
           

            var config = FuncConfigConfig.Get("CommonShowAwards");
            commonShowAwardEvents = JsonMapper.ToObject<List<string>>(config.Numerical1);

        }



        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;
            }
        }

        //通过id找物品，注意检查是否指定背包
        public string GetItemGUIDByID(int itemId, bool includeAuction = true, PackType packType = PackType.Item)
        {
            string guid = string.Empty;
            foreach (var key in itemGUIDDict.Keys)
            {
                if (!includeAuction && itemGUIDDict[key].isAuction)
                {
                    continue;
                }

                if (itemGUIDDict[key].itemId == itemId && packType == itemGUIDDict[key].packType)
                {
                    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 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;
                    }

                    break;
                case PackType.Warehouse:
                    if (singlePack.GetEmptyGridCount() <= 0)
                    {
                        MainRedDot.Instance.redPointDepotFunc.state = RedPointState.Full;
                    }
                    else
                    {
                        MainRedDot.Instance.redPointDepotFunc.state = RedPointState.None;
                    }
                    break;
            }
        }

        
        #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 override void Release()
    {
        DTC0102_tagCDBPlayer.beforePlayerDataInitializeEvent -= OnBeforePlayerDataInitialize;
        DTC0403_tagPlayerLoginLoadOK.playerLoginOkEvent -= OnPlayerLoginOk;
        FuncOpen.Instance.OnFuncStateChangeEvent -= OnFuncStateChangeEvent;
        // SysNotifyMgr.Instance.sysNotifyEvent -= RefreshSysInfo;
    }

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


    private void OnFuncStateChangeEvent(int id)
    {

    }
    public void OnBeforePlayerDataInitialize()
    {
        GlobalTimeEvent.Instance.secondEvent -= UpdateSecond;
        // PlayerDatas.Instance.playerDataRefreshEvent -= UpdatePlayerLv;
        LocalSave.DeleteKey(RecordKnapsackTitle);
        playerPackDict.Clear();
        itemDayUseCntDict.Clear();
        itemSumUseCntDict.Clear();
        itemGUIDDict.Clear();
        PackGirdServerBuyCountDict.Clear();
    }



    public void OnPlayerLoginOk()
    {
        //ItemOperateUtility.Instance.RequestWarehouseData();
        RoleEquipLocalSave = StringUtility.Contact("RoleEquipLocalSave", PlayerDatas.Instance.baseData.PlayerID);
        StrengthAttrShift_RecordKey = StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID, "StrengthAttrShift");
        if (LocalSave.GetIntArray(RoleEquipLocalSave) != null)
        {
            if (string.IsNullOrEmpty(guid) || guid == "")
            {
                lookLineIndex = -1;
                lookItemGUID = "";
            }
            else
            {
                int index = GetItemByGuid(guid).gridIndex;
                lookLineIndex = index / singleRowCount;
                lookItemGUID = guid;
            }

            if (lookEquipEvent != null)
            {
                lookEquipEvent();
            }
            LocalSavePlaceArray = LocalSave.GetIntArray(RoleEquipLocalSave).ToList();
        }

        public event Action RefreshBagEvent;
        public void RefreshBagInfo()
        else
        {
            if (RefreshBagEvent != null)
            {
                RefreshBagEvent();
            }
            LocalSavePlaceArray = null;
        }
        #endregion
        GlobalTimeEvent.Instance.secondEvent += UpdateSecond;
        // PlayerDatas.Instance.playerDataRefreshEvent += UpdatePlayerLv;
        // isUpdatePlayerLv = true;
        FuncOpen.Instance.OnFuncStateChangeEvent += OnFuncStateChangeEvent;
    }

        public void SetJumpToOneKeySell(Transform parent)
        {
            // var goEffect = AchievementGuideEffectPool.Require(1);
            // goEffect.transform.SetParentEx(parent, Vector3.zero, Quaternion.identity, Vector3.one);
            // AchievementGoto.guideAchievementId = 0;
        }
    private void RefreshSysInfo(string key, ArrayList infolist)
    {
        // if (key != "GetMoney") return;
        // if (ItemLogicUtility.Instance.hidePickItem)
        //     return;

        #region 物品使用快捷提示
        // if (PlayerDatas.Instance.baseData.LV < 3)
        //     return;

        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 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;
                    }
                }
            }
        }




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



        #endregion

        #region 判断物品是否达到使用上限
        // public bool IsReachUseLimit(string guid, out ulong count)
        // var type = 0;
        // int.TryParse(infolist[0].ToString(), out type);
        // if (type == 1)
        // {
        //     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)
        //     Vector3 pos = new Vector3(-100, 0, 0);
        //     Vector3 rot = new Vector3(0, 0, 0);
        //     if (!WindowCenter.Instance.IsOpen<MainInterfaceWin>())
        //     {
        //         remainDayCnt = itemModel.config.MaxSkillCnt - haveUseCnt;
        //         if (itemModel.count > remainDayCnt)
        //         {
        //             count = (ulong)remainDayCnt;
        //         }
        //         pos = new Vector3(0, 50, 0);
        //         rot = new Vector3(180, 180, 0);
        //     }

        //     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;
        //     EffectMgr.Instance.PlayUIEffect(1204, 3000, WindowCenter.Instance.uiRoot.tipsCanvas, pos, rot, false);
        // }
        #endregion
        // else if (type == 2)
        // {
        //     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, 3000, WindowCenter.Instance.uiRoot.tipsCanvas, pos, rot, false);
        // }
    }

        
    

        

        public enum EquipColorType
    public void UpdatePack(H0725_tagRolePackRefreshEx packInfo)
    {
        SetLookIndex(null);
        var packType = (PackType)packInfo.PackType;
        if (!playerPackDict.ContainsKey(packType))
        {
            None = 0,
            White = 1,
            Blue = 2,
            Purple = 3,
            Orange = 4,
            Red = 5,

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


        

        public void ReceiveAwardNotify(HA801_tagMCGiveAwardInfo netPack)
        for (int i = 0; i < packInfo.ItemCount; i++)
        {
            var eventName = UIHelper.ServerStringTrim(netPack.EventName);
            if (eventName == "BuyItem")
                return;

            // 仙盟攻城战
            // if (eventName == "FamilyGCZSQGrid" || eventName == "FamilyGCZSQPass" || eventName == "FamilyGCZSQPassAll" ||
            //     eventName == "FamilyGCZContiribution" || eventName == "FamilyGCZAtk")
            // {
            //     ModelCenter.Instance.GetModel<FairySiegeActModel>()?.OnUpdateAwardInfoAction(netPack);
            //     return;
            // }
            if (!commonShowAwardEvents.Contains(eventName))
                return;

            List<Item> showItems = new List<Item>();

            if (netPack.Exp != 0 || netPack.ExpPoint != 0)
            {
                ulong expValue = netPack.Exp + netPack.ExpPoint * (ulong)Constants.ExpPointValue;
                showItems.Add(new Item(GeneralDefine.expDisplayId, expValue));
            }
            if (netPack.MoneyList.Length != 0)
            {
                for (int i = 0; i < netPack.MoneyLen; i++)
                {
                    var moneyType = netPack.MoneyList[i].MoneyType;
                    if (GeneralDefine.moneyDisplayIds.ContainsKey(moneyType) && netPack.MoneyList[i].MoneyValue != 0)
                    {
                        showItems.Add(new Item(GeneralDefine.moneyDisplayIds[moneyType], netPack.MoneyList[i].MoneyValue));
                    }

                }
            }

            if (netPack.ItemList.Length != 0)
            {
                for (int i = 0; i < netPack.ItemLen; i++)
                {
                    showItems.Add(new Item((int)netPack.ItemList[i].ItemID, netPack.ItemList[i].Count, netPack.ItemList[i].IsBind));
                }
            }
            var itemInfo = new ItemInfo(packInfo.ItemInfo[i]);
            var item = playerPackDict[packType].UpdateItem(itemInfo);
            AddItemGUIDDict(item, true);


            string info = string.Empty;
            if (LanguageConfig.HasKey("commonShowAwardEvents_" + eventName))
                info = Language.Get("commonShowAwardEvents_" + eventName);
        }

            if (showItems.Count == 0)
                return;
        if (refrechPackEvent != null)
        {
            refrechPackEvent(packType);
        }
        
        DelayNotifyPackChange(packType);
    }

            ItemLogicUtility.Instance.ShowGetItem(showItems, info, 0, eventName: eventName);
    public void UpdateItem(H0704_tagRolePackRefresh serverItem)
    {
        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 (RefreshItemEvent != null)
        {
            RefreshItemEvent(type, itemInfo.index, itemInfo.itemId);
        }


        // if (type == PackType.Equip)
        // {
        //     if (ItemLogicUtility.Instance.IsRealmEquip(itemInfo.itemId))
        //     {
        //         ItemOperateUtility.Instance.ShowPutOnNewEquipRemind(itemInfo.itemId);
        //     }
        // }
        
        DelayNotifyPackChange(type);
        //EquipDecomRedCtrl();
        AutoUseItem(itemInfo.itemId, serverItem.ItemGUID);
    }


    public void UpdateItemLockState(H0722_tagItemDeadLockRefresh netPack)
    {
        var singlePack = GetSinglePack((PackType)netPack.PackType);
        var item = singlePack.GetItemByIndex(netPack.ItemIndex);
        if (item == null)
        {
            return;
        }
        item.itemInfo.isLock = netPack.IsLock == 1;
        RefreshItemLockEvent?.Invoke((PackType)netPack.PackType, item.guid, item.itemInfo.isLock);
    }

    public void UpdateBuyPackGirdCount(HA207_tagSCPackBuyInfo netPack)
    {
        for (int i = 0; i < netPack.BuyInfoList.Length; i++)
        {
            PackGirdServerBuyCountDict[netPack.BuyInfoList[i].PackType] = netPack.BuyInfoList[i].BuyCnt;
        }
    }

    //购买所需信息 [货币类型，货币数量，购买格数]
    public int[] BuyPackGirdNeedData(PackType packType)
    {
        var curPackGirdCnt = GetSinglePack(packType).unlockedGridCount;
        if (curPackGirdCnt >= PackMaxCountDict[(int)packType])
            return null;

        int buyTimes = 0;
        PackGirdServerBuyCountDict.TryGetValue((int)packType, out buyTimes);
        var moneyType = openGirdMoneyDict[(int)packType];
        var moneyCntList = openGirdMoneyValueDict[(int)packType];
        var money = moneyCntList[Math.Min(buyTimes, moneyCntList.Length - 1)];
        var girdCntList = openGirdCountDict[(int)packType];
        var buyGirdCnt = girdCntList[Math.Min(buyTimes, girdCntList.Length - 1)];
        return new[] {moneyType, money, buyGirdCnt};
    }

    public void BuyPackGird(PackType packType)
    {
        var netPack = new C0741_tagCOpenPackCount();
        netPack.PackType = (byte)packType;
        GameNetSystem.Instance.SendInfo(netPack);
    }

    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);
        }

        
        DelayNotifyPackChange(type);
    }

    

    public void RefreshItemCount(H0707_tagItemCountRefresh refresh)
    {
        SetLookIndex(null);
        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)
            {

                itemModel.RefreshCount((int)refresh.ItemCount);

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

            }
        }
        DelayNotifyPackChange(type);

    }

    public void ClearPack(H0711_tagClearItemPack clearPack)
    {
        PackType type = (PackType)clearPack.PackIndex;
        SinglePack singlePack = null;
        playerPackDict.TryGetValue(type, out singlePack);
        List<string> guidList = new List<string>();
        if (singlePack != null)
        {
            foreach (var item in singlePack.GetAllItems().Values)
            {
                guidList.Add(item.guid);
            }
            singlePack.Clear();
            foreach (var guid in guidList)
            {
                DeleteItemDictByGUID(type, guid);
            }
        }
        refrechPackEvent?.Invoke(type);
    }

    public void RemoveItem(H0709_tagClearItem clearItem)
    {
        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);
            if (itemModel == null)
            {
                Debug.LogErrorFormat("删除不存在的物品索引:{0}", clearItem.ItemIndex);
                return;
            }
            guid = itemModel.guid;
            int itemId = itemModel.itemId;

            singlePack.RemoveItem(clearItem.ItemIndex);
            DeleteItemDictByGUID(type, itemModel.guid,itemId, clearItem.ItemIndex, clearItem.ClearType);

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

        }

        DelayNotifyPackChange(type);

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

    }

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

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


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

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


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

    void DeleteItemDictByGUID(PackType type, string guid, int itemID = 0, int index = 0, int clearType = -1)
    {
        if (itemGUIDDict.ContainsKey(guid))
        {
            if (itemGUIDDict[guid].packType == type)
            {
                itemGUIDDict.Remove(guid);
            }
            //只是背包转移，不删除但也要通知
            DeleteItemEvent?.Invoke(type, guid, itemID, index, clearType);
        }
    }

    /// <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 = (int)useCntInfo.EatCntList[i].EatCnt;
    //         if (!itemSumUseCntDict.ContainsKey(itemId))
    //         {
    //             itemSumUseCntDict.Add(itemId, cnt);
    //         }
    //         else
    //         {
    //             itemSumUseCntDict[itemId] = cnt;
    //         }

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


    #region 玩家装备特殊逻辑
    void ParseConfig()
    {

        ParsePackConfigIni();
        autoUseItemIDs = JsonMapper.ToObject<int[]>(FuncConfigConfig.Get("AutoUseItem").Numerical1);
        var config= FuncConfigConfig.Get("InitBagCellCount");
        initBagGridCount = int.Parse(config.Numerical1);

        config = FuncConfigConfig.Get("PackageSortPriority");
        itemPackSortTyps = ConfigParse.GetMultipleStr<int>(config.Numerical1);

        config = FuncConfigConfig.Get("OpenPack");
        openGirdMoneyDict = ConfigParse.ParseIntDict(config.Numerical1);
        openGirdMoneyValueDict = ConfigParse.ParseIntArrayDict(config.Numerical2);
        openGirdCountDict = ConfigParse.ParseIntArrayDict(config.Numerical3);

        config = FuncConfigConfig.Get("ItemCountShow");
        gameCashShow = JsonMapper.ToObject<int[]>(config.Numerical1);
    }

    void ParsePackConfigIni()
    {
        string[] lines = LoadConfigIni("MapServerConfig");
        foreach (string line in lines)
        {
            if (line.StartsWith("PackCnt") && line.Contains("="))
            {
                string[] parts = line.Split('=');
                if (parts.Length == 2 && int.TryParse(parts[1], out int count))
                {
                    string packTypeStr = parts[0].Replace("PackCnt", "");
                    if (int.TryParse(packTypeStr, out int packTypeIndex))
                    {
                        PackMaxCountDict[packTypeIndex] = count;
                    }
                }
            }
        }
    }

    public string[] LoadConfigIni(string name)
    {
        string path = string.Empty;
#if UNITY_EDITOR
        if (!AssetSource.isUseAssetBundle)
        {
            path = ResourcesPath.CONFIG_FODLER + "/" + name + ".ini";
        }
        else
#endif
        {
            //从服务端拷贝是ini，打包用txt统一处理
            path = AssetVersionUtility.GetAssetFilePath($"Config/{name}.txt");
        }

        return File.ReadAllLines(path);
    }

    public int GetCanBuyPackGirdCount(PackType type)
    {
        if (!PackMaxCountDict.ContainsKey((int)type))
        { 
            return 0;
        }
        return PackMaxCountDict[(int)type] - GetSinglePack(type).unlockedGridCount;
    }


    private void UpdateSecond()
    {
        if (isItemChange)
        {
            isItemChange = false;
            DelayRefreshItemPackEvent();
        }
    }

    // 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;
        if (!playerPackDict.TryGetValue(type, out singlePack))
        { 
            singlePack = new SinglePack(type);
            playerPackDict.Add(type, 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 List<ItemModel> GetItems(PackType packType)
    {
        if (playerPackDict.ContainsKey(packType))
        {
            return playerPackDict[packType].GetItems();
        }
        else
        {
            return null;
        }
    }

    //通过id找物品，注意检查是否指定背包
    public string GetItemGUIDByID(int itemId, bool includeAuction = true, PackType packType = PackType.Item)
    {
        string guid = string.Empty;
        foreach (var key in itemGUIDDict.Keys)
        {
            if (!includeAuction && itemGUIDDict[key].isAuction)
            {
                continue;
            }

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

        return guid;
    }

    //通过index找GUID
    public string GetItemGUIDByIndex(PackType packType, int index)
    {
        string guid = string.Empty;
        if (playerPackDict.ContainsKey(packType))
        {
            var items = playerPackDict[packType].GetAllItems();
            guid = items[index].guid;
        }

        return guid;
    }


    /// <summary>
    /// 得到ID相同的物品数量; 也可以获得部分货币和物品绑定的数量
    /// </summary>
    /// <param name="type"></param>
    /// <param name="id"></param>
    /// <returns></returns>
    public long GetItemCountByID(PackType type, int id, bool includeAuction = true)
    {
        long 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;
    }


    #region 红点逻辑判断

    Redpoint redpointItemPack = new Redpoint(MainRedDot.RedPoint_MainPackKey, MainRedDot.RedPoint_BagFuncKey);
    Redpoint redpointComposePack = new Redpoint(MainRedDot.RedPoint_MainPackKey, MainRedDot.RedPoint_ComposeFuncKey);

    //延迟通知背包变化，避免在同一帧内多次通知
    private void DelayNotifyPackChange(PackType type)
    {
        if (type == PackType.Item)
        {
            isItemChange = true;
        }
    }


    void DelayRefreshItemPackEvent()
    {
        //合成红点
        SinglePack singlePack = GetSinglePack(PackType.Item);
        var items = singlePack.GetAllItems();

        redpointComposePack.state = RedPointState.None;
        foreach (var item in items.Values)
        {
            int makeID = ItemCompoundConfig.GetMakeIDByMaterial(item.itemId);
            if (makeID != 0)
            {
                var config = ItemCompoundConfig.GetItemCompoundConfig(makeID);
                var targetID = config.itemID;
                var targetCnt = config.itemCount;
                if (GetItemCountByID(PackType.Item, targetID) >= targetCnt)
                {
                    redpointComposePack.state = RedPointState.Simple;
                    break;
                }
            }
        }


        //背包红点
        if (singlePack.GetEmptyGridCount() <= 0)
        {
            redpointItemPack.state = RedPointState.Full;
            SysNotifyMgr.Instance.ShowTip("BagFull");
        }
        else
        {
            redpointItemPack.state = RedPointState.None;

            //无条件开启的宝箱红点
            foreach (var item in items.Values)
            {
                var chestConfig = ChestsConfig.Get(item.itemId);
                if (chestConfig != null && chestConfig.ExpendItemID == 0 && chestConfig.OpenMoney == 0)
                {
                    redpointItemPack.state = RedPointState.Simple;
                    break;
                }
            }
        }


    }

    public void RefreshItemComposeList()
    {
        //收集合成物品
        composeItemIDList.Clear();
        canComposeItemIDList.Clear();

        SinglePack singlePack = GetSinglePack(PackType.Item);
        var items = singlePack.GetAllItems();

        foreach (var item in items.Values)
        {
            var makeID = ItemCompoundConfig.GetMakeIDByMaterial(item.itemId);
            if (makeID != 0)
            {
                composeItemIDList.Add(makeID);

                var config = ItemCompoundConfig.GetItemCompoundConfig(makeID);
                var targetID = config.itemID;
                var targetCnt = config.itemCount;
                if (GetItemCountByID(PackType.Item, targetID) >= targetCnt)
                {
                    canComposeItemIDList.Add(makeID);
                }
            }
        }

        composeItemIDList.Sort(SortItemCompose);
    }

    int SortItemCompose(int itemIDA, int itemIDB)
    {
        // 合成材料够不够
        var isEnoughA = canComposeItemIDList.Contains(itemIDA);
        var isEnoughB = canComposeItemIDList.Contains(itemIDB);
        if (isEnoughA != isEnoughB)
        {
            return isEnoughA ? -1 : 1;
        }

        var itemA = ItemConfig.Get(itemIDA);
        var itemB = ItemConfig.Get(itemIDB);

        var colorA = itemA.ItemColor;
        var colorB = itemB.ItemColor;
        if (colorA != colorB)
        {
            return colorB - colorA;
        }

        return itemA.ID - itemB.ID;
    }

    #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)
    {
        return;
        // 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 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;
        //         }
        //     }
        // }
    }




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



    #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

    

    

    public enum EquipColorType
    {
        None = 0,
        White = 1,
        Blue = 2,
        Purple = 3,
        Orange = 4,
        Red = 5,

    }


}