ChatTriggers Framework

Triggers are the fundamental building block of ChatTriggers. You use the register function to listen for specific events.

Common patterns include:

• Chat Triggers: Run code when a specific chat pattern is matched. You can use .setCriteria() to define the pattern and access captured groups.
• Render Triggers: Run code during specific rendering phases (e.g., renderCrosshair).

Note: You can use cancel(event) within a trigger to prevent the original Minecraft event from proceeding.

// Example: A chat trigger that intercepts a message and re-chats it
register("chat", function(name, message, event) {
  cancel(event);
  ChatLib.chat(name + ": " + message);
}).setCriteria("<${name}> ${message}");

// Example: A render trigger that draws a small rectangle at the center of the screen
register("renderCrosshair", function(event) {
  cancel(event);
  Renderer.drawRect(
    0x50ffffff,
    Renderer.screen.getWidth() / 2 - 1,
    Renderer.screen.getHeight() / 2 - 1,
    2, 2
  );
});

The custom Rhino engine supports several modern JavaScript features:

Exponentiation Operator (**)

Replaces Math.pow. Note: if the first argument is negative, you must use parentheses to avoid syntax errors.

print((-5) ** 2); // '25'

Array and Object features

• Array.prototype.includes(object)
• Array.prototype.lastItem / lastIndex
• Object.values(object) / Object.entries(object)
• Object.getOwnPropertyDescriptors(object)
• Object Rest/Spread (ES9):

  const { a, ...rest } = { a: 1, b: 2, c: 3 }; // rest === { b: 2, c: 3 }
  const o = { a: 1, ...spread };

Advanced Operators

• Optional Chaining (?.): Safely access nested properties.
• Nullish Coalescing (??): Returns the right-hand side if the left-hand side is null or undefined.
• Throw Expressions: throw can now be used inside expressions (e.g., in function parameters or with ??).
• Pipeline Operator (|>): Inlines multiple chained function calls.

  const result = a |> f3 |> f2 |> f1;

ChatTriggers' Rhino engine supports modern class syntax and decorators.

Class Fields

Supports public, private (using #), and static fields.

class Foo {
    x = 5;
    #y = 10; // private
    static z = 15;
}

Built-in Decorators

• @wrap(fn): Runs before class creation. The function receives the target (method or class) and returns a new version of it.
• @register(fn): Runs after class creation. The function receives the target (class or prototype) and the key (for public elements).
• @initialize(fn): Runs inside the constructor during instantiation. The function receives (target, key, value).

User-Defined Decorators (UDDs)

Custom decorators can be defined using the decorator keyword and must consist of other decorators.

class Foo {
    @wrap(method => () => method() * 2)
    x() {
        return 6;
    }
}

print((new Foo).x()); // '12'

The following built-in libraries and methods have changed or been added in version 1.0.0:

• Removed: XMLHttpRequest (use the request module instead).
• Commands: ChatLib.command now includes an optional parameter to trigger other client-side commands.
• Message: Added Message#getFormattedText and Message#getUnformattedText.
• Tessellator:
  • Added Tessellator.getRenderPos(x, y, z).
  • Changed parameter order for Tessellator.drawString:
    • Old: (text, x, y, z, renderBlackBox, partialTicks, scale, color, increase)
    • New: (text, x, y, z, color, renderBlackBox, scale, increase)
• Renderer: Added Renderer.getRenderManager.
• World/Client: Moved World.showTitle to Client.showTitle.
• Inventory: Changed parameter order for Inventory#click:
  • Old: (slot, button, shift)
  • New: (slot, shift, button)
• New Triggers: registerRenderArmor.

The following additional functions and properties are available in the custom Rhino build:

Math & Conversion

• Math.signBit(number), Math.clamp(value, min, max)
• Math.DEG_PER_RAD, Math.RAD_PER_DEG
• Math.degrees(number), Math.radians(number)
• Math.fscale(value, min1, max1, min2, max2), Math.scale(value, min1, max1, min2, max2)

Set & Map Operations

• Set.prototype.intersection(set), union(set), difference(set), symmetricDifference(set), isDisjointFrom(set), isSubsetOf(set), isSupersetOf(set), addAll(...items), deleteAll(...items), every(fn), filter(fn), find(fn), join(string), map(fn), reduce(fn, initialValue), some(fn)
• Map.prototype.upsert(key, insertFn, updateFn), merge(map), reduce(fn, initialValue), mapKeys(fn), mapValues(fn), keyBy(set, keyFn), groupBy(set, groupFn)
• Map.prototype.deleteAll(...keys), Map.prototype.every(fn), Map.prototype.filter(fn), Map.prototype.find(fn), Map.prototype.findKey(fn), Map.prototype.includes(obj), Map.prototype.keyOf(obj)

WeakMap/WeakSet

• WeakMap.prototype.upsert(...), deleteAll(...keys)
• WeakSet.prototype.addAll(...items), deleteAll(...items)

A BlockType is an immutable wrapper around a Minecraft block definition. It represents the concept of a block (e.g., 'Stone') rather than a specific instance of a block at a specific coordinate in the world. To interact with a specific block in the world, use withBlockPos(blockPos) to create a Block object.

You can instantiate a BlockType using several different methods:

• By Name: Using the registry name (e.g., minecraft:planks).
• By ID: Using the integer block ID.
• From an Item: Using an existing Item object.
• From another BlockType: Using a copy constructor.

// By registry name
const stoneType = new BlockType("minecraft:stone");

// By ID
const stoneTypeById = new BlockType(1);

// From an Item
const item = ...; // some Item object
const stoneTypeFromItem = new BlockType(item);

// Convert to a specific block instance at a position
const blockAtPos = stoneType.withBlockPos(new BlockPos(0, 64, 0));