All Classes and Interfaces
Class
Description
Renders a button that invokes a no-argument method on the config object.
Game minimenu action opcodes.
Base wrapper for actor units such as players and NPCs.
View specialization for actors such as players and NPCs.
Reflection-backed overlay for classes annotated with
OverlayPanel.Factory methods for scoring candidates by distance to preferred areas.
Builder for area preference scoring.
Builder for area preference scoring after a base score has been set.
Factory methods for timed rectangular area threats.
Builder for timed rectangular area threat tasks.
Typed area threat task factory.
Factory methods for scoring nodes when an attack is ready.
Builder for attack window scoring.
Builder for attack window scoring after the attack predicate has been set.
Convenience facade for reading state from the local player.
Bank accessors backed by the client's inventory data and interface components.
Known withdrawable bank locations.
Base representation of an item stack with helpers for cache-backed item metadata.
View specialization for item wrappers.
A node in a
BehaviorPlugin behavior tree.Functional interface for behavior leaf nodes.
Base class for plugins driven by a behavior tree.
Result returned by behavior tree nodes.
Status produced by a behavior tree node.
Factory methods for blocking coordinates or areas during simulation expansion.
Renders a boolean config field as a checkbox.
Small mutable clock for measuring runtime, countdown windows, pauses, and rates.
Builder-style entry point for creating a clock.
Local collision and reachability helpers for the currently loaded scene.
Bit flags describing tile collision, movement blocking, and visibility blocking.
Renders a color config field as a color picker.
Convenience accessors for common player combat state.
Renders a config field as a combo box.
Meta-annotation marking annotations that render config UI components.
Lazy view over interface components.
Base class for plugin configuration objects.
Renders a list of nested config objects as add/remove rows.
Utilities for manipulating the native client's login and network connection state.
Proxy protocols supported by the native socket hook.
Absolute world tile coordinate.
Fine-grained coordinate, where one tile is 128 fine units.
Coordinate relative to the loaded world's origin.
Helpers for cutscene states
Utility methods for chatbox dialogue prompts and continue buttons.
Width and height pair.
Renders a config field as a combo box whose values come from a config method.
Spot animation/effect currently present in the world.
Lazy view over spot effects.
Factory methods for predicted entity combat rollouts.
Builder for entity combat tasks.
Predicts entity state for a candidate player position and tick.
Typed combat task factory.
Provides queries and interactions for items currently worn by the local player.
Item-id based equipment loadout.
Equipment slots and their corresponding worn-item inventory indexes and interface components.
Static entry point for client state and top-level game queries.
Helpers for converting client cycles to game ticks.
Helpers for resolving cache gameval names to their generated Java constant names.
A resolved gameval constant name.
Grand Exchange state and offer helpers.
Destination used when collecting completed Grand Exchange offers.
Resolves the price used when creating a Grand Exchange offer.
Mutable builder for placing a single Grand Exchange offer.
Grand Exchange interface screens.
Snapshot wrapper for a Grand Exchange offer slot.
Grand Exchange offer lifecycle state.
Grand Exchange offer direction.
Lazy view over Grand Exchange offers.
Compass headings used by game entities, represented as the client's 16-direction heading values.
Hint arrow marker, optionally targeting a unit.
Lazy view over active hint arrows.
A visible hitmark on an actor.
Helpers for the local player hud.
Exposes the game definition id for wrappers backed by cache definitions or
gameval constants.
Interface component/widget wrapper.
Java-side model builder for the native ImGui overlay renderer.
Optional advanced ImGui overlay renderer for interactive native ImGui widgets.
Helpers for submitting values to active modal dialog prompts.
Object that can expose and enqueue game menu options.
A positioned unit that also exposes menu interactions.
World-scoped interaction helpers for simple step-based plugin flows.
Static entry point for interface component queries.
Inventory accessors backed by the client's inventory data and interface components.
Item-id based inventory loadout.
Represents an item stack in an interactive item container, such as inventory, bank, or equipment.
Utilities for reading item-container memory and turning it into item views.
Listener notified when a required loadout item is not available from the bank.
Lazy view over inventory items.
Shared item filtering methods for views over item wrappers.
Actor appearance kit slots exposed by the client appearance data.
Factory methods for scoring straight or diagonal lines away from the current position.
Builder for line preference scoring.
Typed line preference task factory.
Thrown when a loadout cannot be built or applied safely.
Item-id based loadout entry.
Builder for
LoadoutItem.JSON storage for saved loadouts.
Helpers for applying inventory and equipment loadouts.
Magic spellbook helpers backed by item parameters and live player state.
Spellbook families available through the magic tab.
Helpers for the standard Make-X / skill production interface.
Resolves cache menu definitions against current varp and varbit state.
Resolved suboption text and id.
A ready-to-submit game menu action.
Builder for
MenuOption.Generates mouse movement samples before synthetic menu clicks.
Movement rate used by a simulation expansion.
Factory methods for path-dependent moving threats.
Builder for moving threats that need a path-dependent stepper.
Typed moving threat task factory.
Renders a list field as a multi-select list of enum values.
Convenience entry point for server-side path plans.
NPC actor wrapper.
Lazy view over NPCs.
Draws plugin-controlled UI over the game canvas.
Marker for classes that can be registered as plugin overlays.
Renders coord bindings as one-tile world overlays.
Formats final text values rendered by
OverlayText.Formats numeric values as compact OSRS-style GP amounts.
Default formatter based on
String.valueOf(Object).Declares a class as a simple annotation-rendered overlay panel.
Anchor position for an annotated overlay panel.
Renders rect bindings as world area overlays.
Renders text labels at client screen coordinates.
A single screen-space overlay text label.
Renders live skill progress rows in an annotated overlay panel.
Groups an annotated overlay row under a selectable tab.
Renders a field or no-argument method as text lines in an annotated overlay panel.
Player actor wrapper.
Lazy view over players.
Base class for TwiLite plugins.
Declares plugin metadata used for discovery, configuration UI, and optional overlay binding.
Prayers and their live-client state metadata.
Prayerbook helpers backed by live prayer varps and prayerbook components.
Quick-prayer state and setup helpers.
Quick-prayer setup interface helpers.
Projectile moving through the world.
Lazy view over projectiles.
Quest and miniquest metadata used for quest requirement checks.
Quest progress accessors backed by live varp and varbit values.
Convenience helpers for thread-local random values.
Real-time buy and sell prices for an item.
Loads and caches real-time Grand Exchange prices from the Old School RuneScape Wiki.
Rectangular area on a single floor, inclusive of both minimum and maximum tiles.
Grand Exchange restocking helper that can be used as a loadout depletion listener.
Configured restock entry.
Mutable search-tree node for one rollout branch.
Search limits for a rollout simulation.
Best branch selected by a rollout search.
Generic branch-local rollout search for mutable game-state problems.
Builder step after legal actions are known.
Builder for a rollout search.
Final builder step for optional terminal configuration and construction.
Builder step after actions and transition are known.
Typed access to provided simulation task factories.
Runes used by spell and rune pouch helpers.
Accesses the rune pouch contents tracked by client varbits.
Rune pouch storage slots backed by client varbits.
Loadout entry for a rune pouch and its desired contents.
Desired rune and amount for a pouch slot.
Rune pouch variant requirement.
Scene object wrapper for walls, decorations, and ground objects.
Lazy view over scene objects.
Point in client screen space.
Places a config field under the named section heading.
Snapshot of an Old School RuneScape server from the public world list.
Public world-list property flags.
Public world-list location ids.
Loads and caches the public Old School RuneScape server list.
Lazy view over loaded server-list entries.
Generic bounded-node simulator for tick-based movement planning.
Builder for attaching ordered task rules to a simulation.
Typed action signal attached to a simulated movement candidate.
Built-in action categories a simulation result can request.
Timed hazard covering a rectangular area.
Builder for rectangular area threats.
Mutable occupancy tracker for simulated entity collision.
Combat rollout state for branch-local entity prediction.
Predicts one entity for one combat tick.
Simulated entity state for movement and combat prediction.
Input-aware line-of-sight rule used by simulated entity attacks.
Per-run node state storage passed to simulation tasks.
Predicted incoming hit for a simulated movement candidate.
Threat whose next position depends on the simulated player path.
Builder for moving threats.
Mutable state for one simulated movement candidate.
Static bounds and movement settings for a simulation run.
Best movement candidate produced by a simulation run.
Hook points for adding domain-specific simulation rules.
Timed hazard centered on a coordinate.
Builder for coordinate threats.
Broad category for a timed simulation threat.
Timeline of predicted combat events for one simulated candidate path.
A spellbook entry with its backing config item and packed spellbook component id.
Ancient spellbook spells.
Arceuus spellbook spells.
Lunar spellbook spells.
Standard spellbook spells.
Overlay panels that can be stacked by anchor position.
Player skills in the same order as the client's skill arrays.
Skill accessors backed by the live client skill arrays.
Open sub-interface attached under a parent component id.
Places a config field under the named tab.
Top-level gameframe tabs.
Provides helpers for reading and opening gameframe tabs.
Text normalization helpers for game strings.
Renders a config field as a text input.
Factory methods for timed coordinate threats.
Builder for timed coordinate threat tasks.
Typed threat task factory.
Stores a predicted value that is only trusted for the current game tick.
Base class for plugins that run logic on the game server tick.
Scheduling result returned by
TickPlugin.tick().Item stack on a world tile.
Lazy view over tile items.
Top-level interface component mapping for fixed, resizable, and stretched layouts.
Generates time-based one-time passwords from plain-text or Base32 secrets.
Helpers for the player-to-player trade interfaces.
Accessors for the trade offer panel represented by the other side of the API.
Trade interface state.
Accessors for the trade offer panel represented by this side of the API.
Packed entity metadata used by minimenu actions.
Positioned object in a game world.
View specialization for positioned game units.
Small array matching helpers.
Lazy filtered view over game API objects.
Loaded game world/scene wrapper.
Transmitted world entity backed by a child world.
Coordinate projection helpers between a world entity's child space and the root world.
Coordinate helpers between loaded instance space and source template space.