RuneLite translation guide

The API keeps RuneLite's class names, method names and events. This page covers how a RuneLite plugin maps to a Bento one, and where they differ.

Plugin shape

A plugin is a folder with src/main.luau in it, and that file returns the object Plugin.new builds. The chunk body runs once, at load, like a Java constructor and its field initialisers. startUp runs on every enable and shutDown on every disable, so reset in them whatever a Java plugin would.

-- src/main.luau
local GoblinConfig = require("GoblinConfig")
local GoblinOverlay = require("GoblinOverlay")

local plugin = Plugin.new {
    name = "Goblin Watch",
    description = "Marks the nearest goblin",
    tags = { "npcs", "overlay" },
    enabledByDefault = false,
}

local config = configManager:getConfig(GoblinConfig)
local overlay = GoblinOverlay.new(config)

function plugin:startUp()
    overlayManager:add(overlay)
end

function plugin:shutDown()
    overlayManager:remove(overlay)
end

function plugin:onNpcSpawned(event)
    log:info("spawned {}", event:getNpc():getName())
end

return plugin
  • The descriptor keeps @PluginDescriptor's names: name, description, tags, enabledByDefault, hidden, conflicts, developerPlugin. Bento adds icon and dependencies, which replaces @PluginDependency.
  • Services are globals. @Inject private ItemManager itemManager needs no port: the global itemManager is there. The same goes for client, overlayManager, clientThread, eventBus, configManager and the rest.
  • Wiring annotations are dropped: @Inject, @Provides, @Singleton, @Slf4j, @Nullable. Lombok's generated methods are written by hand where other files call them.

The Java syntax translates mechanically:

JavaLuau
new T(a, b)T.new(a, b)
obj.method(a)obj:method(a)
T.staticMethod(a), T.CONSTANTT.staticMethod(a), T.CONSTANT
null, !=, !, &&, ||nil, ~=, not, and, or
c ? a : bif c then a else b
for (int i = 0; i < n; i++)for i = 0, n - 1 do
for (T x : list)for _, x in list do
try { } catch (E e) { }local ok, err = pcall(fn)
throw new X(msg)error(msg, 2)
"a" + x"a" .. x

Classes: class(Base)

A plugin's own classes and every subclass of a framework or Swing class use class(Base). X.new(...) builds the instance, and the Java constructor body is X:init(...).

-- src/GoblinOverlay.luau
local GoblinOverlay = class(Overlay, "GoblinOverlay")

function GoblinOverlay:init(config)
    self.config = config
    self:setPosition(OverlayPosition.DYNAMIC)
    self:setLayer(OverlayLayer.ABOVE_SCENE)
    self:setPriority(Overlay.PRIORITY_MED)
end

function GoblinOverlay:render(graphics)
    local goblin = scene:npcs():named("Goblin"):nearest()
    if goblin == nil then
        return nil
    end
    local tile = goblin:getCanvasTilePoly()
    if tile ~= nil then
        OverlayUtil.renderPolygon(graphics, tile, self.config:markerColor())
    end
    return nil
end

return GoblinOverlay
  • Name the class. class(Base, "Name") keys an overlay's saved position and an infobox's layer. A published plugin's modules carry no file names, so an unnamed class falls back to a name your next change can move.
  • Super calls. super(args) is X.super.init(self, args) as the first line of init; super.render(g) is X.super.render(self, g).
  • Say self:. An unqualified call to an instance method must become self:helper(). This is the most common port bug, and the error is "attempt to call a nil value".
  • Statics are not inherited. Reach them through the class that declares them: Overlay.PRIORITY_MED.
  • init is taken. Rename a Java method called init, and do not give a field the name of a method you inherit.
  • No overloads and no interfaces. Give overloads different names. Any table with the right methods satisfies an interface, and a lambda is a function.

Config

A config interface becomes a ConfigGroup, with one table per @ConfigItem and @ConfigSection. Annotations become fields. The group name and key names stay what they were, so values keep their keys.

