using System;
|
using System.Collections;
|
using System.Collections.Generic;
|
using System.Text;
|
|
using UnityEngine;
|
namespace Snxxz.UI
|
{
|
[XLua.LuaCallCSharp]
|
[XLua.Hotfix]
|
public class VirtualPackModel : Model, IBeforePlayerDataInitialize, IPlayerLoginOk
|
{
|
|
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;
|
|
public override void Init()
|
{
|
ParseConfig();
|
m_VirtualItemPool.Add(PackType.GatherSoul, new ObjectPool<VirtualPackItem>(OnGetItem, OnReleaseItem));
|
m_VirtualItemPool.Add(PackType.RunePack, new ObjectPool<VirtualPackItem>(OnGetItem, OnReleaseItem));
|
}
|
|
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();
|
}
|
|
public void OnPlayerLoginOk()
|
{
|
}
|
|
public override void UnInit()
|
{
|
}
|
|
void ParseConfig()
|
{
|
var funcConfig = FuncConfigConfig.Get("GatherSoulPackCount");
|
virtualPackCapacityDict.Add(PackType.GatherSoul, int.Parse(funcConfig.Numerical1));
|
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);
|
}
|
}
|
}
|
|
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);
|
}
|
}
|
|
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.GatherSoul:
|
return new GatherSoulItem();
|
case PackType.RunePack:
|
return new RuneItem();
|
}
|
return null;
|
}
|
}
|
|
public struct VirtualItem
|
{
|
public PackType packType;
|
public int itemId;
|
public int index;
|
public int level;
|
}
|
}
|
