目录迁移 整理

yyl

2025-06-04 a7f4c5ecc5268c49f6a6caf769b3ebee6f237662

 Main/System/KnapSack/VirtualPackManager.cs

File was renamed from Main/Manager/GameSystemManager/VirtualPackManager.cs
@@ -1,363 +1,363 @@
using System;

using System.Collections;

using System.Collections.Generic;

using System.Text;



using UnityEngine;

namespace vnxbqy.UI

{



    public class VirtualPackManager : GameSystemManager<VirtualPackManager>

    {

        Dictionary<PackType, List<VirtualPackItem>> virtualPackItems

            = new Dictionary<PackType, List<VirtualPackItem>>();

        Dictionary<PackType, ObjectPool<VirtualPackItem>> m_VirtualItemPool

            = new Dictionary<PackType, ObjectPool<VirtualPackItem>>();

        Dictionary<PackType, int> virtualPackCapacityDict = new Dictionary<PackType, int>();



        public event Action<PackType> virtualPackRefresh;

        int getA206Count = 0;          //收到了几次A206包

        bool isFrist = false;          //是不是第一次获得聚魂碎片

        Dictionary<int, int> noPackItemCountDict = new Dictionary<int, int>();  //无需背包的物品数量刷新，自动转化为数值

        public event Action OnNoPackItemCountRefresh;



        public void OnBeforePlayerDataInitialize()

        {

            foreach (var packType in virtualPackItems.Keys)

            {

                var pool = m_VirtualItemPool[packType];

                var items = virtualPackItems[packType];

                foreach (var item in items)

                {

                    pool.Release(item);

                }

            }

            virtualPackItems.Clear();

            noPackItemCountDict.Clear();

            getA206Count = 0;

            isFrist = false;

        }



        public void OnPlayerLoginOk()

        {

            isFrist = noPackItemCountDict.Count == 0;

        }



        public override void Init()

        {

            base.Init();

            ParseConfig();

            m_VirtualItemPool.Add(PackType.GatherSoul, new ObjectPool<VirtualPackItem>(OnGetItem, OnReleaseItem));

            m_VirtualItemPool.Add(PackType.RunePack, new ObjectPool<VirtualPackItem>(OnGetItem, OnReleaseItem));

            DTC0102_tagCDBPlayer.beforePlayerDataInitializeEvent += OnBeforePlayerDataInitialize;

            DTC0403_tagPlayerLoginLoadOK.playerLoginOkEvent += OnPlayerLoginOk;

        }



        public override void Release()

        {

            base.Release();

            DTC0102_tagCDBPlayer.beforePlayerDataInitializeEvent -= OnBeforePlayerDataInitialize;

            DTC0403_tagPlayerLoginLoadOK.playerLoginOkEvent -= OnPlayerLoginOk;

        }



        void ParseConfig()

        {

            var funcConfig = FuncConfigConfig.Get("RunePackageNum");

            virtualPackCapacityDict.Add(PackType.RunePack, int.Parse(funcConfig.Numerical1));

        }



        public bool IsVirtualPack(PackType packType)

        {

            switch (packType)

            {

                case PackType.GatherSoul:

                case PackType.RunePack:

                    return true;

            }

            return false;

        }



        public int GetPackCapacity(PackType packType)

        {

            if (virtualPackCapacityDict.ContainsKey(packType))

            {

                return virtualPackCapacityDict[packType];

            }

            return 0;

        }



        public int GetPackRemainCount(PackType packType)

        {

            var capacity = GetPackCapacity(packType);

            return capacity - GetPackItemCount(packType);

        }



        public int GetPackItemCount(PackType packType)

        {

            if (virtualPackItems.ContainsKey(packType))

            {

                return virtualPackItems[packType].Count;

            }

            return 0;

        }



        public int GetItemCountById(PackType packType, int id)

        {

            var count = 0;

            List<int> list;

            if (TryGetItems(packType, out list))

            {

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

                {

                    VirtualPackItem item;

                    if (TryGetItem(packType, list[i], out item)

                        && item.id == id)

                    {

                        count++;

                    }

                }

            }

            return count;

        }



