Release Microbot 2.6.32: world-hop budget, camera settle, logout and console fixes

docs/AGENT_SERVER.md

@@ -492,6 +492,8 @@ When the client is on the login screen, the response includes `loginIndex` and `
   "loggedIn": true,
   "gameState": "LOGGED_IN",
   "loginAttemptActive": false,
+  "hopsAvailable": 372,
+  "nextHopInMs": 0,
   "loginDurationMs": 120000,
   "activeProfile": {
     "name": "player@email.com",
@@ -514,6 +516,8 @@ When the client is on the login screen, the response includes `loginIndex` and `
 
 `loginIndex` and `loginError` are only present when `gameState` is `LOGIN_SCREEN`. When logged in, these fields are omitted.
 
+`hopsAvailable` and `nextHopInMs` come from the world hop limiter (`HopBudget`). They are present whenever "Pace world hops" is enabled in the Microbot settings. `nextHopInMs` is how long `Microbot.hopToWorld` would wait right now, and is 0 while the allowance is above the login reserve.
+
 #### POST /login
 
 Triggers a login using the active profile. **Blocks by default** until the login succeeds or fails, returning a definitive result.

docs/ARCHITECTURE.md

@@ -31,6 +31,7 @@
 - `BlockingEventManager` uses exponential backoff when no events validate to reduce overhead; events are re-queued if execution fails.
 - Default Gradle `test` tasks are disabled in `runelite-client/build.gradle.kts`; use explicit tasks such as `:client:runUnitTests`, `:client:runTests`, `:client:runDebugTests`, `:client:runIntegrationTest`, or `:client:runClientThreadScanner`.
 - World hopping short-circuits if the player is interacting or already hopping; confirmation widget auto-click handled in `Microbot.hopToWorld`.
+- `Microbot.hopToWorld` paces hops against `HopBudget`, an estimate of Jagex's per-IP hop/login allowance (default 390 tokens, 93 regained per hour, 20 kept in reserve for logins). Every `HOPPING` and `LOGGING_IN` transition spends a token, including manual hops. When the allowance is down to the reserve, script threads wait for the next token, stop waiting if the player is logged out, and press a harmless key so a long wait doesn't trigger the idle logout. The client thread and Swing thread get `false` instead and only check this client's last known state, without touching the file. The state lives in `~/.runelite/microbot-hop-budget.properties`, keyed by SOCKS proxy host, port and a hash of the proxy username, so it survives restarts and is shared by every client on the same exit IP. Writes go to a temporary file that replaces the old one, with `microbot-hop-budget.properties.lock` held while reading and writing. A "Too many login attempts" lockout (login index 33) sets it to zero.
 
 ## References
 - Queryable API guide: `../runelite-client/src/main/java/net/runelite/client/plugins/microbot/api/QUERYABLE_API.md`

docs/entity-guides/README.md

