All Classes and Interfaces
Class
Description
Game action queuing and execution control.
A historical record of an executed game action.
Fired after each queued bot action is executed on the game thread.
Action type IDs corresponding to the game's mini menu system.
The local player's backpack (inv id 93, slot grid at iface 1473 comp 5).
The bank inventory (inv id 95).
Bank interface mode — standard transfer controls or preset selector.
Side panel view alongside the bank grid.
Bank transfer quantity, with its
BANK_CUSTOMOP varbit value and its
op on the item-slot menus.Bank withdraw mode: as item or as bank note.
Simple logging interface for bot scripts and framework components.
Service Provider Interface for bot scripts.
Fired when a break countdown completes and the bot resumes.
Fired when a break begins (logout triggered by fatigue/risk or manual schedule).
Turns a space, a style and a caption into a concrete
DrawCommand.A message from the game chat history.
Event fired when a chat message is received in the game.
Represents a single connected game client with its associated API and event bus.
Launches, stops and watches game clients through the BotWithUs launcher's
background service.
Cross-client script lifecycle and group management.
Result of a script operation on a specific client.
A single active schedule pinned to a specific client.
Result of a schedule operation.
Snapshot of a script's state on a specific client.
Provides access to all connected game clients.
Packed
0xAARRGGBB colours for debug drawing, and the two helpers for
building one.Snapshot of an interface component at the moment the producer answered
an RPC.
Rich wrapper around a
Component record plus its position in a
materialized ComponentTree.Fluent, RPC-backed query over an interface subtree.
Identifies a component by its owning interface and component id within that
interface.
Interface-component query facade.
An immutable, materialized interface subtree fetched in a single
get_interface_tree round-trip.One node of a flattened interface subtree returned by
GameAPI.getInterfaceTree(int, int) — the raw
decode of a single get_interface_tree entry.One CS2 event trigger bound to an interface
Component — the discovery
side of trigger firing.Stable, build-independent semantic category of an interface component.
Describes a single configurable parameter that a script exposes.
A boolean-valued field rendered as a checkbox.
A field whose value is one of an enumerated set of choices.
An integer-valued field.
An integer-valued field representing an item id.
A free-text string-valued field.
Fired when the underlying pipe transport drops mid-session.
Reads RS3 conversation dialogs: selects options on the multi-choice dialog
(interface
DIALOG_OPTIONS, 1188 — "select an option") and advances a
text-only NPC-chat page (interface DIALOG_NPC, 1184).One selectable line of the multi-choice dialog (interface
DIALOG_OPTIONS).The eight compass points, in clockwise order starting at north.
Debug-drawing facade.
Debug drawing: retained overlay commands the producer renders over the client.
What a batched submit actually achieved.
Fluent presentation chain for one draw command.
The words a captioned command draws, and the style to draw them in.
A fixed-point number the producer formats.
Literal text.
The absence of a caption.
Fluent chain for the two commands that draw words — a
text command and
a captioned component highlight.One fully-specified draw command, ready for the wire.
A highlight over a
widthTiles by heightTiles block of ground,
anchored at its minimum corner.A highlight that tracks an interface component rather than a rectangle.
Ellipse inscribed in the given rectangle, stroked or filled.
A highlight that tracks a live entity — an NPC, another player, or the
local player.
A command only a
highlight_* call can carry, because what it marks is
a thing rather than a place.Straight segment from
(x1, y1) to (x2, y2).Polyline over a flat
[x, y, x, y, ...] list of 2 to 32 pairs.A command
debug_draw_set carries: the caller names its kind
and its space, and the producer stores the geometry as sent.Axis-aligned rectangle, stroked or filled per
DrawStyle.isFilled().A caption anchored at
(x, y).A highlight over exactly one game tile, on a named plane.
Turns a space and a style into a concrete
DrawCommand.One retained draw command as the producer currently holds it.
The text styles the producer can draw a caption in.
A tick's worth of drawing, collapsed into as few round-trips as the wire allows.
The primitive shapes the producer's overlay can retain.
The producer's hard limits on debug drawing, named once so no caller has to
spell a bare number.
The coordinate space a draw command's geometry is expressed in.
The producer's own account of its overlay: how full the store is, what it has
refused, and whether the renderer is alive.
The presentation half of a draw command — everything that is not geometry.
The scene's dynamic-region (instance) chunk-descriptor grid (v19+).
Shared surface for everything an
EntityQuery can reason about
without consulting an entity-specific definition.Fluent query builder shared across entity types.
Which list a highlighted entity's index belongs to.
Enum (key-value mapping) definition from the game cache.
The local player's worn equipment (inv id 94, equipment iface 1464).
Semantic equipment slot names paired with their in-game inventory indices.
Publish-subscribe event bus for game events.
A game action to be queued for execution via the pipe RPC.
Slim RPC-shaped surface for talking to the game producer.
Common interface for every typed game event distributed through the
EventBus.Tick-scoped read view over the producer's published game snapshot.
One name↔id pairing from the gameval index.
Resolves gameval symbolic names to entity ids and back.
A gameval name did not resolve.
A gameval name paired with the id it resolved to when the calling code was
written.
A namespace of gameval symbolic names — one per table the game ships in cache
index 67.
Convenience wrapper around the Grand Exchange interface (
STOCKMARKET,
iface 105) and its collect-all panel (STOCKMARKET_COLLECTALL, iface 651).Snapshot of one ground-item stack at the producer's current tick (v15+).
Predicate for filtering
GroundItem entries in a GameSnapshot.Wire-format record returned by
query_ground_items for one stack
of items lying on the ground.Ground-item query facade.
Fluent chain for a highlight — the four calls that mark a thing rather
than a place.
Turns a style and a caption into a concrete
DrawCommand.Highlight.Human-like delay utilities to make bot behavior less detectable.
The game's input dialog (
MESLAYER, interface 1469): the prompt behind
withdraw-X, deposit-X, add-friend and the like.What the game's input dialog is asking for, read from the client variable
MESLAYERMODE.Common RS3 interface ID constants and component hash utilities.
Snapshot of one inventory container.
Snapshot-backed wrapper for one game inventory (backpack, bank, equipment, ...).
One slot of an inventory snapshot.
Item definition from the game cache.
Fired when a key is pressed while the overlay has keyboard focus.
One key event delivered to a component's key (type-10) CS2 trigger — the
argument the trigger's script reads as its key code and key character.
Immutable record describing a single script failure: the lifecycle phase in
which the throwable surfaced, the loop iteration index at the time, the
wall-clock
Instant the runner observed it, and the throwable itself.A client the launcher service manages, as it reported it.
What kind of client it is.
The host connection that launched a client.
A client's licence.
A licence's state; see
LaunchedClient.Licence.Who launched it: the launcher's own UI, or a host over automation.
Where a launch is.
An account the launcher can start a client on.
Something the launcher service reported, or a change in the host's link to
it.
The launcher has a new agent; clients injected before it are now stale.
A client's process exited.
A client started: a launch reached its first record, or auto-restart
replaced the process (then
LaunchedClient.restartOf() is set).A client's launch moved on.
Where a data update is.
A data update was applied.
The state of a data update changed.
Events were missed: the service's sequence skipped, or this listener fell
too far behind.
Why a client exited.
The licence link, or one client's licence, changed.
The host lost the service.
The host has the service again after a
LauncherEvent.ServiceLost.The service is shutting down.
A
ClientLauncher call that failed.A launch the service has queued:
ClientLauncher.launch(String, LaunchOptions).Options for
ClientLauncher.launch(String, LaunchOptions).How a
LaunchHandle ended.The client was injected and the host attached to it.
The service injected the client, but the host could not attach to it:
its pipe or its shared memory never appeared.
The launch failed before the client was injected, or the client exited
first.
How responsive a script runner is, as judged by the runtime's watchdog.
Snapshot of the local (logged-in) player at the producer's current tick.
Snapshot of one scene Location (door / tree / rock / bank / scenery tile)
at the producer's current tick.
Predicate for filtering
Location entries in a GameSnapshot.Location (game object) definition from the game cache.
Factory for obtaining
BotLogger instances.The current login state of the game client.
Fired when the client login state changes (e.g., lobby to logged in).
Context passed to
ManagementScript.onStart(ManagementContext).Service Provider Interface for independent management scripts.
Something a
ManagementScript has been told to manage.One script on one client.
Every client in a group, and every script on each.
Every client on the host, and every script on each.
Async pub/sub message bus for inter-script communication over named channels.
High-level navigation interface providing blocking walk operations.
Navigation and pathfinding.
Snapshot of one NPC at the producer's current tick.
Predicate for filtering
Npc entries in a GameSnapshot.NPC query facade.
Query subclass — wires the snapshot stream + name resolution to
EntityQuery.NPC definition from the game cache.
Fired when a per-item obj var changes value.
One open sub-interface as the snapshot publishes it (wire v23): its id, how the client
opened it, and whether a client script rather than the server did the opening.
Which way an entity is facing, as the client stores it (wire v21).
Result of a pathfinding query.
Identifies which lifecycle hook of a
BotScript
was executing when an event of interest (typically a crash) occurred.Rich wrapper around a snapshot
Player
record.Snapshot of one player at the producer's current tick.
Predicate for filtering
Player entries in a GameSnapshot.Player query facade.
Snapshot of one of the local player's skill stats.
Rich wrapper around a snapshot
Projectile
record — one in-flight projectile at the producer's current tick (v17+).Snapshot of one in-flight projectile at the producer's current tick (v17+).
Predicate for filtering
Projectile entries in a GameSnapshot.In-flight projectile query facade (v17+).
Query subclass — wires the snapshot stream to
EntityQuery.Quest definition from the game cache.
Fired when a radio-group option is selected, observed on the producer's
outbound
SendRadioButton packet builder.Closed state machine describing the lifecycle of a reconnect controller.
Fired whenever the
ReconnectController transitions between
ReconnectState variants.A single resource line on a
WorldMapElement — typically an ore,
fish, or log obtainable at the spot.A group of
ResourceItems available at a WorldMapElement,
grouped under a display title (e.g.Wire-format record returned by
query_locations for one live
scene object.Scene-object query facade.
Categories for classifying
BotScript implementations.Immutable snapshot of a script's configuration values.
Context object passed to
BotScript.onStart(ScriptContext) providing access to
the game API and the event bus.Fire-and-forget publisher for the agent's
script.context broker topic.Fired by the runtime when a script's lifecycle hook throws.
Immutable snapshot of a script's failure history.
Read-only snapshot of a script's metadata and current state.
Fired when the script loader fails to load a JAR (module-info parse error,
missing
provides clause for BotScript, ServiceLoader
instantiation failure, classpath / module-path mismatch, etc.).Per-Connection script lifecycle manager: lists, starts, stops, reloads, and
schedules scripts running against one
Client.Annotation for
BotScript implementations to declare script metadata.An immutable message sent over a named ISC channel.
The result of executing a client script via the pipe RPC.
Thrown when a script that was asked to stop — and did not — tries to act on
the game.
Schedules scripts to run at a future time or on a recurring interval.
A snapshot of one scheduled entry.
Interface for scripts that provide custom UI.
The host's handle on a script's UI, passed to
ScriptUI.attach(ScriptUiHost)
before every frame.Animation sequence definition from the game cache.
Thread-safe key-value store for sharing state between scripts.
One row of the local player's skills array.
A skill requirement associated with a
WorldMapElement.Skill ID constants and stat lookup helpers for RS3.
The static-map tile an instance tile was copied from (v19+).
Fired when a new spot animation (graphic) starts playing.
How
ClientLauncher.stop(String, StopMode) ends a client.Struct definition from the game cache.
Warns once per method-name when a producer-side stub is invoked.
System-level operations: connectivity and client info.
A discrete unit of work within a
TaskScript.Base class for task-based scripts.
Fired each game tick when the server tick counter advances.
Tick-aware timing utilities for bot scripts.
Fired when a varbit changes value.
One varbit read.
Varbit (variable bit) definition from the game cache.
A resolved varbit value: the varbit id paired with its current decoded value.
Fired when a client variable (varc) changes value.
Fired when a player variable (varp) changes value.
Game variable access: varps (player variables), varbits (bit-ranges of a
base variable), and varcs (client variables, int- and string-valued).
How the client stores a set varp's value.
One varp read: its
state, and the value the game would read for it.What a varp read found out about the variable.
Fired when the walker reaches its destination.
Fired when a walk is cancelled (explicitly via
walkCancel(), or
implicitly when an action interrupts it).Fired when a walk fails (pathfinding failure, stuck timeout, context loss, etc.).
Result of a blocking walk operation.
Current walker state.
A world-map element from the game cache.
World-map element query facade.
Fluent filter builder for world-map element queries.
A single placement of a
WorldMapElement on the world map.Configuration for world-scale pathfinding.