Files
Main/Assets/Code/Logic/Item/ItemContianerSystem.cs

1391 lines
50 KiB
C#
Raw Permalink Normal View History

2025-01-25 04:38:09 +08:00
/**********************************************
//作者:#何健#
//日期:#2016.10.17#
//简述:#物品管理类,
#
*********************************************/
using MSG_backpack;
using MSG_SoulArmor;
using System;
using System.Collections;
using System.Collections.Generic;
using Thousandto.Cfg.Data;
using Thousandto.Code.Center;
using Thousandto.Code.Global;
using Thousandto.Core.Base;
using Thousandto.Plugins.Common;
using UnityEngine;
using CoroutinePool = UnityEngine.Gonbest.MagicCube.CoroutinePool;
namespace Thousandto.Code.Logic
{
public class ItemContianerSystem : BaseSystem
{
#region
private Dictionary<int, ItemContianerModel> _itemContianerDic;
private float[] _sortBackPackTime; //背包整理时间
private Dictionary<int, long> _enconomy; //玩家的货币包括经验
public float _curCountTime; //当前计时时间
public bool _isBeginCountDown; //是否倒计时
public bool IsAlertAutoUse; //自动使用物品提示
private Dictionary<int, ItemMsgCondition> _itemMsgConDic;
public ulong CurSelectItemDbid
{
get;set;
}
#endregion
#region
public void Initialize()
{
//设置更新频率
_updateFrameRate = 5;
_sortBackPackTime = new float[(int)ContainerType.ITEM_LOCATION_COUNT];
_itemContianerDic = new Dictionary<int, ItemContianerModel>();
_enconomy = new Dictionary<int, long>();
CurSelectItemDbid = 0;
IsAlertAutoUse = false;
}
public void Uninitialize()
{
if (_itemMsgConDic != null)
_itemMsgConDic.Clear();
_itemContianerDic.Clear();
_enconomy.Clear();
for (int idx = 0; idx < _sortBackPackTime.Length; ++idx)
{
_sortBackPackTime[idx] = 0;
}
}
/// <summary>
/// 更新物品容器更新时间
/// </summary>
protected override bool OnUpdate(float deltaTime)
{
if (_isBeginCountDown == true && _curCountTime > 0)
{
_curCountTime -= deltaTime;
}
if (null == _itemContianerDic)
{
return false;
}
var e = _itemContianerDic.GetEnumerator();
try
{
while (e.MoveNext())
{
e.Current.Value.UseTime += deltaTime;
}
}
finally
{
e.Dispose();
}
if (null != _sortBackPackTime)
{
for (int idx = 0; idx < _sortBackPackTime.Length; ++idx)
{
if (_sortBackPackTime[idx] > 0)
{
_sortBackPackTime[idx] -= deltaTime;
}
}
}
return true;
}
#endregion
#region
public void AddItemMsgCondition(LogicEventDefine itemMsg, int[] items, int id)
{
AddItemMsgCondition((int)itemMsg, items, id);
}
public void AddItemMsgCondition(int itemMsg, int[] items, int id)
{
var itemCon = new ItemMsgCondition(itemMsg, items);
if (_itemMsgConDic != null && _itemMsgConDic.ContainsKey(id))
_itemMsgConDic.Remove(id);
if (_itemMsgConDic == null)
_itemMsgConDic = new Dictionary<int, ItemMsgCondition>();
_itemMsgConDic.Add(id, itemCon);
}
public void ClearItemMsgCondition(int id)
{
if (_itemMsgConDic != null && _itemMsgConDic.ContainsKey(id))
_itemMsgConDic.Remove(id);
GameCenter.MainFunctionSystem.SetAlertFlag(id, false);
}
private void CheckItemChangeMsg(int id)
{
if (_itemMsgConDic == null)
return;
var e = _itemMsgConDic.GetEnumerator();
try
{
while (e.MoveNext())
{
e.Current.Value.Check(id);
}
}
finally { e.Dispose(); }
}
/// <summary>
/// 获取背包剩余格子数
/// </summary>
/// <returns></returns>
public int GetRemainCount()
{
ItemContianerModel bpModel = GetBackpackModelByType(ContainerType.ITEM_LOCATION_BAG);
var ret = 0;
if (null != bpModel)
{
ret = bpModel.OpenedCount - bpModel.ItemsOfUID.Values.Count;
}
return ret;
}
//获取背包整理所需时间
public float GetBagSortTime(ContainerType type)
{
float ret = default(float);
if (type >= ContainerType.ITEM_LOCATION_COUNT)
{
//TODO 写日志
return ret;
}
return _sortBackPackTime[(int)type];
}
//设置背包整理时间
public void SetBagSortTime(ContainerType type, float time)
{
if (type >= ContainerType.ITEM_LOCATION_COUNT)
{
//TODO 写日志
return;
}
_sortBackPackTime[(int)type] = time;
}
//根据容器类型获取容器信息
public ItemContianerModel GetBackpackModelByType(ContainerType type)
{
ItemContianerModel bpModel = null;
if (_itemContianerDic != null)
_itemContianerDic.TryGetValue((int)type, out bpModel);
return bpModel;
}
/// <summary>
/// 设置容器
/// </summary>
/// <param name="type"></param>
/// <param name="model"></param>
public void SetBackpackModelByType(ContainerType type, ItemContianerModel model)
{
if (null != model && ContainerType.ITEM_LOCATION_COUNT > type)
{
_itemContianerDic.Add((int)type, model);
}
}
//更新物品
public int UpdateItemFromContainer(ContainerType type, ItemInfo item, bool isNew = false, int resonCode = 0, bool pushEvent = true)
{
if (item.cdTime > 0)
{
item.cdTime = item.cdTime / 1000;
}
int retIndex = -1;
ItemContianerModel bpModel = GetBackpackModelByType(type);
if (null != bpModel && null != item)
{
ItemBase itemBase = null;
itemBase = new ItemBase(item);
switch (itemBase.Type)
{
case ItemType.Equip:
itemBase = new Equipment(item);
break;
case ItemType.ImmortalEquip:
itemBase = new ImmortalEquip(item);
if (type == ContainerType.ITEM_LOCATION_BACKEQUIP)
itemBase.Index = itemBase.Part;
break;
default:
itemBase = new ItemModel(item);
break;
}
itemBase.IsNew = isNew;
if (isNew && type == ContainerType.ITEM_LOCATION_BAG)
{
//引导检测
GameCenter.GuideSystem.Check(GuideTriggerType.GetItem, item.itemModelId);
}
if (null != itemBase)
{
itemBase.ContainerType = type;
if (type == ContainerType.ITEM_LOCATION_IMMORTAL)
{
itemBase.Index = bpModel.GetNewImmortalEquipIndex();
}
long oldCount = 0;
var oldItem = bpModel.GetItemByUID<ItemBase>(itemBase.DBID);
if(oldItem != null)
{
oldCount = oldItem.Count;
}
var newCount = itemBase.Count;
retIndex = bpModel.UpdateItem(itemBase);
if(type == ContainerType.ITEM_LOCATION_BAG || type == ContainerType.ITEM_LOCATION_IMMORTAL)
{
GameCenter.LuaSystem.Adaptor.AddUseNewItem(itemBase, resonCode, newCount - oldCount);
}
}
if(pushEvent)
{
UpdateContianerItems(type, itemBase);
}
}
return retIndex;
}
/// <summary>
/// 属性物品信息,如果没有则创建
/// </summary>
/// <param name="type"></param>
/// <param name="item"></param>
/// <returns></returns>
public int UpdateItemFromContainer(ContainerType type, ItemBase item)
{
int retIndex = -1;
ItemContianerModel bpModel = GetBackpackModelByType(type);
if (null == bpModel)
{
bpModel = new ItemContianerModel();
bpModel.ContainerType = type;
_itemContianerDic.Add((int)type, bpModel);
}
if (null != bpModel && null != item)
{
ItemBase itemBase = null;
var itemModel = item as ItemModel;
var equip = item as Equipment;
if (null != itemModel)
{
itemBase = new ItemModel(itemModel);
}
else
{
itemBase = new Equipment(equip);
}
if (null != itemBase)
{
itemBase.ContainerType = type;
retIndex = bpModel.UpdateItem(itemBase);
}
}
return retIndex;
}
/// <summary>
/// 更新物品时,向对应容器发送更新信息
/// </summary>
/// <param name="type"></param>
/// <param name="obj"></param>
public void UpdateContianerItems(ContainerType type, object obj = null)
{
switch (type)
{
case ContainerType.ITEM_LOCATION_BAG:
case ContainerType.ITEM_LOCATION_IMMORTAL:
GameCenter.PushFixEvent(LogicEventDefine.EVENT_BACKFORM_ITEM_UPDATE, obj);
break;
case ContainerType.ITEM_LOCATION_STORAGE:
GameCenter.PushFixEvent(LogicEventDefine.EVENT_STORAGE_ITEM_UPDATE, obj);
break;
case ContainerType.ITEM_LOCATION_EQUIP:
case ContainerType.ITEM_LOCATION_BACKEQUIP:
GameCenter.PushFixEvent(LogicEventDefine.EVENT_EQUIPMENTFORM_ITEM_UPDATE, obj);
break;
case ContainerType.ITEM_LOCATION_CLEAR:
GameCenter.PushFixEvent(LogicEventDefine.EID_EVENT_CLEARBAG_UPDATE, obj);
break;
}
}
/// <summary>
/// 更新容器时更新对应form
/// </summary>
/// <param name="type"></param>
/// <param name="obj"></param>
public void UpdateContainerForm(ContainerType type, object obj = null)
{
switch (type)
{
case ContainerType.ITEM_LOCATION_BAG:
case ContainerType.ITEM_LOCATION_IMMORTAL:
GameCenter.PushFixEvent(LogicEventDefine.EVENT_BACKFORM_UPDATE_ALL, obj);
break;
case ContainerType.ITEM_LOCATION_STORAGE:
GameCenter.PushFixEvent(LogicEventDefine.EVENT_STORAGE_FORM_UPDATE, obj);
break;
case ContainerType.ITEM_LOCATION_EQUIP:
case ContainerType.ITEM_LOCATION_BACKEQUIP:
GameCenter.PushFixEvent(LogicEventDefine.EVENT_EQUIPMENTFORM_UPDATE_FORM, obj);
break;
case ContainerType.ITEM_LOCATION_CLEAR:
GameCenter.PushFixEvent(LogicEventDefine.EID_EVENT_CLEARBAG_UPDATE, obj);
break;
}
}
/// <summary>
/// 根据绑定类型获取物品列表
/// </summary>
/// <typeparam name="T">物品类型,可能是物品或者装备</typeparam>
/// <param name="type">容器类型</param>
/// <param name="bind">是否绑定</param>
/// <returns></returns>
public List<ItemBase> GetItemListByBind(ContainerType type, bool bind)
{
_cacheList.Clear();
ItemContianerModel bpModel = GetBackpackModelByType(type);
if (null != bpModel)
{
var tmpList = bpModel.ItemsOfIndex;
if (null != tmpList)
{
var enumerator = tmpList.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
var retItem = enumerator.Current.Value as ItemBase;
if (null != retItem && retItem.IsBind == bind)
{
_cacheList.Add(retItem);
}
}
}
finally
{
enumerator.Dispose();
}
}
}
return _cacheList;
}
//获取物品列表没有GC
private static List<ItemBase> _cacheList = new List<ItemBase>();
public List<ItemBase> GetItemListNOGC<T>(ContainerType type) where T : ItemBase
{
_cacheList.Clear();
ItemContianerModel bpModel = GetBackpackModelByType(type);
if (null != bpModel)
{
var eumerater = bpModel.ItemsOfUID.GetEnumerator();
try
{
while (eumerater.MoveNext())
{
if (eumerater.Current.Value is T)
{
_cacheList.Add(eumerater.Current.Value as ItemBase);
}
}
}
finally
{
eumerater.Dispose();
}
}
return _cacheList;
}
/// <summary>
/// 根据物品大分类获取对应物品容器中的物品列表
/// </summary>
/// <typeparam name="T">物品类型,可能是物品或者装备</typeparam>
/// <param name="type">容器类型</param>
/// <param name="bigType">物品大类型</param>
/// <returns></returns>
public List<T> GetItemList<T>(ContainerType type, ItemBigType bigType) where T : ItemBase
{
ItemContianerModel bpModel = GetBackpackModelByType(type);
if (null != bpModel)
{
List<T> baseList = new List<T>(bpModel.ItemsOfUID.Count);
var enumerator = bpModel.ItemsOfUID.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
T retItem = enumerator.Current.Value as T;
if (null != retItem)
{
baseList.Add(retItem);
}
}
}
finally
{
enumerator.Dispose();
}
return baseList;
}
return new List<T>();
}
/// <summary>
/// 获取容器所有物品
/// </summary>
/// <typeparam name="T">物品类型,可能是物品或者装备</typeparam>
/// <param name="type">容器类型</param>
/// <returns></returns>
public List<T> GetItemList<T>(ContainerType type) where T : ItemBase
{
List<T> baseList = new List<T>();
ItemContianerModel bpModel = GetBackpackModelByType(type);
if (null != bpModel)
{
var tmpList = bpModel.ItemsOfIndex;
if (null != tmpList)
{
var enumerator = tmpList.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
T retItem = enumerator.Current.Value as T;
if (null != retItem)
{
baseList.Add(retItem);
}
}
}
finally
{
enumerator.Dispose();
}
}
}
return baseList;
}
/// <summary>
/// 根据UID获取物品的cfgID
/// </summary>
/// <param name="type">容器类型</param>
/// <param name="Uid">物品的UID</param>
/// <returns></returns>
public int GetItemCfgIdWithUID(ContainerType type, ulong Uid)
{
int cfgId = 0;
ItemContianerModel bpModel = GetBackpackModelByType(type);
if (null != bpModel)
{
ItemBase item = GetItemByUID<ItemBase>(type, Uid);
if (null != item)
{
cfgId = item.CfgID;
}
}
return cfgId;
}
//根据UID以及容器类型 获取物品信息
public T GetItemByUID<T>(ContainerType type, ulong uid) where T : ItemBase
{
T retItem = null;
ItemContianerModel bpModel = GetBackpackModelByType(type);
if (null != bpModel)
{
retItem = bpModel.GetItemByUID<T>(uid);
}
return retItem;
}
public ItemBase GetItemByUIDFormBag(ulong uid)
{
ItemBase retItem = null;
ItemContianerModel bpModel = GetBackpackModelByType(ContainerType.ITEM_LOCATION_BAG);
if (null != bpModel)
{
retItem = bpModel.GetItemByUID<ItemBase>(uid);
}
return retItem;
}
public ItemBase GetItemByUIDFormImmortalBag(ulong uid)
{
ItemBase retItem = null;
ItemContianerModel bpModel = GetBackpackModelByType(ContainerType.ITEM_LOCATION_IMMORTAL);
if (null != bpModel)
{
retItem = bpModel.GetItemByUID<ItemBase>(uid);
}
return retItem;
}
//根据物品所在位置以及容器类型,获取物品信息
public T GetItemByIndex<T>(ContainerType type, int index) where T : ItemBase
{
T retItem = null;
ItemContianerModel bpModel = GetBackpackModelByType(type);
if (null != bpModel)
{
retItem = bpModel.GetItemByIndex<T>(index);
}
return retItem;
}
public List<ItemBase> GetItemListByCfgidNOGC<T>(ContainerType type, int cfgid) where T : ItemBase
{
_cacheList.Clear();
ItemContianerModel bpModel = GetBackpackModelByType(type);
if (null != bpModel)
{
var eumerater = bpModel.ItemsOfUID.GetEnumerator();
try
{
while (eumerater.MoveNext())
{
var item = eumerater.Current.Value as T;
if (null != item && item.CfgID == cfgid)
{
_cacheList.Add(item);
}
}
}
finally
{
eumerater.Dispose();
}
}
return _cacheList;
}
public List<ItemBase> GetItemListByCfgidNOGC(ContainerType type, int cfgid)
{
_cacheList.Clear();
ItemContianerModel bpModel = GetBackpackModelByType(type);
if (null != bpModel)
{
var eumerater = bpModel.ItemsOfUID.GetEnumerator();
try
{
while (eumerater.MoveNext())
{
var item = eumerater.Current.Value;
if (null != item && item.CfgID == cfgid)
{
_cacheList.Add(item);
}
}
}
finally
{
eumerater.Dispose();
}
}
return _cacheList;
}
//此方法和上面的方法一样但是lua不支持泛型这个重载方法用于给lua调用
public List<ItemBase> GetItemListByCfgid(ContainerType type, int cfgid)
{
List<ItemBase> baseList = new List<ItemBase>();
ItemContianerModel bpModel = GetBackpackModelByType(type);
if (null != bpModel)
{
var tmpList = bpModel.ItemsOfIndex;
if (null != tmpList)
{
var enumerator = tmpList.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
ItemBase retItem = enumerator.Current.Value as ItemBase;
if (null != retItem && retItem.CfgID == cfgid)
{
baseList.Add(retItem);
}
}
}
finally
{
enumerator.Dispose();
}
}
}
return baseList;
}
/// <summary>
/// 获取可合成道具列表
/// </summary>
/// <returns></returns>
public List<ItemBase> GetCanSynthItemList()
{
List<ItemBase> baseList = new List<ItemBase>();
ItemContianerModel bpModel = GetBackpackModelByType(ContainerType.ITEM_LOCATION_BAG);
if (null != bpModel)
{
var tmpList = bpModel.ItemsOfIndex;
if (null != tmpList)
{
var enumerator = tmpList.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
var retItem = enumerator.Current.Value;
if (retItem.Type == ItemType.Equip)
continue;
var modelItem = retItem as ItemModel;
if (null != modelItem && modelItem.ItemInfo != null && !string.IsNullOrEmpty(modelItem.ItemInfo.HechenTarget))
{
baseList.Add(modelItem);
}
}
}
finally
{
enumerator.Dispose();
}
}
}
return baseList;
}
/// <summary>
/// 获取可合成碎片列表
/// </summary>
/// <returns></returns>
public List<ItemModel> GetCanSynthPieceList()
{
List<ItemModel> baseList = new List<ItemModel>();
ItemContianerModel bpModel = GetBackpackModelByType(ContainerType.ITEM_LOCATION_BAG);
if (null != bpModel)
{
var tmpList = bpModel.ItemsOfIndex;
if (null != tmpList)
{
var enumerator = tmpList.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
var retItem = enumerator.Current.Value as ItemModel;
if (retItem == null)
continue;
if (retItem.Type == ItemType.Equip)
continue;
if (null != retItem && retItem.ItemInfo != null && !string.IsNullOrEmpty(retItem.ItemInfo.HechenTarget)
&& retItem.Type == ItemType.SpecialPingZiItem)
{
baseList.Add(retItem);
}
}
}
finally
{
enumerator.Dispose();
}
}
}
return baseList;
}
//根据礼物、材料物品ID列表获取背包中所有的物品列表
public List<ItemModel> GetItemListByCfgidList(List<int> list)
{
if (list == null)
return null;
List<ItemModel> baseList = new List<ItemModel>();
ItemContianerModel bpModel = GetBackpackModelByType(ContainerType.ITEM_LOCATION_BAG);
if (null != bpModel)
{
var tmpList = bpModel.ItemsOfIndex;
if (null != tmpList)
{
var enumerator = tmpList.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
var retItem = enumerator.Current.Value as ItemModel;
if (retItem == null)
continue;
if (retItem.Type == ItemType.Equip)
continue;
if (null != retItem && retItem.ItemInfo != null && list.Contains(retItem.CfgID))
{
baseList.Add(retItem);
}
}
}
finally
{
enumerator.Dispose();
}
}
}
return baseList;
}
//根据cfgid获取某个道具的数量
//默认为背包
public long GetItemCountFromCfgId(int cfgId)
{
long ret = 0;
var _contType = ContainerType.ITEM_LOCATION_BAG;
var itemType = ItemBase.GetItemTypeByModelID(cfgId);
if (itemType == ItemType.ImmortalEquip)
{
_contType = ContainerType.ITEM_LOCATION_IMMORTAL;
}
ItemContianerModel bpModel = GetBackpackModelByType(_contType);
if (null != bpModel)
{
ret = bpModel.GetCountByCfgId(cfgId);
}
if (ret == 0)
{
ret = GetEconomyWithType(cfgId);
}
return ret;
}
//删除道具
public void DeleteItemFromContainer(ContainerType type, ulong uid)
{
ItemContianerModel bpModel = GetBackpackModelByType(type);
if (null != bpModel)
{
ItemBase item = bpModel.GetItemByUID<ItemBase>(uid);
bpModel.DeleteItem(uid);
//删除一个物品成功后需要关闭tips
GameCenter.LuaSystem.Adaptor.CloseItemTips();
UpdateContianerItems(type, item);
GameCenter.PushFixEvent(LogicEventDefine.EID_EVENT_BACKFORM_ITEM_UNSELCT);
}
}
//批量删除道具
private IEnumerator DeleteItemListFromContainer(ContainerType type, List<ulong> uidList)
{
yield return null;
ItemContianerModel bpModel = GetBackpackModelByType(type);
if (null != bpModel && uidList != null)
{
for(int i = 0; i < uidList.Count; i++)
{
ItemBase item = bpModel.GetItemByUID<ItemBase>(uidList[i]);
bpModel.DeleteItem(uidList[i]);
//删除一个物品成功后需要关闭tips
GameCenter.LuaSystem.Adaptor.CloseItemTips();
UpdateContianerItems(type, item);
//GameCenter.PushFixEvent(LogicEventDefine.EID_EVENT_BACKFORM_ITEM_UNSELCT);
//GameCenter.PushFixEvent(LogicEventDefine.EVENT_ITEM_CHANGE_UPDATE, item.CfgID);
}
}
GameCenter.PushFixEvent(LogicEventDefine.EID_EVENT_ITEM_DELETELIST_UPDATE, uidList);
}
/// <summary>
/// 修改货币值
/// </summary>
/// <param name="type"></param>
/// <param name="value"></param>
private void ChangeEconomy(bool isNew, int type, long value, long changeValue = 0, int reson = 0)
{
long aValue = 0;
if (_enconomy.TryGetValue((int)type, out aValue))
{
_enconomy[(int)type] = value;
var addValue = value - aValue;
if(!isNew)
{
if (type == ItemTypeCode.Exp)
{
if(changeValue >= 100)
{
//100一下经验不展示
GameCenter.LuaSystem.Adaptor.AddShowNewItem(reson, (int)type, changeValue);
}
if(changeValue > 0)
GameCenter.PushFixEvent(LogicEventDefine.EVENT_COIN_ADD_UPDATE, new object[] { (int)type, changeValue });
}
else
{
GameCenter.LuaSystem.Adaptor.AddShowNewItem(reson, (int)type, addValue);
if(addValue > 0)
GameCenter.PushFixEvent(LogicEventDefine.EVENT_COIN_ADD_UPDATE, new object[] { (int)type, addValue });
}
}
}
else
{
_enconomy.Add((int)type, value);
}
}
/// <summary>
/// 根据货币类型获取货币值
/// </summary>
/// <param name="type">此处为long型主要是为了以后扩展</param>
/// <returns></returns>
public long GetEconomyWithType(int type)
{
long ret = 0;
if (null != _enconomy)
{
_enconomy.TryGetValue((int)type, out ret);
}
return ret;
}
/// <summary>
/// 整理背包,客户端自行整理
/// </summary>
/// <param name="type"></param>
public void SortBag(ContainerType type)
{
ItemContianerModel bpModel = GetBackpackModelByType(type);
if (bpModel != null)
bpModel.SortBag();
}
#endregion
#region //背包网络消息
//玩家背包物品信息,上线和背包变化时返回给玩家
public void GS2U_ResItemInfos(ResItemInfos result)
{
ItemContianerModel bpModel = GetBackpackModelByType(ContainerType.ITEM_LOCATION_BAG);
ResItemInfos infos = result as ResItemInfos;
if (null == bpModel)
{
bpModel = new ItemContianerModel();
bpModel.ContainerType = ContainerType.ITEM_LOCATION_BAG;
_itemContianerDic.Add((int)ContainerType.ITEM_LOCATION_BAG, bpModel);
}
else
{
if (GetBagSortTime(ContainerType.ITEM_LOCATION_BAG) == 0)
{
SetBagSortTime(ContainerType.ITEM_LOCATION_BAG, 10);
}
}
bpModel.Clear();
bpModel.OpenedCount = infos.cellnum;
bpModel.NowOpenIndex = infos.cellnum + 5;
bpModel.UseTime = infos.cellTime;
bpModel.IsInitializing = true;
for (int i = 0; i < infos.itemInfoList.Count; i++)
{
UpdateItemFromContainer(ContainerType.ITEM_LOCATION_BAG, infos.itemInfoList[i], false, 0, false);
}
UpdateContainerForm(ContainerType.ITEM_LOCATION_BAG);
bpModel.IsInitializing = false;
//for (int i = 0; i < infos.itemInfoList.Count; ++i)
//{
// GameCenter.PushFixEvent(LogicEventDefine.EVENT_ITEM_CHANGE_UPDATE, infos.itemInfoList[i].itemModelId);
//}
GameCenter.PushFixEvent(LogicEventDefine.EID_EVENT_ONLINE_ITEMINFO);
}
//物品新增
public void GS2U_ResItemAdd(ResItemAdd result)
{
UpdateItemFromContainer(ContainerType.ITEM_LOCATION_BAG, result.itemInfo, true, result.reason);
//发送新物品消息
ItemBase itemBase = GetItemByUID<ItemBase>(ContainerType.ITEM_LOCATION_BAG, result.itemInfo.itemId);
if (itemBase == null)
{
return;
}
GameCenter.PushFixEvent(LogicEventDefine.EVENT_BACKFORM_NEW_ITEM, itemBase);
GameCenter.PushFixEvent(LogicEventDefine.EVENT_ITEM_CHANGE_UPDATE, result.itemInfo.itemModelId);
if (itemBase.Type == ItemType.Equip)
GameCenter.PushFixEvent(LogicEventDefine.EVENT_EQUIP_ADD, result.itemInfo.itemModelId);
//展示物品获取效果
GameCenter.LuaSystem.Adaptor.AddShowNewItem(result.reason, itemBase, itemBase.Count);
CheckItemChangeMsg(result.itemInfo.itemModelId);
}
//物品信息改变
public void GS2U_ResItemChange(ResItemChange result)
{
long oldCount = 0;
ItemBase oldItem = GetItemByIndex<ItemBase>(ContainerType.ITEM_LOCATION_BAG, result.itemInfo.gridId);
if (oldItem != null)
{
oldCount = oldItem.Count;
}
UpdateItemFromContainer(ContainerType.ITEM_LOCATION_BAG, result.itemInfo, false, result.reason);
//if (result.itemInfo.cdTime > 0)
//{
// var item = DeclareItem.Get(result.itemInfo.itemModelId);
// if (item == null)
// {
// return;
// }
// List<ItemBase> list = GetItemListByCDID<ItemBase>(item.CoolingTimeId, ContainerType.ITEM_LOCATION_BAG);
// for (int i = 0; i < list.Count; i++)
// {
// list[i].CDTime = result.itemInfo.cdTime;
// UpdateItemFromContainer(ContainerType.ITEM_LOCATION_BAG, list[i]);
// }
//}
GameCenter.PushFixEvent(LogicEventDefine.EVENT_ITEM_CHANGE_UPDATE, result.itemInfo.itemModelId);
if (result.reason == 246)
{
GameCenter.PushFixEvent(LogicEventDefine.EID_EVENT_UI_EQUIPSKILLCOM_SUC, true);
}
ItemBase newItem = GetItemByIndex<ItemBase>(ContainerType.ITEM_LOCATION_BAG, result.itemInfo.gridId);
if (newItem == null)
return;
long addCount = newItem.Count - oldCount;
//展示物品获取效果
GameCenter.LuaSystem.Adaptor.AddShowNewItem(result.reason, newItem, addCount);
CheckItemChangeMsg(result.itemInfo.itemModelId);
}
//物品删除
public void GS2U_ResItemDelete(ResItemDelete result)
{
int itemModelId = 0;
int itemType = ItemType.UnDefine;
ItemContianerModel bpModel = GetBackpackModelByType(ContainerType.ITEM_LOCATION_BAG);
if (null != bpModel)
{
ItemBase item = GetItemByUID<ItemBase>(ContainerType.ITEM_LOCATION_BAG, result.itemId);
if (null != item)
{
itemModelId = item.CfgID;
itemType = item.Type;
}
}
DeleteItemFromContainer(ContainerType.ITEM_LOCATION_BAG, result.itemId);
GameCenter.PushFixEvent(LogicEventDefine.EVENT_ITEM_CHANGE_UPDATE, itemModelId);
if (itemType == ItemType.Equip)
GameCenter.PushFixEvent(LogicEventDefine.EVENT_EQUIP_DEL, itemModelId);
CheckItemChangeMsg(itemModelId);
}
//物品删除 批量批除 在遇到需要大批量删除物品时,建议使用这条消息
public void ResItemListDelete(ResItemListDelete result)
{
if(result.itemIds != null)
{
CoroutinePool.AddTask(DeleteItemListFromContainer(ContainerType.ITEM_LOCATION_BAG, result.itemIds));
}
}
/// <summary>
/// 货币信息
/// </summary>
/// <param name="result"></param>
public void GS2U_ResCoinInfos(ResCoinInfos result)
{
ResCoinInfos coins = result as ResCoinInfos;
for (int idx = 0; idx < coins.coinList.Count; ++idx)
{
ItemCoin coin = coins.coinList[idx];
ChangeEconomy(true, coin.type, coin.value);
GameCenter.PushFixEvent(LogicEventDefine.EVENT_COIN_CHANGE_UPDATE, coin.type);
}
//货币改变消息
for (int idx = 0; idx < coins.coinList.Count; ++idx)
{
GameCenter.PushFixEvent(LogicEventDefine.EVENT_COIN_CHANGE_UPDATE, coins.coinList[idx].type);
}
}
/// <summary>
/// 货币改变
/// </summary>
/// <param name="result"></param>
public void GS2U_ResCoinChange(ResCoinChange result)
{
ResCoinChange coinChange = result as ResCoinChange;
if (coinChange.changeCoin.type == ItemTypeCode.Exp)
{
ChangeEconomy(false, coinChange.changeCoin.type, coinChange.changeCoin.value, 0, result.reason);
var lp = GameCenter.GameSceneSystem.GetLocalPlayer();
if (lp != null)
{
lp.PropMoudle.Exp = (ulong)coinChange.changeCoin.value;
}
}
else
{
//货币变化统计
GameCenter.SDKSystem.ActionCoinChange(coinChange);
ChangeEconomy(false, coinChange.changeCoin.type, coinChange.changeCoin.value, 0, result.reason);
}
GameCenter.PushFixEvent(LogicEventDefine.EVENT_COIN_CHANGE_UPDATE, coinChange.changeCoin.type);
}
/// <summary>
/// 经验值的变化
/// </summary>
public void GS2U_ResExpChange(ResExpChange result)
{
ChangeEconomy(false, result.changeCoin.type, result.changeCoin.value, result.changeNum, result.reason);
GameCenter.PushFixEvent(LogicEventDefine.EVENT_COIN_EXP_CHANGE_UPDATE, result.changeNum);
var lp = GameCenter.GameSceneSystem.GetLocalPlayer();
if (lp != null)
{
lp.PropMoudle.Exp = (ulong)result.changeCoin.value;
}
}
/// <summary>
/// 背包打开结果
/// </summary>
/// <param name="result"></param>
public void GS2U_ResOpenBagCellSuccess(ResOpenBagCellSuccess result)
{
ItemContianerModel bpModel = GetBackpackModelByType(ContainerType.ITEM_LOCATION_BAG);
if (null == bpModel)
{
bpModel = new ItemContianerModel();
bpModel.ContainerType = ContainerType.ITEM_LOCATION_BAG;
_itemContianerDic.Add((int)ContainerType.ITEM_LOCATION_BAG, bpModel);
}
bpModel.OpenedCount = result.nowCellId;
bpModel.NowOpenIndex = bpModel.OpenedCount + 5;
bpModel.UseTime = 0;
GameCenter.PushFixEvent(LogicEventDefine.EID_EVENT_BAG_OPENCELL_UPDATE);
}
/// <summary>
/// 背包打开失败
/// </summary>
/// <param name="result"></param>
public void GS2U_ResOpenBagCellFailed(ResOpenBagCellFailed result)
{
GameCenter.MsgPromptSystem.ShowPrompt(DeclareMessageString.Get(DeclareMessageString.C_ITEM_OPENCELL_FIALD));
}
public void ResUseItemMakeBuff(ResUseItemMakeBuff result)
{
if(result.state == 0 || result.state == 1)
{
var list = GameCenter.ItemContianerSystem.GetItemListByCfgidNOGC<ItemBase>(ContainerType.ITEM_LOCATION_BAG, result.itemModelId);
if(list.Count > 0)
{
RequestUseItem(list[0].DBID);
}
}
else if(result.state == 2)
{
GameCenter.MsgPromptSystem.ShowPrompt(Thousandto.Cfg.Data.DeclareMessageString.Get(Thousandto.Cfg.Data.DeclareMessageString.C_ITEM_EXPITEMISFOOD));
}
else
{
GameCenter.MsgPromptSystem.ShowMsgBox(Thousandto.Cfg.Data.DeclareMessageString.Get(Thousandto.Cfg.Data.DeclareMessageString.C_ITEM_EXPITEMFAILED), x =>
{
if (x == MsgBoxResultCode.Button2)
{
var list = GameCenter.ItemContianerSystem.GetItemListByCfgidNOGC<ItemBase>(ContainerType.ITEM_LOCATION_BAG, result.itemModelId);
if (list.Count > 0)
{
RequestUseItem(list[0].DBID);
}
}
});
}
}
//网络请求
public static void RequestUseItem(ulong uid, int num = 1)
{
ReqUseItem useItem = new ReqUseItem();
useItem.itemId = uid;
useItem.num = num;
useItem.Send();
}
/// <summary>
/// 删除物品
/// </summary>
/// <param name="uid"></param>
public static void RequestDelItem(ulong uid)
{
MSG_backpack.ReqDelItem itemDelete = new MSG_backpack.ReqDelItem();
itemDelete.itemId = uid;
itemDelete.Send();
}
/// <summary>
/// 背包清理
/// </summary>
public static void RequestClearUp()
{
ReqBagClearUp clearUP = new ReqBagClearUp();
clearUP.Send();
}
/// <summary>
/// 开启背包格子
/// </summary>
/// <param name="type"></param>
/// <param name="targetIdx"></param>
public static void RequestOpenCell(ContainerType type, int targetIdx)
{
switch (type)
{
case ContainerType.ITEM_LOCATION_BAG:
{
MSG_backpack.ReqOpenBagCell openCell = new MSG_backpack.ReqOpenBagCell();
openCell.cellId = targetIdx;
openCell.Send();
}
break;
}
}
/// <summary>
/// 请求分割物品
/// </summary>
/// <param name="uid"></param>
/// <param name="num"></param>
public static void RequestSqlitItem(ulong uid, int num)
{
ReqMoveItem sqlitItem = new ReqMoveItem();
sqlitItem.itemId = uid;
sqlitItem.num = num;
sqlitItem.Send();
}
public static void RequestSellItem(ulong dbId, long num = 1)
{
if (dbId != 0)
{
ReqSellItems sellItems = new ReqSellItems();
sellItems.itemId = dbId;
sellItems.num = (int)num;
sellItems.Send();
}
}
/// <summary>
/// 请求合成
/// </summary>
public static void RequestSynthItem(List<ulong> bindIdList, List<ulong> nonBindIDList, int type)
{
ReqCompound msg = new ReqCompound();
if(bindIdList != null)
{
for (int i = 0; i < bindIdList.Count; i++)
{
msg.bindId.Add(bindIdList[i]);
}
}
if (nonBindIDList != null)
{
for (int i = 0; i < nonBindIDList.Count; i++)
{
msg.nonBindId.Add(nonBindIDList[i]);
}
}
msg.type = type;
msg.Send();
}
#endregion
#region //仓库网络消息
public void GS2U_ResStoreItemInfos(MSG_store.ResStoreItemInfos result)
{
ItemContianerModel storeModel = GetBackpackModelByType(ContainerType.ITEM_LOCATION_STORAGE);
if (null == storeModel)
{
storeModel = new ItemContianerModel();
storeModel.ContainerType = ContainerType.ITEM_LOCATION_STORAGE;
_itemContianerDic.Add((int)ContainerType.ITEM_LOCATION_STORAGE, storeModel);
}
else
{
if (GetBagSortTime(ContainerType.ITEM_LOCATION_STORAGE) == 0)
{
SetBagSortTime(ContainerType.ITEM_LOCATION_STORAGE, 10);
}
}
storeModel.Clear();
storeModel.OpenedCount = result.cellnum;
storeModel.NowOpenIndex = result.cellnum + 5;
storeModel.UseTime = result.cellTime;
for (int i = 0; i < result.itemInfoList.Count; i++)
{
UpdateItemFromContainer(ContainerType.ITEM_LOCATION_STORAGE, result.itemInfoList[i]);
}
UpdateContainerForm(ContainerType.ITEM_LOCATION_STORAGE);
}
public void GS2U_ResStoreItemAdd(MSG_store.ResStoreItemAdd result)
{
UpdateItemFromContainer(ContainerType.ITEM_LOCATION_STORAGE, result.itemInfo, true);
}
public void GS2U_ResStoreItemChange(MSG_store.ResStoreItemChange result)
{
UpdateItemFromContainer(ContainerType.ITEM_LOCATION_STORAGE, result.itemInfo);
}
public void GS2U_ResStoreItemDelete(MSG_store.ResStoreItemDelete result)
{
DeleteItemFromContainer(ContainerType.ITEM_LOCATION_STORAGE, result.itemId);
}
public void GS2U_ResOpenStoreCellSuccess(MSG_store.ResOpenStoreCellSuccess result)
{
ItemContianerModel bpModel = GetBackpackModelByType(ContainerType.ITEM_LOCATION_STORAGE);
if (null == bpModel)
{
bpModel = new ItemContianerModel();
bpModel.ContainerType = ContainerType.ITEM_LOCATION_STORAGE;
_itemContianerDic.Add((int)ContainerType.ITEM_LOCATION_STORAGE, bpModel);
}
bpModel.OpenedCount = result.nowCellId;
bpModel.NowOpenIndex = bpModel.OpenedCount + 5;
bpModel.UseTime = 0;
UpdateContainerForm(ContainerType.ITEM_LOCATION_STORAGE);
}
public void GS2U_ResOpenStoreCellFailed(MSG_store.ResOpenStoreCellFailed result)
{
GameCenter.MsgPromptSystem.ShowPrompt(DeclareMessageString.Get(DeclareMessageString.C_STOREGE_OPENCELL_FAILE));
}
public static void RequestToBag(int cellIdx)
{
MSG_store.ReqStoreToBag toBag = new MSG_store.ReqStoreToBag();
toBag.cellId = cellIdx;
toBag.Send();
}
public static void RequestToStore(int cellIdx)
{
MSG_store.ReqBagToStore toStore = new MSG_store.ReqBagToStore();
toStore.cellId = cellIdx;
toStore.Send();
}
#endregion
#region //静态方法
/// 根据物品id获取物品配置表中的信息
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="cfgid"></param>
/// <returns></returns>
public static T GetItemCfgWithID<T>(int cfgid) where T : ItemBase
{
ItemBase retItem = null;
if (cfgid > 0)
{
retItem = ItemBase.CreateItemBase(cfgid);
}
return retItem as T;
}
/// <summary>
/// 根据配置表获取背包或仓库最大格子数
/// </summary>
/// <param name="aType"></param>
/// <returns></returns>
public static int GetBagMaxCount(ContainerType aType)
{
int result = 0;
int type = 1;
if (aType == ContainerType.ITEM_LOCATION_BAG)
type = 1;
else
{
result = int.Parse(DeclareGlobal.Get((int)GlobalName.StoreCreateNum).Params);
type = 2;
}
var e = DeclareBagGrid.CacheData.GetEnumerator();
while(e.MoveNext())
{
if (e.Current.Value.Grid > result && e.Current.Value.Bag == type)
result = e.Current.Value.Grid;
}
return result;
}
#endregion
}
//物品改变定制消息
public class ItemMsgCondition
{
private List<int> items;
public List<int> Items
{
get
{
if (items == null)
{
items = new List<int>();
}
return items;
}
}
public int MsgID { get; private set; }
public ItemMsgCondition(int msgID, int[] itemss)
{
MsgID = msgID;
if (itemss == null || itemss.Length <= 0)
{
return;
}
for (int i = 0; i < itemss.Length; ++i)
{
Items.Add(itemss[i]);
}
}
public void Check(int id)
{
if (Items.Contains(id))
GameCenter.PushFixEvent(MsgID);
}
}
}