HungDK
394 lines
12 KiB
C#
394 lines
12 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
|
|
namespace PerfectWorld.Scripts.Managers
|
|
{
|
|
|
|
public static class EC_Inventory
|
|
{
|
|
private static readonly Dictionary<byte, int> _packSizeByPackage = new Dictionary<byte, int>();
|
|
private static readonly Dictionary<byte, Dictionary<int, InventoryItemData>> _itemsByPackage = new Dictionary<byte, Dictionary<int, InventoryItemData>>();
|
|
private const int MaxContentHexToLog = 64;
|
|
|
|
// Package constants to mirror legacy C++ names
|
|
public const byte PACK_INVENTORY = 0;
|
|
public const byte PACK_EQUIPMENT = 1;
|
|
public const byte PACK_TASKINVENTORY = 2;
|
|
|
|
private static string GetPackageName(byte pkg)
|
|
{
|
|
switch (pkg)
|
|
{
|
|
case 0: return "PACK_INVENTORY";
|
|
case 1: return "PACK_EQUIPMENT";
|
|
case 2: return "PACK_TASKINVENTORY";
|
|
default: return "PACK_UNKNOWN";
|
|
}
|
|
}
|
|
|
|
private static string BytesToHex(byte[] bytes, int max)
|
|
{
|
|
if (bytes == null || bytes.Length == 0) return "";
|
|
int len = Math.Min(bytes.Length, max);
|
|
string hex = BitConverter.ToString(bytes, 0, len);
|
|
if (bytes.Length > len) hex += "-...";
|
|
return hex;
|
|
}
|
|
|
|
public static InventoryItemData GetItem(int iSlot, bool bRemove)
|
|
{
|
|
// Backward-compatible overload defaulting to inventory package
|
|
return GetItem(PACK_INVENTORY, iSlot, bRemove);
|
|
}
|
|
|
|
public static InventoryItemData GetItem(byte byPackage, int slot, bool remove)
|
|
{
|
|
if (!_itemsByPackage.TryGetValue(byPackage, out var slots) || slot < 0)
|
|
return null;
|
|
if (!slots.TryGetValue(slot, out var item))
|
|
return null;
|
|
if (remove)
|
|
slots.Remove(slot);
|
|
return item;
|
|
}
|
|
|
|
private static Dictionary<int, InventoryItemData> EnsureSlots(byte byPackage)
|
|
{
|
|
if (!_itemsByPackage.TryGetValue(byPackage, out var slots) || slots == null)
|
|
{
|
|
slots = new Dictionary<int, InventoryItemData>();
|
|
_itemsByPackage[byPackage] = slots;
|
|
}
|
|
return slots;
|
|
}
|
|
|
|
public static void Resize(byte byPackage, int newSize)
|
|
{
|
|
_packSizeByPackage[byPackage] = Math.Max(0, newSize);
|
|
EnsureSlots(byPackage);
|
|
}
|
|
|
|
public static InventoryItemData PutItem(byte byPackage, int slot, InventoryItemData item)
|
|
{
|
|
var slots = EnsureSlots(byPackage);
|
|
if (slot < 0) return null;
|
|
slots.TryGetValue(slot, out var oldItem);
|
|
slots[slot] = item;
|
|
return oldItem;
|
|
}
|
|
|
|
public static void SetItem(byte byPackage, int slot, InventoryItemData item)
|
|
{
|
|
var slots = EnsureSlots(byPackage);
|
|
if (slot < 0) return;
|
|
slots[slot] = item;
|
|
}
|
|
|
|
public static void ExchangeItem(byte byPackage, int slot1, int slot2)
|
|
{
|
|
if (slot1 == slot2) return;
|
|
var slots = EnsureSlots(byPackage);
|
|
slots.TryGetValue(slot1, out var i1);
|
|
slots.TryGetValue(slot2, out var i2);
|
|
if (i1 != null) slots[slot2] = i1; else slots.Remove(slot2);
|
|
if (i2 != null) slots[slot1] = i2; else slots.Remove(slot1);
|
|
}
|
|
|
|
public static bool RemoveItem(byte byPackage, int slot, int amount)
|
|
{
|
|
var slots = EnsureSlots(byPackage);
|
|
if (!slots.TryGetValue(slot, out var item) || item == null)
|
|
return true;
|
|
int newCount = Math.Max(0, item.Count - Math.Max(0, amount));
|
|
item.Count = newCount;
|
|
if (newCount <= 0)
|
|
slots.Remove(slot);
|
|
else
|
|
slots[slot] = item;
|
|
return true;
|
|
}
|
|
|
|
public static void RemoveAllItems(byte byPackage)
|
|
{
|
|
var slots = EnsureSlots(byPackage);
|
|
slots.Clear();
|
|
}
|
|
|
|
public static int SearchEmpty(byte byPackage)
|
|
{
|
|
int size = _packSizeByPackage.TryGetValue(byPackage, out var s) ? s : 0;
|
|
var slots = EnsureSlots(byPackage);
|
|
for (int i = 0; i < size; i++)
|
|
if (!slots.ContainsKey(i)) return i;
|
|
return -1;
|
|
}
|
|
|
|
public static int GetEmptySlotNum(byte byPackage)
|
|
{
|
|
int size = _packSizeByPackage.TryGetValue(byPackage, out var s) ? s : 0;
|
|
int occupied = EnsureSlots(byPackage).Count;
|
|
int empty = Math.Max(0, size - occupied);
|
|
return empty;
|
|
}
|
|
|
|
public static int FindItem(byte byPackage, int templateId, int baseIdx = 0)
|
|
{
|
|
var slots = EnsureSlots(byPackage);
|
|
int size = _packSizeByPackage.TryGetValue(byPackage, out var s) ? s : 0;
|
|
if (baseIdx < 0) baseIdx = 0;
|
|
for (int i = baseIdx; i < size; i++)
|
|
{
|
|
if (slots.TryGetValue(i, out var it) && it != null && it.TemplateId == templateId)
|
|
return i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
public static int GetItemTotalNum(byte byPackage, int templateId)
|
|
{
|
|
int total = 0;
|
|
foreach (var kv in EnsureSlots(byPackage))
|
|
{
|
|
var it = kv.Value;
|
|
if (it != null && it.TemplateId == templateId)
|
|
total += Math.Max(0, it.Count);
|
|
}
|
|
return total;
|
|
}
|
|
|
|
public static int GetItemCanPileCount(byte byPackage, int templateId)
|
|
{
|
|
int ret = 0;
|
|
foreach (var kv in EnsureSlots(byPackage))
|
|
{
|
|
var it = kv.Value;
|
|
if (it != null && it.TemplateId == templateId)
|
|
{
|
|
int pileLimit = Math.Max(1, EC_IvtrItem.GetPileLimit(templateId));
|
|
ret += Math.Max(0, pileLimit - Math.Max(0, it.Count));
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
public static int CanAddItem(byte byPackage, int templateId, int amount, bool tryPile)
|
|
{
|
|
int firstEmpty = -1;
|
|
int pileLimit = Math.Max(1, EC_IvtrItem.GetPileLimit(templateId));
|
|
int size = _packSizeByPackage.TryGetValue(byPackage, out var s) ? s : 0;
|
|
var slots = EnsureSlots(byPackage);
|
|
for (int i = 0; i < size; i++)
|
|
{
|
|
if (!slots.TryGetValue(i, out var it) || it == null)
|
|
{
|
|
if (!tryPile) return i;
|
|
if (firstEmpty < 0) firstEmpty = i;
|
|
}
|
|
else if (it.TemplateId == templateId && it.Count + amount <= pileLimit)
|
|
{
|
|
return i;
|
|
}
|
|
}
|
|
return firstEmpty;
|
|
}
|
|
|
|
public static bool MergeItem(byte byPackage, int templateId, int expireDate, int amount, out int lastSlot, out int slotAmount)
|
|
{
|
|
lastSlot = -1;
|
|
slotAmount = 0;
|
|
var slots = EnsureSlots(byPackage);
|
|
int pileLimit = Math.Max(1, EC_IvtrItem.GetPileLimit(templateId));
|
|
int firstEmpty = -1;
|
|
int size = _packSizeByPackage.TryGetValue(byPackage, out var s) ? s : 0;
|
|
for (int i = 0; i < size && amount > 0; i++)
|
|
{
|
|
slots.TryGetValue(i, out var slotItem);
|
|
if (slotItem == null)
|
|
{
|
|
if (firstEmpty < 0) firstEmpty = i;
|
|
continue;
|
|
}
|
|
if (slotItem.TemplateId != templateId) continue;
|
|
int canAdd = Math.Max(0, pileLimit - Math.Max(0, slotItem.Count));
|
|
if (canAdd <= 0) continue;
|
|
int add = Math.Min(canAdd, amount);
|
|
slotItem.Count += add;
|
|
amount -= add;
|
|
lastSlot = i;
|
|
slotAmount = slotItem.Count;
|
|
}
|
|
if (amount <= 0) return true;
|
|
if (firstEmpty < 0) return false;
|
|
var newItem = new InventoryItemData
|
|
{
|
|
Package = byPackage,
|
|
Slot = firstEmpty,
|
|
TemplateId = templateId,
|
|
ExpireDate = expireDate,
|
|
State = 0,
|
|
Count = amount,
|
|
Crc = 0,
|
|
Content = null
|
|
};
|
|
slots[firstEmpty] = newItem;
|
|
lastSlot = firstEmpty;
|
|
slotAmount = amount;
|
|
return true;
|
|
}
|
|
|
|
public static bool MoveItem(byte byPackage, int src, int dest, int amount)
|
|
{
|
|
if (src == dest) return false;
|
|
if (amount <= 0) return false;
|
|
int size = _packSizeByPackage.TryGetValue(byPackage, out var s) ? s : 0;
|
|
if (src < 0 || src >= size || dest < 0 || dest >= size) return false;
|
|
var slots = EnsureSlots(byPackage);
|
|
if (!slots.TryGetValue(src, out var srcItem) || srcItem == null) return false;
|
|
slots.TryGetValue(dest, out var dstItem);
|
|
if (dstItem == null)
|
|
{
|
|
var clone = new InventoryItemData
|
|
{
|
|
Package = byPackage,
|
|
Slot = dest,
|
|
TemplateId = srcItem.TemplateId,
|
|
ExpireDate = srcItem.ExpireDate,
|
|
State = srcItem.State,
|
|
Count = amount,
|
|
Crc = srcItem.Crc,
|
|
Content = srcItem.Content != null ? (byte[])srcItem.Content.Clone() : null
|
|
};
|
|
slots[dest] = clone;
|
|
}
|
|
else
|
|
{
|
|
if (dstItem.TemplateId != srcItem.TemplateId) return false;
|
|
int pileLimit = Math.Max(1, EC_IvtrItem.GetPileLimit(dstItem.TemplateId));
|
|
int canAdd = Math.Max(0, pileLimit - Math.Max(0, dstItem.Count));
|
|
int add = Math.Min(canAdd, amount);
|
|
if (add <= 0) return false;
|
|
dstItem.Count += add;
|
|
amount = add;
|
|
}
|
|
RemoveItem(byPackage, src, amount);
|
|
return true;
|
|
}
|
|
public static void UpdatePack(byte byPackage, int ivtrSize, IEnumerable<InventoryItemData> items)
|
|
{
|
|
_packSizeByPackage[byPackage] = ivtrSize;
|
|
if (!_itemsByPackage.TryGetValue(byPackage, out var slots))
|
|
{
|
|
slots = new Dictionary<int, InventoryItemData>();
|
|
_itemsByPackage[byPackage] = slots;
|
|
}
|
|
slots.Clear();
|
|
if (items != null)
|
|
{
|
|
foreach (var it in items)
|
|
{
|
|
if (it != null && it.Slot >= 0)
|
|
{
|
|
slots[it.Slot] = it;
|
|
}
|
|
}
|
|
}
|
|
// Log this pack's items
|
|
LogPackInternal(byPackage, ivtrSize, slots);
|
|
}
|
|
|
|
public static bool ResetWithDetailData(byte byPackage, int ivtrSize, byte[] data)
|
|
{
|
|
// Uses EC_IvtrItem.TryParseInventoryDetail format
|
|
if (data == null)
|
|
{
|
|
Resize(byPackage, ivtrSize);
|
|
RemoveAllItems(byPackage);
|
|
return true;
|
|
}
|
|
if (!EC_IvtrItem.TryParseInventoryDetail(data, out var pkg, out var size, out var items))
|
|
return false;
|
|
// Prefer header values when valid
|
|
byte finalPkg = byPackage;
|
|
if (pkg == byPackage) finalPkg = pkg;
|
|
int finalSize = ivtrSize > 0 ? ivtrSize : size;
|
|
UpdatePack(finalPkg, finalSize, items);
|
|
return true;
|
|
}
|
|
|
|
|
|
private static void LogPackInternal(byte byPackage, int ivtrSize, IReadOnlyDictionary<int, InventoryItemData> slots)
|
|
{
|
|
Debug.Log($"[Inventory] === Pack {GetPackageName(byPackage)}({byPackage}) size={ivtrSize}, items={(slots?.Count ?? 0)} ===");
|
|
if (slots == null || slots.Count == 0)
|
|
{
|
|
Debug.Log("[Inventory] (empty)");
|
|
return;
|
|
}
|
|
foreach (var kv in slots)
|
|
{
|
|
var it = kv.Value;
|
|
string itemName = EC_IvtrItem.ResolveItemName(it.TemplateId);
|
|
string extraHex = it.Content != null && it.Content.Length > 0 ? EC_IvtrItem.BytesToHex(it.Content, MaxContentHexToLog) : "";
|
|
int extraLen = it.Content?.Length ?? 0;
|
|
Debug.Log(
|
|
$"[Inventory] pkg={GetPackageName(it.Package)}({it.Package}) slot={it.Slot} tid={it.TemplateId}{(string.IsNullOrEmpty(itemName) ? "" : " \"" + itemName + "\"")} count={it.Count} state={it.State} expire={it.ExpireDate} crc={it.Crc} content_len={extraLen}{(extraLen > 0 ? ", content_hex=" + extraHex : "")}"
|
|
);
|
|
}
|
|
}
|
|
|
|
public static void LogInventoryPacket(string tag, byte[] buffer, int hostId)
|
|
{
|
|
if (buffer == null)
|
|
{
|
|
Debug.LogWarning($"[Inventory] {tag}: buffer is null (hostId={hostId})");
|
|
return;
|
|
}
|
|
|
|
int index = 0;
|
|
if (buffer.Length < 6)
|
|
{
|
|
Debug.LogWarning($"[Inventory] {tag}: buffer too small: {buffer.Length} bytes (hostId={hostId})");
|
|
LogInventoryRaw(tag, buffer);
|
|
return;
|
|
}
|
|
|
|
byte byPackage = buffer[index++];
|
|
byte ivtrSize = buffer[index++];
|
|
uint contentLength = BitConverter.ToUInt32(buffer, index); index += 4;
|
|
|
|
int remaining = buffer.Length - index;
|
|
int contentBytes = remaining;
|
|
if (contentLength < (uint)remaining)
|
|
{
|
|
contentBytes = (int)contentLength;
|
|
}
|
|
|
|
Debug.Log($"[Inventory] {tag}: hostId={hostId}, totalBytes={buffer.Length}, byPackage={byPackage}, ivtrSize={ivtrSize}, contentLength={contentLength}, actualContentBytes={contentBytes}");
|
|
|
|
if (contentBytes > 0)
|
|
{
|
|
byte[] content = new byte[contentBytes];
|
|
Buffer.BlockCopy(buffer, index, content, 0, contentBytes);
|
|
Debug.Log($"[Inventory] {tag}: content HEX=\n{BitConverter.ToString(content)}");
|
|
}
|
|
|
|
int trailing = buffer.Length - (index + contentBytes);
|
|
if (trailing > 0)
|
|
{
|
|
byte[] tail = new byte[trailing];
|
|
Buffer.BlockCopy(buffer, index + contentBytes, tail, 0, trailing);
|
|
Debug.Log($"[Inventory] {tag}: trailing {trailing} byte(s) HEX=\n{BitConverter.ToString(tail)}");
|
|
}
|
|
}
|
|
|
|
public static void LogInventoryRaw(string tag, byte[] buffer)
|
|
{
|
|
Debug.Log($"[Inventory] {tag}: RAW HEX (len={buffer?.Length ?? 0})=\n{(buffer == null ? "<null>" : BitConverter.ToString(buffer))}");
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
|