All Classes and Interfaces
Class
Description
A caller-driven proof.
Factories for worker-polled action proof; each plugin owns and invalidates its own tracker.
Immutable confirmation observation; safe to publish to an overlay or event consumer.
Tracks already-dispatched actions without a polling thread.
The PrivBot plugin API version, and the rule that decides whether a plugin built against one version may run
on another.
A load decision with a message fit to show the user.
Maps the cues an NPC shows when it attacks (its animation id, its projectile id) to the
CombatStyle the
attack demands, plus the animation ids that are known to be harmless and how many cycles pass between an animation
and its projectile launching.Collects cues.
Single-owner count of consecutive accepted attacks whose pending windows expired without an observed fire.
Detects attack fires from caller-supplied, server-ID-space cues and separately confirmed spec-energy fires.
Single-owner record of accepted attack sends and independently confirmed fires, eats and clearing exits.
Pure attack timing calculations, adapted from ElorinPvP's AttackClock.
A step-out interval, inclusive at both ends.
Ordered automation stages for
StagedTaskRunner.Bank queries and interactions through the game client.
The bank contents the player last saw, so AI Builder can answer "what is in my bank" without the bank being open.
Bank chrome buttons: deposit-inventory, deposit-worn, close.
One occupied slot in the bank's item container.
The menu identifier of a bank item option on a RuneLite-shaped (EventBus) client, read from the slot widget's own
action list instead of assumed.
Run/script-scoped key-value scratchpad ("memory") for workflow flows and plugins.
Decides when to drink another dose of a stat boost (overload, super combat, and so on) from the boost the account
actually shows.
Tracks progress through a list of
(item, quantity) purchase lines.One
(item, quantity) pair.Why a line was retired without reaching its target.
What the unified API supports on the server this plugin runs on.
One thing a plugin can ask the unified API to read or do.
Passive recording for a plugin:
ctx.capture.Chat message reading and sending via the RuneLite
Client.Shared base class for child task behaviors owned by a
Parent.A collapsible section with a clickable header that toggles content visibility.
A value-to-colour rule, so a threshold ladder is written once and reused.
Maps a plain value.
Thread-safe combat reads and player/spec interactions for scripts.
One detached collision read from the local player's tile, returned by
ctx.combat.collision() and reusable
for every candidate target of one decision.The facade that hands out collision reads:
ctx.combat.Detached boosted and real combat levels; null means an individual read was unavailable.
The three combat styles and the overhead prayer that blocks each.
What the engine is committed to: a STYLE, and on top of it at most one fixed-plan EPISODE (plan fix 6, D44).
A fixed-plan episode, or none.
A task node that holds child nodes and delegates execution using a strategy.
Execution strategy for child nodes.
One-time, versioned changes to a plugin's saved settings, for a default that changed after users saved the old one.
One value a step changed:
key from from to to; to is null when the key was unset.Minimal view of RuneLite's ConfigManager for one config group, so tests need no client.
One change, applied when its version is above the stored one.
Stable ordering for inventory consumables when multiple slots match (e.g.
Pure per-tick consume planning over detached inputs.
Detached current inputs from one decision tick.
Pure consume cooldown rules.
One occupied slot in a widget-backed item container.
Holds the combat style the most recently LAUNCHED attack demands.
Detached historical damage distribution.
Detects the local player's death and respawn by POLLING, one
DeathWatch.observe(java.lang.Integer, java.lang.Integer, net.runelite.api.coords.WorldPoint, int) call per game tick.What one observation says.
A place to travel to: a name, a tile, how close counts as "there", and optionally a teleport to try first.
Dialogue state inspection and interaction.
A dialogue read: the root widget id it came from, plus the stitched, normalised text.
Dispatch acknowledgement is independent of the resulting game state.
Observes a potion-family dose total before and after an accepted drink.
Bounded non-critical food timing.
Immutable effect evidence at the instant observe() was called.
Creates independent, memory-only effect trackers for a plugin's lifetime.
Per-plugin effect bookkeeping.
Source-compatible live local timer; restarting preserves the object's identity.
Historical Elorin PvP capture cues copied from the flagship's September 2026 tables.
Pure emergency consume selection.
Worn equipment:
ctx.equipment.Typed game events for plugins, backed by POLLING:
ctx.events.An animation change on the local player or an NPC.
A chat line that arrived since the previous tick.
The local player died.
Everything one poll observed.
Builds a
Events.Frame; every part defaults to "not read".A graphics object (spot animation in the scene) that appeared since the previous tick.
One graphics object as read on a tick.
A hitsplat that landed since the previous tick.
What one poll should read; anything not needed is skipped so an idle facade costs nothing.
One NPC's animation as read on a tick.
A projectile that appeared since the previous tick.
One projectile as read on a tick.
Reads one
Events.Frame.A registered listener;
Events.Subscription.cancel() (or close) removes it.A watched varp or varbit changed between two readable ticks.
One exact-tile dispatch followed by caller-driven arrival proof; never plans or retries a route.
The facade supplies the correct client-thread dispatch/read boundary.
Text drawn in runs, so characters the chosen font has no glyph for (an emoji, a pickaxe) are drawn
in "Segoe UI Emoji", then "Dialog", at the same size and style instead of as a missing-glyph box.
Detached observations for one PvP decision.
One fight frame plus newly observed local hits and graphics from the same client-thread batch.
A bounded observation of one accepted food action, using a pre-send count and later detached inventory snapshots.
Square-footprint maths for big NPCs, on server tiles.
The clock of a freeze on an opponent: when it should end, whether a move of theirs ended it by running out or by
breaking, and the immunity after it.
How a move of theirs relates to a running freeze.
Friends list queries via RuneLite's
Client.Modal configuration window: PrivBot studio chrome around embedded Swing content (tabbed forms, etc.).
Annotation-driven settings page renderer — the "free studio" for any RuneLite-style
Config.Lightweight descriptor of a
@ConfigSection for nav wiring.Layout and styling helpers for PrivBot JavaFX settings pages.
Wraps a
TextArea in a column with a bottom drag grip so the user can resize height
(compact default; does not auto-grow with text — content scrolls inside until extended).Same page chrome as
FxSwingSection (title, subtitle, optional outer scroll) for pure JavaFX bodies.Cross-thread helpers for JavaFX embedded in Swing (e.g.
The PrivBot settings studio: an ink masthead (brand mark, name, product, optional running pill), underlined
section tabs, a large page heading, a scrolling workspace and a footer with the actions — the workspace look
Elorin Wilderness Slayer introduced, shared by every plugin.
Describes a studio;
FxStudioShell.Builder.build() creates the window (hidden) on the EDT.Wraps legacy Swing settings panels in JavaFX page chrome (title, subtitle, scroll).
Session and client state:
ctx.game (server, login, tick, tabs, instance, run mode).Scene object query (KSBot-style).
ToA / Tombs rewards-room anchor classifier (legacy
WardenLootTask reference): first GameObject on
the anchor scene tile, matching sarcophagus id, gate action on resolved composition (default Open).Where the anchor sarcophagus is and which action marks a purple.
What the anchor sarcophagus shows.
Static utility for thread-safe game state access — mirrors the dispatch layer of other
bot frameworks.
How
GameThread gets a read onto a thread that may touch the client.The decisions
GameThread makes, as pure functions of what a copy knows and where it is
called from.What one
GameThread copy knows at the moment of a call.Where a call runs.
Which item names are the same piece of gear.
An immutable description of the gear a fight needs, the same on every server: what is worn, or what is carried.
One wanted item.
Whether a setup describes worn equipment or carried supplies.
What a carried item is for.
Shared PvP visual design system (consolidated from the formerly-duplicated
autopvp.gui.GearTheme and aipvp.gui.GearTheme, which were byte-identical).Pure decisions for the Elorin-observed instant granite maul behavior.
Fluent query for scene graphics objects (e.g.
Scene graphics query hook (graphics objects deque).
A detached copy of one graphics object (a ground effect such as a falling rock or a pool) taken at the tick of a
ThreatSnapshot.Fluent filter chain over ground item stacks, built by
ctx.groundItems.query().Ground loot query (KSBot-style).
Picks up ground items by name fragment and proves each pickup: Take, then wait for the inventory count of that id to
rise.
Detached ground item facts (read on the client thread, used on the worker).
The tiles that hurt right now: timed ones (a graphic or a telegraphed attack that lasts a few ticks) and
persistent ones (ground the fight never lets you stand on).
Dodging:
ctx.hazards.Detached recent health observations for the eat decision.
Queues configured key presses for the plugin's worker to drain.
Thread-safe pacing for player-visible automation (script thread /
execute() only).Translates OSRS ids to the ids this server uses, and back.
Chooses an incoming combat style from detached, independently classified threat evidence.
A null style means the inputs do not establish a style; keep the current protection.
A detached instant-maul proposal over the selected opponent and one fight frame.
Marks a type or member that is
public for technical reasons but is NOT part of the supported plugin
API, even though it lives in a PublicApi package.Inventory hook backed by the client's inventory snapshots.
Modular inventory food resolution: Inventory query plus Eat (Warden-style),
optional name-pattern tier when composition actions are wrong, then item-id fallback.
Which item container a
PrivItem row came from; picks the widget an item action
is sent to.Detached item facts, safe to rank on a worker or display on the UI without client access.
One occupied slot, by value.
A list of
(item, quantity) pairs, and the parser that reads one from user text.One
(item, quantity) pair.Fluent filter chain over inventory-style slot rows wrapped as
PrivItem.A multi-tick piece of work a task node drives by calling
Job.step(privbot.task.PrivTaskContext) once per pass until it is finished.Where a
Job stands.Pure probability calculations adapted from ElorinPvP's KO-risk model; inputs are estimates, not guarantees.
Combines caller-supplied risk estimates with a hit-time estimate.
One independently justified possible attack.
Pure KO-weapon switch timing adapted from the Dharok-mode policy.
KEEP also covers an accepted equip that has not yet appeared in the worn read; it is not a new dispatch.
Frame-bound gear proposals for the KO-weapon decision.
Gear setups and loadouts:
ctx.loadouts.The local player, read through the plugin's own adapter:
ctx.player.Picks up the drops a
LootSpec wants, one proved item per step: ctx.loot.A ground stack found by the configured-loot scan (
GroundItems.configuredDrop(java.util.function.Predicate<privbot.hooks.LootDrop>, int)) or picked for a Take
(GroundItems.takeConfiguredDrop(java.util.function.Predicate<privbot.hooks.LootDrop>, int)).A loot setting as name fragments: "drygore, soul, contract" wants any ground item whose name contains one of them,
case-insensitively.
Which ground items are worth picking up: by exact name, by id, or by stack value.
Builds a
LootSpec.Counts kills and loot per NPC name, so a plugin can report what a trip earned.
Magic spell casting through the game client.
What happened to a cast's target click.
A cast's outcome plus, for REFUSED, the gate that held it (the outcome's gate) and, for
UNREACHABLE, the name of the reason the action could not be reached.
The magic tab as the client holds it.
PrivBot UI design system (EasyFlow).
Chip-style toggle for small filters/sort options.
Rule Studio–style filter chip: JButton with active state and rounded rect
paint.
Logo/mark label (used in headers, similar to Rule Studio's icon + title).
Badge label with a mutable accent color (useful for live status badges).
Modern styled button with hover effects.
Modern scroll bar UI.
Modern text field with placeholder support.
Modern Toggle Switch (replaces JCheckBox).
Toggle button that paints background + text in one pass (no
super.paintComponent) to avoid glitch.
Bounded, non-blocking navigation lifecycle.
The shared travel facade supplies the driver; tests can supply deterministic observations.
Detached result of a bounded NPC attacker scan.
Fluent filter chain over the NPCs in the scene, built by
ctx.npcs.query().Snapshot NPC hook: call
NPCs.query() for a fluent NPCQuery (filters, closest, player north/south/east/west).One NPC reduced to what targeting and hazard maths need.
Fluent filter chain over scene objects (walls, decorations, ground objects and game objects),
built by
ctx.objects.query().The result of one read of game state, with "could not read it" kept apart from every real answer.
Which of the three answers a read gave.
Which offensive prayer to keep on, and when to give one up.
Conservative observed-swing timing for one locked opponent.
Conservative upper bound for an opponent's special energy, based only on independently confirmed spends and
caller-supplied regeneration rules.
The locked opponent.
Detached opponent-lock selection.
Facts about one observed player.
Single-owner opponent lock history.
Pure timing rules adapted from ElorinPvP's opponent clock; no client reads or claimed hit observations.
What happened when a verb was asked to act: an explicit answer instead of
false plus a log line.Why an action was or was not sent.
An opponent's overhead prayer, debounced: "has their prayer blocked this style long enough to act on it".
The full-colour icon set offered for Builder flow overlays (ids such as
skill:mining or
tile:combat)."Move overlay" on clients without RuneLite's MouseManager (Impact, Elorin, SpawnPK): an
EventQueue pushed only while move mode is on, so a drag on a panel never also clicks the
game.Feeds the game canvas's mouse into an
OverlayMoveMode while "Move overlay" is on."Move overlay": drag a flow's Builder panel to a new place, or drag its bottom-right corner to
resize its width, in game.
Receives a saved move: the corner anchor nearest the panel's centre and the offsets from it
(
OverlayPlacement rules), or FREE with the panel's top-left when the viewport is unknown.The resolved colours of one overlay: the scheme's, with a custom scheme's per-colour overrides.
Where a flow's overlay panel goes on the game canvas: its anchor plus offsets, clamped inside the
viewport, and moved off any panel placed before it.
The overlays a plugin registered, as one handle:
OverlaySet.setVisible(boolean) adds or removes them
all, OverlaySet.close() removes them for shutDown().The one palette for in-game overlays.
Combines a cue detector and confirmed-action history for our attack cycle.
The colours a user chose for one overlay, as
OverlayPalette.of(PaletteSettings) reads them: a built-in
PaletteSettings.Scheme, and for PaletteSettings.Scheme.CUSTOM a colour per PaletteSettings.Slot that replaces Classic's.The built-in colour schemes, the ones the Workflow Studio HUD offers.
The colours of a palette, one per
OverlayPalette field.The states a plugin sidebar shows, each with a glyph so state is never carried by colour alone.
Shared parent node that owns a local group of
Child tasks and selects
the highest-priority eligible child when it executes.Named-location registry: resolves a human place name ("Bank", "Edgeville bank",
"Banker", an NPC/area name) to an anchor
WorldPoint + arrival radius,
drawing from the current server's movement config (banks + NPC anchors).A resolved named location: an anchor tile and the radius that counts as "at" it.
Strict cardinal comparisons between the player's tile and an anchor tile.
Fluent filter chain over the loaded players, returned by
ctx.players.query().The facade that hands out searches:
ctx.players.Thin wrapper so
PrivContext exposes players via injected Client.One player reduced to what a PvP fight needs.
Shared helpers for plugin nav and panel icons.
The plugin-side wiring every sidebar needed: build the panel on the EDT, add the navigation
button, and take both down again on
shutDown().Prayer activation, deactivation, and state checks.
Which prayer book the prayer tab has mounted, as
Prayer.mountedBook() reads it.Protection-prayer planner for several simultaneous attackers.
Planner settings.
Stops a prayer toggle the state read never confirmed from being sent again and again.
One unconfirmed toggle: the direction asked for and when it was sent.
Documentation hub for the supported PrivBot plugin interface.
Shared drawing helpers for PrivBot-branded chatbox overlays.
Shared metric layout helpers for PrivBot chatbox overlays.
One key/value row for the chatbox layouts; build with
row(...).Guice module that binds
PrivContext so a plugin injector can supply ctx.Reusable main frame for PrivBot plugin GUIs.
Section metadata.
Shared PrivBot JavaFX stylesheet and style-class tokens (studio / settings shell).
A themed HUD panel composed from a published state on every render.
Entry point of the overlay kit: describe a HUD panel or a scene overlay, then install the set.
Describes a HUD panel;
PrivBotOverlays.PanelBuilder.rows(java.util.function.Supplier<S>, java.util.function.BiConsumer<privbot.ui.overlay.Rows, S>) is the terminal step.Describes a scene overlay;
PrivBotOverlays.SceneBuilder.draw(java.util.function.Supplier<S>, java.util.function.BiConsumer<privbot.ui.overlay.SceneCanvas, S>) is the terminal step.Reusable sidebar panel for PrivBot plugins.
Fluent description of a sidebar;
PrivBotPanel.Builder.build() assembles it.A scene overlay (tiles, outlines, labels, paths) drawn from a published state on every render.
Single entry point for scripts: hooks and timing helpers.
Ground stack wrapper;
interact("Take") routes through the game client.Inventory/bank/equipment slot wrapper; interactions route through the game client.
NPC wrapper returned by
ctx.npcs.query(); interactions route through the game client.Scene object wrapper; interactions go through the game client.
Other-player wrapper.
Base context for TaskNode-based scripts that exposes all PrivContext hooks directly.
Create/make an item via the standard skill-creation interface (smithing/anvil,
cooking, fletching, crafting, …).
Interface for panels that participate in profile save/load.
Notices a bot that has stopped making progress.
A missing/stale observation is UNKNOWN, never evidence that an action succeeded.
Marks a package or type as part of the supported PrivBot plugin API.
ctx.pvp: a detached, per-tick copy of a PvP fight (the local player and the players around it: overhead,
skull, HP bar, animation, graphic, worn item ids, tile and who they interact with), the same on every server.Composes detached consumption decisions with the PvP action-family arbiter.
The original consume decision is explanatory; dispatch only non-held entries from
PvpActionPlanner.Plan.actions().Pure action-family conflict resolution for a detached PvP plan.
Current decision facts.
Single-owner coordinator for detached PvP observations.
Detached inputs derived from the same observation.
Immutable results for one sampled tick.
Chooses between same-frame instant-maul and KO-weapon episodes before combining with ordinary actions.
Combines a KO-weapon gear episode with an ordinary same-frame PvP plan.
Combines an ordinary PvP proposal and an instant-maul proposal from the exact same frame and arbiter facts.
Detached proposal for the flagship PvP closing and step-out rules.
What a
ctx.pvp.snapshot(..) call should include.A detached copy of one tick of a PvP fight: the local player and the other players around it.
Reuses detached observations within one synchronous decision, never across decisions or threads.
Recover after the local player dies:
ctx.recovery.What
ctx.recovery.afterDeath does once the player is back: an optional restock, then an optional trip back.Builds a
RecoveryPlan.Bank to a gear setup:
ctx.restock.Builds a
Restock.Request.What a restock needs; each server reads only its own fields.
One restock trip as a stage machine: IDLE --begin--> HOME -> POOL -> BANK -> RETURNING -> IDLE.
What a plugin tells
RestockRunner and GroundLoot about itself: when to give up, where the player is,
what counts as "back at the activity", and where capture rows go.What a restock trip clicks and how long each step may take: the home spell and where it lands, the restoring object,
the bank and its preset action, and the teleport widget's way back.
Runs a
RestockCycle one confirmed step per call, on the script worker (it waits for each confirmation):
Home: the home spell, after closing an open bank; confirmed by landing in the route's home area.
Pool: the restoring object; confirmed by RestockHost.restored(); skipped when already full.
Bank: the preset action on the nearest bank object, else a banker; confirmed by the worn and carried items
changing.Whether the carried supplies call for a restock trip: how much food (items with an Eat action) and how many potions
(items whose name contains one of the configured names; a flask or a vial counts once whatever its doses) are left,
against the plugin's minimums.
What a restock should end with, the same on every server: an optional worn setup, an optional carried setup, whether
to empty the backpack of unwanted items first, and an optional server preset to try before withdrawing.
Builds a
RestockTarget.Pure valuation over caller-supplied prices and death rules.
One physical entry.
Value and death treatment for one item ID, from a caller-verified server-specific source.
The rows of a HUD panel, composed fresh on every render.
Finds the nearest tile to step to that is out of every hazard and clear of every big NPC's footprint.
The scene-drawing primitives every tile overlay used to hand-roll, over one
SceneProjection.World → canvas, the same way on every server.
One detached flood-fill for ranking many destinations.
Collects every interactable object in the loaded scene, on every plane.
Runs script logic on a dedicated thread so that
sleep() and
sleepUntil() block only the script — never the client (game-tick)
thread.Search field used by Rule Studio and AutoPvP for consistent look and behavior.
The live server a plugin runs on, as the unified API names it.
Which account the per-session game memory (the manual-click log and the last-seen bank) belongs to.
What a
GearSetup still lacks, compared with the player's real containers, the same on every server.High-level shop interaction: open an NPC's shop, then sell items from inventory
using the shop's widget actions (Sell 1 / Sell 5 / Sell 10 / Sell 50).
Finds the open shop's stock and buys from it;
ctx.shop uses it on Impact, Elorin and SpawnPK.A single purchasable option read off a live shop-slot widget, e.g.
One occupied slot in a shop's stock container.
Tells a new projectile launch from one already seen.
One projectile in flight, reduced to what attack tracking needs.
Abstract convenience base for single-tick task nodes.
Lightweight vector skill/category icons for Swing UIs (Rule Studio, etc.).
Skill levels and experience:
ctx.skills.State published on the game tick and read on the render thread.
Whether a special attack fired between two readings of special-attack energy: a fire is an energy drop.
Pure special-attack phase ordering.
All flags are nullable: null is unreadable.
Single-owner special-energy observation history; it never treats an unreadable sample as an energy value.
Freeze, Vengeance and Tele Block on us and on opponents, tracked from the graphics and animations a PvP snapshot
reads each tick.
Runs
TaskNodes in AutomationStage order.Deterministic style-set planning with the flagship's least-switching, range and commitment rules.
One carried item matched to a missing equipment slot.
Which combat style to fight in against an opponent's protection prayer.
How well the unified API does one
Capability on one server.Keeps the player alive and boosted:
ctx.sustain.What
SustainPolicy says to do about hitpoints, prayer or a boost this tick.The kinds of answer.
What one call of
ctx.sustain.maintain did.The kinds of outcome.
What to eat and drink, and when.
Builds a
SustainPlan.Chooses the one sustain action to take this tick (eat, brew, prayer restore, boost dose) from values the caller
has already read.
Swing form layout + button styling helpers shared across plugins (sidebar panels, Swing dialogs).
Proves a same-tick gear switch on later ticks, and backs off a switch that keeps failing.
A verdict on the outstanding switch.
What one
ctx.loadouts.switchTo(..) call sent.Spreads a first hit across every NPC in a group before finishing any, the tag-all-then-kill pattern.
Chooses which NPC to fight and sticks to it, so a bot does not flip between two targets every tick.
Picking a target:
ctx.targets.Which NPCs count as a target: by name, by id, minus an ignore list, optionally inside an area.
Base interface for all task nodes in the PrivBot task framework.
Manages a flat list of
TaskNodes and executes the highest-priority
valid node each tick.Optional named integers for catalog and staged task trees.
Optional read-only diagnostics.
Teleport actions: casting teleport spells, using teleport tabs, and item-based teleports.
Teleport to a named destination with whatever this server provides:
ctx.teleports.Single-owner rolling threat memory.
A verified magic tell and its lead in client cycles; callers perform server-ID matching before construction.
What a
ctx.threats.snapshot(..) call should include.ctx.threats: a detached, per-tick copy of the fight around the local player (NPCs, projectiles, graphics,
hitpoints and chosen prayers), the same on every server.A detached copy of one tick of a fight: the local player, the NPCs, projectiles and graphics around them, and the
prayers that were checked.
Script-thread sleep utilities — matching the Unethicalite
Time /
DreamBot Sleep API.Modern toggle switch for ON/OFF (same visual language as RuleEngine; lives in shared-lib for reuse).
Trade interface state and interaction via
Client and the game client.Resolves which action to click in order to open a shop.
Request for using a movement-catalog transport/NPC entry followed by an exact widget path.
One step along the post-interaction widget path: label text, packed widget id, or inspector path
with optional
[index] nesting.Get to a named place (walk + transports + teleports), unifying
PathingAPI
with the Places named-location registry.Local-player state queries via
Client and the game client.One read of the local overhead:
User.Overhead.isReadable() false means nothing can be said about the
prayer the server shows — never treat it as "no overhead".The evidence-backed names
ctx.vars.byName(...) knows on one server.One named variable.
Whether a name resolves to a whole varp or a varbit.
Player variables:
ctx.vars.How many ticks a weapon takes between attacks.
Weapon name to combat style, for Elorin's RS2-era item names.
Interface widgets:
ctx.widgets (find by id or visible text, read text, click options).How visible text is matched.
What a confirmed widget click observed.
Explicit, caller-verified wilderness coordinate rules.
How many units of one item may be withdrawn right now, given the inventory's free space.
One withdraw quantity PrivBot can actually send on this server, e.g.
Tracks progress through a list of
(item, quantity) withdraw lines.One
(item, quantity) pair — the shared shape, so one parser serves buy and withdraw.Why a line was retired without reaching its target.
Workflow execution hook — the simplest way to run workflows from plugin code.
Notices a world that has stopped changing while the tick counter keeps running: the signature of a death or a
disconnect the client never reported (a real fight always moves something).