-- src/GoblinConfig.luau
return ConfigGroup("goblinwatch", {
    ConfigSection { keyName = "marker", name = "Marker", description = "The marker's look", position = 0 },
    ConfigItem {
        keyName = "markerColor", name = "Color", description = "The marker's color",
        position = 1, section = "marker", type = Color, alpha = true, default = Color.CYAN,
    },
    ConfigItem {
        keyName = "borderWidth", name = "Border width", description = "In pixels",
        position = 2, section = "marker", type = "double", default = 2,
        range = { min = 1, max = 10 }, units = Units.PIXELS,
    },
})
  • type is the method's return type: "boolean", "int", "long", "double", "String", Color, WorldPoint, an enum, Keybind, ModifierlessKeybind, Notification, Duration, Instant, Dimension, Point, Rectangle, or { set = SomeEnum } for a set of an enum.
  • Reading. configManager:getConfig(group) returns a proxy, and config:keyName() is the current value, typed. An item never written reads as its default.
  • Writing and other groups. getConfiguration, setConfiguration, unsetConfiguration, getRSProfileConfiguration and getConfigurationKeys are on configManager. ConfigChanged is raised before setConfiguration returns.

Events

A method named on and an event's class name is a subscription: function plugin:onChatMessage(event). It takes one argument, the event, with the getters and setters you expect: event:getMessage(), event:getMenuEntry():setOption(...), event:consume().

  • Define handlers before main.luau returns. They are resolved once, at load. Use eventBus:register(obj) or eventBus:subscribe for subscriptions that come and go.
  • Do not name a helper after an event. A method called onSomething matching an event class subscribes. A @Subscribe method with another name is subscribed in Java by its parameter type, so rename it here.
  • Synchronous, in the same order. Handlers run on the game thread at the game's own call, so reads see the state the event describes. Order across plugins is priority, then plugin id, then registration order. Ties within one plugin break by registration order, so give two handlers that must run in order different priorities.
  • Setters write back. A later subscriber sees an earlier one's writes, and the game reads them when the last subscriber returns. A kept event object returns its last values, and a setter called on it later changes nothing in the game.
  • Filters. A handler that returns on its first line for most events can use eventBus:subscribe(AnimationChanged, fn, 0, { actor = "local" }). The filter is tested before your code is entered. varbit, varp, eventName and scriptId filter the same way. A handler method takes its filter from the object's eventFilters table, keyed by the method's name.
  • Script events: name the scripts. An onScriptPreFired or onScriptPostFired handler with no filter takes every script the client runs, as in RuneLite. Give it a scriptId filter where you can: plugin.eventFilters = { onScriptPostFired = { scriptId = { ScriptID.X } } }, or the fourth argument to eventBus:subscribe. Take the ids from the handler's first-line getScriptId() == X tests. Subscribe once, not every tick.

Handles and values

  • Entities are handles. NPC, Player, TileObject, TileItem, Projectile, Widget and friends have one handle per spawn, so == and table keys work, and they survive across ticks. After a despawn a handle returns its last values; isPresent() asks whether it is still there. A getter reads the game live, so keep what you use twice in a local.
  • WorldPoint is a value. == compares coordinates and it works as a table key. wp.x, wp.y and wp.z are fast fields. Do not use vector arithmetic on one; use wp:dx(n) and wp:dy(n).
  • AWT values keep Java's identity. == on Point, Dimension and Insets is identity, and :equals compares values. A table keys them by identity too, so key a map by a WorldPoint or a string instead.
  • Colours are numbers. Color.new(r, g, b, a) and Color.RED are packed integers, so instance methods become statics: Color.getRed(c).
  • One number type. Luau has a 64-bit float. // floors where Java's int division truncates, % takes the divisor's sign, and nothing wraps on overflow. 0 and "" are true, so write if x ~= 0 then.
  • Strings are bytes. #s counts bytes, and string.find takes a Lua pattern unless you pass 1, true. Use Regex and Pattern for Java's regular expressions.

Collections and indexing

A position in a list you hold is 1-based, and a number the game owns keeps the game's meaning.

  • Returned lists are 1-based arrays: list.get(0) is list[1]. Write loops as for _, npc in client:getNpcs() do, which also works when a call returns an iterator instead of an array.
  • Index arguments keep their meaning. widget:getChild(0) is the first child, and container:getItem(0) the first slot.
  • Nullable arrays such as composition:getActions() are tables with holes plus n: loop to actions.n, because #actions is not the length.
  • Live lists such as panelComponent:getChildren() are the list itself: table.insert is .add.
  • Sets and maps are tables, and a table has no order. Walk Skill.values() or an array wherever an EnumMap or LinkedHashMap's order shows. table.sort takes a less-than function and is not stable.

Enums

