408 lines
14 KiB
C#
408 lines
14 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Net.Sockets;
|
|
using System.Runtime.InteropServices;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
|
|
|
|
using ServerCore;
|
|
using ServerBase;
|
|
using MetaAssets;
|
|
using ServerControlCenter;
|
|
|
|
|
|
using SESSION_ID = System.Int32;
|
|
using META_ID = System.UInt32;
|
|
using ENTITY_GUID = System.String;
|
|
using ACCOUNT_ID = System.String;
|
|
using OWNER_GUID = System.String;
|
|
using USER_GUID = System.String;
|
|
using CHARACTER_GUID = System.String;
|
|
using ITEM_GUID = System.String;
|
|
|
|
|
|
|
|
|
|
namespace ServerCommon;
|
|
|
|
public static class InventoryRuleHelper
|
|
{
|
|
public static Int16 getBagTapMaxSlotCount()
|
|
{
|
|
return MetaHelper.GameConfigMeta.MaxItemCategorySlotNum;
|
|
}
|
|
|
|
// 임시로 관련 메타 정보를 반환 한다.
|
|
// 추후 인벤토리 메타 정보를 추가하여 처리되도록 개선하자. - kangms
|
|
public static Int16 getBagTapMaxSlotCountByBagTabType(EntityType entityType, BagTabType tabType)
|
|
{
|
|
switch (entityType)
|
|
{
|
|
case EntityType.MyHome:
|
|
return getMyHomeMaxSlotCountByBagTabType(tabType);
|
|
|
|
default:
|
|
return getNormalMaxSlotCountByBagTabType(tabType);
|
|
}
|
|
}
|
|
public static Int16 getNormalMaxSlotCountByBagTabType(BagTabType tabType)
|
|
{
|
|
switch (tabType)
|
|
{
|
|
case BagTabType._0:
|
|
return MetaHelper.GameConfigMeta.Inventory1Slot;
|
|
|
|
case BagTabType._1:
|
|
return MetaHelper.GameConfigMeta.Inventory3Slot;
|
|
|
|
case BagTabType._2:
|
|
return MetaHelper.GameConfigMeta.Inventory5Slot;
|
|
|
|
case BagTabType._3:
|
|
return MetaHelper.GameConfigMeta.Inventory7Slot;
|
|
|
|
case BagTabType._4:
|
|
return MetaHelper.GameConfigMeta.Inventory9Slot;
|
|
|
|
case BagTabType._5:
|
|
return MetaHelper.GameConfigMeta.Inventory2Slot;
|
|
|
|
case BagTabType._6:
|
|
return MetaHelper.GameConfigMeta.Inventory4Slot;
|
|
|
|
case BagTabType._7:
|
|
return MetaHelper.GameConfigMeta.Inventory6Slot;
|
|
|
|
case BagTabType._8:
|
|
return MetaHelper.GameConfigMeta.Inventory8Slot;
|
|
|
|
case BagTabType._9:
|
|
return MetaHelper.GameConfigMeta.Inventory10Slot;
|
|
|
|
default:
|
|
throw new ArgumentException($"Invalid BagTabType !!!, in getNormalMaxSlotCountByBagTabType() : BagTabType:{tabType}");
|
|
}
|
|
}
|
|
|
|
public static Int16 getMyHomeMaxSlotCountByBagTabType(BagTabType tabType)
|
|
{
|
|
switch (tabType)
|
|
{
|
|
case BagTabType._0:
|
|
return MetaHelper.GameConfigMeta.MyHomeInventory1Slot;
|
|
|
|
case BagTabType._1:
|
|
return MetaHelper.GameConfigMeta.MyHomeInventory3Slot;
|
|
|
|
case BagTabType._2:
|
|
return MetaHelper.GameConfigMeta.MyHomeInventory5Slot;
|
|
|
|
case BagTabType._3:
|
|
return MetaHelper.GameConfigMeta.MyHomeInventory7Slot;
|
|
|
|
case BagTabType._4:
|
|
return MetaHelper.GameConfigMeta.MyHomeInventory9Slot;
|
|
|
|
case BagTabType._5:
|
|
return MetaHelper.GameConfigMeta.MyHomeInventory2Slot;
|
|
|
|
case BagTabType._6:
|
|
return MetaHelper.GameConfigMeta.MyHomeInventory4Slot;
|
|
|
|
case BagTabType._7:
|
|
return MetaHelper.GameConfigMeta.MyHomeInventory6Slot;
|
|
|
|
case BagTabType._8:
|
|
return MetaHelper.GameConfigMeta.MyHomeInventory8Slot;
|
|
|
|
case BagTabType._9:
|
|
return MetaHelper.GameConfigMeta.MyHomeInventory10Slot;
|
|
|
|
default:
|
|
throw new ArgumentException($"Invalid BagTabType !!!, in getMyHomeMaxSlotCountByBagTabType() : BagTabType:{tabType}");
|
|
}
|
|
}
|
|
|
|
public static List<ITEM_GUID> findContainDuplicatedItemGuid(List<ITEM_GUID> toCheckItemGuids)
|
|
{
|
|
return toCheckItemGuids.GroupBy(x => x)
|
|
.Where(g => g.Count() > 1)
|
|
.Select(g => g.Key)
|
|
.ToList();
|
|
}
|
|
|
|
public static InvenEquipType toInvenEquipType(this EntityType entityInvenType)
|
|
{
|
|
switch (entityInvenType)
|
|
{
|
|
case EntityType.ClothEquipInven:
|
|
return InvenEquipType.Cloth;
|
|
|
|
case EntityType.ToolEquipInven:
|
|
return InvenEquipType.Tool;
|
|
|
|
case EntityType.TattooEquipInven:
|
|
return InvenEquipType.Tattoo;
|
|
|
|
default:
|
|
Log.getLogger().error($"Invalid EntityType !!!, can't convert InvenEquipType : EntityType:{entityInvenType}");
|
|
return InvenEquipType.None;
|
|
}
|
|
}
|
|
|
|
//=========================================================================================
|
|
// 해당 가방에 장착 가능한 EItemLargeType 목록을 반환 한다.
|
|
//=========================================================================================
|
|
public static List<MetaAssets.EItemLargeType> toEquipableItemLargeTypes(this InvenBagType toEquipBagType)
|
|
{
|
|
switch (toEquipBagType)
|
|
{
|
|
case InvenBagType.Cloth:
|
|
return new List<MetaAssets.EItemLargeType>() { MetaAssets.EItemLargeType.CLOTH };
|
|
|
|
case InvenBagType.Prop:
|
|
return new List<MetaAssets.EItemLargeType>() { MetaAssets.EItemLargeType.PROP };
|
|
|
|
case InvenBagType.Beauty:
|
|
return new List<MetaAssets.EItemLargeType>() { MetaAssets.EItemLargeType.BEAUTY };
|
|
|
|
case InvenBagType.Tattoo:
|
|
return new List<MetaAssets.EItemLargeType>() { MetaAssets.EItemLargeType.TATTOO };
|
|
|
|
case InvenBagType.Etc:
|
|
return new List<MetaAssets.EItemLargeType>() { MetaAssets.EItemLargeType.TOOL
|
|
, MetaAssets.EItemLargeType.EXPENDABLE
|
|
, MetaAssets.EItemLargeType.TICKET
|
|
, MetaAssets.EItemLargeType.RAND_BOX
|
|
, MetaAssets.EItemLargeType.SET_BOX
|
|
};
|
|
|
|
default:
|
|
Log.getLogger().error($"Invalid InvenBagType !!!, can't equip EItemLargeType : toEquipInvenBagType:{toEquipBagType}");
|
|
return new List<MetaAssets.EItemLargeType>();
|
|
}
|
|
}
|
|
|
|
public static BagTabType toUsableBagTabType(this InvenBagType bagType)
|
|
{
|
|
switch (bagType)
|
|
{
|
|
case InvenBagType.Cloth:
|
|
return BagTabType._1;
|
|
|
|
case InvenBagType.Prop:
|
|
return BagTabType._2;
|
|
|
|
case InvenBagType.Beauty:
|
|
return BagTabType._3;
|
|
|
|
case InvenBagType.Tattoo:
|
|
return BagTabType._4;
|
|
|
|
case InvenBagType.Etc:
|
|
return BagTabType._0;
|
|
|
|
default:
|
|
Log.getLogger().error($"Invalid InvenBagType !!!, can't usable BagTabType : InvenBagType:{bagType}");
|
|
return BagTabType.None;
|
|
}
|
|
}
|
|
|
|
public static InvenBagType toUsableInvenBagType(this BagTabType bagType)
|
|
{
|
|
switch (bagType)
|
|
{
|
|
case BagTabType._1:
|
|
return InvenBagType.Cloth;
|
|
|
|
case BagTabType._2:
|
|
return InvenBagType.Prop;
|
|
|
|
case BagTabType._3:
|
|
return InvenBagType.Beauty;
|
|
|
|
case BagTabType._4:
|
|
return InvenBagType.Tattoo;
|
|
|
|
case BagTabType._0:
|
|
return InvenBagType.Etc;
|
|
|
|
default:
|
|
return InvenBagType.None;
|
|
}
|
|
}
|
|
|
|
public static string toUsableInvenBagName(this BagTabType bagTabType)
|
|
{
|
|
var is_nft = false;
|
|
|
|
var inven_bag_type = InventoryRuleHelper.toUsableInvenBagType(bagTabType);
|
|
if(InvenBagType.None == inven_bag_type)
|
|
{
|
|
if(BagTabType._5 <= bagTabType && bagTabType < BagTabType.MAX)
|
|
{
|
|
is_nft = true;
|
|
|
|
bagTabType -= (BagTabType.MAX - BagTabType._5);
|
|
inven_bag_type = InventoryRuleHelper.toUsableInvenBagType(bagTabType);
|
|
}
|
|
}
|
|
|
|
var inven_bag_name = EnumHelper.convertEnumToEnumTypeAndValueString(inven_bag_type);
|
|
|
|
if (false == is_nft)
|
|
{
|
|
inven_bag_name += $"_NormalTab";
|
|
}
|
|
else
|
|
{
|
|
inven_bag_name += $"_NftTab";
|
|
}
|
|
|
|
return inven_bag_name;
|
|
}
|
|
|
|
public static BagTabType toNFTTabOffset(this BagTabType bagTabType, MetaAssets.ItemMetaData itemMeta)
|
|
{
|
|
return bagTabType + (true == itemMeta.IsNFT ? (BagTabType.MAX - BagTabType._5) : 0);
|
|
}
|
|
|
|
public static EntityDynamoDbSortKeyType toEntitySKType(this InvenEquipType equipType)
|
|
{
|
|
switch (equipType)
|
|
{
|
|
case InvenEquipType.Cloth:
|
|
return EntityDynamoDbSortKeyType.Guid;
|
|
|
|
case InvenEquipType.Tool:
|
|
return EntityDynamoDbSortKeyType.Guid;
|
|
|
|
case InvenEquipType.Tattoo:
|
|
return EntityDynamoDbSortKeyType.Guid;
|
|
|
|
default:
|
|
Log.getLogger().error($"Invalid InvenEquipType !!!, can't use EntityDynamoDbSortKeyType : InvenEquipType:{equipType}");
|
|
return EntityDynamoDbSortKeyType.None;
|
|
}
|
|
}
|
|
|
|
public static List<MetaAssets.EItemLargeType> toEquipableItemLargeTypes(this InvenEquipType equipType)
|
|
{
|
|
switch (equipType)
|
|
{
|
|
case InvenEquipType.Cloth:
|
|
return new List<MetaAssets.EItemLargeType>() { MetaAssets.EItemLargeType.CLOTH };
|
|
|
|
case InvenEquipType.Tool:
|
|
return new List<MetaAssets.EItemLargeType>() { MetaAssets.EItemLargeType.TOOL };
|
|
|
|
case InvenEquipType.Tattoo:
|
|
return new List<MetaAssets.EItemLargeType>() { MetaAssets.EItemLargeType.TATTOO };
|
|
|
|
default:
|
|
Log.getLogger().error($"Invalid InvenEquipType !!!, can't equip EItemLargeType : InvenEquipType:{equipType}");
|
|
return new List<MetaAssets.EItemLargeType>();
|
|
}
|
|
}
|
|
|
|
public static List<MetaAssets.EItemSmallType> toEquipableItemSmallTypesWithClothSlotType(this InvenEquipType equipType, ClothSlotType clothSlotType)
|
|
{
|
|
switch (equipType)
|
|
{
|
|
case InvenEquipType.Cloth:
|
|
return clothSlotType.toEquipableItemSmallTypes();
|
|
|
|
default:
|
|
Log.getLogger().error($"Invalid InvenEquipType !!!, can't equip ClothSlotType : InvenEquipType:{equipType}, ClothSlotType:{clothSlotType}");
|
|
return new List<MetaAssets.EItemSmallType>();
|
|
}
|
|
}
|
|
|
|
public static List<MetaAssets.EItemSmallType> toEquipableItemSmallTypes(this ClothSlotType clothSlotType)
|
|
{
|
|
var list = new List<EItemSmallType>();
|
|
|
|
foreach (var equipData in MetaData.Instance.Meta.ClothEquipTypeMetaTable.ClothEquipTypeDataList)
|
|
{
|
|
if (false == EnumHelper.tryParse<ClothSlotType>(equipData.EquipSlotType, out var slotType)) continue;
|
|
if (slotType != clothSlotType) continue;
|
|
if (false == EnumHelper.tryParse<EItemSmallType>(equipData.SmallType, out var smallType)) continue;
|
|
list.Add(smallType);
|
|
}
|
|
|
|
if (list.Count <= 0)
|
|
{
|
|
Log.getLogger().warn($"Invalid ClothSlotType !!!, can't equip ClothSlotType : ClothSlotType:{clothSlotType}");
|
|
}
|
|
|
|
return list;
|
|
}
|
|
|
|
public static List<ToolSlotType> toEquipableToolSlotTypes(this InvenEquipType equipType)
|
|
{
|
|
switch (equipType)
|
|
{
|
|
case InvenEquipType.Tool:
|
|
return new List<ToolSlotType>() { ToolSlotType._1, ToolSlotType._2, ToolSlotType._3, ToolSlotType._4 };
|
|
|
|
default:
|
|
Log.getLogger().error($"Invalid InvenEquipType !!!, can't equip ToolSlotType : InvenEquipType:{equipType}");
|
|
return new List<ToolSlotType>();
|
|
}
|
|
}
|
|
|
|
public static List<TattooSlotType> toEquipableTattooSlotTypes(this InvenEquipType equipType, EntityType entityType = EntityType.None)
|
|
{
|
|
switch (equipType)
|
|
{
|
|
case InvenEquipType.Tattoo:
|
|
{
|
|
if( EntityType.UgcNpc == entityType
|
|
|| EntityType.Beacon == entityType )
|
|
{
|
|
return new List<TattooSlotType>() { TattooSlotType._1, TattooSlotType._2, TattooSlotType._3 };
|
|
}
|
|
|
|
return new List<TattooSlotType>() { TattooSlotType._1, TattooSlotType._2, TattooSlotType._3, TattooSlotType._4 };
|
|
}
|
|
}
|
|
|
|
Log.getLogger().error($"Invalid InvenEquipType !!!, can't equip TattooSlotType : InvenEquipType:{equipType}");
|
|
return new List<TattooSlotType>();
|
|
}
|
|
|
|
public static bool isEquipableTattooSlotType(this InvenEquipType equipType, TattooSlotType slotType, EntityType entityType)
|
|
{
|
|
var equipable_slot_types = equipType.toEquipableTattooSlotTypes(entityType);
|
|
var found_slot_type = equipable_slot_types.FirstOrDefault(x => x == slotType, TattooSlotType.None);
|
|
if (TattooSlotType.None == found_slot_type)
|
|
{
|
|
var err_msg = $"Not found TattooSlotType !!! : InvenEquipType:{equipType}, TattooSlotType:{slotType} - entityType:{entityType}";
|
|
Log.getLogger().error(err_msg);
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public static ClothSlotType toClothSlotType(this MetaAssets.EItemSmallType smallType)
|
|
{
|
|
if (false == MetaData.Instance.Meta.ClothEquipTypeMetaTable.ClothEquipTypeDataListbyId.TryGetValue(smallType.ToString(), out var slotTypeData))
|
|
{
|
|
Log.getLogger().warn($"Invalid EItemSmallType !!!, can't convert ClothSlotType : EItemSmallType:{smallType}");
|
|
return ClothSlotType.None;
|
|
}
|
|
|
|
if (false == EnumHelper.tryParse<ClothSlotType>(slotTypeData.EquipSlotType, out var slotType))
|
|
{
|
|
Log.getLogger().warn($"Invalid EquipSlotType !!!, can't convert ClothSlotType : EquipSlotType:{slotTypeData.EquipSlotType}");
|
|
return ClothSlotType.None;
|
|
}
|
|
|
|
return slotType;
|
|
}
|
|
}
|