Official sandbox

gradle.properties

@@ -1,4 +1,4 @@
-plugin_version=0.3.0
+plugin_version=0.3.1
 plugin_name=OpenCraft
 plugin_id=opencraft
 mc=1.21.4

src/main/java/com/zenith/plugin/opencraft/automation/CardinalMovementService.java

@@ -1,7 +1,9 @@
 package com.zenith.plugin.opencraft.automation;
 
 import com.zenith.Proxy;
+import com.zenith.cache.data.entity.EntityPlayer;
 import com.zenith.feature.pathfinder.PathingRequestFuture;
+import com.zenith.feature.pathfinder.goals.GoalNear;
 import com.zenith.plugin.opencraft.auth.UserIdentity;
 import com.zenith.plugin.opencraft.discord.DiscordNotifier;
 import com.zenith.util.math.MathHelper;
@@ -15,6 +17,7 @@
 
 import static com.zenith.Globals.BARITONE;
 import static com.zenith.Globals.BOT;
+import static com.zenith.Globals.CACHE;
 import static com.zenith.Globals.EXECUTOR;
 
 public final class CardinalMovementService {
@@ -36,62 +39,196 @@ public String moveFromCurrent(final String requestId,
                                   final String direction,
                                   final int blocks) {
         ensureInGame();
-        if (blocks < 1 || blocks > 512) {
-            throw new IllegalArgumentException("Movement distance must be between 1 and 512 blocks.");
-        }
+        validateDistance(blocks);
 
         final DirectionOffset offset = normalize(direction);
         final int currentX = MathHelper.floorI(BOT.getX());
         final int currentZ = MathHelper.floorI(BOT.getZ());
         final int targetX = currentX + (offset.dx() * blocks);
         final int targetZ = currentZ + (offset.dz() * blocks);
 
-        final PathingRequestFuture future = BARITONE.pathTo(targetX, targetZ);
-        if (!future.isAccepted()) {
-            throw new IllegalStateException("Pathfinder rejected the directional movement request.");
-        }
-
-        watchMoveCompletion(requestId, identity, offset.label(), blocks, targetX, targetZ);
+        pathTo(requestId, identity, "directional move", targetX, targetZ);
 
         logger.info("[OpenCraft] Started directional move {} {} blocks from ({}, {}) to ({}, {})",
             offset.label(), blocks, currentX, currentZ, targetX, targetZ);
         return "Moving " + blocks + " block(s) " + offset.label()
             + " from the current position to (" + targetX + ", " + targetZ + ").";
     }
 
+    public String moveThisWay(final String requestId,
+                              final UserIdentity identity,
+                              final int blocks) {
+        ensureInGame();
+        validateDistance(blocks);
+
+        final PathingRequestFuture future = BARITONE.thisWay(blocks);
+        if (!future.isAccepted()) {
+            throw new IllegalStateException("Pathfinder rejected the facing-direction movement request.");
+        }
+
+        watchMoveCompletion(requestId, identity, "facing direction", "Facing-direction move timed out.");
+
+        logger.info("[OpenCraft] Started facing-direction move {} blocks from ({}, {}) yaw={}",
+            blocks, MathHelper.floorI(BOT.getX()), MathHelper.floorI(BOT.getZ()), BOT.getYaw());
+        return "Moving " + blocks + " block(s) in the current facing direction.";
+    }
+
+    public String gotoXz(final String requestId,
+                         final UserIdentity identity,
+                         final int x,
+                         final int z) {
+        ensureInGame();
+        pathTo(requestId, identity, "navigation", x, z);
+        logger.info("[OpenCraft] Started navigation to ({}, {})", x, z);
+        return "Navigating to x=" + x + ", z=" + z + ".";
+    }
+
+    public String gotoXyz(final String requestId,
+                          final UserIdentity identity,
+                          final int x,
+                          final int y,
+                          final int z) {
+        ensureInGame();
+        final PathingRequestFuture future = BARITONE.pathTo(x, y, z);
+        if (!future.isAccepted()) {
+            throw new IllegalStateException("Pathfinder rejected the exact-coordinate navigation request.");
+        }
+        watchMoveCompletion(requestId, identity, "exact coordinate", "Exact-coordinate navigation timed out.");
+        logger.info("[OpenCraft] Started navigation to ({}, {}, {})", x, y, z);
+        return "Navigating to x=" + x + ", y=" + y + ", z=" + z + ".";
+    }
+
+    public String near(final String requestId,
+                       final UserIdentity identity,
+                       final int x,
+                       final int y,
+                       final int z,
+                       final int rangeSq) {
+        ensureInGame();
+        if (rangeSq < 1 || rangeSq > 262144) {
+            throw new IllegalArgumentException("Near rangeSq must be between 1 and 262144.");
+        }
+        final PathingRequestFuture future = BARITONE.pathTo(new GoalNear(x, y, z, rangeSq));
+        if (!future.isAccepted()) {
+            throw new IllegalStateException("Pathfinder rejected the near-position navigation request.");
+        }
+        watchMoveCompletion(requestId, identity, "near-position", "Near-position navigation timed out.");
+        logger.info("[OpenCraft] Started navigation near ({}, {}, {}) rangeSq={}", x, y, z, rangeSq);
+        return "Navigating near x=" + x + ", y=" + y + ", z=" + z + ".";
+    }
+
+    public String followPlayer(final String requestId,
+                               final UserIdentity identity,
+                               final String playerName) {
+        ensureInGame();
+        final String safeName = validatePlayerName(playerName);
+        final EntityPlayer target = CACHE.getEntityCache().getPlayers().values().stream()
+            .filter(player -> player.getUuid() != null)
+            .filter(player -> CACHE.getTabListCache()
+                .get(player.getUuid())
+                .filter(entry -> entry.getName().equalsIgnoreCase(safeName))
+                .isPresent())
+            .findFirst()
+            .orElseThrow(() -> new IllegalArgumentException("Player '" + safeName + "' is not currently visible."));
+
+        BARITONE.follow(target);
+
+        discordNotifier.notifyMilestone(requestId, identity, "pathfinder",
+            "Started following " + safeName + ".");
+        logger.info("[OpenCraft] Started following player {} ({})", safeName, target.getUuid());
+        return "Following " + safeName + ".";
+    }
+
+    public String pickup(final String requestId,
+                         final UserIdentity identity) {
+        ensureInGame();
+        BARITONE.pickup();
+        discordNotifier.notifyMilestone(requestId, identity, "pathfinder", "Started pickup pathing.");
+        logger.info("[OpenCraft] Started pickup pathing.");
+        return "Picking up nearby items.";
+    }
+
+    public String stop() {
+        BARITONE.stop();
+        return "Stopped pathfinder navigation.";
+    }
+
+    public String status() {
+        if (!Proxy.getInstance().isConnected()) {
+            return "Pathfinder unavailable: bot is disconnected.";
+        }
+        if (Proxy.getInstance().isInQueue()) {
+            return "Pathfinder unavailable: bot is in queue.";
+        }
+        if (!BARITONE.isActive()) {
+            return "Pathfinder is idle.";
+        }
+        final var goal = BARITONE.currentGoal();
+        return "Pathfinder is active" + (goal == null ? "." : ": " + goal + ".");
+    }
+
+    private void pathTo(final String requestId,
+                        final UserIdentity identity,
+                        final String label,
+                        final int targetX,
+                        final int targetZ) {
+        final PathingRequestFuture future = BARITONE.pathTo(targetX, targetZ);
+        if (!future.isAccepted()) {
+            throw new IllegalStateException("Pathfinder rejected the " + label + " request.");
+        }
+        watchMoveCompletion(requestId, identity, label, label + " timed out.");
+    }
+
     private void watchMoveCompletion(final String requestId,
                                      final UserIdentity identity,
-                                     final String directionLabel,
-                                     final int blocks,
-                                     final int targetX,
-                                     final int targetZ) {
+                                     final String moveLabel,
+                                     final String timeoutDetail) {
         final Instant deadline = Instant.now().plus(MOVE_TIMEOUT);
         final ScheduledFuture<?>[] pollRef = new ScheduledFuture<?>[1];
         pollRef[0] = EXECUTOR.scheduleAtFixedRate(() -> {
             try {
                 if (Instant.now().isAfter(deadline)) {
                     final ScheduledFuture<?> poll = pollRef[0];
                     if (poll != null) poll.cancel(false);
-                    discordNotifier.notifyMilestone(requestId, identity, "cardinal",
-                        "Directional move " + directionLabel + " " + blocks + " block(s) timed out.");
+                    discordNotifier.notifyMilestone(requestId, identity, "pathfinder",
+                        timeoutDetail);
                     return;
                 }
                 if (!BARITONE.isActive()) {
                     final ScheduledFuture<?> poll = pollRef[0];
                     if (poll != null) poll.cancel(false);
-                    discordNotifier.notifyMilestone(requestId, identity, "cardinal",
-                        "Finished moving " + directionLabel + " " + blocks
-                            + " block(s) — arrived near (" + targetX + ", " + targetZ + ").");
+                    discordNotifier.notifyMilestone(requestId, identity, "pathfinder",
+                        "Finished " + moveLabel + ".");
                 }
             } catch (final Exception e) {
                 final ScheduledFuture<?> poll = pollRef[0];
                 if (poll != null) poll.cancel(false);
-                discordNotifier.notifyMilestone(requestId, identity, "cardinal",
-                    "Directional move completion watcher failed: " + e.getMessage());
+                discordNotifier.notifyMilestone(requestId, identity, "pathfinder",
+                    "Pathfinder completion watcher failed: " + e.getMessage());
             }
         }, POLL_INTERVAL_SECONDS, POLL_INTERVAL_SECONDS, TimeUnit.SECONDS);
     }
 
+    private static void validateDistance(final int blocks) {
+        if (blocks < 1 || blocks > 512) {
+            throw new IllegalArgumentException("Movement distance must be between 1 and 512 blocks.");
+        }
+    }
+
+    private static String validatePlayerName(final String playerName) {
+        final String value = playerName == null ? "" : playerName.strip();
+        if (value.length() < 1 || value.length() > 16) {
+            throw new IllegalArgumentException("Player name must be between 1 and 16 characters.");
+        }
+        for (int i = 0; i < value.length(); i++) {
+            final char ch = value.charAt(i);
+            if (!(Character.isLetterOrDigit(ch) || ch == '_')) {
+                throw new IllegalArgumentException("Player name may only use letters, digits, or underscores.");
+            }
+        }
+        return value;
+    }
+
     static DirectionOffset normalize(final String rawDirection) {
         if (rawDirection == null) {
             throw new IllegalArgumentException("Direction is required.");

src/main/java/com/zenith/plugin/opencraft/intent/CommandExecutor.java

@@ -186,13 +186,55 @@ private String executeInternal(final String commandId,
                                    final UserIdentity identity,
                                    final String requestId) {
         return switch (commandId) {
+            case "pathfinder.status" ->
+                cardinalMovementService.status();
+            case "pathfinder.stop" ->
+                cardinalMovementService.stop();
+            case "pathfinder.goto.xz" ->
+                cardinalMovementService.gotoXz(
+                    requestId,
+                    identity,
+                    Integer.parseInt(args.get("x").strip()),
+                    Integer.parseInt(args.get("z").strip())
+                );
+            case "pathfinder.goto.xyz" ->
+                cardinalMovementService.gotoXyz(
+                    requestId,
+                    identity,
+                    Integer.parseInt(args.get("x").strip()),
+                    Integer.parseInt(args.get("y").strip()),
+                    Integer.parseInt(args.get("z").strip())
+                );
+            case "pathfinder.thisway" ->
+                cardinalMovementService.moveThisWay(
+                    requestId,
+                    identity,
+                    Integer.parseInt(args.get("blocks").strip())
+                );
             case "pathfinder.cardinal" ->
                 cardinalMovementService.moveFromCurrent(
                     requestId,
                     identity,
                     args.get("direction").strip(),
                     Integer.parseInt(args.get("blocks").strip())
                 );
+            case "pathfinder.near" ->
+                cardinalMovementService.near(
+                    requestId,
+                    identity,
+                    Integer.parseInt(args.get("x").strip()),
+                    Integer.parseInt(args.get("y").strip()),
+                    Integer.parseInt(args.get("z").strip()),
+                    Integer.parseInt(args.get("rangeSq").strip())
+                );
+            case "pathfinder.follow" ->
+                cardinalMovementService.followPlayer(
+                    requestId,
+                    identity,
+                    args.get("player").strip()
+                );
+            case "pathfinder.pickup" ->
+                cardinalMovementService.pickup(requestId, identity);
             case "patrol.once.current" ->
                 patrolService.patrolOnceCurrent(requestId, identity,
                     Integer.parseInt(args.get("radius").strip()));

src/main/java/com/zenith/plugin/opencraft/plan/BaselineOperations.java

@@ -16,35 +16,35 @@ public static List<CommandDefinition> definitions() {
             define(
                 "pathfinder.status",
                 "Check current pathfinder navigation status and active goal",
-                "pathfinder status",
+                "@internal:pathfinder.status",
                 "admin", "low", false,
                 Map.of()
             ),
             define(
                 "pathfinder.stop",
                 "Stop any active pathfinder navigation immediately",
-                "pathfinder stop",
+                "@internal:pathfinder.stop",
                 "admin", "low", false,
                 Map.of()
             ),
             define(
                 "pathfinder.goto.xz",
                 "Navigate to X,Z coordinates (Y determined automatically)",
-                "pathfinder goto {x} {z}",
+                "@internal:pathfinder.goto.xz {x} {z}",
                 "admin", "medium", false,
                 Map.of("x", "integer", "z", "integer")
             ),
             define(
                 "pathfinder.goto.xyz",
                 "Navigate to exact X,Y,Z coordinates",
-                "pathfinder goto {x} {y} {z}",
+                "@internal:pathfinder.goto.xyz {x} {y} {z}",
                 "admin", "medium", false,
                 Map.of("x", "integer", "y", "integer", "z", "integer")
             ),
             define(
                 "pathfinder.thisway",
                 "Move N blocks in the current facing direction",
-                "pathfinder thisway {blocks}",
+                "@internal:pathfinder.thisway {blocks}",
                 "admin", "medium", false,
                 Map.of("blocks", "integer")
             ),
@@ -58,21 +58,21 @@ public static List<CommandDefinition> definitions() {
             define(
                 "pathfinder.near",
                 "Navigate to anywhere within a radius of the target X,Y,Z position",
-                "pathfinder near {x} {y} {z} {rangeSq}",
+                "@internal:pathfinder.near {x} {y} {z} {rangeSq}",
                 "admin", "medium", false,
                 Map.of("x", "integer", "y", "integer", "z", "integer", "rangeSq", "integer")
             ),
             define(
                 "pathfinder.follow",
                 "Follow a player by name (stops when command is cancelled)",
-                "pathfinder follow {player}",
+                "@internal:pathfinder.follow {player}",
                 "admin", "medium", false,
                 Map.of("player", "string")
             ),
             define(
                 "pathfinder.pickup",
                 "Navigate toward and pick up all nearby items on the ground",
-                "pathfinder pickup",
+                "@internal:pathfinder.pickup",
                 "admin", "low", false,
                 Map.of()
             ),