A constant is one interned value, so == and table keys work. Java's methods stay methods: Skill.ATTACK:name(), :ordinal() (0-based), :toString(), :compareTo(). The class has Skill.values() and Skill.valueOf("ATTACK"). values() is one frozen array, so table.clone it before sorting. A switch is an if and elseif chain.

Your own enums use enum("Mode", { "ALWAYS", "NEVER" }) and have the same methods. A constant with data is { "NEXT", "Next world" } plus a constructor as the third argument. Constants are frozen once built, so keep mutable state elsewhere.

Threading and task

All plugin code runs on the game's client thread: handlers, overlays, Swing listeners, timers and tasks. synchronized and AtomicInteger become plain variables. There is no other thread to hand work to, and a callback that blocks holds up the game: a 50 ms handler is a 50 ms hitch, and a loop that never returns freezes it.

  • clientThread keeps its timing, since ports use it to schedule: invoke, invokeLater, invokeAtTickEnd, and a job that returns false runs again.
  • Delays. executor:schedule(fn, 5, TimeUnit.SECONDS) works as written. The shorter forms are timer:after(ms, fn), timer:every(ms, fn), timer:afterTicks(n, fn) and timer:everyTicks(n, fn).
  • Blocking code runs as a task, a coroutine resumed once per game tick. sleepTicks(n) and waitUntil(pred, ticks) suspend it. Durations are in ticks. Yield only from the task's own code, not from inside a table.sort comparator or a render.
local trip = task(function()
    bank:open()
    if not waitUntil(function() return bank:isOpen() end, 10) then
        return -- gave up after 10 ticks
    end
    sleepTicks(2)
    log:info("bank is open")
end)

-- Later, or leave it: shutDown cancels every task still running.
trip:cancel()
  • Errors. An uncaught error is logged and the plugin carries on. An error in startUp fails the plugin, and a task that raises stops alone.
  • HTTP is asynchronous only: okHttpClient:newCall(r):enqueue(cb) or http:get(url, fn), with the callback on the client thread. A local plugin is unrestricted. A published plugin reaches only the OSRS Wiki's API. Every request to the wiki, from any plugin, needs a User-Agent you set with RequestBuilder:header, where the original sent the client's own; see Limits. The DPS calculator's link comes from wiki:dpsCalculatorLink(userAgent, fn) rather than a shortlink request of your own.

Overlays

The overlay framework is the one you know: subclass Overlay, OverlayPanel, WidgetItemOverlay or WidgetOverlay, and register it with overlayManager:add(overlay). render(graphics) runs every frame and returns a Dimension or nil. The default layer is UNDER_WIDGETS, positions and Alt-drag work, and saved positions live in the client config group.

graphics is a Graphics2D with Java's names: state setters, drawString with y on the baseline, draw(shape), fill(shape), and drawImage, where you pass nil for the observer. Perspective, OverlayUtil, ImageUtil, FontManager and the panel components keep their names, and infoboxes are class(InfoBox), Counter and Timer through infoBoxManager.

A new plugin can also define plugin:renderOverlay(draw, layer), whose Draw surface takes WorldPoints and stays on the tile while the camera turns.

Swing

Side panels are Swing under Swing's names. JPanel, JLabel, JButton, the layout managers, the borders, PluginPanel and MaterialTabGroup are all there, so a port builds the tree the Java builds: class(PluginPanel, "ExamplePanel"), a constructor in init, listeners as functions, and clientToolbar:addNavigation(NavigationButton.builder():panel(panel):build()). Bento lays out and paints the tree, and your code runs only in constructors and listeners.

  • On the client thread. A slow listener stalls the game.
  • Dialogs. Inside a listener, JOptionPane.showConfirmDialog blocks and returns its answer. Anywhere else, use ui:confirmDialog with a callback. JFileChooser is ui:fileOpen and ui:fileSave, which return bytes and never a path.
  • Timers. javax.swing.Timer is SwingTimer.new(delay, listener), because Timer is the infobox timer.
  • Not there. JTable and JTree are not bound, and a Luau Border's paintBorder and an Icon's paintIcon are not painted.

A new plugin does not need any of this: function plugin:sidePanel(panel) is the short form, shown in Write a plugin. Swing, AWT and the JDK classes are in the Compatibility classes section of the reference.

Acting on the game

