refactor: improve NBT comparison logic and enhance armor slot mixin functionality

Author: YoannDev90

.gitignore

@@ -3,7 +3,7 @@
 .kotlin/
 .env
 compile_config.json
-clear_workflows.py
+scripts/*.py
 
 # gradle
 

src/main/kotlin/stackabletools/StackableToolsUtils.kt

@@ -12,12 +12,61 @@ import net.minecraft.registry.Registries
 import java.util.concurrent.ConcurrentHashMap
 import stackabletools.config.ConfigManager
 import stackabletools.config.StackingCategory
+import net.minecraft.nbt.NbtCompound
+import net.minecraft.item.Items
 
 object StackableToolsUtils {
 
     private val stackableCache = ConcurrentHashMap<String, Boolean>()
     private var lastConfigHash = 0
 
+    /**
+     * Compares two ItemStack NBT tags, ignoring cosmetic differences like custom names.
+     * Enchantments are compared as sets (order-insensitive).
+     */
+    private fun areNBTsEquivalent(nbt1: NbtCompound?, nbt2: NbtCompound?): Boolean {
+        // Both null = equivalent
+        if (nbt1 == null && nbt2 == null) return true
+        // One null, one not = not equivalent
+        if (nbt1 == null || nbt2 == null) return false
+        
+        // Extract enchantment lists
+        val enc1 = nbt1.getList("Enchantments", 10) // 10 = NbtElement.COMPOUND_TYPE
+        val enc2 = nbt2.getList("Enchantments", 10)
+        
+        // Compare enchantments as sets (order-insensitive)
+        if (enc1.size != enc2.size) return false
+        
+        val enc1Set = mutableSetOf<String>()
+        for (i in 0 until enc1.size) {
+            enc1Set.add(enc1.getCompound(i).toString())
+        }
+        
+        val enc2Set = mutableSetOf<String>()
+        for (i in 0 until enc2.size) {
+            enc2Set.add(enc2.getCompound(i).toString())
+        }
+        
+        if (enc1Set != enc2Set) return false
+        
+        // Check that there are no other conflicting NBT tags (ignore display/cosmetic ones)
+        val cosmetics = setOf("display", "HideFlags", "CustomModelData", "Damage")
+        
+        val relevantKeys1 = nbt1.keys.filter { it !in cosmetics }
+        val relevantKeys2 = nbt2.keys.filter { it !in cosmetics }
+        
+        if (relevantKeys1.toSet() != relevantKeys2.toSet()) return false
+        
+        // Compare non-cosmetic keys
+        for (key in relevantKeys1) {
+            val v1 = nbt1.get(key)?.toString()
+            val v2 = nbt2.get(key)?.toString()
+            if (v1 != v2) return false
+        }
+        
+        return true
+    }
+
     /**
      * Checks if two item stacks can be merged (same item, same durability, same NBT).
      * @param a First item stack.
@@ -36,9 +85,9 @@ object StackableToolsUtils {
         // For other items, check exact durability
         if (a.damage != b.damage) return false
 
-        // CRUCIAL RULE: Check that enchantments (NBT) are STRICTLY identical
-        // ItemStack.canCombine already checks for NBT equality (enchantments, custom names, etc.)
-        if (!ItemStack.canCombine(a, b)) return false
+        // Compare NBT tags: enchantments must match (order-insensitive), 
+        // but ignore cosmetic differences like custom names
+        if (!areNBTsEquivalent(a.nbt, b.nbt)) return false
 
         return true
     }

src/main/kotlin/stackabletools/mixin/ArmorSlotMixin.kt

@@ -2,24 +2,32 @@ package stackabletools.mixin
 
 import net.minecraft.item.ItemStack
 import net.minecraft.screen.slot.Slot
+import net.minecraft.screen.PlayerScreenHandler
 import org.spongepowered.asm.mixin.Mixin
 import org.spongepowered.asm.mixin.injection.At
 import org.spongepowered.asm.mixin.injection.Inject
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable
 
 /**
- * Mixin specifically targeting armor slots to ensure they never accept more than 1 item,
+ * Mixin targeting armor slots to ensure they never accept more than 1 item,
  * even if our mod makes the item stackable in the general inventory.
  */
-@Mixin(targets = ["net.minecraft.screen.PlayerScreenHandler$1"])
-abstract class ArmorSlotMixin : Slot(null, 0, 0, 0) {
+@Mixin(Slot::class)
+abstract class ArmorSlotMixin {
 
     /**
-     * Forces the maximum item count for the armor slots in PlayerScreenHandler to be 1.
+     * Forces the maximum item count for armor slots to be 1.
      * This prevents stacking items like Elytras or Armor pieces in the equipment slots.
      */
-    @Inject(method = ["getMaxItemCount(Lnet/minecraft/item/ItemStack;)I"], at = [At("HEAD")], cancellable = true)
+    @Inject(method = ["getMaxItemCount"], at = [At("HEAD")], cancellable = true)
     private fun onGetMaxItemCount(stack: ItemStack, cir: CallbackInfoReturnable<Int>) {
-        cir.returnValue = 1
+        val slot = this as Slot
+        
+        // Check if this is an armor slot (PlayerScreenHandler inner classes target armor/offhand)
+        // Armor slots are typically indices 5-8 in PlayerScreenHandler
+        if (slot.javaClass.name.contains("PlayerScreenHandler") && 
+            (slot.index in 5..8 || slot.javaClass.simpleName in listOf("OffhandSlot", "ArmorSlot"))) {
+            cir.returnValue = 1
+        }
     }
 }