mirror of
https://github.com/tym1116/BH3.git
synced 2025-12-16 16:34:41 +01:00
447 lines
16 KiB
C#
447 lines
16 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using MoleMole.Config;
|
|
using proto;
|
|
|
|
namespace MoleMole
|
|
{
|
|
public class StorageModule : BaseModule
|
|
{
|
|
public enum StorageSortType
|
|
{
|
|
Rarity_DESC = 0,
|
|
Rarity_ASC = 1,
|
|
Level_DESC = 2,
|
|
Level_ASC = 3,
|
|
BaseType_DESC = 4,
|
|
BaseType_ASC = 5,
|
|
Cost_DESC = 6,
|
|
Cost_ASC = 7,
|
|
Suite_DESC = 8,
|
|
Suite_ASC = 9,
|
|
Time_DESC = 10,
|
|
Time_ASC = 11
|
|
}
|
|
|
|
private Dictionary<KeyValuePair<Type, int>, StorageDataItemBase> _userStorageDict;
|
|
|
|
private HashSet<int> _everOwnItemIDs;
|
|
|
|
public Dictionary<string, StorageSortType> sortTypeMap;
|
|
|
|
public Dictionary<StorageSortType, Comparison<StorageDataItemBase>> sortComparisionMap;
|
|
|
|
public List<StorageDataItemBase> UserStorageItemList { get; private set; }
|
|
|
|
public StorageModule()
|
|
{
|
|
Singleton<NotifyManager>.Instance.RegisterModule(this);
|
|
UserStorageItemList = new List<StorageDataItemBase>();
|
|
_userStorageDict = new Dictionary<KeyValuePair<Type, int>, StorageDataItemBase>();
|
|
_everOwnItemIDs = new HashSet<int>();
|
|
InitForSort();
|
|
}
|
|
|
|
private void InitForSort()
|
|
{
|
|
sortTypeMap = new Dictionary<string, StorageSortType>();
|
|
sortComparisionMap = new Dictionary<StorageSortType, Comparison<StorageDataItemBase>>();
|
|
string[] tAB_KEY = StorageShowPageContext.TAB_KEY;
|
|
foreach (string key in tAB_KEY)
|
|
{
|
|
sortTypeMap.Add(key, StorageSortType.Rarity_DESC);
|
|
}
|
|
sortComparisionMap.Add(StorageSortType.Rarity_DESC, StorageDataItemBase.CompareToRarityDesc);
|
|
sortComparisionMap.Add(StorageSortType.Rarity_ASC, StorageDataItemBase.CompareToRarityAsc);
|
|
sortComparisionMap.Add(StorageSortType.Level_DESC, StorageDataItemBase.CompareToLevelDesc);
|
|
sortComparisionMap.Add(StorageSortType.Level_ASC, StorageDataItemBase.CompareToLevelAsc);
|
|
sortComparisionMap.Add(StorageSortType.Cost_DESC, StorageDataItemBase.CompareToCostDesc);
|
|
sortComparisionMap.Add(StorageSortType.Cost_ASC, StorageDataItemBase.CompareToCostAsc);
|
|
sortComparisionMap.Add(StorageSortType.BaseType_DESC, StorageDataItemBase.CompareToBaseTypeDesc);
|
|
sortComparisionMap.Add(StorageSortType.BaseType_ASC, StorageDataItemBase.CompareToBaseTypeAsc);
|
|
sortComparisionMap.Add(StorageSortType.Time_DESC, StorageDataItemBase.CompareToUidDesc);
|
|
sortComparisionMap.Add(StorageSortType.Time_ASC, StorageDataItemBase.CompareToUidAsc);
|
|
}
|
|
|
|
public override bool OnPacket(NetPacketV1 pkt)
|
|
{
|
|
switch (pkt.getCmdId())
|
|
{
|
|
case 27:
|
|
return OnGetEquipmentDataRsp(pkt.getData<GetEquipmentDataRsp>());
|
|
case 28:
|
|
return OnDelEquipmentNotify(pkt.getData<DelEquipmentNotify>());
|
|
case 32:
|
|
return OnEquipmentPowerUpRsp(pkt.getData<EquipmentPowerUpRsp>());
|
|
case 34:
|
|
return OnEquipmentSellRsp(pkt.getData<EquipmentSellRsp>());
|
|
case 103:
|
|
return OnSellAvatarFragmentRsp(pkt.getData<SellAvatarFragmentRsp>());
|
|
case 38:
|
|
return OnEquipmentEvoRsp(pkt.getData<EquipmentEvoRsp>());
|
|
case 40:
|
|
return OnDressEquipmentRsp(pkt.getData<DressEquipmentRsp>());
|
|
case 105:
|
|
return OnGetHasGotItemIdListRsp(pkt.getData<GetHasGotItemIdListRsp>());
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private bool OnGetEquipmentDataRsp(GetEquipmentDataRsp rsp)
|
|
{
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
|
if ((int)rsp.retcode == 0)
|
|
{
|
|
foreach (Weapon item in rsp.weapon_list)
|
|
{
|
|
WeaponDataItem weaponDataItem = null;
|
|
if (_userStorageDict.ContainsKey(new KeyValuePair<Type, int>(typeof(WeaponDataItem), (int)item.unique_id)))
|
|
{
|
|
weaponDataItem = _userStorageDict[new KeyValuePair<Type, int>(typeof(WeaponDataItem), (int)item.unique_id)] as WeaponDataItem;
|
|
}
|
|
else
|
|
{
|
|
WeaponMetaData weaponMetaDataByKey = WeaponMetaDataReader.GetWeaponMetaDataByKey((int)item.id);
|
|
weaponDataItem = new WeaponDataItem((int)item.unique_id, weaponMetaDataByKey);
|
|
UserStorageItemList.Add(weaponDataItem);
|
|
_userStorageDict.Add(new KeyValuePair<Type, int>(weaponDataItem.GetType(), weaponDataItem.uid), weaponDataItem);
|
|
Singleton<ItempediaModule>.Instance.UnlockItem((int)item.id);
|
|
}
|
|
weaponDataItem.level = (int)item.level;
|
|
weaponDataItem.exp = (int)item.exp;
|
|
weaponDataItem.isProtected = item.is_protected;
|
|
}
|
|
foreach (Stigmata item2 in rsp.stigmata_list)
|
|
{
|
|
StigmataDataItem stigmataDataItem = null;
|
|
if (_userStorageDict.ContainsKey(new KeyValuePair<Type, int>(typeof(StigmataDataItem), (int)item2.unique_id)))
|
|
{
|
|
stigmataDataItem = _userStorageDict[new KeyValuePair<Type, int>(typeof(StigmataDataItem), (int)item2.unique_id)] as StigmataDataItem;
|
|
}
|
|
else
|
|
{
|
|
StigmataMetaData stigmataMetaDataByKey = StigmataMetaDataReader.GetStigmataMetaDataByKey((int)item2.id);
|
|
stigmataDataItem = new StigmataDataItem((int)item2.unique_id, stigmataMetaDataByKey);
|
|
UserStorageItemList.Add(stigmataDataItem);
|
|
_userStorageDict.Add(new KeyValuePair<Type, int>(stigmataDataItem.GetType(), stigmataDataItem.uid), stigmataDataItem);
|
|
Singleton<ItempediaModule>.Instance.UnlockItem((int)item2.id);
|
|
}
|
|
stigmataDataItem.level = (int)item2.level;
|
|
stigmataDataItem.exp = (int)item2.exp;
|
|
stigmataDataItem.isProtected = item2.is_protected;
|
|
bool is_affix_identify = !item2.is_affix_identifySpecified || item2.is_affix_identify;
|
|
int pre_affix_id = (int)(item2.pre_affix_idSpecified ? item2.pre_affix_id : 0);
|
|
int suf_affix_id = (int)(item2.suf_affix_idSpecified ? item2.suf_affix_id : 0);
|
|
stigmataDataItem.SetAffixSkill(is_affix_identify, pre_affix_id, suf_affix_id);
|
|
}
|
|
foreach (Material item3 in rsp.material_list)
|
|
{
|
|
MaterialDataItem materialDataItem = null;
|
|
if (_userStorageDict.ContainsKey(new KeyValuePair<Type, int>(typeof(MaterialDataItem), (int)item3.id)))
|
|
{
|
|
materialDataItem = _userStorageDict[new KeyValuePair<Type, int>(typeof(MaterialDataItem), (int)item3.id)] as MaterialDataItem;
|
|
if (item3.num == 0)
|
|
{
|
|
_userStorageDict.Remove(new KeyValuePair<Type, int>(typeof(MaterialDataItem), (int)item3.id));
|
|
UserStorageItemList.Remove(materialDataItem);
|
|
continue;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ItemMetaData itemMetaDataByKey = ItemMetaDataReader.GetItemMetaDataByKey((int)item3.id);
|
|
materialDataItem = new MaterialDataItem(itemMetaDataByKey);
|
|
UserStorageItemList.Add(materialDataItem);
|
|
_userStorageDict.Add(new KeyValuePair<Type, int>(materialDataItem.GetType(), materialDataItem.ID), materialDataItem);
|
|
Singleton<ItempediaModule>.Instance.UnlockItem((int)item3.id);
|
|
}
|
|
materialDataItem.number = (int)item3.num;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private bool OnDelEquipmentNotify(DelEquipmentNotify rsp)
|
|
{
|
|
foreach (uint item in rsp.weapon_unique_id_list)
|
|
{
|
|
int value = (int)item;
|
|
WeaponDataItem weaponDataItem = null;
|
|
if (_userStorageDict.ContainsKey(new KeyValuePair<Type, int>(typeof(WeaponDataItem), value)))
|
|
{
|
|
weaponDataItem = _userStorageDict[new KeyValuePair<Type, int>(typeof(WeaponDataItem), value)] as WeaponDataItem;
|
|
UserStorageItemList.Remove(weaponDataItem);
|
|
_userStorageDict.Remove(new KeyValuePair<Type, int>(typeof(WeaponDataItem), value));
|
|
}
|
|
}
|
|
foreach (uint item2 in rsp.stigmata_unique_id_list)
|
|
{
|
|
int value2 = (int)item2;
|
|
StigmataDataItem stigmataDataItem = null;
|
|
if (_userStorageDict.ContainsKey(new KeyValuePair<Type, int>(typeof(StigmataDataItem), value2)))
|
|
{
|
|
stigmataDataItem = _userStorageDict[new KeyValuePair<Type, int>(typeof(StigmataDataItem), value2)] as StigmataDataItem;
|
|
UserStorageItemList.Remove(stigmataDataItem);
|
|
_userStorageDict.Remove(new KeyValuePair<Type, int>(typeof(StigmataDataItem), value2));
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private bool OnEquipmentPowerUpRsp(EquipmentPowerUpRsp rsp)
|
|
{
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
|
if ((int)rsp.retcode == 0)
|
|
{
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private bool OnEquipmentSellRsp(EquipmentSellRsp rsp)
|
|
{
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
|
if ((int)rsp.retcode == 0)
|
|
{
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private bool OnSellAvatarFragmentRsp(SellAvatarFragmentRsp rsp)
|
|
{
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
|
if ((int)rsp.retcode == 0)
|
|
{
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private bool OnEquipmentEvoRsp(EquipmentEvoRsp rsp)
|
|
{
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
|
if ((int)rsp.retcode == 0)
|
|
{
|
|
EquipmentItem new_item = rsp.new_item;
|
|
Singleton<NetworkManager>.Instance.RequestHasGotItemIdList();
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private bool OnDressEquipmentRsp(DressEquipmentRsp rsp)
|
|
{
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
|
if ((int)rsp.retcode == 0)
|
|
{
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private bool OnGetHasGotItemIdListRsp(GetHasGotItemIdListRsp rsp)
|
|
{
|
|
_everOwnItemIDs.Clear();
|
|
foreach (uint item in rsp.item_id_list)
|
|
{
|
|
_everOwnItemIDs.Add((int)item);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public bool IsItemNew(int id)
|
|
{
|
|
return !_everOwnItemIDs.Contains(id);
|
|
}
|
|
|
|
public void RecordNewItem(int id)
|
|
{
|
|
_everOwnItemIDs.Add(id);
|
|
}
|
|
|
|
public StorageDataItemBase GetStorageItemByTypeAndID(Type type, int id)
|
|
{
|
|
KeyValuePair<Type, int> key = new KeyValuePair<Type, int>(type, id);
|
|
StorageDataItemBase value;
|
|
_userStorageDict.TryGetValue(key, out value);
|
|
return value;
|
|
}
|
|
|
|
public List<StorageDataItemBase> GetAllUserWeapons()
|
|
{
|
|
return UserStorageItemList.FindAll((StorageDataItemBase dataItem) => dataItem is WeaponDataItem);
|
|
}
|
|
|
|
public List<StorageDataItemBase> GetAllUserStigmata()
|
|
{
|
|
return UserStorageItemList.FindAll((StorageDataItemBase dataItem) => dataItem is StigmataDataItem);
|
|
}
|
|
|
|
public List<StorageDataItemBase> GetAllUserMaterial()
|
|
{
|
|
return UserStorageItemList.FindAll((StorageDataItemBase dataItem) => dataItem is MaterialDataItem);
|
|
}
|
|
|
|
public List<StorageDataItemBase> GetAllVentureSpeedUpMaterial()
|
|
{
|
|
return UserStorageItemList.FindAll((StorageDataItemBase dataItem) => IsVentureSpeedUpMaterial(dataItem.ID));
|
|
}
|
|
|
|
public bool IsVentureSpeedUpMaterial(int metaID)
|
|
{
|
|
return MaterialVentureSpeedUpDataReader.TryGetMaterialVentureSpeedUpDataByKey(metaID) != null;
|
|
}
|
|
|
|
public bool HasEnoughItem(int itemMetaId, int itemNum)
|
|
{
|
|
if (GetDummyStorageDataItem(itemMetaId) == null)
|
|
{
|
|
return true;
|
|
}
|
|
StorageDataItemBase value;
|
|
_userStorageDict.TryGetValue(new KeyValuePair<Type, int>(typeof(MaterialDataItem), itemMetaId), out value);
|
|
if (value == null || value.number < itemNum)
|
|
{
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public List<StorageDataItemBase> GetAllAvatarExpAddMaterial()
|
|
{
|
|
List<StorageDataItemBase> list = new List<StorageDataItemBase>();
|
|
list.AddRange(UserStorageItemList.FindAll((StorageDataItemBase dataItem) => dataItem is MaterialDataItem && (dataItem as MaterialDataItem).GetAvatarExpProvideNum() > 0f));
|
|
return list;
|
|
}
|
|
|
|
public StorageDataItemBase GetDummyStorageDataItem(int metaId, int level = 1)
|
|
{
|
|
StorageDataItemBase storageDataItemBase = null;
|
|
ItemMetaData itemMetaData = ItemMetaDataReader.TryGetItemMetaDataByKey(metaId);
|
|
if (itemMetaData != null)
|
|
{
|
|
storageDataItemBase = new MaterialDataItem(itemMetaData);
|
|
storageDataItemBase.level = level;
|
|
return storageDataItemBase;
|
|
}
|
|
WeaponMetaData weaponMetaData = WeaponMetaDataReader.TryGetWeaponMetaDataByKey(metaId);
|
|
if (weaponMetaData != null)
|
|
{
|
|
storageDataItemBase = new WeaponDataItem(0, weaponMetaData);
|
|
storageDataItemBase.level = level;
|
|
return storageDataItemBase;
|
|
}
|
|
StigmataMetaData stigmataMetaData = StigmataMetaDataReader.TryGetStigmataMetaDataByKey(metaId);
|
|
if (stigmataMetaData != null)
|
|
{
|
|
storageDataItemBase = new StigmataDataItem(0, stigmataMetaData);
|
|
storageDataItemBase.level = level;
|
|
(storageDataItemBase as StigmataDataItem).SetDummyAffixSkill();
|
|
return storageDataItemBase;
|
|
}
|
|
AvatarCardMetaData avatarCardMetaData = AvatarCardMetaDataReader.TryGetAvatarCardMetaDataByKey(metaId);
|
|
if (avatarCardMetaData != null)
|
|
{
|
|
storageDataItemBase = new AvatarCardDataItem(avatarCardMetaData);
|
|
storageDataItemBase.level = level;
|
|
return storageDataItemBase;
|
|
}
|
|
AvatarFragmentMetaData avatarFragmentMetaData = AvatarFragmentMetaDataReader.TryGetAvatarFragmentMetaDataByKey(metaId);
|
|
if (avatarFragmentMetaData != null)
|
|
{
|
|
storageDataItemBase = new AvatarFragmentDataItem(avatarFragmentMetaData);
|
|
storageDataItemBase.level = level;
|
|
return storageDataItemBase;
|
|
}
|
|
EndlessToolMetaData endlessToolMetaData = EndlessToolMetaDataReader.TryGetEndlessToolMetaDataByKey(metaId);
|
|
if (endlessToolMetaData != null)
|
|
{
|
|
storageDataItemBase = new EndlessToolDataItem(metaId);
|
|
storageDataItemBase.level = level;
|
|
return storageDataItemBase;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public List<StorageDataItemBase> TryGetStorageDataItemByMetaId(int metaId, int number = 1)
|
|
{
|
|
return UserStorageItemList.FindAll((StorageDataItemBase x) => x.ID == metaId && x.number >= number);
|
|
}
|
|
|
|
public int GetCurrentCapacity()
|
|
{
|
|
return UserStorageItemList.Count;
|
|
}
|
|
|
|
public bool IsFull()
|
|
{
|
|
return UserStorageItemList.Count >= Singleton<PlayerModule>.Instance.playerData.equipmentSizeLimit;
|
|
}
|
|
|
|
public List<StorageDataItemBase> GetFragmentList()
|
|
{
|
|
List<StorageDataItemBase> list = new List<StorageDataItemBase>();
|
|
foreach (AvatarDataItem userAvatar in Singleton<AvatarModule>.Instance.UserAvatarList)
|
|
{
|
|
if (userAvatar.fragment > 0)
|
|
{
|
|
list.Add(userAvatar.GetAvatarFragmentDataItem());
|
|
}
|
|
}
|
|
return list;
|
|
}
|
|
|
|
public MaterialDataItem TryGetMaterialDataByID(int id)
|
|
{
|
|
StorageDataItemBase value;
|
|
_userStorageDict.TryGetValue(new KeyValuePair<Type, int>(typeof(MaterialDataItem), id), out value);
|
|
return value as MaterialDataItem;
|
|
}
|
|
|
|
public List<StigmataDataItem> GetStigmatasCanUseForNewAffix(StigmataDataItem stigmata)
|
|
{
|
|
List<StorageDataItemBase> allUserStigmata = GetAllUserStigmata();
|
|
List<StigmataDataItem> list = new List<StigmataDataItem>();
|
|
foreach (StorageDataItemBase item in allUserStigmata)
|
|
{
|
|
StigmataDataItem stigmataDataItem = item as StigmataDataItem;
|
|
if (stigmataDataItem != null && stigmataDataItem.uid != stigmata.uid && (stigmataDataItem.ID == stigmata.ID || StigmataMetaDataReaderExtend.IsEvoRelation(stigmataDataItem.ID, stigmata.ID)) && stigmataDataItem.CanRefine)
|
|
{
|
|
list.Add(stigmataDataItem);
|
|
}
|
|
}
|
|
return list;
|
|
}
|
|
|
|
public WeaponDataItem GetDummyFirstWeaponDataByRole(EntityRoleName role, int level)
|
|
{
|
|
foreach (ConfigWeapon value in WeaponData.GetAllWeaponConfigs().Values)
|
|
{
|
|
if (value.OwnerRole == role)
|
|
{
|
|
WeaponMetaData weaponMetaData = new WeaponMetaData(value.WeaponID, "DUMMY WEAPON", 1, 1, 1, 1, 1, 1, 1, 1, 1f, 1f, 1f, 1f, "TYPE_FOON", 1, 1, "BODY_MOD", "DUMMY WEAPON", "DUMMY WEAPON", 1, string.Empty, string.Empty, 0f, 0f, 0f, 0f, 0f, 0f, 0f, 0f, 0f, 0f, 1f, 1f, 1f, 1f, 1, new List<string>(), 1, 0, 0f, 0f, 0f, 0f, 0f, 0f, 0, 0f, 0f, 0f, 0f, 0f, 0f, 0, 0f, 0f, 0f, 0f, 0f, 0f);
|
|
return new WeaponDataItem(1, weaponMetaData);
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public WeaponDataItem GetDummyWeaponDataItem(int weaponID, int level)
|
|
{
|
|
WeaponMetaData weaponMetaDataByKey = WeaponMetaDataReader.GetWeaponMetaDataByKey(weaponID);
|
|
WeaponDataItem weaponDataItem = new WeaponDataItem(0, weaponMetaDataByKey);
|
|
weaponDataItem.level = level;
|
|
return weaponDataItem;
|
|
}
|
|
|
|
public StigmataDataItem GetDummyStigmataDataItem(int stigmataID, int level)
|
|
{
|
|
StigmataMetaData stigmataMetaDataByKey = StigmataMetaDataReader.GetStigmataMetaDataByKey(stigmataID);
|
|
if (stigmataMetaDataByKey == null)
|
|
{
|
|
return null;
|
|
}
|
|
StigmataDataItem stigmataDataItem = new StigmataDataItem(20000, stigmataMetaDataByKey);
|
|
stigmataDataItem.level = level;
|
|
return stigmataDataItem;
|
|
}
|
|
}
|
|
}
|