void RPC_S2C_STO_Store(uLink.BitStream stream, uLink.NetworkMessageInfo info)
{
int index = stream.Read <int>();
int objId = stream.Read <int>();
bool suc = stream.Read <bool>();
ItemObject itemObj = ItemMgr.Instance.Get(objId);
if (itemObj == null)
{
return;
}
int tabIndex = itemObj.protoData.tabIndex;
int key = IndexToKey(index, tabIndex);
if (suc)
{
//1.data
CSStorageData recordData = (CSStorageData)_ColonyObj._RecordData;
recordData.m_Items[key] = objId;
ItemPackage m_Package = ((CSStorage)m_Entity).m_Package;
int listCnt = m_Package.GetSlotList().Length;
int key2 = key % listCnt;
m_Package.GetSlotList(itemObj.protoId)[key2] = itemObj;
}
if (CSUI_MainWndCtrl.Instance.StorageUI != null && CSUI_MainWndCtrl.Instance.StorageUI.StorageMainUI != null)
{
CSUI_MainWndCtrl.Instance.StorageUI.StorageMainUI.CSStoreResultStore(suc, index, objId, (CSStorage)m_Entity);
}
}
public ItemObject FindSpecifiedItem()
{
List <ItemObject> items = new List <ItemObject>(m_Package.GetSlotList(ItemPackage.ESlotType.Item));
return(items.Find((item0) =>
{
if (item0 == null)
{
return false;
}
ItemAsset.Consume consume = item0.GetCmpt <ItemAsset.Consume>();
return null != consume;
}));
}
void RPC_S2C_STO_SyncItemList(uLink.BitStream stream, uLink.NetworkMessageInfo info)
{
int[] indexList = stream.Read <int[]>();
int[] ids = stream.Read <int[]>();
CSStorageData recordData = (CSStorageData)_ColonyObj._RecordData;
ItemPackage m_Package = ((CSStorage)m_Entity).m_Package;
for (int i = 0; i < indexList.Length; i++)
{
int key = indexList[i];
int type;
int index = KeyToIndex(key, out type);
SlotList slotList = m_Package.GetSlotList((ItemAsset.ItemPackage.ESlotType)type);
if (ids[i] == -1)
{
recordData.m_Items.Remove(key);
slotList[index] = null;
}
else
{
ItemObject ioject = ItemMgr.Instance.Get(ids[i]);
if (ioject != null)
{
recordData.m_Items[key] = ids[i];
slotList[index] = ioject;
}
}
}
//2.ui
if (CSUI_MainWndCtrl.Instance.StorageUI != null && CSUI_MainWndCtrl.Instance.StorageUI.StorageMainUI != null)
{
CSUI_MainWndCtrl.Instance.StorageUI.StorageMainUI.CSStorageResultSyncItemList((CSStorage)m_Entity);
}
}
void RPC_S2C_STO_Split(uLink.BitStream stream, uLink.NetworkMessageInfo info)
{
int objId = stream.Read <int>();
int destIndex = stream.Read <int> ();
bool suc = stream.Read <bool>();
ItemObject itemObj = ItemMgr.Instance.Get(objId);
if (itemObj == null)
{
return;
}
if (suc)
{
//1.data
CSStorageData recordData = (CSStorageData)_ColonyObj._RecordData;
int key = IndexToKey(destIndex, itemObj.protoData.tabIndex);
recordData.m_Items[key] = objId;
ItemPackage m_Package = ((CSStorage)m_Entity).m_Package;
SlotList slotList = m_Package.GetSlotList(itemObj.protoId);
slotList[destIndex] = itemObj;
}
//2.ui
if (CSUI_MainWndCtrl.Instance.StorageUI != null && CSUI_MainWndCtrl.Instance.StorageUI.StorageMainUI != null)
{
CSUI_MainWndCtrl.Instance.StorageUI.StorageMainUI.CSStoreResultSplit(suc, objId, destIndex, (CSStorage)m_Entity);
}
}
public static bool Add(this ItemPackage package, int prototypeId, int count, bool newFlag = false)
{
if (count <= 0)
{
return(false);
}
SlotList accessor = package.GetSlotList(ItemPackage.GetSlotType(prototypeId));
if (null == accessor)
{
return(false);
}
if (ItemProto.Mgr.Instance.Get(prototypeId).maxStackNum > 1)
{
return(accessor.Add(prototypeId, count, newFlag));
}
else
{
bool result = true;
for (int i = 0; i < count; i++)
{
if (result)
{
result = accessor.Add(ItemMgr.Instance.CreateItem(prototypeId), newFlag);
}
else
{
accessor.Add(ItemMgr.Instance.CreateItem(prototypeId), newFlag);
}
}
return(result);
}
}
public static bool CanAdd(this ItemPackage package, IEnumerable <ItemAsset.MaterialItem> list)
{
int[] sum = new int[(int)ItemPackage.ESlotType.Max];
foreach (ItemAsset.MaterialItem mi in list)
{
int type = (int)ItemPackage.GetSlotType(mi.protoId);
if (type < sum.Length)
{
sum[type] += SlotListHelper.SlotListAccessor.GetNeedSlotCount(mi.protoId, mi.count);
}
}
for (int i = 0; i < sum.Length; i++)
{
SlotList slotList = package.GetSlotList((ItemPackage.ESlotType)i);
if (slotList.GetVacancyCount() < sum[i])
{
return(false);
}
}
return(true);
}
void RPC_S2C_STO_Delete(uLink.BitStream stream, uLink.NetworkMessageInfo info)
{
int objId = stream.Read <int>();
bool suc = stream.Read <bool>();
ItemObject itemObj = ItemMgr.Instance.Get(objId);
if (itemObj == null)
{
return;
}
int index = -1;
if (suc)
{
//1.data
CSStorageData recordData = (CSStorageData)_ColonyObj._RecordData;
foreach (KeyValuePair <int, int> kvp in recordData.m_Items)
{
if (kvp.Value == objId)
{
recordData.m_Items.Remove(kvp.Key);
ItemPackage m_Package = ((CSStorage)m_Entity).m_Package;
int listCnt = m_Package.GetSlotList().Length;
index = kvp.Key % listCnt;
m_Package.GetSlotList(itemObj.protoId)[index] = null;
break;
}
}
}
if (m_Entity == null)
{
Debug.LogError("entity not ready");
return;
}
//2.ui
if (CSUI_MainWndCtrl.Instance.StorageUI != null && CSUI_MainWndCtrl.Instance.StorageUI.StorageMainUI != null)
{
CSUI_MainWndCtrl.Instance.StorageUI.StorageMainUI.CSStoreResultDelete(suc, index, objId, (CSStorage)m_Entity);
}
if (suc)
{
ItemMgr.Instance.DestroyItem(itemObj.instanceId);
}
}
public ItemObject GetItemObj(int index)
{
ShortCutItem shortCutItem = GetItem(index);
if (null == shortCutItem)
{
return(null);
}
ItemObject itemObj = ItemMgr.Instance.Get(shortCutItem.itemInstanceId);
if (null == itemObj)
{
if (shortCutItem.UseProtoID)
{
if (null != mPkg)
{
return(mPkg.GetItemByProtoID(shortCutItem.protoId));
}
}
return(null);
}
if (null != mPkg)
{
SlotList slotList = mPkg.GetSlotList(shortCutItem.protoId);
if (null != slotList && slotList.HasItem(shortCutItem.itemInstanceId))
{
return(itemObj);
}
}
if (null != mEquip)
{
for (int i = 0; i < mEquip._ItemList.Count; i++)
{
if (mEquip._ItemList[i].instanceId == shortCutItem.itemInstanceId)
{
return(mEquip._ItemList[i]);
}
}
}
return(null);
}
void RPC_S2C_STO_Exchange(uLink.BitStream stream, uLink.NetworkMessageInfo info)
{
int objId = stream.Read <int>();
int destIndex = stream.Read <int> ();
int destId = stream.Read <int> ();
int originIndex = stream.Read <int> ();
bool suc = stream.Read <bool> ();
ItemObject originObj = ItemMgr.Instance.Get(objId);
if (originObj == null)
{
return;
}
ItemObject destObj;
if (destId == -1)
{
destObj = null;
}
else
{
destObj = ItemMgr.Instance.Get(destId);
if (destObj == null)
{
return;
}
}
int type = originObj.protoData.tabIndex;
int destKey = IndexToKey(destIndex, type);
int originKey = IndexToKey(originIndex, type);
if (suc)
{
//1.data
CSStorageData recordData = (CSStorageData)_ColonyObj._RecordData;
recordData.m_Items[destKey] = objId;
ItemPackage m_Package = ((CSStorage)m_Entity).m_Package;
SlotList slotList = m_Package.GetSlotList((ItemAsset.ItemPackage.ESlotType)type);
slotList.Swap(originIndex, destIndex);
if (destObj != null)
{
recordData.m_Items[originKey] = destId;
}
else
{
recordData.m_Items.Remove(originKey);
}
}
//2.ui
if (CSUI_MainWndCtrl.Instance.StorageUI != null && CSUI_MainWndCtrl.Instance.StorageUI.StorageMainUI != null)
{
CSUI_MainWndCtrl.Instance.StorageUI.StorageMainUI.CSStoreResultExchange(suc, objId, destIndex, destId, originIndex, (CSStorage)m_Entity);
}
}
public static List <ItemObject> GetAllItemByProtoId(this ItemPackage package, int protoID)
{
List <ItemObject> allItems = new List <ItemObject> ();
for (int i = 0; i < (int)ItemAsset.ItemPackage.ESlotType.Max; i++)
{
SlotList accessor = package.GetSlotList((ItemAsset.ItemPackage.ESlotType)i);
allItems.AddRange(accessor.GetAllItemByProtoID(protoID));
}
return(allItems);
}
public static bool CanAdd(this ItemPackage package, int prototypeId, int count)
{
SlotList accessor = package.GetSlotList(ItemPackage.GetSlotType(prototypeId));
if (null == accessor)
{
return(false);
}
return(accessor.CanAdd(prototypeId, count));
}
public static int GetCreationCount(this ItemPackage package, ECreation type)
{
int count = 0;
for (int i = 0; i < (int)ItemAsset.ItemPackage.ESlotType.Max; i++)
{
SlotList accessor = package.GetSlotList((ItemAsset.ItemPackage.ESlotType)i);
count += accessor.GetCreationCount(type);
}
return(count);
}
public static int GetCountByEditorType(this ItemPackage package, int editorType)
{
int count = 0;
for (int i = 0; i < (int)ItemAsset.ItemPackage.ESlotType.Max; i++)
{
SlotList accessor = package.GetSlotList((ItemAsset.ItemPackage.ESlotType)i);
count += accessor.GetCountByEditorType(editorType);
}
return(count);
}
public static bool ContainsItem(this ItemPackage package, int prototypeId)
{
for (int i = 0; i < (int)ItemAsset.ItemPackage.ESlotType.Max; i++)
{
SlotList accessor = package.GetSlotList((ItemAsset.ItemPackage.ESlotType)i);
if (accessor.ConatinsItem(prototypeId))
{
return(true);
}
}
return(false);
}
public static int GetCount(this ItemPackage package, int prototypeId)
{
// Opt
ItemProto proto = ItemProto.Mgr.Instance.Get(prototypeId);
if (proto != null)
{
SlotList accessor = package.GetSlotList((ItemAsset.ItemPackage.ESlotType)proto.tabIndex);
return(accessor != null?accessor.GetCount(prototypeId) : 0);
}
return(0);
}
/// <summary>
/// Gets the first item by proto ID.
/// </summary>
/// <returns>The item by proto I.</returns>
public static ItemObject GetItemByProtoID(this ItemPackage package, int protoID)
{
for (int i = 0; i < (int)ItemAsset.ItemPackage.ESlotType.Max; i++)
{
SlotList accessor = package.GetSlotList((ItemAsset.ItemPackage.ESlotType)i);
ItemObject itemObj = accessor.GetItemByProtoID(protoID);
if (null != itemObj)
{
return(itemObj);
}
}
return(null);
}
public static List <int> GetCreationInstanceId(this ItemPackage package, ECreation type)
{
List <int> tmp = new List <int>();
for (int i = 0; i < (int)ItemAsset.ItemPackage.ESlotType.Max; i++)
{
SlotList accessor = package.GetSlotList((ItemAsset.ItemPackage.ESlotType)i);
foreach (var item in accessor.GetCreationInstanceId(type))
{
tmp.Add(item);
}
}
return(tmp);
}
public static void ResetPackageItems(this ItemPackage package, int tab, int index, int id)
{
SlotList slotList = package.GetSlotList((ItemPackage.ESlotType)tab);
if (-1 == id)
{
slotList[index] = null;
}
else
{
ItemObject item = ItemMgr.Instance.Get(id);
slotList[index] = item;
}
}
public void Clear(ItemPackage.ESlotType type = ItemPackage.ESlotType.Max, bool isMissionPkg = false)
{
if (type == ItemPackage.ESlotType.Max)
{
GetSlotList(ItemPackage.ESlotType.Item).Clear();
GetSlotList(ItemPackage.ESlotType.Equipment).Clear();
GetSlotList(ItemPackage.ESlotType.Resource).Clear();
GetSlotList(ItemPackage.ESlotType.Armor).Clear();
GetSlotList(ItemPackage.ESlotType.Item, true).Clear();
}
else
{
if (isMissionPkg)
{
_missionPak.GetSlotList(type).Clear();
}
else
{
_playerPak.GetSlotList(type).Clear();
}
}
if (isMissionPkg)
{
_missionPak.changeEventor.Dispatch(new ItemPackage.EventArg()
{
op = ItemPackage.EventArg.Op.Clear, itemObj = null
});
}
else
{
_playerPak.changeEventor.Dispatch(new ItemPackage.EventArg()
{
op = ItemPackage.EventArg.Op.Clear, itemObj = null
});
}
}
public static bool DestroyItem(this ItemPackage package, ItemObject item, int count)
{
if (count <= 0)
{
return(false);
}
if (item.GetCount() < count)
{
return(false);
}
SlotList accessor = package.GetSlotList(ItemPackage.GetSlotType(item.protoId));
return(accessor.DestroyItem(item.instanceId, count));
}
public static bool Set(this ItemPackage package, int prototypeId, int count)
{
if (count <= 0)
{
return(false);
}
SlotList accessor = package.GetSlotList(ItemPackage.GetSlotType(prototypeId));
if (null == accessor)
{
return(false);
}
return(accessor.Set(prototypeId, count));
}
public static bool AddAsOneItem(this ItemPackage package, int prototypeId, int count, bool newFlag = false)
{
if (count <= 0)
{
return(false);
}
SlotList accessor = package.GetSlotList(ItemPackage.GetSlotType(prototypeId));
if (null == accessor)
{
return(false);
}
return(accessor.AddAsNew(prototypeId, count, newFlag));
}
void RPC_S2C_STO_Sort(uLink.BitStream stream, uLink.NetworkMessageInfo info)
{
bool suc = stream.Read <bool>();
if (suc)
{
int tabIndex = stream.Read <int>();
int [] ids = stream.Read <int[]> ();
//1.data
CSStorageData recordData = (CSStorageData)_ColonyObj._RecordData;
int keyStart = IndexToKey(0, tabIndex);
ItemPackage m_Package = ((CSStorage)m_Entity).m_Package;
SlotList slotList = m_Package.GetSlotList((ItemAsset.ItemPackage.ESlotType)tabIndex);
int listCnt = slotList.Length;
for (int i = 0; i < ids.Length; i++)
{
int key = keyStart + i;
int index = key % listCnt;
if (ids[i] == -1)
{
recordData.m_Items.Remove(key);
slotList[index] = null;
}
else
{
recordData.m_Items[key] = ids[i];
ItemObject ioject = ItemMgr.Instance.Get(ids[i]);
if (ioject != null)
{
slotList[index] = ioject;
}
}
}
//2.ui
if (CSUI_MainWndCtrl.Instance.StorageUI != null && CSUI_MainWndCtrl.Instance.StorageUI.StorageMainUI != null)
{
CSUI_MainWndCtrl.Instance.StorageUI.StorageMainUI.CSStoreSortSuccess(tabIndex, ids, (CSStorage)m_Entity);
}
}
}
public static bool DestroyItem(this ItemPackage package, int instanceId, int count)
{
if (count <= 0)
{
return(false);
}
ItemObject item = ItemMgr.Instance.Get(instanceId);
if (item.stackCount < count)
{
return(false);
}
SlotList accessor = package.GetSlotList(ItemPackage.GetSlotType(item.protoId));
return(accessor.DestroyItem(instanceId, count));
}
public static void ResetPackageItems(this ItemPackage package, int tab, int[] ids)
{
SlotList slotList = package.GetSlotList((ItemPackage.ESlotType)tab);
int count = Mathf.Min(slotList.Count, ids.Length);
for (int i = 0; i < count; i++)
{
if (-1 == ids[i])
{
slotList[i] = null;
}
else
{
ItemObject item = ItemMgr.Instance.Get(ids[i]);
slotList[i] = item;
}
}
}
public static SlotList GetSlotList(ItemPackage.ESlotType type)
{
return(_itemPackage.GetSlotList(type));
}
public void RestItems()
{
if (m_Grids == null)
{
return;
}
if (m_Package == null)
{
Debug.LogWarning("It must need a package to Reset the items!");
return;
}
m_CurPack = m_Package.GetSlotList((ItemPackage.ESlotType)m_Type);
int pageCount = m_GridsRow * m_GridsCol;
if ((m_CurPack.Count - 1) / pageCount < m_PageIndex)
{
m_PageIndex = (m_CurPack.Count - 1) / pageCount;
}
int itemCount;
if ((m_CurPack.Count - 1) / pageCount == m_PageIndex)
{
itemCount = (m_CurPack.Count - m_PageIndex * pageCount);
}
else
{
itemCount = pageCount;
}
for (int index = 0; index < itemCount; index++)
{
m_Grids[index].SetItem(m_CurPack[index + m_PageIndex * pageCount]);
if (m_storage != null)
{
m_Grids[index].SetItemPlace(ItemPlaceType.IPT_CSStorage, index + m_PageIndex * pageCount);
}
else
{
m_Grids[index].SetItemPlace(ItemPlaceType.IPT_NPCStorage, index + m_PageIndex * pageCount);
}
switch (m_Type)
{
case (int)ItemPackage.ESlotType.Item:
m_Grids[index].SetGridMask(GridMask.GM_Item);
break;
case (int)ItemPackage.ESlotType.Equipment:
m_Grids[index].SetGridMask(GridMask.GM_Equipment);
break;
case (int)ItemPackage.ESlotType.Resource:
m_Grids[index].SetGridMask(GridMask.GM_Resource);
break;
case (int)ItemPackage.ESlotType.Armor:
m_Grids[index].SetGridMask(GridMask.GM_Armor);
break;
}
}
m_PageLb.text = (m_PageIndex + 1).ToString() + "/" + ((m_CurPack.Count - 1) / pageCount + 1);
}
public void ResetItem(int type, int pageIndex)
{
if (mItemPackage == null)
{
return;
}
mCurrentPickTab = type;
switch (type)
{
case 0:
mItemCheckbox.isChecked = true;
break;
case 1:
mEquipCheckbox.isChecked = true;
break;
case 2:
mResCheckbox.isChecked = true;
break;
case 3:
mArmorCheckbox.isChecked = true;
break;
}
m_CurrentPack = mItemPackage.GetSlotList((ItemPackage.ESlotType)type);
if ((m_CurrentPack.Count - 1) / mPageCount < pageIndex)
{
pageIndex = (m_CurrentPack.Count - 1) / mPageCount;
}
mPageIndex = pageIndex;
int itemCount;
if ((m_CurrentPack.Count - 1) / mPageCount == mPageIndex)
{
itemCount = (m_CurrentPack.Count - pageIndex * mPageCount);
}
else
{
itemCount = mPageCount;
}
for (int index = 0; index < itemCount; index++)
{
mItems[index].SetItem(m_CurrentPack[index + pageIndex * mPageCount]);
mItems[index].SetItemPlace(ItemPlaceType.IPT_Warehouse, index + pageIndex * mPageCount);
switch (mCurrentPickTab)
{
case 0:
mItems[index].SetGridMask(GridMask.GM_Item);
break;
case 1:
mItems[index].SetGridMask(GridMask.GM_Equipment);
break;
case 2:
mItems[index].SetGridMask(GridMask.GM_Resource);
break;
case 3:
mItems[index].SetGridMask(GridMask.GM_Armor);
break;
}
}
mPageCountText.text = (mPageIndex + 1).ToString() + "/" + ((m_CurrentPack.Count - 1) / mPageCount + 1);
}
