feat: Speedup huffman, type descendancy checks and paired stats lookups

Author: ResurrectedTrader

src/D2SSharp/Data/TxtFileExternalData.cs

@@ -148,7 +148,8 @@ private static VersionData BuildVersionData(ItemStatCostEntry[] itemStatCost, It
             ItemStatCost = itemStatCost,
             ItemTypes = itemTypes,
             Items = items,
-            ItemCodeToIndex = BuildItemCodeIndex(items)
+            ItemCodeToIndex = BuildItemCodeIndex(items),
+            TypeDescendants = BuildTypeDescendants(itemTypes)
         };
     }
 
@@ -507,54 +508,86 @@ public ItemTypeInfo GetItemInfo(int itemIndex, uint saveVersion)
             hasVariableGfx = data.ItemTypes[typeIndex].VarInvGfx > 0;
         }
 
+        uint typeCode = typeIndex < data.ItemTypes.Length ? data.ItemTypes[typeIndex].Code : 0;
+
         return new ItemTypeInfo(
             CompactSave: item.CompactSave != 0,
             HasVariableGfx: hasVariableGfx,
-            IsArmor: IsTypeOrDescendant(data.ItemTypes, typeIndex, ItemTypeCodes.Armor),
-            IsWeapon: IsTypeOrDescendant(data.ItemTypes, typeIndex, ItemTypeCodes.Weapon),
-            IsGold: IsTypeOrDescendant(data.ItemTypes, typeIndex, ItemTypeCodes.Gold),
+            IsArmor: data.IsDescendant(ItemTypeCodes.Armor, typeCode),
+            IsWeapon: data.IsDescendant(ItemTypeCodes.Weapon, typeCode),
+            IsGold: data.IsDescendant(ItemTypeCodes.Gold, typeCode),
             IsStackable: item.Stackable != 0,
-            IsCharm: IsTypeOrDescendant(data.ItemTypes, typeIndex, ItemTypeCodes.Charm),
-            IsBodyPart: IsTypeOrDescendant(data.ItemTypes, typeIndex, ItemTypeCodes.BodyPart),
-            IsPlayerBodyPart: IsTypeOrDescendant(data.ItemTypes, typeIndex, ItemTypeCodes.PlayerBodyPart),
-            IsScrollOrBook: IsTypeOrDescendant(data.ItemTypes, typeIndex, ItemTypeCodes.Scroll) ||
-                            IsTypeOrDescendant(data.ItemTypes, typeIndex, ItemTypeCodes.Book),
+            IsCharm: data.IsDescendant(ItemTypeCodes.Charm, typeCode),
+            IsBodyPart: data.IsDescendant(ItemTypeCodes.BodyPart, typeCode),
+            IsPlayerBodyPart: data.IsDescendant(ItemTypeCodes.PlayerBodyPart, typeCode),
+            IsScrollOrBook: data.IsDescendant(ItemTypeCodes.Scroll, typeCode) ||
+                            data.IsDescendant(ItemTypeCodes.Book, typeCode),
             IsQuest: item.Quest != 0,
             QuestDiffCheck: item.QuestDiffCheck != 0
         );
     }
 
-    /// <summary>
-    /// Checks if the given type index is or descends from the target type code.
-    /// Traverses the equiv1/equiv2 parent chain.
-    /// </summary>
-    private static bool IsTypeOrDescendant(ItemTypeEntry[] itemTypes, int typeIndex, uint targetTypeCode)
+    private static Dictionary<uint, HashSet<uint>> BuildTypeDescendants(ItemTypeEntry[] itemTypes)
     {
-        // Use a visited set to prevent infinite loops
-        var visited = new HashSet<int>();
-        var stack = new Stack<int>();
-        stack.Push(typeIndex);
+        var children = new List<int>[itemTypes.Length];
+        for (int i = 0; i < itemTypes.Length; i++)
+        {
+            children[i] = [];
+        }
 
-        while (stack.Count > 0)
+        for (int i = 0; i < itemTypes.Length; i++)
         {
-            var current = stack.Pop();
-            if (current < 0 || current >= itemTypes.Length || !visited.Add(current))
-                continue;
+            ref readonly var itemType = ref itemTypes[i];
+            if (itemType.Equiv1 != 0 && itemType.Equiv1 != 0xFFFF)
+                children[itemType.Equiv1].Add(i);
+            if (itemType.Equiv2 != 0 && itemType.Equiv2 != 0xFFFF)
+                children[itemType.Equiv2].Add(i);
+        }
 
-            ref readonly var itemType = ref itemTypes[current];
+        var descendantsByIndex = new HashSet<uint>[itemTypes.Length];
 
-            // Check if this type matches the target
-            if (itemType.Code == targetTypeCode)
-                return true;
+        HashSet<uint> ComputeDescendants(int index)
+        {
+            var cached = descendantsByIndex[index];
+            if (cached != null)
+                return cached;
 
-            // Add parent types to check
-            if (itemType.Equiv1 != 0 && itemType.Equiv1 != 0xFFFF)
-                stack.Push(itemType.Equiv1);
-            if (itemType.Equiv2 != 0 && itemType.Equiv2 != 0xFFFF)
-                stack.Push(itemType.Equiv2);
+            var set = new HashSet<uint>();
+            uint code = itemTypes[index].Code;
+            if (code != 0)
+                set.Add(code);
+
+            foreach (int child in children[index])
+            {
+                uint childCode = itemTypes[child].Code;
+                if (childCode != 0)
+                    set.Add(childCode);
+                set.UnionWith(ComputeDescendants(child));
+            }
+
+            descendantsByIndex[index] = set;
+            return set;
         }
 
-        return false;
+        var result = new Dictionary<uint, HashSet<uint>>();
+        for (int i = 0; i < itemTypes.Length; i++)
+        {
+            uint code = itemTypes[i].Code;
+            if (code == 0)
+                continue;
+
+            var set = ComputeDescendants(i);
+            if (!result.TryGetValue(code, out var existing))
+            {
+                result[code] = set;
+            }
+            else
+            {
+                existing.UnionWith(set);
+            }
+        }
+
+        return result;
     }
 
     // Internal data structures