client.menuAction has no equivalent. A plugin names what it wants to act on, and the action is queued and happens over the next frames, so true means queued, not done. A call that fails on game state returns false or nil; wrong use raises.

  • Entities: npc:interact(option), tileObject:interact(option), tileItem:interact(option), widget:interact(...).
  • Finding them: scene:npcs():named("Goblin") matches the whole name, and containing matches part of it.
  • Walking: player:walkTo(worldPoint), and player:webwalk():start(worldPoint) for a route across the map.
  • The bank: bank:newLoadout(equipment, inventory) builds a goal, and :run() moves towards it.

Different names

Three kinds of name differ. A name carrying the RuneLite brand has a client-neutral one with no alias, so the old name reads nil or raises; semantics are unchanged. A member that cannot work the same way has a similar name: Ping.ping blocks, so it is Ping.pingCached. A nested class takes a flat name: new Request.Builder() is RequestBuilder.new().

Some things have no counterpart: the GPU plugin's renderer and custom renderers, RuneLite account sessions, the plugin hub, the party relay and JNA. A File stays inside the plugin's own directory. pluginManager lists, starts and stops every plugin, as RuneLite's does, and returns each one's own object. A published plugin gets a local package's object as a read-only view. It calls the package's methods and reads its fields. While that call runs, the package is held to the published plugin's limits, and so is whatever the call registers (timers, overlays, listeners), whenever it runs. The published plugin reads the package's config without writing it.

Lookup table

The differences you are most likely to meet. A symbol not listed here most likely has its RuneLite name: search for it with /. Stand-ins for Swing, AWT, the JDK and third-party libraries are listed under Compatibility classes.

