Baritone goal waypoint sync and right click action to path to goal

build.gradle

@@ -52,6 +52,7 @@ dependencies {
 	modImplementation "maven.modrinth:xaeros-minimap:23.5.0_Fabric_1.20"
 	modImplementation "maven.modrinth:open-parties-and-claims:fabric-1.20-0.17.5"
 	modImplementation "maven.modrinth:forge-config-api-port:v8.0.0-1.20.1-Fabric"
+	modImplementation files("libs/baritone-api-fabric-1.10.1.jar")
 }
 
 processResources {

src/main/java/xaeroplus/mixin/client/MixinGuiMap.java

@@ -1,5 +1,7 @@
 package xaeroplus.mixin.client;
 
+import baritone.api.BaritoneAPI;
+import baritone.api.pathing.goals.GoalXZ;
 import com.mojang.blaze3d.platform.GlStateManager;
 import com.mojang.blaze3d.systems.RenderSystem;
 import net.minecraft.client.MinecraftClient;
@@ -48,6 +50,7 @@
 import xaero.map.graphics.shader.MapShaders;
 import xaero.map.gui.*;
 import xaero.map.gui.dropdown.rightclick.GuiRightClickMenu;
+import xaero.map.gui.dropdown.rightclick.RightClickOption;
 import xaero.map.misc.Misc;
 import xaero.map.misc.OptimizedMath;
 import xaero.map.mods.SupportMods;
@@ -1917,6 +1920,25 @@ public void onInputPress(final int code, final int scanCode, final int modifiers
         }
     }
 
