Add Baritone integration for automatic mining (xpple#117)

xpple · web-flow · commit 77907b2a11fc · 2026-01-20T00:10:55.000+01:00
* Add Baritone integration for automatic mining

* Keep track of already mined blocks

* Add information about Baritone integration

* Also allow ore vein blocks to be automatically mined

* Stop automatically mining blocks when Baritone's #stop is executed

* Update README
diff --git a/README.md b/README.md
@@ -77,6 +77,9 @@ Usage: `/sm:source (run)|(as <entity>)|(positioned <position>)|(rotated <rotatio
 
 Executes a given command from a modified source. For example, modifying the source's position will execute the command as if you were in that position. This command is really powerful, use it!
 
+### Baritone integration
+If [Meteor's version of Baritone](https://maven.meteordev.org/#/snapshots/meteordevelopment/baritone) is present, the `AutoMine` config will be visible. When set to true, certain blocks highlighted by `/sm:highlight` will be automatically mined. You can stop Baritone by executing `#stop` as usual. Make sure `#allowBreak` is set to true in Baritone's configs, otherwise Baritone will get stuck forever and no blocks will be mined.
+
 ## Building from source
 This mod internally uses (a fork of) the C library [cubiomes](https://github.com/Cubitect/cubiomes) by Cubitect. Java bindings for this library were created with (also a fork of) [jextract](https://github.com/openjdk/jextract). The bindings use the [Foreign Function & Memory API](https://openjdk.org/jeps/454) from [Project Panama](https://openjdk.org/projects/panama/). See [CreateJavaBindingsTask.java](https://github.com/xpple/SeedMapper/blob/master/buildSrc/src/main/java/dev/xpple/seedmapper/buildscript/CreateJavaBindingsTask.java) for the Gradle task that automates this.
 
diff --git a/build.gradle b/build.gradle
@@ -31,6 +31,10 @@ repositories {
 		name = 'DJtheRedstoner'
 		url = 'https://pkgs.dev.azure.com/djtheredstoner/DevAuth/_packaging/public/maven/v1'
 	}
+	maven {
+		name = 'MeteorDevelopment'
+		url = 'https://maven.meteordev.org/snapshots'
+	}
 }
 
 dependencies {
@@ -57,6 +61,8 @@ dependencies {
 		exclude group: 'net.fabricmc', module: 'fabric-loader'
 	}
 
+	modCompileOnly "meteordevelopment:baritone:${project.baritone_version}"
+
 	testImplementation platform("org.junit:junit-bom:${project.junit_version}")
 	testImplementation 'org.junit.jupiter:junit-jupiter'
 	testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
diff --git a/gradle.properties b/gradle.properties
@@ -24,6 +24,9 @@ betterconfig_version=2.5.0
 clientarguments_version=1.11.6
 simplewaypoints_version=1.2.0
 
+# Optional library dependencies
+baritone_version=1.21.11-SNAPSHOT
+
 devauth_version=1.2.2
 
 # Test dependencies
diff --git a/src/main/java/dev/xpple/seedmapper/MixinConfigPlugin.java b/src/main/java/dev/xpple/seedmapper/MixinConfigPlugin.java
@@ -0,0 +1,50 @@
+package dev.xpple.seedmapper;
+
+import org.objectweb.asm.tree.ClassNode;
+import org.spongepowered.asm.mixin.extensibility.IMixinConfigPlugin;
+import org.spongepowered.asm.mixin.extensibility.IMixinInfo;
+
+import java.util.List;
+import java.util.Set;
+
+public class MixinConfigPlugin implements IMixinConfigPlugin {
+
+    private static final Set<String> BARITONE_MIXINS = Set.of(
+        "dev.xpple.seedmapper.mixin.baritone.CustomGoalProcessMixin",
+        "dev.xpple.seedmapper.mixin.baritone.PathingBehaviorMixin"
+    );
+
+    @Override
+    public void onLoad(String mixinPackage) {
+    }
+
+    @Override
+    public String getRefMapperConfig() {
+        return null;
+    }
+
+    @Override
+    public boolean shouldApplyMixin(String targetClassName, String mixinClassName) {
+        if (BARITONE_MIXINS.contains(mixinClassName)) {
+            return SeedMapper.BARITONE_AVAILABLE;
+        }
+        return true;
+    }
+
+    @Override
+    public void acceptTargets(Set<String> myTargets, Set<String> otherTargets) {
+    }
+
+    @Override
+    public List<String> getMixins() {
+        return null;
+    }
+
+    @Override
+    public void preApply(String targetClassName, ClassNode targetClass, String mixinClassName, IMixinInfo mixinInfo) {
+    }
+
+    @Override
+    public void postApply(String targetClassName, ClassNode targetClass, String mixinClassName, IMixinInfo mixinInfo) {
+    }
+}
diff --git a/src/main/java/dev/xpple/seedmapper/SeedMapper.java b/src/main/java/dev/xpple/seedmapper/SeedMapper.java
@@ -2,6 +2,7 @@
 
 import com.mojang.blaze3d.platform.InputConstants;
 import com.mojang.brigadier.CommandDispatcher;
+import com.mojang.logging.LogUtils;
 import dev.xpple.betterconfig.api.ModConfigBuilder;
 import dev.xpple.seedmapper.command.arguments.DurationArgument;
 import dev.xpple.seedmapper.command.arguments.MapFeatureArgument;
@@ -40,6 +41,7 @@
 import net.minecraft.client.KeyMapping;
 import net.minecraft.commands.CommandBuildContext;
 import net.minecraft.resources.Identifier;
+import org.slf4j.Logger;
 
 import java.io.IOException;
 import java.nio.file.Files;
@@ -53,6 +55,10 @@ public class SeedMapper implements ClientModInitializer {
 
     public static final Path modConfigPath = FabricLoader.getInstance().getConfigDir().resolve(MOD_ID);
 
+    private static final Logger LOGGER = LogUtils.getLogger();
+
+    public static final boolean BARITONE_AVAILABLE = FabricLoader.getInstance().getModContainer("baritone-meteor").isPresent();
+
     static {
         String libraryName = System.mapLibraryName("cubiomes");
         ModContainer modContainer = FabricLoader.getInstance().getModContainer(MOD_ID).orElseThrow();
@@ -102,6 +108,11 @@ public void onInitializeClient() {
         ClientCommandRegistrationCallback.EVENT.register(SeedMapper::registerCommands);
         RenderManager.registerEvents();
         MinimapManager.registerHudElement();
+
+        if (BARITONE_AVAILABLE) {
+            LOGGER.info("Baritone detected, Baritone integration will be available!");
+            LOGGER.info("Set AutoMine to true to automatically mine certain blocks highlighted by `/sm:highlight`");
+        }
     }
 
     private static void registerCommands(CommandDispatcher<FabricClientCommandSource> dispatcher, CommandBuildContext context) {
diff --git a/src/main/java/dev/xpple/seedmapper/command/commands/HighlightCommand.java b/src/main/java/dev/xpple/seedmapper/command/commands/HighlightCommand.java
@@ -13,11 +13,13 @@
 import com.mojang.brigadier.CommandDispatcher;
 import com.mojang.brigadier.exceptions.CommandSyntaxException;
 import com.mojang.datafixers.util.Pair;
+import dev.xpple.seedmapper.SeedMapper;
 import dev.xpple.seedmapper.command.CommandExceptions;
 import dev.xpple.seedmapper.command.CustomClientCommandSource;
 import dev.xpple.seedmapper.config.Configs;
 import dev.xpple.seedmapper.feature.OreTypes;
 import dev.xpple.seedmapper.render.RenderManager;
+import dev.xpple.seedmapper.util.BaritoneIntegration;
 import dev.xpple.seedmapper.util.ComponentUtils;
 import dev.xpple.seedmapper.util.SeedIdentifier;
 import dev.xpple.seedmapper.util.SpiralLoop;
@@ -172,6 +174,9 @@ private static int highlightBlock(CustomClientCommandSource source, Pair<Integer
                 count[0] += blockOres.size();
                 source.getClient().schedule(() -> {
                     RenderManager.drawBoxes(blockOres, colour);
+                    if (SeedMapper.BARITONE_AVAILABLE && Configs.AutoMine) {
+                        BaritoneIntegration.addGoals(blockOres);
+                    }
                     source.sendFeedback(Component.translatable("command.highlight.block.chunkSuccess", accent(String.valueOf(blockOres.size())), ComponentUtils.formatXZ(chunkX, chunkZ)));
                 });
 
@@ -232,6 +237,9 @@ private static int highlightOreVein(CustomClientCommandSource source, int chunkR
                     count[0] += positions.size();
                     int colour = BLOCKS.values().stream().filter(pair -> Objects.equals(block, pair.getFirst())).findAny().orElseThrow().getSecond();
                     RenderManager.drawBoxes(positions, colour);
+                    if (SeedMapper.BARITONE_AVAILABLE && Configs.AutoMine) {
+                        BaritoneIntegration.addGoals(positions);
+                    }
                     if (block == Cubiomes.RAW_COPPER_BLOCK() || block == Cubiomes.RAW_IRON_BLOCK()) {
                         source.getClient().schedule(() -> source.sendFeedback(Component.translatable("command.highlight.oreVein.rawBlocks", ComponentUtils.formatXYZCollection(positions))));
                     }
diff --git a/src/main/java/dev/xpple/seedmapper/command/commands/LocateCommand.java b/src/main/java/dev/xpple/seedmapper/command/commands/LocateCommand.java
@@ -257,6 +257,7 @@ public static TwoDTree calculateStrongholds(long seed, int dimension, int versio
                 tree.insert(new BlockPos(Pos.x(pos), 0, Pos.z(pos)));
             }
         }
+        tree.balance();
         return tree;
     }
 
diff --git a/src/main/java/dev/xpple/seedmapper/config/Configs.java b/src/main/java/dev/xpple/seedmapper/config/Configs.java
@@ -9,10 +9,12 @@
 import dev.xpple.seedmapper.render.RenderManager;
 import dev.xpple.seedmapper.seedmap.MapFeature;
 import dev.xpple.seedmapper.seedmap.SeedMapScreen;
+import dev.xpple.seedmapper.util.BaritoneIntegration;
 import dev.xpple.seedmapper.util.ComponentUtils;
 import dev.xpple.seedmapper.util.SeedIdentifier;
 import net.minecraft.ChatFormatting;
 import net.minecraft.client.Minecraft;
+import net.minecraft.commands.SharedSuggestionProvider;
 import net.minecraft.network.chat.Component;
 import net.minecraft.util.Util;
 
@@ -140,4 +142,15 @@ private static Component getDevModeComment() {
     private static void updateHighlightDuration(Duration oldValue, Duration newValue) {
         RenderManager.rebuildLineSet();
     }
+
+    @Config(condition = "hasBaritoneAvailable", onChange = "updateBaritoneGoals")
+    public static boolean AutoMine = false;
+    private static boolean hasBaritoneAvailable(SharedSuggestionProvider source) {
+        return SeedMapper.BARITONE_AVAILABLE;
+    }
+    private static void updateBaritoneGoals(boolean oldValue, boolean newValue) {
+        if (!newValue) {
+            BaritoneIntegration.clearGoals();
+        }
+    }
 }
diff --git a/src/main/java/dev/xpple/seedmapper/mixin/ClientPacketListenerMixin.java b/src/main/java/dev/xpple/seedmapper/mixin/ClientPacketListenerMixin.java
@@ -1,8 +1,10 @@
 package dev.xpple.seedmapper.mixin;
 
+import dev.xpple.seedmapper.SeedMapper;
 import dev.xpple.seedmapper.command.CustomClientCommandSource;
 import dev.xpple.seedmapper.render.RenderManager;
 import dev.xpple.seedmapper.seedmap.MinimapManager;
+import dev.xpple.seedmapper.util.BaritoneIntegration;
 import net.minecraft.client.multiplayer.ClientPacketListener;
 import net.minecraft.network.protocol.game.ClientboundLoginPacket;
 import net.minecraft.network.protocol.game.ClientboundRespawnPacket;
@@ -18,6 +20,10 @@ private void onHandleLogin(ClientboundLoginPacket packet, CallbackInfo ci) {
         RenderManager.clear();
 
         MinimapManager.hide();
+
+        if (SeedMapper.BARITONE_AVAILABLE) {
+            BaritoneIntegration.clearMinedBlocks();
+        }
     }
 
     @Inject(method = "handleRespawn", at = @At(value = "INVOKE", target = "Lnet/minecraft/network/protocol/PacketUtils;ensureRunningOnSameThread(Lnet/minecraft/network/protocol/Packet;Lnet/minecraft/network/PacketListener;Lnet/minecraft/network/PacketProcessor;)V", shift = At.Shift.AFTER))
@@ -26,5 +32,9 @@ private void onHandleRespawn(ClientboundRespawnPacket packet, CallbackInfo ci) {
 
         int dimension = CustomClientCommandSource.inferDimension(packet.commonPlayerSpawnInfo().dimensionType().value());
         MinimapManager.updateDimension(dimension);
+
+        if (SeedMapper.BARITONE_AVAILABLE) {
+            BaritoneIntegration.clearMinedBlocks();
+        }
     }
 }
diff --git a/src/main/java/dev/xpple/seedmapper/mixin/baritone/CustomGoalProcessMixin.java b/src/main/java/dev/xpple/seedmapper/mixin/baritone/CustomGoalProcessMixin.java
@@ -0,0 +1,31 @@
+package dev.xpple.seedmapper.mixin.baritone;
+
+import baritone.Baritone;
+import baritone.api.pathing.goals.Goal;
+import baritone.api.process.ICustomGoalProcess;
+import baritone.process.CustomGoalProcess;
+import baritone.utils.BaritoneProcessHelper;
+import dev.xpple.seedmapper.SeedMapper;
+import dev.xpple.seedmapper.config.Configs;
+import dev.xpple.seedmapper.util.BaritoneIntegration;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Mixin(value = CustomGoalProcess.class, remap = false)
+public abstract class CustomGoalProcessMixin extends BaritoneProcessHelper implements ICustomGoalProcess {
+    @Shadow private Goal a;
+
+    public CustomGoalProcessMixin(Baritone baritone) {
+        super(baritone);
+    }
+
+    @Inject(method = "onLostControl", at = @At("HEAD"), remap = false)
+    private void onFinished(CallbackInfo ci) {
+        if (SeedMapper.BARITONE_AVAILABLE && Configs.AutoMine) {
+            BaritoneIntegration.onGoalCompletion(this.a);
+        }
+    }
+}
diff --git a/src/main/java/dev/xpple/seedmapper/mixin/baritone/PathingBehaviorMixin.java b/src/main/java/dev/xpple/seedmapper/mixin/baritone/PathingBehaviorMixin.java
@@ -0,0 +1,16 @@
+package dev.xpple.seedmapper.mixin.baritone;
+
+import baritone.behavior.PathingBehavior;
+import dev.xpple.seedmapper.util.BaritoneIntegration;
+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(value = PathingBehavior.class, remap = false)
+public class PathingBehaviorMixin {
+    @Inject(method = "cancelEverything", at = @At("HEAD"), remap = false)
+    private void onCancelEverything(CallbackInfoReturnable<Boolean> cir) {
+        BaritoneIntegration.clearGoals();
+    }
+}
diff --git a/src/main/java/dev/xpple/seedmapper/util/BaritoneIntegration.java b/src/main/java/dev/xpple/seedmapper/util/BaritoneIntegration.java
@@ -0,0 +1,86 @@
+package dev.xpple.seedmapper.util;
+
+import baritone.api.BaritoneAPI;
+import baritone.api.pathing.goals.Goal;
+import baritone.api.pathing.goals.GoalBlock;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.player.LocalPlayer;
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.phys.Vec3;
+import org.jspecify.annotations.Nullable;
+
+import java.util.Comparator;
+import java.util.List;
+import java.util.concurrent.ConcurrentHashMap;
+
+/*
+ * This class should NOT be loaded if Baritone is not available.
+ */
+public class BaritoneIntegration {
+    /*
+     * There probably exists a more efficient data structure, but I couldn't find one that really appealed to me.
+     * Basically, you want a data structure that implements fast nearest-neighbour searches with popping (i.e. find the
+     * closest block to a given input block and remove it). Particularly the removing aspect is limiting, and for
+     * instance rules out 3D-trees. I figured for a not too large number of blocks, a hash set suffices.
+     */
+    private static final ConcurrentHashMap.KeySetView<BlockPos, ?> targetBlocks = ConcurrentHashMap.newKeySet();
+    private static @Nullable GoalBlock currentGoal = null;
+    private static final Object CURRENT_GOAL_LOCK = new Object();
+
+    private static final ConcurrentHashMap.KeySetView<BlockPos, ?> minedBlocks = ConcurrentHashMap.newKeySet();
+
+    public static void addGoals(List<BlockPos> blocks) {
+        blocks.stream()
+            .filter(v -> !minedBlocks.contains(v))
+            .forEach(targetBlocks::add);
+
+        synchronized (CURRENT_GOAL_LOCK) {
+            if (currentGoal == null) {
+                setGoalForNextBlock();
+            }
+        }
+    }
+
+    public static void onGoalCompletion(Goal goal) {
+        if (currentGoal == null) {
+            return;
+        }
+
+        // check goal equality by reference, this makes sure it was the goal from SeedMapper that was completed
+        synchronized (CURRENT_GOAL_LOCK) {
+            if (goal == currentGoal) {
+                minedBlocks.add(currentGoal.getGoalPos());
+                setGoalForNextBlock();
+            }
+        }
+    }
+
+    private static void setGoalForNextBlock() {
+        if (targetBlocks.isEmpty()) {
+            currentGoal = null;
+            return;
+        }
+        LocalPlayer player = Minecraft.getInstance().player;
+        if (player == null) {
+            return;
+        }
+        Vec3 playerPos = player.position();
+        BlockPos closest = targetBlocks.stream().min(Comparator.comparingDouble(b -> b.distToLowCornerSqr(playerPos.x, playerPos.y, playerPos.z))).orElseThrow();
+        targetBlocks.remove(closest);
+        currentGoal = new GoalBlock(closest);
+        // delay configuring the goal until the next tick, otherwise the new goal won't be executed
+        Minecraft.getInstance().schedule(() -> BaritoneAPI.getProvider().getPrimaryBaritone().getCustomGoalProcess().setGoalAndPath(currentGoal));
+    }
+
+    public static void clearGoals() {
+        targetBlocks.clear();
+        synchronized (CURRENT_GOAL_LOCK) {
+            currentGoal = null;
+        }
+        BaritoneAPI.getProvider().getPrimaryBaritone().getCustomGoalProcess().setGoal(null);
+    }
+
+    public static void clearMinedBlocks() {
+        minedBlocks.clear();
+    }
+}
diff --git a/src/main/java/dev/xpple/seedmapper/util/TwoDTree.java b/src/main/java/dev/xpple/seedmapper/util/TwoDTree.java
diff --git a/src/main/resources/mixins.seedmapper.json b/src/main/resources/mixins.seedmapper.json

Original file line number	Diff line number	Diff line change
`@@ -31,6 +31,10 @@ repositories {`
`31`	`31`	`name = 'DJtheRedstoner'`
`32`	`32`	`url = 'https://pkgs.dev.azure.com/djtheredstoner/DevAuth/_packaging/public/maven/v1'`
`33`	`33`	`}`
	`34`	`+ maven {`
	`35`	`+ name = 'MeteorDevelopment'`
	`36`	`+ url = 'https://maven.meteordev.org/snapshots'`
	`37`	`+ }`
`34`	`38`	`}`
`35`	`39`
`36`	`40`	`dependencies {`
`@@ -57,6 +61,8 @@ dependencies {`
`57`	`61`	`exclude group: 'net.fabricmc', module: 'fabric-loader'`
`58`	`62`	`}`
`59`	`63`
	`64`	`+ modCompileOnly "meteordevelopment:baritone:${project.baritone_version}"`
	`65`	`+`
`60`	`66`	`testImplementation platform("org.junit:junit-bom:${project.junit_version}")`
`61`	`67`	`testImplementation 'org.junit.jupiter:junit-jupiter'`
`62`	`68`	`testRuntimeOnly 'org.junit.platform:junit-platform-launcher'`
Original file line number	Diff line number	Diff line change
`@@ -257,6 +257,7 @@ public static TwoDTree calculateStrongholds(long seed, int dimension, int versio`
`257`	`257`	`tree.insert(new BlockPos(Pos.x(pos), 0, Pos.z(pos)));`
`258`	`258`	`}`
`259`	`259`	`}`
	`260`	`+ tree.balance();`
`260`	`261`	`return tree;`
`261`	`262`	`}`
`262`	`263`