RuneLiteBentoNote
@PluginDescriptor(...) class P extends PluginPlugin.new { ... }The same field names. src/main.luau returns the object.
@Inject ItemManager itemManageritemManagerEvery injected service is a global, named as the field conventionally is.
@Provides provideConfig(ConfigManager)configManager:getConfig(Group)The first group asked for during load is the plugin's own. Define plugin:provideConfig() to choose another.
@PluginDependency(Other.class)dependencies = { "other" }A field of Plugin.new, by plugin id.
@Subscribe onGameTick(GameTick e)function plugin:onGameTick(event)The method name is the subscription.
@Subscribe(priority = 5)eventBus:subscribe(GameTick, fn, 5)A fourth argument adds a filter.
eventBus.register(obj)eventBus:register(obj)on<Event> methods of any table subscribe.
@ConfigGroup, @ConfigItem, @ConfigSectionConfigGroup, ConfigItem, ConfigSectionFunctions taking tables.
@Range(min = 1, max = 10)range = { min = 1, max = 10 }A field of ConfigItem.
@Alphaalpha = trueA field of ConfigItem.
@Units(Units.PIXELS)units = Units.PIXELSA field of ConfigItem.
@Slf4j, log.info("x {}", v)log:info("x {}", v)The same {} placeholders. Debug and trace write nothing by default.
new T(a, b)T.new(a, b)
obj.method(a)obj:method(a)A colon passes the receiver. A static call keeps the dot.
obj.end(), a.until(b, unit)obj:end_(), a:until_(b, unit)A member named like a Luau reserved word gets _.
class X extends Overlaylocal X = class(Overlay, "X")Name every overlay and infobox class: the name keys its saved position.
super(a)X.super.init(self, a)The first line of X:init.
super.render(g)X.super.render(self, g)
x instanceof MyClassMyClass.isInstance(x)True for a subclass too.
x instanceof NPCtypeof(x) == "NPC"For handle, enum and value classes.
enum Mode { ALWAYS, NEVER }enum("Mode", { "ALWAYS", "NEVER" })Constants are frozen after construction.
Skill.ATTACK.name(), .ordinal()Skill.ATTACK:name(), :ordinal()Methods, and ordinal stays 0-based.
list.get(0)list[1]A list the API returns is a 1-based array.
widget.getChild(0)widget:getChild(0)Index arguments keep their meaning: this is the first child.
composition.getActions()composition:getActions()A table with holes: loop to actions.n, not #actions.
Set<T>, Map<K, V>{ [k] = true }, { [k] = v }Tables have no order. Walk an array where order shows.
new WorldPoint(x, y, plane)WorldPoint.new(x, y, plane)A value: == compares coordinates, and it works as a table key.
worldPoint.getPlane()wp:getPlane(), wp.zwp.x, wp.y and wp.z are fast fields. wp.plane is an error.
color.getRed(), color.darker()Color.getRed(c), Color.darker(c)A colour is a packed number, so its methods are statics.
point.equals(other)point:equals(other)== is identity on Point, Dimension and Insets, as in Java.
client.getAccountHash()client:getAccountHashString()A string, because a number cannot hold a long beyond 2^53.
Thread.sleep(600)sleepTicks(1)Inside task(fn). Durations are in game ticks.
a worker thread's wait loopwaitUntil(pred, ticks)Inside task(fn). Returns whether pred became true.
executor.schedule(r, 5, SECONDS)executor:schedule(fn, 5, TimeUnit.SECONDS)Runs on the client thread. timer:after(5000, fn) is the shorter form.
@Schedule(period = 1, unit = SECONDS)timer:every(1000, fn)timer:everyTicks(n, fn) counts game ticks.
clientThread.invokeLater(r)clientThread:invokeLater(fn)Same timing, and returning false runs it again.
SwingUtilities.invokeLater(r)SwingUtilities.invokeLater(fn)Ports as written, though everything is already on one thread.
synchronized, volatile, AtomicIntegerplain variablesAll plugin code runs on one thread.
System.currentTimeMillis()Instant.now():toEpochMilli()utils:elapsedMs() measures a difference within the session.
javax.swing.TimerSwingTimer.new(delay, listener)Timer is the infobox timer.
JOptionPane.showConfirmDialog(...)ui:confirmDialog(...)With a callback, outside a Swing listener. Inside one, JOptionPane works as written.
JFileChooserui:fileOpen, ui:fileSaveThey return bytes, never a path.
NavigationButton.builder().tooltip(t).build()NavigationButton.builder():tooltip(t):build()
call.execute()call:enqueue(callback)No blocking call. The callback runs on the client thread.
new Request.Builder()RequestBuilder.new()A nested class takes a flat name. http:get is the shorter form.
gson.toJson(x), gson.fromJson(s, T.class)Json.encode(x), Json.parse(s)Plain tables come back: rebuild your own classes from them.
getResourceAsStream("x.json")Asset.text("assets/x.json"), Asset.bytes(...)An asset ships only if your source names it with a literal path.
ImageUtil.loadImageResource(getClass(), "x.png")ImageUtil.loadImageResource(plugin, "x.png")Reads assets/x.png.
s.split(regex), s.replaceAll(regex, r)Regex.split(s, regex), Regex.replaceAll(s, regex, r)Java's regex syntax. string.gsub takes Lua patterns.
s.contains(t)string.find(s, t, 1, true) ~= nilWithout 1, true the text is a Lua pattern.
a / b on intsa // bBoth non-negative only: // floors where Java truncates.
client.menuAction(...)npc:interact(option), widget:interact(...)Actions name what they act on. true means queued, not done.
Scene.setRoofRemovalMode(int)client:getScene():setRoofsHidden(hidden)Takes no mode: it hides every roof above the player's plane. Each plugin's setting is its own.
Ping.ping(world)Ping.pingCached(world)The last measured time, or -1. Nothing can block the game thread.
hiscoreClient.lookup(name, endpoint)hiscoreClient:lookupAsync(name, endpoint)Or lookupCached, which returns nil until the result arrives.
RuneLite.RUNELITE_DIRClientPaths.CLIENT_DIRCACHE_DIR, NOTIFICATIONS_DIR and SCREENSHOT_DIR move too. A File stays inside the plugin's own directory.
RuneLiteObject, client.createRuneLiteObject()ClientObject, client:createClientObject()
RuneLiteObjectControllerClientObjectController
RuneLiteConfigclientConfigIts type is ClientConfig. Read-only.
MenuAction.RUNELITE, RUNELITE_OVERLAY, ...MenuAction.CLIENT, CLIENT_OVERLAY, ...Every RUNELITE* constant, with the same id. The old names raise.
InputType.RUNELITE, RUNELITE_CHATBOX_PANELInputType.CLIENT, CLIENT_CHATBOX_PANEL
MessageNode.getRuneLiteFormatMessage()messageNode:getClientFormatMessage()setClientFormatMessage writes it.
QueuedMessage.builder().runeLiteFormattedMessage(s)QueuedMessage.builder():clientFormattedMessage(s)
RuneliteColorPickerColorPickerWhat colorPickerManager:create returns.
config group "runelite"config group "client"Overlay positions, fonts and notification defaults.
PartyService, WSClientNoneBento has no party server. Keep what runs outside a party.
SessionManagerNoneBento has no such account. Keep the signed-out branch.
JTable, JTreeNoneNot bound.
api.AnimationIDLegacyAnimationIDRuneLite's older id class. AnimationID here holds the game's own names, as gameval.AnimationID does.
api.InventoryIDLegacyInventoryIDThe older enum. InventoryID here holds the game's own names, as gameval.InventoryID does.
api.ItemIDLegacyItemIDRuneLite's older id class. ItemID here holds the game's own names, as gameval.ItemID does.
api.NpcIDLegacyNpcIDRuneLite's older id class. NpcID here holds the game's own names, as gameval.NpcID does.
api.ObjectIDLegacyObjectIDRuneLite's older id class. ObjectID here holds the game's own names, as gameval.ObjectID does.
chat.TaskChatTaskA slayer task as the chat API stores it (!task).
ChatClientChatApiThe chat API: the kill counts, personal bests and the rest that !kc-style chat commands show.
chatClient.getDuels()chatApi:getDuelsAsync()The duel record, nil until fetched.
chatClient.getGc()chatApi:getGcAsync()The gamble count, nil until fetched.
chatClient.getKc()chatApi:getKcAsync()The kill count, nil until fetched.
chatClient.getLayout()chatApi:getLayoutAsync()The raid layout, nil until fetched.
chatClient.getPb()chatApi:getPbAsync()The personal best in seconds, nil until fetched.
chatClient.getPetList()chatApi:getPetListAsync()The pets' item ids, nil until fetched.
chatClient.getQp()chatApi:getQpAsync()Quest points, nil until fetched.
chatClient.getTask()chatApi:getTaskAsync()The slayer task, nil until fetched.
chatClient.submitDuels()chatApi:submitDuelsAsync()Submit the duel record, sent in the background.
chatClient.submitGc()chatApi:submitGcAsync()Submit the gamble count, sent in the background.
chatClient.submitKc()chatApi:submitKcAsync()Submit the kill count, sent in the background; true when it was queued, whether or not the server takes it.
chatClient.submitLayout()chatApi:submitLayoutAsync()Submit the raid layout, sent in the background.
chatClient.submitPb()chatApi:submitPbAsync()Submit the personal best, sent in the background.
chatClient.submitPetList()chatApi:submitPetListAsync()Submit the pet list, sent in the background.
chatClient.submitQp()chatApi:submitQpAsync()Submit quest points, sent in the background.
chatClient.submitTask()chatApi:submitTaskAsync()Submit the slayer task, sent in the background. location may be nil (a task with none): the parameter is sent with no value.
client.setIdleTimeout()client:setIdleTimeoutMinutes()Set the idle logout, in whole minutes: the client keeps it in minutes (its "AFK timeout" setting).
drawManager.requestNextFrameListener()imageCapture:requestNextFrame()Calls back once, with the next frame drawn.
dynamicObject.getAnimation()gameObject:getAnimationId()The animation's id, in one call.
Geometry.filterPath()Perspective.localPathToCanvas()Projects and clips a path in one call.
Geometry.transformPath()Perspective.localPathToCanvas()Projects and clips a path in one call.
HiscoreClientHiscoreLookupThe hiscoreClient global's class: lookupAsync returns a future (uncached), and lookupCached returns a cached result to poll.
IterableHashTableChatMessageTableThe chat history by message id: what client:getMessages() returns. for _, node in table walks every message, oldest first.
messageNode.setRuneLiteFormatMessage()messageNode:setClientFormatMessage()Set the client format the chatbox shows in place of the text; nil shows the text again.
playerLootReceived.getPlayer()playerLootReceived:getPlayerName()The dead player's name, as the last tick before it despawned had it ("" when none did).
queuedMessage.getRuneLiteFormattedMessage()queuedMessage:getClientFormattedMessage()The client-formatted markup, or nil.
queuedMessage.setRuneLiteFormattedMessage()queuedMessage:setClientFormattedMessage()Set the client-formatted markup.
rsTimeUnit.getDuration()rsTimeUnit:getDurationMillis()getDurationMillis(): the constant's duration as a number of milliseconds.
widgets.InterfaceIDLegacyInterfaceIDRuneLite's older id class. InterfaceID here holds the game's own names, as gameval.InterfaceID does.
worldMapOverlay.mapWorldPointToGraphicsPoint()worldMap:worldPointToGraphicsPoint()nil when the map is shut or does not show the tile.
worlds.WorldTypeHttpWorldTypeThe world list's types. WorldType here is the client API's.