feat: NBT Tag matching (1.21.1)

build.gradle

@@ -142,6 +142,12 @@ runs {
         jvmArguments '-XX:+IgnoreUnrecognizedVMOptions', '-XX:+AllowRedefinitionToAddDeleteMethods'
 
         modSource project.sourceSets.main
+
+        // JMESPath library for NBT filtering
+        dependencies {
+            runtime 'io.burt:jmespath-core:0.6.0'
+            runtime 'io.burt:jmespath-gson:0.6.0'
+        }
     }
 
     client {
@@ -267,6 +273,22 @@ dependencies {
     // http://www.gradle.org/docs/current/userguide/dependency_management.html
 
     antlr 'org.antlr:antlr4:4.13.1'
+
+    // JMESPath for NBT filtering - bundled via JarJar for distribution
+    jarJar(implementation('io.burt:jmespath-core:0.6.0')) {
+        version {
+            strictly '[0.6.0,0.7.0)'
+        }
+    }
+    jarJar(implementation('io.burt:jmespath-gson:0.6.0')) {
+        version {
+            strictly '[0.6.0,0.7.0)'
+        }
+    }
+    // Add to runtime classpath for development (runClient, runGameTestServer, etc.)
+    runtimeOnly 'io.burt:jmespath-core:0.6.0'
+    runtimeOnly 'io.burt:jmespath-gson:0.6.0'
+
     testImplementation 'com.github.javaparser:javaparser-symbol-solver-core:3.26.4'
     testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.1'
     testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.1'
@@ -342,13 +364,24 @@ jar {
                 "Specification-Vendor"    : mod_authors,
                 "Specification-Version"   : "1", // We are version 1 of ourselves
                 "Implementation-Title"    : project.name,
-                "Implementation-Version"  : project.jar.archiveVersion,
+                "Implementation-Version"  : mod_version,
                 "Implementation-Vendor"   : mod_authors,
                 "Implementation-Timestamp": new Date().format("yyyy-MM-dd'T'HH:mm:ssZ")
         ])
     }
 }
 