@@ -21,6 +21,8 @@ Scene walk-click render validity and destination confirmation: [movement gotcha
 
 Route camera turns only for unreachable targets: [movement gotcha 23](movement.md#23-route-camera-turns-are-for-targets-the-scene-cannot-reach).
 
+Camera turns wait for the yaw to settle before returning: [movement gotcha 24](movement.md#24-a-camera-turn-is-finished-only-when-the-yaw-stops-changing).
+
 ## Format
 
 Each entity guide is a numbered list of gotchas. Each entry follows this structure:

docs/entity-guides/items.md

@@ -272,3 +272,10 @@ An ordinary logout can be a break or world hop, so it must keep normal AutoLogin
 **Pattern to follow:** The helper arms suppression before closing the bank and reports whether logout was observed or only requested. Uncompleted requests expire after 15 seconds using a monotonic clock, including when no game-state event occurs; observed terminal logouts do not expire. Ordinary `logout()` is unchanged; scripts that use it for terminal failure must explicitly adopt the new API.
 
 **Defensive check:** Run `AutoLoginSuppressionTest`, `AutoLoginPluginSupplyStopTest`, `ScriptStartedTest`, `TerminalSupplyLogoutTest`, and `InventorySetupSupplyLogoutTest`. Verify live that a shortage stays logged out and restarting a gameplay script permits login.
+
+
+## Terminal supply stops need observed logout
+
+An owning script can set `withMissingSupplyHandler` on its Inventory Setup loader to keep its scheduled loop alive while `TerminalLogoutPrompt` closes the bank and requests logout. Do not show a blocking shortage notification or cancel that loop until `LOGGED_OUT` is observed. The default loader policy stays unchanged when no handler is supplied; ordinary breaks and world hops do not arm terminal Auto Login suppression.
+
+The observed terminal state is `LOGIN_SCREEN`; loading, hopping, connection loss and login transitions are not successful logout. A terminal prompt requests Auto Login suppression once across its retries so an explicit script/Auto Login restart is not repeatedly re-blocked by the old prompt.

docs/entity-guides/movement.md

@@ -451,3 +451,33 @@ fallback click toward a nearer visible tile, the walker aligns toward the reques
 
 **Defensive check:** `RouteCameraPolicyTest` covers visible, hidden, aligned, recently
 failed, near, and throttled cases.
+
+## 24. A camera turn is finished only when the yaw stops changing
+
+Releasing the arrow key does not stop the camera. The yaw keeps easing for several client
+ticks, and any canvas point computed in that window belongs to a view that no longer exists.
+
+**Why this matters:** In a live probe at the Grand Exchange, the yaw kept changing for
+115–126 ms (7 client ticks) after `setAngle` released the key. It drifted another 12.6–17.6
+degrees, and the target object's canvas point moved 56–121 px. Door and transport
+interactions click right after `turnTo`, so they could land on a stale position.
+
+**Where this applies:** `Rs2Camera.setAngle`, `turnTo` and `adjustPitch` all go through
+`holdUntil`. After releasing the key, it waits with `sleepUntil` (600 ms cap) until yaw and
+pitch read the same on two samples taken on different client ticks. Each sample is read on
+the client thread. Callers should not add their own sleeps after `turnTo`.
+
+The settle check cannot tell our own coasting apart from anything else that moves the camera.
+While `NpcTracker` is steering the yaw with `setCameraYawTarget`, the QoL plugin's smooth camera
+tracking is on, or the user is dragging the camera, the yaw never holds still for two ticks
+and every turn waits the full 600 ms cap before returning. That is the bound working, not a
+hang; the view is still moving when the call returns, so a canvas point taken right after it
+can still be stale.
+
+If the client-thread read fails (thread interrupted or the client-thread timeout), `getYaw` and
+`getPitch` fall back to reading the camera directly instead of returning 0. A yaw of 0 is
+north and a pitch of 0 sends `adjustPitch` holding UP, so a fake 0 looked like a real angle.
+`adjustPitch` returns without pressing a key when the pitch is already at the target.
+
+**Defensive check:** `Rs2CameraSettleTest` simulates a camera that coasts after release. It
+also covers the timeout bound and the client-thread no-op.

gradle.properties

@@ -32,7 +32,7 @@ project.build.version=1.13.1
 runelite.injected-client.version=1.13.1
 
 glslang.path=
-microbot.version=2.6.31
+microbot.version=2.6.32
 microbot.commit.sha=nogit
 microbot.repo.url=http://138.201.81.246:8081/repository/microbot-snapshot/
 microbot.repo.username=

runelite-client/src/main/java/net/runelite/client/plugins/microbot/BlockingEventManager.java

@@ -59,6 +59,7 @@ public BlockingEventManager()
         blockingEvents.add(new BankJagexPopupEvent());
         blockingEvents.add(new PluginPauseEvent());
 		blockingEvents.add(new EnjoyRSChatboxEvent());
+		blockingEvents.add(new MembershipPromptEvent());
 		blockingEvents.add(new DisableWorldSwitcherConfirmationEvent());
 		blockingEvents.add(new HideRoofsEvent());
 

runelite-client/src/main/java/net/runelite/client/plugins/microbot/GameChatAppender.java

@@ -1,13 +1,16 @@
 package net.runelite.client.plugins.microbot;
 
 import ch.qos.logback.classic.Level;
+import ch.qos.logback.classic.LoggerContext;
 import ch.qos.logback.classic.PatternLayout;
 import ch.qos.logback.classic.spi.ILoggingEvent;
 import ch.qos.logback.core.AppenderBase;
 import ch.qos.logback.core.Context;
 import ch.qos.logback.core.filter.Filter;
 import ch.qos.logback.core.spi.FilterReply;
+import java.util.function.BooleanSupplier;
 import net.runelite.api.ChatMessageType;
+import net.runelite.client.util.ResetResistantAttachment;
 
 public class GameChatAppender extends AppenderBase<ILoggingEvent> {
     private final PatternLayout layout = new PatternLayout();
@@ -28,6 +31,15 @@ public GameChatAppender() {
         this("[%d{HH:mm:ss}] %msg%ex{0}%n"); // Default simple pattern
     }
 
+    public ResetResistantAttachment install(LoggerContext context, BooleanSupplier enabled) {
+        setContext(context);
+        Runnable startIfEnabled = () -> {
+            if (enabled.getAsBoolean()) start();
+        };
+        startIfEnabled.run();
+        return ResetResistantAttachment.attach(context, this, startIfEnabled);
+    }
+
     @Override
     public void setContext(Context context) {
         super.setContext(context);

runelite-client/src/main/java/net/runelite/client/plugins/microbot/Microbot.java

@@ -12,8 +12,10 @@
 import net.runelite.api.annotations.Component;
 import net.runelite.api.annotations.Varbit;
 import net.runelite.api.annotations.Varp;
+import net.runelite.api.coords.WorldPoint;
 import net.runelite.api.events.ItemContainerChanged;
 import net.runelite.api.gameval.InterfaceID;
+import net.runelite.api.gameval.VarClientID;
 import net.runelite.api.widgets.Widget;
 import net.runelite.api.widgets.WidgetModalMode;
 import net.runelite.client.Notifier;
@@ -42,10 +44,12 @@
 import net.runelite.client.plugins.microbot.util.inventory.Rs2ItemModel;
 import net.runelite.client.plugins.microbot.util.shop.Rs2Shop;
 import net.runelite.client.plugins.microbot.util.item.Rs2ItemManager;
+import net.runelite.client.plugins.microbot.util.keyboard.Rs2Keyboard;
 import net.runelite.client.plugins.microbot.util.math.Rs2Random;
 import net.runelite.client.plugins.microbot.util.menu.NewMenuEntry;
 import net.runelite.client.plugins.microbot.util.misc.Rs2UiHelper;
 import net.runelite.client.plugins.microbot.util.mouse.Mouse;
+import net.runelite.client.plugins.microbot.util.player.Rs2Player;
 import net.runelite.client.plugins.microbot.util.mouse.VirtualMouse;
 import net.runelite.client.plugins.microbot.util.mouse.naturalmouse.NaturalMouse;
 import net.runelite.client.plugins.microbot.api.boat.Rs2BoatCache;
@@ -55,6 +59,7 @@
 import net.runelite.client.plugins.microbot.api.playerstate.Rs2PlayerStateCache;
 import net.runelite.client.plugins.microbot.api.tileitem.Rs2TileItemCache;
 import net.runelite.client.plugins.microbot.api.tileobject.Rs2TileObjectCache;
+import net.runelite.client.plugins.microbot.util.security.HopBudget;
 import net.runelite.client.plugins.microbot.util.security.LoginManager;
 import net.runelite.client.plugins.microbot.util.widget.Rs2Widget;
 import net.runelite.client.ui.overlay.infobox.InfoBoxManager;
@@ -69,6 +74,7 @@
 import javax.swing.Timer;
 import javax.swing.*;
 import java.awt.*;
+import java.awt.event.KeyEvent;
 import java.io.BufferedWriter;
 import java.io.File;
 import java.io.FileWriter;
@@ -173,6 +179,8 @@ public class Microbot {
     private static net.runelite.api.World quickHopTargetWorld;
     private static final int WORLD_SWITCHER_LOAD_TIMEOUT_MS = 5000;
     private static final int WORLD_SWITCHER_REOPEN_INTERVAL_MS = 600;
+    private static final int HOP_WAIT_MIN_IDLE_MARGIN_TICKS = 3000;
+    private static final int HOP_WAIT_MAX_IDLE_MARGIN_TICKS = 10000;
     /**
      * PouchScript is injected in the main MicrobotPlugin as it's being used in multiple scripts
      */
@@ -194,7 +202,8 @@ public class Microbot {
     private static GameState lastGameState = null;
 
     public static boolean cantReachTarget = false;
-    public static boolean cantHopWorld = false;
+    public static volatile boolean cantHopWorld = false;
+    private static volatile WorldPoint cantHopWorldLocation = null;
 
     public static int cantReachTargetRetries = 0;
 
@@ -372,18 +381,25 @@ public static boolean hopToWorld(int worldNumber) {
             log.error("Already hopping world");
             return true;
         }
-        if (Microbot.cantHopWorld) {
-            log.error("Can't hop world, already trying to hop");
-            return false;
+        if (Microbot.getClient().getWorld() != worldNumber) {
+            if (isNonMembersHopRefused(worldNumber)) {
+                log.error("Can't hop to non-members world {} from a members-only area", worldNumber);
+                return false;
+            }
+            String blocker = Microbot.getClientThread().runOnClientThreadOptional(Microbot::hopBlocker).orElse(null);
+            if (blocker != null) {
+                log.error(blocker);
+                return false;
+            }
+            if (!awaitHopBudget(worldNumber)) {
+                return false;
+            }
         }
         final net.runelite.api.World[] target = new net.runelite.api.World[1];
         boolean prepared = Microbot.getClientThread().runOnClientThreadOptional(() -> {
-            if (Rs2Combat.inCombat()) {
-                log.error("Player is in combat, cannot hop worlds");
-                return false;
-            }
-            if (Rs2Bank.isOpen() || Rs2Shop.isOpen() || Rs2Dialogue.isInDialogue()) {
-                log.error("Blocking widget open (bank/shop/dialogue), cannot hop worlds");
+            String blocker = hopBlocker();
+            if (blocker != null) {
+                log.error(blocker);
                 return false;
             }
             if (quickHopTargetWorld != null || Microbot.getClient().getGameState() != GameState.LOGGED_IN) {
@@ -464,6 +480,92 @@ public static boolean hopToWorld(int worldNumber) {
         return success;
     }
 
+    public static void markNonMembersHopRefused(WorldPoint location) {
+        cantHopWorldLocation = location;
+        cantHopWorld = true;
+    }
+
+    static boolean isNonMembersHopRefused(int worldNumber) {
+        if (!cantHopWorld) {
+            return false;
+        }
+        WorldPoint refusedAt = cantHopWorldLocation;
+        if (refusedAt == null || !refusedAt.equals(Rs2Player.getWorldLocation())) {
+            cantHopWorld = false;
+            cantHopWorldLocation = null;
+            return false;
+        }
+        WorldService service = getWorldService();
+        net.runelite.http.api.worlds.WorldResult worlds = service == null ? null : service.getWorlds();
+        World world = worlds == null ? null : worlds.findWorld(worldNumber);
+        return world != null && !world.getTypes().contains(net.runelite.http.api.worlds.WorldType.MEMBERS);
+    }
+
+    private static String hopBlocker() {
+        if (Rs2Combat.inCombat()) {
+            return "Player is in combat, cannot hop worlds";
+        }
+        if (Rs2Bank.isOpen() || Rs2Shop.isOpen() || Rs2Dialogue.isInDialogue()) {
+            return "Blocking widget open (bank/shop/dialogue), cannot hop worlds";
+        }
+        return null;
+    }
+
+    static boolean awaitHopBudget(int worldNumber) {
+        HopBudget budget = HopBudget.getInstance();
+        if (Microbot.getClient().isClientThread() || SwingUtilities.isEventDispatchThread()) {
+            long waitMs = budget.cachedMillisUntilHopAllowed();
+            if (waitMs <= 0) {
+                return true;
+            }
+            log.warn("Hop limit reached - not hopping to world {}, next hop allowed in {}s",
+                    worldNumber, TimeUnit.MILLISECONDS.toSeconds(waitMs));
+            return false;
+        }
+        long waitMs = budget.millisUntilHopAllowed();
+        if (waitMs <= 0) {
+            return true;
+        }
+        log.info("Hop limit reached - waiting {}s before hopping to world {}",
+                TimeUnit.MILLISECONDS.toSeconds(waitMs), worldNumber);
+        String previousStatus = status;
+        int idleMargin = Rs2Random.between(HOP_WAIT_MIN_IDLE_MARGIN_TICKS, HOP_WAIT_MAX_IDLE_MARGIN_TICKS);
+        try {
+            while (waitMs > 0) {
+                if (!isLoggedIn()) {
+                    log.info("Logged out while waiting for the hop limit - not hopping to world {}", worldNumber);
+                    return false;
+                }
+                if (shouldPreventIdleLogout(idleMargin)) {
+                    Rs2Keyboard.keyPress(KeyEvent.VK_BACK_SPACE);
+                    idleMargin = Rs2Random.between(HOP_WAIT_MIN_IDLE_MARGIN_TICKS, HOP_WAIT_MAX_IDLE_MARGIN_TICKS);
+                }
+                status = "Hop limit - next hop in " + TimeUnit.MILLISECONDS.toSeconds(waitMs + 999) + "s";
+                Thread.sleep(Math.min(waitMs, 1000L));
+                waitMs = budget.millisUntilHopAllowed();
+            }
+            return true;
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+            return false;
+        } finally {
+            status = previousStatus;
+        }
+    }
+
+    private static boolean shouldPreventIdleLogout(int idleMargin) {
+        return Microbot.getClientThread().runOnClientThreadOptional(() -> {
+            Client client = Microbot.getClient();
+            return Rs2Player.checkIdleLogout(idleMargin)
+                    && isNullOrEmpty(client.getVarcStrValue(VarClientID.CHATINPUT))
+                    && isNullOrEmpty(client.getVarcStrValue(VarClientID.MESLAYERINPUT));
+        }).orElse(false);
+    }
+
+    private static boolean isNullOrEmpty(String value) {
+        return value == null || value.isEmpty();
+    }
+
     static boolean hopViaWorldSwitcher(net.runelite.api.World rsWorld, int loadTimeoutMs) {
         if (!isWorldSwitcherLoaded()
                 && !sleepUntil(Microbot::isWorldSwitcherLoaded, Microbot::openWorldSwitcher, loadTimeoutMs, WORLD_SWITCHER_REOPEN_INTERVAL_MS)) {
@@ -490,6 +592,17 @@ private static boolean isWorldSwitcherLoaded() {
                 () -> Microbot.getClient().getWidget(InterfaceID.Worldswitcher.BUTTONS) != null).orElse(false);
     }
 
+    public static String supplyMessage(String supplies) {
+        String item = supplies == null ? "required supplies" : supplies.trim();
+        item = item.replaceFirst("(?i)^ran out of supplies:\\s*", "")
+                .replaceFirst("(?i)^(?:out of|missing|no|not enough|insufficient)\\s+", "")
+                .replaceFirst("(?i)\\s+(?:not found|found|missing)(?: (?:in|from) (?:the )?bank)?[.!]?$", "")
+                .replaceFirst("(?i)\\s+(?:remaining|in bank)[.!]?$", "")
+                .replaceFirst("[.!]+$", "");
+        if (item.isEmpty()) item = "required supplies";
+        return "Ran out of supplies: " + item;
+    }
+
     public static void showMessage(String message) {
         try {
             Runnable messageRunnable = () ->