using System;
|
using System.Collections;
|
using System.Collections.Generic;
|
using System.Text;
|
|
using UnityEngine;
|
|
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;
|
}
|