+    @Inject(method = "getRightClickOptions", at = @At(value = "RETURN"), remap = false)
+    public void getRightClickOptionsInject(final CallbackInfoReturnable<ArrayList<RightClickOption>> cir) {
+        if (BaritoneHelper.isBaritonePresent()) {
+            final ArrayList<RightClickOption> options = cir.getReturnValue();
+            options.add(new RightClickOption("Baritone Goal Here", options.size(), this) {
+                @Override
+                public void onAction(Screen screen) {
+                    BaritoneAPI.getProvider().getPrimaryBaritone().getCustomGoalProcess().setGoal(new GoalXZ(rightClickX, rightClickZ));
+                }
+            });
+            options.add(new RightClickOption("Baritone Path Here", options.size(), this) {
+                @Override
+                public void onAction(Screen screen) {
+                    BaritoneAPI.getProvider().getPrimaryBaritone().getCustomGoalProcess().setGoalAndPath(new GoalXZ(rightClickX, rightClickZ));
+                }
+            });
+        }
+    }
+
     public void addColoredLineToExistingBuffer(
             MatrixStack.Entry matrices, VertexConsumer vertexBuffer, float x1, float y1, float x2, float y2, float r, float g, float b, float a
     ) {

src/main/java/xaeroplus/module/impl/BaritoneGoalSync.java

@@ -0,0 +1,91 @@
+package xaeroplus.module.impl;
+
+import baritone.api.BaritoneAPI;
+import baritone.api.pathing.goals.Goal;
+import baritone.api.pathing.goals.GoalXZ;
+import baritone.api.utils.interfaces.IGoalRenderPos;
+import com.collarmc.pounce.Subscribe;
+import net.minecraft.util.math.BlockPos;
+import xaero.common.XaeroMinimapSession;
+import xaero.common.minimap.waypoints.Waypoint;
+import xaero.common.minimap.waypoints.WaypointSet;
+import xaero.common.minimap.waypoints.WaypointsManager;
+import xaero.common.misc.OptimizedMath;
+import xaero.map.mods.SupportMods;
+import xaeroplus.event.ClientTickEvent;
+import xaeroplus.module.Module;
+import xaeroplus.util.BaritoneHelper;
+
+import java.util.List;
+import java.util.Optional;
+
+@Module.ModuleInfo()
+public class BaritoneGoalSync extends Module {
+
+    @Subscribe
+    public void onClientTickEvent(final ClientTickEvent.Post event) {
+        if (!BaritoneHelper.isBaritonePresent()) return;
+        XaeroMinimapSession minimapSession = XaeroMinimapSession.getCurrentSession();
+        if (minimapSession == null) return;
+        final WaypointsManager waypointsManager = minimapSession.getWaypointsManager();
+        WaypointSet waypointSet = waypointsManager.getWaypoints();
+        if (waypointSet == null) return;
+        final List<Waypoint> waypoints = waypointSet.getList();
+        Optional<Waypoint> baritoneGoalWaypoint = waypoints.stream()
+                .filter(waypoint -> waypoint.getName().equals("Baritone Goal"))
+                .findFirst();
+        final Goal goal = BaritoneAPI.getProvider().getPrimaryBaritone().getCustomGoalProcess().getGoal();
+        if (goal == null) {
+            baritoneGoalWaypoint.ifPresent(waypoint -> removeBaritoneGoalWaypoint(waypoints, waypoint));
+            return;
+        }
+        final BlockPos baritoneGoalBlockPos = getBaritoneGoalBlockPos(goal);
+        if (baritoneGoalBlockPos == null) {
+            baritoneGoalWaypoint.ifPresent(waypoint -> removeBaritoneGoalWaypoint(waypoints, waypoint));
+            return;
+        };
+        final double dimDiv = waypointsManager.getDimensionDivision(waypointsManager.getCurrentContainerID());
+        final int x = OptimizedMath.myFloor(baritoneGoalBlockPos.getX() * dimDiv);
+        final int z = OptimizedMath.myFloor(baritoneGoalBlockPos.getZ() * dimDiv);
+        if (baritoneGoalWaypoint.isPresent()) {
+            final Waypoint waypoint = baritoneGoalWaypoint.get();
+            if (waypoint.getX() != x ||
+                    waypoint.getY() != baritoneGoalBlockPos.getY() ||
+                    waypoint.getZ() != z) {
+                waypoint.setX(x);
+                waypoint.setY(baritoneGoalBlockPos.getY());
+                waypoint.setZ(z);
+                SupportMods.xaeroMinimap.requestWaypointsRefresh();
+            }
+        } else {
+            final Waypoint waypoint = new Waypoint(
+                    x,
+                    baritoneGoalBlockPos.getY(),
+                    z,
+                    "Baritone Goal",
+                    "B",
+                    10, // green
+                    0,
+                    true);
+            waypoints.add(waypoint);
+            SupportMods.xaeroMinimap.requestWaypointsRefresh();
+        }
+
+    }
+
+    private void removeBaritoneGoalWaypoint(List<Waypoint> waypoints, Waypoint waypoint) {
+        if (waypoints.remove(waypoint)) {
+            SupportMods.xaeroMinimap.requestWaypointsRefresh();
+        }
+    }
+
+    private BlockPos getBaritoneGoalBlockPos(Goal goal) {
+        if (goal instanceof GoalXZ) {
+            return new BlockPos(((GoalXZ) goal).getX(), 64, ((GoalXZ) goal).getZ());
+        } else if (goal instanceof IGoalRenderPos) {
+            return ((IGoalRenderPos) goal).getGoalPos();
+        } else {
+            return null;
+        }
+    }
+}

src/main/java/xaeroplus/settings/XaeroPlusSettingRegistry.java

@@ -1,6 +1,7 @@
 package xaeroplus.settings;
 
 import xaeroplus.module.ModuleManager;
+import xaeroplus.module.impl.BaritoneGoalSync;
 import xaeroplus.module.impl.NewChunks;
 import xaeroplus.module.impl.PortalSkipDetection;
 import xaeroplus.util.ColorHelper;
@@ -32,6 +33,10 @@ public final class XaeroPlusSettingRegistry {
             "Fast Mapping must be enabled. \n " +
                     "Limits how many chunks can be written in a single cycle. Lower values improve FPS at high render distances.",
             50, SettingLocation.WORLD_MAP_MAIN);
+    public static final XaeroPlusBooleanSetting baritoneWaypointSyncSetting = XaeroPlusBooleanSetting.create("Baritone Goal Waypoint",
+             "Syncs Baritone goals as temporary waypoints.",
+             (b) -> ModuleManager.getModule(BaritoneGoalSync.class).setEnabled(b),
+             true, SettingLocation.WORLD_MAP_MAIN);
     public static final XaeroPlusBooleanSetting persistMapDimensionSwitchSetting = XaeroPlusBooleanSetting.create("Persist WM Dim Switch",
                     "If enabled, the dimension will not be switched back to current when the WorldMap GUI is closed.",
             false, SettingLocation.WORLD_MAP_MAIN);

src/main/java/xaeroplus/util/BaritoneHelper.java

@@ -0,0 +1,24 @@
+package xaeroplus.util;
+
+import baritone.api.BaritoneAPI;
+import xaeroplus.XaeroPlus;
+
+public class BaritoneHelper {
+    private static boolean isBaritonePresent = false;
+    private static boolean checked = false;
+
+    public static boolean isBaritonePresent() {
+        if (!checked) {
+            try {
+                Class.forName(BaritoneAPI.class.getName());
+                XaeroPlus.LOGGER.info("Found Baritone API. Enabling Baritone support.");
+                isBaritonePresent = true;
+            } catch (final Throwable e) {
+                XaeroPlus.LOGGER.info("Baritone API not found. Disabling Baritone support.");
+                isBaritonePresent = false;
+            }
+            checked = true;
+        }
+        return isBaritonePresent;
+    }
+}