0015 卡牌服务端搭建 - 去掉旧命名空间vnxbqy.UI，调整目录如ui里是界面 旧项目是 ui/window 等

hch

2025-06-06 9e7cf1d676f79c79a5afc0d3cce20ed4481368e2

 Main/System/KnapSack/VirtualPackManager.cs

@@ -4,360 +4,357 @@
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 class VirtualPackManager : GameSystemManager<VirtualPackManager>
    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()
    {
        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)
        {
            foreach (var packType in virtualPackItems.Keys)
            var pool = m_VirtualItemPool[packType];
            var items = virtualPackItems[packType];
            foreach (var item in items)
            {
                var pool = m_VirtualItemPool[packType];
                var items = virtualPackItems[packType];
                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);
                }
            }
            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);
                virtualPackRefresh(packType);
            }

        }
    }

        public void OnReceiveServerPack(HA205_tagMCVPackClear package)

    public void UpdateAutoItemCountRefresh(HA206_tagMCAutoItemCountRefresh netPack)
    {

        ShowRewardWin(netPack);//vNetData中ItemCount传的是碎片总数，需要在noPackItemCountDict写入数据之前计算差值
        for (int i = 0; i < netPack.Count; i++)
        {
            var packType = (PackType)package.PackType;
            if (!IsVirtualPack(packType))
            {
            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;
            }
            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);
                }
            }
            ItemLogicUtility.Instance.RefreshPickItem(PackType.Item, itemID.ToString());
        }
    }


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

            ShowRewardWin(netPack);//vNetData中ItemCount传的是碎片总数，需要在noPackItemCountDict写入数据之前计算差值
            for (int i = 0; i < netPack.Count; i++)
    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) =>
            {
                noPackItemCountDict[(int)netPack.ItemCountList[i].ItemID] = (int)netPack.ItemCountList[i].ItemCount;
                return x.index == items[i].ItemPlace;
            });
            if (item != null)
            {
                item.Release();
            }
            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++)
            else
            {
                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) =>
                if (pool.inactivedCount > 0)
                {
                    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);
                    item = pool.Get();
                    list.Add(item);
                }
                item.ParsePackItem(items[i].ItemPlace, items[i].ItemData);

                ItemLogicUtility.Instance.RefreshPickItem(packType, item.id.ToString());
            }
        }
            if (item == null)
            {
                item = VirtualPackItem.Get(packType);
                list.Add(item);
            }
            item.ParsePackItem(items[i].ItemPlace, items[i].ItemData);

        static void OnGetItem(VirtualPackItem item)
        {

        }

        static void OnReleaseItem(VirtualPackItem item)
        {
            item.Release();
            ItemLogicUtility.Instance.RefreshPickItem(packType, item.id.ToString());
        }
    }

    public abstract class VirtualPackItem
    static void OnGetItem(VirtualPackItem item)
    {
        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
    static void OnReleaseItem(VirtualPackItem item)
    {
        public PackType packType;
        public int itemId;
        public int index;
        public int level;
        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;
}