        public void GetItemIndexs(PackType packType, ref List<int> list)

        {

            list.Clear();

            List<VirtualPackItem> _list;

            if (virtualPackItems.TryGetValue(packType, out _list))

            {

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

                {

                    list.Add(_list[i].index);

                }

            }

        }



        public bool TryGetItems(PackType packType, out List<int> list)

        {

            list = new List<int>();

            List<VirtualPackItem> _list;

            if (virtualPackItems.TryGetValue(packType, out _list))

            {

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

                {

                    list.Add(_list[i].index);

                }

                return true;

            }

            return false;

        }



        public bool TryGetItem<T>(PackType packType, int packIndex, out T item) where T : VirtualPackItem

        {

            item = default(T);

            if (virtualPackItems.ContainsKey(packType))

            {

                var _index = virtualPackItems[packType].FindIndex((x) =>

                 {

                     return x.index == packIndex;

                 });

                if (_index != -1)

                {

                    item = virtualPackItems[packType][_index] as T;

                }

                return _index != -1;

            }

            return false;

        }



        public void OnReceiveServerPack(HA204_tagMCVPackRefresh package)

        {

            var packType = (PackType)package.PackType;

            if (!IsVirtualPack(packType))

            {

                return;

            }

            List<VirtualPackItem> list;

            if (!virtualPackItems.TryGetValue(packType, out list))

            {

                list = new List<VirtualPackItem>();

                virtualPackItems.Add(packType, list);

            }

            SetVirtualItem(packType, ref list, package.VPacklItemList);

            if (virtualPackRefresh != null)

            {

                virtualPackRefresh((PackType)package.PackType);

            }



        }



        public void OnReceiveServerPack(HA205_tagMCVPackClear package)

        {

            var packType = (PackType)package.PackType;

            if (!IsVirtualPack(packType))

            {

                return;

            }

            List<VirtualPackItem> list;

            if (virtualPackItems.TryGetValue(packType, out list))

            {

                var pool = m_VirtualItemPool[packType];

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

                {

                    var index = package.ItemPlaceList[i];

                    var items = list.FindAll((x) =>

                    {

                        return x.index == index;

                    });

                    foreach (var item in items)

                    {

                        list.Remove(item);

                        pool.Release(item);

                    }

                }

                if (virtualPackRefresh != null)

                {

                    virtualPackRefresh(packType);

                }

            }

        }





        public void UpdateAutoItemCountRefresh(HA206_tagMCAutoItemCountRefresh netPack)

        {



            ShowRewardWin(netPack);//vNetData中ItemCount传的是碎片总数，需要在noPackItemCountDict写入数据之前计算差值

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

            {

                noPackItemCountDict[(int)netPack.ItemCountList[i].ItemID] = (int)netPack.ItemCountList[i].ItemCount;

            }

            OnNoPackItemCountRefresh?.Invoke();

        }



        void ShowRewardWin(HA206_tagMCAutoItemCountRefresh vNetData)

        {

            getA206Count += 1;

            if (ItemLogicUtility.Instance.hidePickItem)

                return;

            // if (ModelCenter.Instance.GetModel<GatheringSoulModel>().isOpenXBWin)

            //     return;

            if (getA206Count <= 1 && !isFrist)

                return;



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

            {

                int itemID = (int)vNetData.ItemCountList[i].ItemID;

                int itemCount = (int)vNetData.ItemCountList[i].ItemCount;

                if (noPackItemCountDict.ContainsKey(itemID) && noPackItemCountDict[itemID] > itemCount)

                    return;

                ItemLogicUtility.Instance.RefreshPickItem(PackType.Item, itemID.ToString());

            }

        }





        public int GetNoPackItemCount(int id)

        {

            if (noPackItemCountDict.ContainsKey(id))

            {

                return noPackItemCountDict[id];

            }

            return 0;

        }



        public Dictionary<int, int> GetAllNoPackItem()

        {

            return noPackItemCountDict;

        }