@@ -564,6 +597,14 @@ private class VersionData
         public required ItemTypeEntry[] ItemTypes { get; init; }
         public required ItemEntry[] Items { get; init; }
         public required Dictionary<uint, int> ItemCodeToIndex { get; init; }
+        public required Dictionary<uint, HashSet<uint>> TypeDescendants { get; init; }
+
+        public bool IsDescendant(uint targetTypeCode, uint typeCode)
+        {
+            return typeCode != 0 &&
+                   TypeDescendants.TryGetValue(targetTypeCode, out var set) &&
+                   set.Contains(typeCode);
+        }
     }
 
     private struct ItemStatCostEntry

src/D2SSharp/HuffmanEncoding.cs

@@ -53,17 +53,27 @@ private static readonly (char Symbol, uint Bits, int Length)[] Table =
     // Lookup table for encoding: indexed by character, returns (bits in LSB order, length)
     private static readonly (uint Bits, int Length)[] EncodeLookup;
 
+    // Lookup tables for decoding: indexed by code length, maps MSB-first code to symbol
+    private static readonly Dictionary<uint, char>[] DecodeLookup;
+
     // Maximum code length in the table
     private const int MaxCodeLength = 9;
 
     static HuffmanEncoding()
     {
         // Build encode lookup table (supports ASCII characters up to 127)
         EncodeLookup = new (uint Bits, int Length)[128];
+        DecodeLookup = new Dictionary<uint, char>[MaxCodeLength + 1];
+        for (int i = 0; i <= MaxCodeLength; i++)
+        {
+            DecodeLookup[i] = new Dictionary<uint, char>();
+        }
+
         foreach (var (symbol, bits, length) in Table)
         {
             // Reverse bits from MSB-first to LSB-first for writing
             EncodeLookup[symbol] = (ReverseBits(bits, length), length);
+            DecodeLookup[length][bits] = symbol;
         }
     }
 
@@ -124,18 +134,11 @@ public static uint Decode(ref BitReader reader)
                 code = (code << 1) | bit;
                 length++;
 
-                // Check if this code matches any entry
-                foreach (var (symbol, bits, len) in Table)
+                if (DecodeLookup[length].TryGetValue(code, out var symbol))
                 {
-                    if (len == length && bits == code)
-                    {
-                        decoded = symbol;
-                        break;
-                    }
-                }
-
-                if (decoded.HasValue)
+                    decoded = symbol;
                     break;
+                }
             }
 
             if (!decoded.HasValue)

src/D2SSharp/Model/Item.cs

@@ -788,6 +788,11 @@ private static void WriteStatList(ref BitWriter writer, List<Stat> stats, IExter
     {
         // Build a set of paired follower stats so we don't write them individually
         var writtenStats = new HashSet<StatId>();
+        var statMap = new Dictionary<StatId, Stat>(stats.Count);
+        foreach (var stat in stats)
+        {
+            statMap[stat.Id] = stat;
+        }
 
         foreach (var stat in stats)
         {
@@ -826,7 +831,7 @@ private static void WriteStatList(ref BitWriter writer, List<Stat> stats, IExter
             var pairedStatIds = stat.Id.GetPairedStats();
             foreach (StatId pairedStatId in pairedStatIds)
             {
-                var pairedStat = stats.Single(s => s.Id == pairedStatId);
+                statMap.TryGetValue(pairedStatId, out var pairedStat);
                 var pairedInfo = externalData.GetStatInfo(pairedStatId, saveVersion);
 
                 writtenStats.Add(pairedStatId);