+// Enable jarJar for bundling JMESPath library
+jarJar.enable()
+
+// Use jarJar as the main output (remove -all suffix)
+tasks.named('jarJar') {
+    archiveClassifier = ''
+}
+tasks.named('jar') {
+    archiveClassifier = 'slim'
+}
+
 // Example configuration to allow publishing using the maven-publish plugin
 publishing {
     publications {

src/gametest/java/ca/teamdman/sfm/gametest/tests/compat/mekanism/MekBinNbtCountFilterGameTest.java

@@ -0,0 +1,81 @@
+package ca.teamdman.sfm.gametest.tests.compat.mekanism;
+
+import ca.teamdman.sfm.common.blockentity.ManagerBlockEntity;
+import ca.teamdman.sfm.common.label.LabelPositionHolder;
+import ca.teamdman.sfm.common.registry.SFMBlocks;
+import ca.teamdman.sfm.common.registry.SFMItems;
+import ca.teamdman.sfm.gametest.SFMGameTest;
+import ca.teamdman.sfm.gametest.SFMGameTestDefinition;
+import ca.teamdman.sfm.gametest.SFMGameTestHelper;
+import mekanism.common.registries.MekanismBlocks;
+import mekanism.common.tile.TileEntityBin;
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.Items;
+
+import static ca.teamdman.sfm.gametest.SFMGameTestMethodHelpers.assertTrue;
+
+/**
+ * Tests that NBT count filtering works correctly with stack sizes greater than 99.
+ * Uses Mekanism bins which can hold oversized stacks.
+ * This tests for issues with ItemStack.save() where count might have serialization issues.
+ */
+@SuppressWarnings({
+        "RedundantSuppression",
+        "DataFlowIssue",
+        "OptionalGetWithoutIsPresent",
+        "DuplicatedCode",
+        "ArraysAsListWithZeroOrOneArgument"
+})
+@SFMGameTest
+public class MekBinNbtCountFilterGameTest extends SFMGameTestDefinition {
+
+    @Override
+    public String template() {
+        return "3x2x1";
+    }
+
+    @Override
+    public void run(SFMGameTestHelper helper) {
+        // designate positions
+        var leftPos = new BlockPos(2, 2, 0);
+        var rightPos = new BlockPos(0, 2, 0);
+        var managerPos = new BlockPos(1, 2, 0);
+
+        // set up the world
+        helper.setBlock(leftPos, MekanismBlocks.ULTIMATE_BIN.getBlock());
+        var left = ((TileEntityBin) helper.getBlockEntity(leftPos));
+        helper.setBlock(rightPos, MekanismBlocks.ULTIMATE_BIN.getBlock());
+        var right = ((TileEntityBin) helper.getBlockEntity(rightPos));
+        helper.setBlock(managerPos, SFMBlocks.MANAGER_BLOCK.get());
+        var manager = ((ManagerBlockEntity) helper.getBlockEntity(managerPos));
+
+        // set up the program - only move items with count > 32
+        // Note: Even though the bin contains 128 items, SFM queries return ItemStacks
+        // capped at maxStackSize (64), so we test with count > 32 to verify NBT filtering works
+        manager.setItem(0, new ItemStack(SFMItems.DISK_ITEM.get()));
+        manager.setProgram("""
+                EVERY 20 TICKS DO
+                    INPUT WITH NBT count > 32 FROM a NORTH SIDE
+                    OUTPUT TO b TOP SIDE
+                END
+                """.stripIndent());
+
+        // set the labels
+        LabelPositionHolder.empty()
+                .add("a", helper.absolutePos(leftPos))
+                .add("b", helper.absolutePos(rightPos))
+                .save(manager.getDisk());
+
+        // Put 128 diamonds in the left bin
+        // SFM will see stacks of 64 (maxStackSize), which is > 32, so they should be moved
+        left.getBinSlot().setStack(new ItemStack(Items.DIAMOND, 128));
+
+        helper.succeedIfManagerDidThingWithoutLagging(manager, () -> {
+            // 64 diamonds should have moved (one maxStackSize worth)
+            assertTrue(left.getBinSlot().getCount() == 128 - 64, "Left bin should have 64 remaining (128 - 64 transferred)");
+            assertTrue(right.getBinSlot().getCount() == 64, "Right bin should have 64 diamonds");
+            assertTrue(right.getBinSlot().getStack().getItem() == Items.DIAMOND, "Right bin should contain diamonds");
+        });
+    }
+}

src/gametest/java/ca/teamdman/sfm/gametest/tests/nbt_filtering/NbtFilterCombinedWithTagGameTest.java

@@ -0,0 +1,62 @@
+package ca.teamdman.sfm.gametest.tests.nbt_filtering;
+
+import ca.teamdman.sfm.gametest.LeftRightManagerTest;
+import ca.teamdman.sfm.gametest.SFMGameTest;
+import ca.teamdman.sfm.gametest.SFMGameTestDefinition;
+import ca.teamdman.sfm.gametest.SFMGameTestHelper;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.Items;
+import net.minecraft.world.item.enchantment.Enchantments;
+
+import java.util.Arrays;
+
+/**
+ * Tests combining NBT filtering with TAG filtering.
+ * Move only damaged swords (not other damaged items).
+ */
+@SFMGameTest
+public class NbtFilterCombinedWithTagGameTest extends SFMGameTestDefinition {
+    @Override
+    public String template() {
+        return "3x2x1";
+    }
+
+    @Override
+    public void run(SFMGameTestHelper helper) {
+        var test = new LeftRightManagerTest(helper);
+
+        // Create a damaged sword
+        ItemStack damagedSword = new ItemStack(Items.DIAMOND_SWORD);
+        damagedSword.setDamageValue(50);
+
+        // Create a damaged pickaxe
+        ItemStack damagedPickaxe = new ItemStack(Items.DIAMOND_PICKAXE);
+        damagedPickaxe.setDamageValue(50);
+
+        test.setProgram("""
+            EVERY 20 TICKS DO
+                -- Only move damaged items that are also swords (have the sword tag)
+                INPUT WITH NBT damage > 0 AND TAG minecraft:swords FROM left
+                OUTPUT TO right
+            END
+        """);
+
+        // Put both items in the left chest
+        test.preContents("left", Arrays.asList(
+                damagedSword,
+                damagedPickaxe
+        ));
+
+        // Only the damaged sword should move (matches both NBT and TAG filters)
+        // The damaged pickaxe stays because it doesn't have the sword tag
+        test.postContents("left", Arrays.asList(
+                ItemStack.EMPTY,
+                damagedPickaxe.copy()
+        ));
+        test.postContents("right", Arrays.asList(
+                damagedSword.copy()
+        ));
+
+        test.run();
+    }
+}

src/gametest/java/ca/teamdman/sfm/gametest/tests/nbt_filtering/NbtFilterDamagedItemsGameTest.java

@@ -0,0 +1,60 @@
+package ca.teamdman.sfm.gametest.tests.nbt_filtering;
+
+import ca.teamdman.sfm.gametest.LeftRightManagerTest;
+import ca.teamdman.sfm.gametest.SFMGameTest;
+import ca.teamdman.sfm.gametest.SFMGameTestDefinition;
+import ca.teamdman.sfm.gametest.SFMGameTestHelper;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.Items;
+
+import java.util.Arrays;
+import java.util.Collections;
+
+/**
+ * Tests that NBT filtering can move only damaged items (Damage > 0).
+ */
+@SFMGameTest
+public class NbtFilterDamagedItemsGameTest extends SFMGameTestDefinition {
+    @Override
+    public String template() {
+        return "3x2x1";
+    }
+
+    @Override
+    public void run(SFMGameTestHelper helper) {
+        var test = new LeftRightManagerTest(helper);
+
+        // Create a damaged sword (has Damage NBT)
+        ItemStack damagedSword = new ItemStack(Items.DIAMOND_SWORD);
+        damagedSword.setDamageValue(50);
+
+        // Create an undamaged sword (Damage = 0, but still has the tag)
+        ItemStack undamagedSword = new ItemStack(Items.DIAMOND_SWORD);
+
+        test.setProgram("""
+            EVERY 20 TICKS DO
+                -- Only move items with damage > 0
+                INPUT WITH NBT damage > 0 FROM left
+                OUTPUT TO right
+            END
+        """);
+
+        // Put both swords in the left chest
+        test.preContents("left", Arrays.asList(
+                damagedSword,
+                undamagedSword
+        ));
+
+        // Only the damaged sword should move to the right
+        // The undamaged sword stays in the left
+        test.postContents("left", Arrays.asList(
+                ItemStack.EMPTY,
+                undamagedSword.copy()
+        ));
+        test.postContents("right", Arrays.asList(
+                damagedSword.copy()
+        ));
+
+        test.run();
+    }
+}

src/gametest/java/ca/teamdman/sfm/gametest/tests/nbt_filtering/NbtFilterEnchantedItemsGameTest.java

@@ -0,0 +1,63 @@
+package ca.teamdman.sfm.gametest.tests.nbt_filtering;
+
+import ca.teamdman.sfm.common.enchantment.SFMEnchantmentCollection;
+import ca.teamdman.sfm.common.enchantment.SFMEnchantmentCollectionKind;
+import ca.teamdman.sfm.gametest.LeftRightManagerTest;
+import ca.teamdman.sfm.gametest.SFMGameTest;
+import ca.teamdman.sfm.gametest.SFMGameTestDefinition;
+import ca.teamdman.sfm.gametest.SFMGameTestHelper;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.Items;
+import net.minecraft.world.item.enchantment.Enchantments;
+
+import java.util.Arrays;
+
+/**
+ * Tests that NBT filtering can move only enchanted items.
+ */
+@SFMGameTest
+public class NbtFilterEnchantedItemsGameTest extends SFMGameTestDefinition {
+    @Override
+    public String template() {
+        return "3x2x1";
+    }
+
+    @Override
+    public void run(SFMGameTestHelper helper) {
+        var test = new LeftRightManagerTest(helper);
+
+        // Create an enchanted sword
+        ItemStack enchantedSword = new ItemStack(Items.DIAMOND_SWORD);
+        SFMEnchantmentCollection enchantments = new SFMEnchantmentCollection();
+        enchantments.add(helper.createEnchantmentEntry(Enchantments.SHARPNESS, 5));
+        enchantments.write(enchantedSword, SFMEnchantmentCollectionKind.EnchantedLikeATool);
+
+        // Create a plain sword (no enchantments)
+        ItemStack plainSword = new ItemStack(Items.DIAMOND_SWORD);
+
+        test.setProgram("""
+            EVERY 20 TICKS DO
+                -- Only move items with enchantments (enchantments array is non-empty)
+                INPUT WITH NBT enchantments[0] FROM left
+                OUTPUT TO right
+            END
+        """);
+
+        // Put both swords in the left chest
+        test.preContents("left", Arrays.asList(
+                enchantedSword,
+                plainSword
+        ));
+
+        // Only the enchanted sword should move to the right
+        test.postContents("left", Arrays.asList(
+                ItemStack.EMPTY,
+                plainSword.copy()
+        ));
+        test.postContents("right", Arrays.asList(
+                enchantedSword.copy()
+        ));
+
+        test.run();
+    }
+}