        void SetVirtualItem(PackType packType, ref List<VirtualPackItem> list, HA204_tagMCVPackRefresh.tagMCVPackItem[] items)

        {

            var pool = m_VirtualItemPool[packType];

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

            {

                var item = list.Find((x) =>

                {

                    return x.index == items[i].ItemPlace;

                });

                if (item != null)

                {

                    item.Release();

                }

                else

                {

                    if (pool.inactivedCount > 0)

                    {

                        item = pool.Get();

                        list.Add(item);

                    }

                }

                if (item == null)

                {

                    item = VirtualPackItem.Get(packType);

                    list.Add(item);

                }

                item.ParsePackItem(items[i].ItemPlace, items[i].ItemData);



                ItemLogicUtility.Instance.RefreshPickItem(packType, item.id.ToString());

            }

        }



        static void OnGetItem(VirtualPackItem item)

        {



        }



        static void OnReleaseItem(VirtualPackItem item)

        {

            item.Release();

        }

    }



    public abstract class VirtualPackItem

    {

        public int index { get; private set; }



        public int id { get; private set; }



        public int level { get; private set; }



        protected string dataString { get; set; }



        protected static StringBuilder sb = new StringBuilder();



        public virtual void ParsePackItem(int index, uint data)

        {

            this.index = index;



            dataString = data.ToString();

            int delta = 10 - dataString.Length;

            sb.Length = 0;

            sb.Append('0', delta);

            dataString = dataString.Insert(0, sb.ToString());



            id = int.Parse(dataString.Substring(5, 5));

            level = int.Parse(dataString.Substring(2, 3)) + 1;

        }



        public virtual void Release()

        {

            dataString = null;

        }



        public static VirtualPackItem Get(PackType packType)

        {

            // switch (packType)

            // {

            //     case PackType.RunePack:

            //         return new RuneItem();

            // }

            return null;

        }

    }



    public struct VirtualItem

    {

        public PackType packType;

        public int itemId;

        public int index;

        public int level;

    }

}



using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;

using UnityEngine;
namespace vnxbqy.UI
{

    public class VirtualPackManager : GameSystemManager<VirtualPackManager>
    {
        Dictionary<PackType, List<VirtualPackItem>> virtualPackItems
            = new Dictionary<PackType, List<VirtualPackItem>>();
        Dictionary<PackType, ObjectPool<VirtualPackItem>> m_VirtualItemPool
            = new Dictionary<PackType, ObjectPool<VirtualPackItem>>();
        Dictionary<PackType, int> virtualPackCapacityDict = new Dictionary<PackType, int>();

        public event Action<PackType> virtualPackRefresh;
        int getA206Count = 0;          //收到了几次A206包
        bool isFrist = false;          //是不是第一次获得聚魂碎片
        Dictionary<int, int> noPackItemCountDict = new Dictionary<int, int>();  //无需背包的物品数量刷新，自动转化为数值
        public event Action OnNoPackItemCountRefresh;

        public void OnBeforePlayerDataInitialize()
        {
            foreach (var packType in virtualPackItems.Keys)
            {
                var pool = m_VirtualItemPool[packType];
                var items = virtualPackItems[packType];
                foreach (var item in items)
                {
                    pool.Release(item);
                }
            }
            virtualPackItems.Clear();
            noPackItemCountDict.Clear();
            getA206Count = 0;
            isFrist = false;
        }

        public void OnPlayerLoginOk()
        {
            isFrist = noPackItemCountDict.Count == 0;
        }

        public override void Init()
        {
            base.Init();
            ParseConfig();
            m_VirtualItemPool.Add(PackType.GatherSoul, new ObjectPool<VirtualPackItem>(OnGetItem, OnReleaseItem));
            m_VirtualItemPool.Add(PackType.RunePack, new ObjectPool<VirtualPackItem>(OnGetItem, OnReleaseItem));
            DTC0102_tagCDBPlayer.beforePlayerDataInitializeEvent += OnBeforePlayerDataInitialize;
            DTC0403_tagPlayerLoginLoadOK.playerLoginOkEvent += OnPlayerLoginOk;
        }

        public override void Release()
        {
            base.Release();
            DTC0102_tagCDBPlayer.beforePlayerDataInitializeEvent -= OnBeforePlayerDataInitialize;
            DTC0403_tagPlayerLoginLoadOK.playerLoginOkEvent -= OnPlayerLoginOk;
        }

        void ParseConfig()
        {
            var funcConfig = FuncConfigConfig.Get("RunePackageNum");
            virtualPackCapacityDict.Add(PackType.RunePack, int.Parse(funcConfig.Numerical1));
        }

        public bool IsVirtualPack(PackType packType)
        {
            switch (packType)
            {
                case PackType.GatherSoul:
                case PackType.RunePack:
                    return true;
            }
            return false;
        }

        public int GetPackCapacity(PackType packType)
        {
            if (virtualPackCapacityDict.ContainsKey(packType))
            {
                return virtualPackCapacityDict[packType];
            }
            return 0;
        }

        public int GetPackRemainCount(PackType packType)
        {
            var capacity = GetPackCapacity(packType);
            return capacity - GetPackItemCount(packType);
        }

        public int GetPackItemCount(PackType packType)
        {
            if (virtualPackItems.ContainsKey(packType))
            {
                return virtualPackItems[packType].Count;
            }
            return 0;
        }

        public int GetItemCountById(PackType packType, int id)
        {
            var count = 0;
            List<int> list;
            if (TryGetItems(packType, out list))
            {
                for (int i = 0; i < list.Count; i++)
                {
                    VirtualPackItem item;
                    if (TryGetItem(packType, list[i], out item)
                        && item.id == id)
                    {
                        count++;
                    }
                }
            }
            return count;
        }

        public void GetItemIndexs(PackType packType, ref List<int> list)
        {
            list.Clear();
            List<VirtualPackItem> _list;
            if (virtualPackItems.TryGetValue(packType, out _list))
            {
                for (int i = 0; i < _list.Count; i++)
                {
                    list.Add(_list[i].index);
                }
            }
        }

        public bool TryGetItems(PackType packType, out List<int> list)
        {
            list = new List<int>();
            List<VirtualPackItem> _list;
            if (virtualPackItems.TryGetValue(packType, out _list))
            {
                for (int i = 0; i < _list.Count; i++)
                {
                    list.Add(_list[i].index);
                }
                return true;
            }
            return false;
        }

        public bool TryGetItem<T>(PackType packType, int packIndex, out T item) where T : VirtualPackItem
        {
            item = default(T);
            if (virtualPackItems.ContainsKey(packType))
            {
                var _index = virtualPackItems[packType].FindIndex((x) =>
                 {
                     return x.index == packIndex;
                 });
                if (_index != -1)
                {
                    item = virtualPackItems[packType][_index] as T;
                }
                return _index != -1;
            }
            return false;
        }

        public void OnReceiveServerPack(HA204_tagMCVPackRefresh package)
        {
            var packType = (PackType)package.PackType;
            if (!IsVirtualPack(packType))
            {
                return;
            }
            List<VirtualPackItem> list;
            if (!virtualPackItems.TryGetValue(packType, out list))
            {
                list = new List<VirtualPackItem>();
                virtualPackItems.Add(packType, list);
            }
            SetVirtualItem(packType, ref list, package.VPacklItemList);
            if (virtualPackRefresh != null)
            {
                virtualPackRefresh((PackType)package.PackType);
            }

        }

        public void OnReceiveServerPack(HA205_tagMCVPackClear package)
        {
            var packType = (PackType)package.PackType;
            if (!IsVirtualPack(packType))
            {
                return;
            }
            List<VirtualPackItem> list;
            if (virtualPackItems.TryGetValue(packType, out list))
            {
                var pool = m_VirtualItemPool[packType];
                for (int i = 0; i < package.Count; i++)
                {
                    var index = package.ItemPlaceList[i];
                    var items = list.FindAll((x) =>
                    {
                        return x.index == index;
                    });
                    foreach (var item in items)
                    {
                        list.Remove(item);
                        pool.Release(item);
                    }
                }
                if (virtualPackRefresh != null)
                {
                    virtualPackRefresh(packType);
                }
            }
        }


        public void UpdateAutoItemCountRefresh(HA206_tagMCAutoItemCountRefresh netPack)
        {

            ShowRewardWin(netPack);//vNetData中ItemCount传的是碎片总数，需要在noPackItemCountDict写入数据之前计算差值
            for (int i = 0; i < netPack.Count; i++)
            {
                noPackItemCountDict[(int)netPack.ItemCountList[i].ItemID] = (int)netPack.ItemCountList[i].ItemCount;
            }
            OnNoPackItemCountRefresh?.Invoke();
        }

        void ShowRewardWin(HA206_tagMCAutoItemCountRefresh vNetData)
        {
            getA206Count += 1;
            if (ItemLogicUtility.Instance.hidePickItem)
                return;
            // if (ModelCenter.Instance.GetModel<GatheringSoulModel>().isOpenXBWin)
            //     return;
            if (getA206Count <= 1 && !isFrist)
                return;

            for (int i = 0; i < vNetData.ItemCountList.Length; i++)
            {
                int itemID = (int)vNetData.ItemCountList[i].ItemID;
                int itemCount = (int)vNetData.ItemCountList[i].ItemCount;
                if (noPackItemCountDict.ContainsKey(itemID) && noPackItemCountDict[itemID] > itemCount)
                    return;
                ItemLogicUtility.Instance.RefreshPickItem(PackType.Item, itemID.ToString());
            }
        }


        public int GetNoPackItemCount(int id)
        {
            if (noPackItemCountDict.ContainsKey(id))
            {
                return noPackItemCountDict[id];
            }
            return 0;
        }

        public Dictionary<int, int> GetAllNoPackItem()
        {
            return noPackItemCountDict;
        }



        void SetVirtualItem(PackType packType, ref List<VirtualPackItem> list, HA204_tagMCVPackRefresh.tagMCVPackItem[] items)
        {
            var pool = m_VirtualItemPool[packType];
            for (int i = 0; i < items.Length; i++)
            {
                var item = list.Find((x) =>
                {
                    return x.index == items[i].ItemPlace;
                });
                if (item != null)
                {
                    item.Release();
                }
                else
                {
                    if (pool.inactivedCount > 0)
                    {
                        item = pool.Get();
                        list.Add(item);
                    }
                }
                if (item == null)
                {
                    item = VirtualPackItem.Get(packType);
                    list.Add(item);
                }
                item.ParsePackItem(items[i].ItemPlace, items[i].ItemData);

                ItemLogicUtility.Instance.RefreshPickItem(packType, item.id.ToString());
            }
        }

        static void OnGetItem(VirtualPackItem item)
        {

        }

        static void OnReleaseItem(VirtualPackItem item)
        {
            item.Release();
        }
    }

    public abstract class VirtualPackItem
    {
        public int index { get; private set; }

        public int id { get; private set; }

        public int level { get; private set; }

        protected string dataString { get; set; }

        protected static StringBuilder sb = new StringBuilder();

        public virtual void ParsePackItem(int index, uint data)
        {
            this.index = index;

            dataString = data.ToString();
            int delta = 10 - dataString.Length;
            sb.Length = 0;
            sb.Append('0', delta);
            dataString = dataString.Insert(0, sb.ToString());

            id = int.Parse(dataString.Substring(5, 5));
            level = int.Parse(dataString.Substring(2, 3)) + 1;
        }

        public virtual void Release()
        {
            dataString = null;
        }

        public static VirtualPackItem Get(PackType packType)
        {
            // switch (packType)
            // {
            //     case PackType.RunePack:
            //         return new RuneItem();
            // }
            return null;
        }
    }

    public struct VirtualItem
    {
        public PackType packType;
        public int itemId;
        public int index;
        public int level;
    }
}