Function Reference

Broadcasts a message on the specified channel within 20m range. Channel 0 is public chat visible to all nearby avatars.

// Greet anyone nearby on public chat
this.say(0, "Hello, world!");

// Send data on a private channel
this.say(42, "secret-handshake:confirmed");

Sends a message on the specified channel with a 10m range — half the range of say.

// Whisper a hint to nearby avatars
this.whisper(0, "Psst... click the red button.");

Shouts a message on the specified channel with a 100m range — five times the range of say.

// Announce an event across a wide area
this.shout(0, "The treasure hunt begins in 30 seconds!");

Broadcasts a message region-wide on a non-zero channel. Cannot be used on channel 0 to prevent spam.

// Broadcast a game state update to all listeners in the region
this.world.regionSay(100, JSON.stringify({ event: "round-start", round: 3 }));

Sends a message to a specific object or avatar by UUID, anywhere in the region.

// Send a direct message to a specific object
this.world.regionSayTo(targetId, 42, "ping");

Registers a listener for messages on a channel. Filter by sender name, UUID, or message content. Returns a handle for later removal.

// Listen for all messages on channel 42
const handle = this.listen(42, "", "", "");

// Listen for a specific command from anyone
const cmdHandle = this.listen(0, "", "", "open sesame");

Removes a previously registered listener. In poqpoq, call .remove() on the handle returned by listen().

const handle = this.listen(42, "", "", "");
// Later, stop listening
handle.remove();

Sends a private instant message to an avatar by UUID. The message appears in their IM window.

// Notify the owner when someone touches the object
this.world.instantMessage(this.owner.id, "Your object was touched!");

Sends a message visible only to the object's owner. Useful for debug output and owner-only notifications.

// Debug output only the owner sees
this.say(0, "State changed to: " + currentState);

Sends a link message to other scripts in the same object. Used for inter-script communication within a linkset.

// Tell all scripts in this object to reset
this.sendLinkMessage(LINK_SET, 0, "reset", "");

// Send data to the root prim's scripts
this.sendLinkMessage(LINK_ROOT, 100, "update-score", "42");

Moves the object to the given position. Unlike LSL, there is no 0.2-second delay between moves.

// Move to a specific world coordinate
this.object.setPosition({ x: 128, y: 128, z: 25 });

// Move relative to current position
const pos = this.object.getPosition();
this.object.setPosition({ x: pos.x, y: pos.y, z: pos.z + 5 });

Returns the object's current position as a Vector3 ({ x, y, z }).

const pos = this.object.getPosition();
this.say(0, `I'm at <${pos.x}, ${pos.y}, ${pos.z}>`);

Sets the object's rotation using a quaternion ({ x, y, z, w }).

// Rotate 90 degrees around the Z axis
const rot = Quaternion.fromEuler({ x: 0, y: 0, z: Math.PI / 2 });
this.object.setRotation(rot);

Returns the object's current rotation as a quaternion ({ x, y, z, w }).

const rot = this.object.getRotation();
this.say(0, `Facing: ${rot.w.toFixed(2)}`);

Sets the object's size. Each axis can be scaled independently.

// Make the object twice as tall
this.object.setScale({ x: 1, y: 1, z: 2 });

// Uniform scale to 50%
this.object.setScale({ x: 0.5, y: 0.5, z: 0.5 });

Returns the object's current size as a Vector3 ({ x, y, z }).

const size = this.object.getScale();
this.say(0, `Size: ${size.x} x ${size.y} x ${size.z}`);

Sets the color of one face or all faces of the object. Color is an RGB vector with values from 0 to 1.

// Make the whole object red
this.object.setColor({ x: 1, y: 0, z: 0 }, ALL_SIDES);

// Set just face 0 to blue
this.object.setColor({ x: 0, y: 0.4, z: 1 }, 0);

Sets the transparency of the object. 1.0 is fully opaque, 0.0 is fully invisible.

// Make the object semi-transparent
this.object.setAlpha(0.5, ALL_SIDES);

// Make it invisible
this.object.setAlpha(0.0, ALL_SIDES);

Applies a texture to one or all faces of the object by asset name or UUID.

// Apply a texture to all faces
this.object.setTexture("wood-planks", ALL_SIDES);

// Apply to a specific face
this.object.setTexture("glass-panel", 2);

Displays floating text above the object. Set text to empty string to remove it.

// Show a label above the object
this.object.setText("Welcome!", { x: 0, y: 1, z: 0 }, 1.0);

// Remove floating text
this.object.setText("", { x: 0, y: 0, z: 0 }, 0);

Sets multiple visual properties of the object at once using a structured config instead of LSL's flat rule list.

// Set a shiny metal appearance on face 0
this.object.setMaterial({
  color: { x: 0.8, y: 0.8, z: 0.9 },
  glow: 0.1,
  shininess: 0.9
}, 0);

Returns the name of the object this script is running in.

const name = this.object.name;
this.say(0, `I am ${name}`);

Returns the description string of the object.

const desc = this.object.description;
if (desc) this.say(0, desc);

Returns the UUID of the object this script is running in.

const myId = this.object.id;
this.say(0, `My UUID is ${myId}`);

Returns the UUID of the avatar who created this object.

const creator = this.object.creatorId;
this.say(0, `Created by ${creator}`);

Returns the UUID of the object's current owner.

const ownerId = this.owner.id;
this.world.instantMessage(ownerId, "Script initialized!");

Returns the number of prims (links) in the linkset, including seated avatars.

const count = this.object.getLinkCount();
this.say(0, `This object has ${count} linked parts`);

Returns the UUID of a specific link (prim) in the linkset by link number.

const rootId = this.object.getLink(1)?.id;
if (rootId) this.say(0, `Root prim: ${rootId}`);

Applies an instantaneous force impulse to a physical object. If local is true, force is relative to the object's rotation.

// Launch the object upward
this.object.applyImpulse({ x: 0, y: 0, z: 10 }, false);

// Push forward relative to the object's facing direction
this.object.applyImpulse({ x: 5, y: 0, z: 0 }, true);

Applies an instantaneous rotational impulse (torque) to a physical object, causing it to spin.

// Spin the object around the Y axis
this.object.applyTorque({ x: 0, y: 5, z: 0 }, false);

Applies a continuous force to a physical object. The force persists until changed or set to zero.

// Apply a constant upward force (hover effect)
this.object.applyForce({ x: 0, y: 0, z: 9.8 }, false);
// Stop the force
this.object.applyForce({ x: 0, y: 0, z: 0 }, false);

Returns the object's current velocity as a Vector3. Useful for physics calculations and movement prediction.

const vel = this.object.getVelocity();
const speed = Math.sqrt(vel.x ** 2 + vel.y ** 2 + vel.z ** 2);
this.say(0, `Speed: ${speed.toFixed(1)} m/s`);

Controls how gravity affects a physical object. In poqpoq, gravity is toggled on/off via physics config rather than a float buoyancy value.

// Make the object float (disable gravity)
this.object.setPhysics({ gravity: false });

Smoothly moves a physical object toward a target position over a duration. Uses animation options instead of LSL's tau parameter.

// Glide to a position over 2 seconds
this.object.setPosition({ x: 128, y: 128, z: 30 }, { duration: 2.0 });

Configures the physical material properties of the object such as friction, restitution (bounciness), and density.

// Make the object bouncy like a rubber ball
this.object.setPhysics({ restitution: 0.9, friction: 0.3 });

Returns the UUID of a detected agent or object from a sensor or touch event. In poqpoq, use array indexing on the detected parameter.

// In a touch_start handler
const toucherId = detected[0].id;
this.say(0, `Touched by ${toucherId}`);

Returns the name of a detected agent or object from a sensor or touch event.

const who = detected[0].name;
this.say(0, `Hello, ${who}!`);

Returns the position of a detected agent or object at the time of detection.

const pos = detected[0].position;
this.say(0, `They are at ${pos.x.toFixed(0)}, ${pos.y.toFixed(0)}`);

Returns the rotation of a detected agent or object at the time of detection.

const rot = detected[0].rotation;
// Use rotation to orient a response effect

Returns the velocity of a detected agent or object at the time of detection.

const vel = detected[0].velocity;
const isMoving = vel.x !== 0 || vel.y !== 0 || vel.z !== 0;

Returns the type of a detected entity (agent, active object, passive object, scripted, etc.).

const type = detected[0].type;
if (type === AGENT) this.say(0, "An avatar touched me!");

Returns the bounding box size of an avatar. In poqpoq, agent size is not directly available; agent position is returned instead.

const agentPos = agent.getPosition();
// Agent size not yet fully supported

Requests runtime permissions from an avatar (e.g., animation, camera control, payments). Triggers a run_time_permissions event when granted.

// Request permission to animate the toucher
this.requestPermissions(detected[0].id, PERMISSION_TRIGGER_ANIMATION);

Sets a sit target on the object, defining where and how an avatar sits on it.

// Set a sit position 0.5m above the object
this.object.setSitTarget(
  { x: 0, y: 0, z: 0.5 },
  { x: 0, y: 0, z: 0, w: 1 }
);

Attaches the object to the specified attachment point on the avatar who granted permissions.

// Attach to the right hand
this.world.attachToAvatar(ATTACH_RHAND);

Temporarily attaches the object to an avatar. The attachment is removed when the avatar logs out.

// Temporarily attach a party hat
this.world.attachToAvatarTemp(ATTACH_HEAD);

Detaches the object from the avatar it is currently attached to.

// Detach after use
this.say(0, "Removing attachment...");
this.world.detachFromAvatar();

Returns the attachment point the object is attached to, or 0 if not attached to any avatar.

const point = this.object.getAttached();
if (point > 0) this.say(0, "I am worn as an attachment");

Creates a particle emitter on the object. Uses a structured ParticleConfig object instead of LSL's flat rule list. Pass an empty config to stop particles.

// Fire-like particle effect
this.object.particles({
  texture: "flame",
  color: { start: { x: 1, y: 0.6, z: 0 }, end: { x: 1, y: 0, z: 0 } },
  alpha: { start: 0.8, end: 0.0 },
  scale: { start: { x: 0.3, y: 0.3, z: 0 }, end: { x: 0.1, y: 0.1, z: 0 } },
  count: 20,
  rate: 0.05,
  lifetime: 1.5,
  speed: { min: 0.5, max: 1.5 },
});

// Stop particles
this.object.particles({});

Plays a sound once at the object's position. The sound is spatialized — it gets quieter with distance.

// Play a click sound
this.object.playSound("ui-click");

Plays a sound in a continuous loop at the specified volume (0.0 to 1.0).

// Ambient waterfall sound at 60% volume
this.object.loopSound("waterfall-ambient", 0.6);

Stops any currently playing or looping sound on the object.

// Stop the looping sound
this.object.stopSound();

Plays a sound at full volume regardless of distance. Unlike playSound, the sound is not spatialized.

// Play a UI notification at full volume
this.object.playSound("notification", { spatial: false });

Sets visual properties on a linked prim without the usual delay. In poqpoq, all property changes are instant.

// Change color of link 2
this.object.getLink(2)?.setMaterial({
  color: { x: 1, y: 0, z: 0 },
  glow: 0.2
});

Starts a repeating timer that fires the timer() event at the specified interval in seconds. Set to 0 to stop. poqpoq supports multiple named timers.

// Fire timer() every 2 seconds
this.setTimer(2.0);

// Stop the timer
this.setTimer(0);

Pauses the current script for the specified duration. Unlike LSL, this does NOT block other scripts — it uses async/await.

// Wait 3 seconds, then do something
await this.delay(3.0);
this.say(0, "Done waiting!");

Performs a one-shot scan for objects or avatars within range and arc. Triggers sensor() or no_sensor() event.

// Scan for avatars within 20m, 90-degree arc
this.sensor("", "", AGENT, 20.0, Math.PI / 2);

Starts a repeating sensor scan at the specified rate (in seconds). Triggers sensor() or no_sensor() on each scan.

// Scan for nearby avatars every 5 seconds within 30m
this.sensorRepeat("", "", AGENT, 30.0, Math.PI, 5.0);

Stops the currently active repeating sensor scan started by sensorRepeat().

// Stop scanning for avatars
this.sensorRemove();

Casts a ray between two points and returns information about what it hits. Useful for line-of-sight checks and targeting.

// Check if there's a clear line of sight
const hits = this.world.raycast(
  this.object.getPosition(),
  targetPos
);

Returns the number of avatars currently present in the region.

const count = this.world.getAgentCount();
this.say(0, `There are ${count} visitors here.`);

Returns a list of all avatars currently in the region with their IDs and positions.

const agents = this.world.getAgents();
for (const agent of agents) {
  this.say(0, agent.name);
}

Reads data from persistent storage. In poqpoq, notecards are replaced by a key-value store that returns data directly via await.

// Read a config value
const greeting = await this.world.storage.get("welcome-message");
this.say(0, greeting ?? "Welcome!");

Makes an HTTP request to an external URL. Returns the response directly via await — no callback event needed.

// Fetch data from an API
const response = await this.world.http.get("https://api.example.com/scores");
this.say(0, `High score: ${response}`);

Deprecated. LSL scripts had a 64KB memory limit; poqpoq scripts run in a modern JS sandbox with no such restriction.

// No equivalent needed in poqpoq
// LSL: llGetFreeMemory() -> integer bytes remaining

Returns the number of lines in a notecard stored in the object's inventory. Uses async/await instead of the LSL dataserver callback.

const lineCount = await this.world.getNumberOfNotecardLines("config");
this.say(0, `Config has ${lineCount} lines`);

Calculates the Euclidean distance between two vectors.

const dist = myPos.distanceTo(targetPos);
if (dist < 10) this.say(0, "Target is nearby!");

Returns a unit vector (length 1) pointing in the same direction as the input vector.

const direction = offset.normalize();
// Move 5 meters in that direction
const step = { x: direction.x * 5, y: direction.y * 5, z: direction.z * 5 };

Returns the magnitude (length) of a vector. Useful for calculating speed or distance from origin.

const speed = velocity.length();
this.say(0, `Moving at ${speed.toFixed(1)} m/s`);

Converts a quaternion rotation to Euler angles (radians) as a Vector3.

const euler = this.object.getRotation().toEuler();
this.say(0, `Heading: ${(euler.z * 180 / Math.PI).toFixed(0)} degrees`);

Converts Euler angles (radians) to a quaternion rotation.

// Create a 45-degree rotation around the Z axis
const rot = Quaternion.fromEuler({ x: 0, y: 0, z: Math.PI / 4 });

Creates a quaternion rotation from an axis vector and angle in radians.

// Rotate 90 degrees around the Y axis
const rot = Quaternion.fromAxisAngle({ x: 0, y: 1, z: 0 }, Math.PI / 2);

Returns a random floating-point number between 0 and the given maximum.

// Random delay between 1 and 5 seconds
const delay = 1 + Math.random() * 4;
await this.delay(delay);

Returns the absolute (non-negative) value of an integer.

const distance = Math.abs(posA.x - posB.x);

Rounds a float down to the nearest integer.

const gridX = Math.floor(pos.x / 4);
const gridY = Math.floor(pos.y / 4);

Rounds a float up to the nearest integer.

const pagesNeeded = Math.ceil(totalItems / itemsPerPage);

Rounds a float to the nearest integer.

const rounded = Math.round(score * 100) / 100;
this.say(0, `Score: ${rounded}`);

Returns the square root of a number.

const hypotenuse = Math.sqrt(dx * dx + dy * dy);

Returns the base raised to the exponent power.

// Exponential falloff for damage over distance
const falloff = Math.pow(0.5, dist / 10);

Returns the sine of an angle in radians.

// Bobbing motion using sine wave
const z = baseZ + Math.sin(time * 2) * 0.5;

Returns the cosine of an angle in radians.

// Circular orbit path
const x = center.x + Math.cos(angle) * radius;
const y = center.y + Math.sin(angle) * radius;

Returns the tangent of an angle in radians.

const slope = Math.tan(angle);

Returns the arcsine (inverse sine) of a value, in radians.

const angle = Math.asin(opposite / hypotenuse);

Returns the arccosine (inverse cosine) of a value, in radians.

// Calculate angle between two normalized vectors via dot product
const angle = Math.acos(dot);

Returns the angle in radians between the positive X axis and the point (x, y). Handles all four quadrants correctly.

// Calculate heading angle to a target
const dx = target.x - myPos.x;
const dy = target.y - myPos.y;
const heading = Math.atan2(dy, dx);

Returns the number of characters in a string.

const len = message.length;
if (len > 255) this.say(0, "Message too long!");

Returns the index of the first occurrence of a substring, or -1 if not found.

const idx = message.indexOf("password");
if (idx !== -1) this.say(0, "Keyword detected!");

Extracts a portion of a string between the start and end indices.

const prefix = command.substring(0, 3);
if (prefix === "cmd") this.say(0, "Command received");

Removes a substring between the given indices from a string and returns the result.

// Remove characters 3-5 from a string
const cleaned = text.slice(0, 3) + text.slice(6);

Converts all characters in a string to lowercase.

const cmd = message.toLowerCase();
if (cmd === "help") this.say(0, "Available commands: help, reset");

Converts all characters in a string to uppercase.

const shout = name.toUpperCase();
this.say(0, `ANNOUNCING: ${shout}`);

Splits a string into an array using the specified separator.

const parts = message.split("|");
const command = parts[0];
const data = parts[1];

Removes leading and trailing whitespace from a string.

const cleaned = input.trim();
if (cleaned.length > 0) this.say(0, cleaned);

Returns the number of elements in an array.

const count = inventory.length;
this.say(0, `You have ${count} items`);

Returns the element at the given index as a string. In TypeScript, simply access the array by index.

const names = ["Alice", "Bob", "Charlie"];
const first = names[0]; // "Alice"

Returns the element at the given index as an integer. In TypeScript, array access returns the typed value directly.

const scores = [100, 250, 50];
const topScore = scores[1]; // 250

Returns the element at the given index as a float. TypeScript numbers handle both integer and float values.

const heights = [1.5, 2.0, 0.8];
const tallest = heights[1]; // 2.0

Returns the element at the given index as a Vector3. TypeScript arrays can store typed vector objects directly.

const waypoints: Vector3[] = [{ x: 10, y: 20, z: 0 }, { x: 30, y: 40, z: 0 }];
const next = waypoints[0];

Sorts the array in place. Accepts an optional comparator function for custom sort order.

const scores = [30, 10, 50, 20];
scores.sort((a, b) => b - a); // [50, 30, 20, 10]

Returns the index of the first element matching a condition, or -1 if not found.

const players = ["Alice", "Bob", "Charlie"];
const idx = players.findIndex(p => p === "Bob"); // 1

Converts an array to a comma-separated string.

const tags = ["red", "large", "sale"];
const csv = tags.join(","); // "red,large,sale"

Parses a comma-separated string into an array.

const data = "Alice,100,true".split(",");
const name = data[0]; // "Alice"

Inserts elements into an array at the specified position without removing existing elements.

const queue = ["A", "C", "D"];
queue.splice(1, 0, "B"); // ["A", "B", "C", "D"]

Removes elements from an array starting at the given index for the specified count.

const items = ["sword", "shield", "potion", "scroll"];
items.splice(1, 2); // removes "shield" and "potion"

Returns the current in-world time of day as seconds since midnight.

const seconds = this.world.environment.getTimeOfDay();
const hours = Math.floor(seconds / 3600);
this.say(0, `It is ${hours}:00 in-world time`);

Returns a normalized Vector3 pointing toward the sun. Useful for lighting effects and shadow calculations.

const sunDir = this.world.environment.getSunDirection();
const isNight = sunDir.z < 0;

Returns the name of the region (sim) the object is currently in.

const region = this.world.getRegionName();
this.say(0, `Welcome to ${region}!`);

Returns the current Unix timestamp (seconds since January 1, 1970).

const now = this.world.getUnixTime();
const elapsed = now - startTime;
this.say(0, `Elapsed: ${elapsed} seconds`);

Returns the terrain height at a given position. Useful for placing objects on the ground.

const pos = this.object.getPosition();
const groundZ = this.world.getGroundHeight(pos);
this.say(0, `Height above ground: ${(pos.z - groundZ).toFixed(1)}m`);

Sets the in-world time of day, which controls sun position. In poqpoq, this is done by hour rather than setting a direction vector.

// Set the world to sunset (6 PM)
this.world.environment.setTimeOfDay(18);

Spawns a non-player character at the given position with a named appearance. Returns an NPC handle for controlling the character.

// Create a shopkeeper NPC
const npc = this.world.npc.create(
  "Merchant Bob",
  { x: 128, y: 128, z: 25 },
  "shopkeeper-appearance"
);

Removes an NPC from the world. The NPC handle becomes invalid after this call.

// Despawn the NPC
npc.remove();

Commands the NPC to walk to a target position. Returns a Promise that resolves when the NPC arrives.

// Walk the NPC to the door, then say something
await npc.moveTo({ x: 130, y: 128, z: 25 });
npc.say("I've arrived!", 0);

Makes the NPC speak a message on the specified channel.

// NPC greets visitors
npc.say("Welcome to my shop! Browse the wares.", 0);

Commands an NPC to sit on a target object (chair, bench, vehicle).

// Sit the NPC on a nearby bench
npc.sit(benchId);

Commands a seated NPC to stand up.

// Stand up after a rest
npc.stand();
await npc.moveTo({ x: 130, y: 128, z: 25 });

Plays a named animation on the NPC (e.g., waving, sitting, dancing).

// Make the NPC wave
npc.playAnimation("wave");

// After a delay, stop waving
await this.delay(3.0);
npc.stopAnimation("wave");

Stops a currently playing animation on the NPC.

npc.stopAnimation("dance");

Sets the NPC's facing rotation.

// Face the NPC toward the entrance
npc.setRotation({ x: 0, y: 0.707, z: 0, w: 0.707 });

Reads the entire contents of a notecard as a string. In poqpoq, maps to key-value storage.

const config = await this.world.storage.get("settings");
this.say(0, "Config: " + config);

Parses a JSON string into a JavaScript object. Maps directly to native JSON.parse().

const data = JSON.parse(jsonStr);
this.say(0, "Name: " + data.name);

Modifies terrain height at a position. Requires elevated permissions (Tier 3).

// Raise terrain at position
this.world.environment.setTerrainTexture(
  { x: 128, y: 128, z: 0 }, "grass", 5
);

Returns the dominant ground texture ID at a world position.

const tex = this.world.getGroundTexture({ x: 128, y: 128, z: 0 });
this.say(0, "Ground: " + tex);

Paints a terrain texture at a position with a given radius. Requires Tier 3 permission.

// Paint sand texture in a 10m radius
this.world.environment.setTerrainTexture(
  { x: 128, y: 128, z: 0 }, "sand", 10
);

Teleports an avatar to a destination region and position. Requires permission from the agent.

// Teleport the toucher to the spawn point
await agent.teleport({ region: "Welcome", position: { x: 128, y: 128, z: 25 } });

Sets a prim face texture from a URL. Partially supported — UUID-based textures are not resolved.

// Apply a web-hosted texture
this.object.setTexture("https://example.com/logo.png", 0);

Configures a media surface (web page, video, etc.) on a prim face using PRIM_MEDIA_* rule constants.

// Display a web page on face 0
this.object.setMediaParams(0, [
  PRIM_MEDIA_CURRENT_URL, "https://poqpoq.com",
  PRIM_MEDIA_AUTO_PLAY, true
]);

Removes the media surface from a prim face, stopping any playing media.

// Remove media from face 0
this.object.clearMedia(0);

Retrieves current media parameter values for a prim face. Returns a list of values matching the requested PRIM_MEDIA_* keys.

// Get the current URL on face 0
const params = this.object.getMediaParams(0, [PRIM_MEDIA_CURRENT_URL]);
this.say(0, "Playing: " + params[0]);

Configures a media surface on a face of a linked prim. Combines link traversal with media parameter setting.

// Set video on face 1 of link 3
this.object.getLink(3)?.setMediaParams(1, [
  PRIM_MEDIA_CURRENT_URL, "https://example.com/video"
]);

Removes the media surface from a face on a linked prim.

// Clear media from face 0 of link 2
this.object.getLink(2)?.clearMedia(0);

Retrieves media parameter values from a face on a linked prim.

// Check what URL is playing on link 3, face 0
const params = this.object.getLink(3)?.getMediaParams(0, [PRIM_MEDIA_CURRENT_URL]);

Shows a dialog box to an avatar with up to 12 buttons. The avatar's button choice is sent as a chat message on the specified channel.

// Ask the user to pick a color
this.world.dialog(
  detected[0].id,
  "Choose your team color:",
  ["Red", "Blue", "Green"],
  42
);
// Listen for the response
this.listen(42, "", detected[0].id, "");

Shows a text input box to an avatar. The typed text is sent as a chat message on the specified channel.

// Ask for the player's name
this.world.textBox(detected[0].id, "Enter your character name:", 42);

Opens a dialog asking the avatar to visit an external URL. The avatar must confirm before the browser opens.

// Offer a link to documentation
this.world.loadURL(detected[0].id, "View the wiki?", "https://wiki.poqpoq.com");

Opens the world map centered on a specific region and location, allowing the avatar to teleport there.

// Show the map pointing to a destination
this.world.mapDestination("Welcome Plaza", { x: 128, y: 128, z: 25 }, { x: 128, y: 129, z: 25 });

Returns the number of inventory items of a given type (scripts, textures, sounds, etc.) in the object.

const scriptCount = this.container.getAssetCount(INVENTORY_SCRIPT);
this.say(0, `Contains ${scriptCount} scripts`);

Returns the name of an inventory item by type and index. Useful for iterating over all items of a given type.

// List all textures in the object
const count = this.container.getAssetCount(INVENTORY_TEXTURE);
for (let i = 0; i < count; i++) {
  this.say(0, this.container.getAssetName(INVENTORY_TEXTURE, i));
}

Returns the type constant for a named inventory item, or -1 if not found.

const type = this.container.getAssetType("my-asset");
if (type === INVENTORY_SOUND) {
  this.object.playSound("my-asset");
}

Returns the UUID of a named inventory item, or undefined if not found.

const texId = this.container.getAsset("logo")?.id;
if (texId) this.object.setTexture(texId, 0);

Returns the UUID of the creator of a named inventory item.

const creator = this.container.getAssetCreator("my-script");
this.say(0, "Script created by: " + creator);

Returns the permission bitmask for a named inventory item. Check against PERM_COPY, PERM_MODIFY, PERM_TRANSFER constants.

const perms = this.container.getAssetPermMask("gadget", MASK_OWNER);
const canCopy = (perms & PERM_COPY) !== 0;

Enables or disables dropping inventory items into this object, even without modify permissions.

// Allow anyone to drop items into this object
this.object.allowInventoryDrop(true);

Gives a named inventory item from this object to a destination avatar or object by UUID.

// Give a notecard to whoever touched the object
this.world.giveInventory(detected[0].id, "Welcome Guide");

Gives multiple inventory items bundled into a named folder to a destination avatar.

// Give a starter kit to a new visitor
this.world.giveInventoryList(
  detected[0].id,
  "Starter Kit",
  ["Map", "Compass", "Guide"]
);

Removes a named item from the object's inventory. Use with caution as this is irreversible.

// Remove a used single-use item
this.container.removeAsset("one-time-pass");

Gives money from the object owner's account to the specified avatar or object.

// Pay the player 50 coins for completing a quest
this.world.giveMoney(detected[0].id, 50);

Transfers currency to another avatar asynchronously. Returns a transaction key and triggers a transaction_result event on completion.

const txnId = await this.world.transferLindenDollars(buyerId, 100);
this.say(0, `Transaction ${txnId} initiated`);

Configures the pay dialog that appears when an avatar right-clicks the object and selects Pay. Sets a default amount and up to four quick-pay buttons.

// Set default to 10, with quick buttons for 5, 10, 25, 50
this.world.setPayPrice(10, [5, 10, 25, 50]);

Returns the object owner's current currency balance.

const balance = this.world.getBalance();
this.say(0, `Your balance: ${balance} coins`);

Inflicts damage on an NPC. Returns true if the NPC was alive before the hit. Optionally identifies the damage source.

const wasAlive = this.world.npcDamage(npcId, 25, this.object.id);
if (!wasAlive) this.say(0, "Target already defeated!");

Returns true if the NPC is flagged as hostile toward players.

if (this.world.npcIsHostile(npcId)) {
  this.say(0, "Warning: hostile NPC detected!");
}

Sets or clears the hostility flag on an NPC, changing how it interacts with players and other NPCs.

// Make the guard hostile when provoked
this.world.npcSetHostile(guardId, true);

Finds the nearest valid NPC target from a world position within an optional range. Returns target info or null if none found.

const target = this.world.npcGetNearestTarget(myPos, 20);
if (target) {
  this.say(0, `Nearest enemy: ${target.name} at ${target.distance}m`);
}

Returns an array of all NPC targets within the specified radius from a world position.

const enemies = this.world.npcGetTargetsInRadius(myPos, 30);
this.say(0, `${enemies.length} enemies nearby`);

Respawns a defeated NPC at its original spawn point or at an optional new position with full health.

// Respawn after a delay
await this.delay(10);
this.world.npcRespawn(npcId);

Assigns one or more autonomous steering behaviors to an NPC. Behaviors are blended together each frame for natural movement.

// Patrol NPC that wanders but stays near home
this.world.npcSetSteering(guardId, [
  { type: "wander", weight: 1.0 },
  { type: "tether", target: spawnPos, radius: 15, weight: 2.0 }
], 3.0);

Removes all active steering behaviors from an NPC, stopping autonomous movement.

// Stop the NPC when the player interacts
this.world.npcClearSteering(npcId);
npc.say("You wanted to talk?", 0);

Returns the current world-space position of an NPC, or null if the NPC doesn't exist.

const pos = this.world.npcGetPosition(npcId);
if (pos) this.say(0, `NPC is at ${pos.x}, ${pos.y}, ${pos.z}`);

Returns the current rotation quaternion of an NPC, or null if the NPC doesn't exist.

const rot = this.world.npcGetRotation(npcId);
if (rot) this.say(0, "NPC facing: " + JSON.stringify(rot));

Equips the current object to a named attachment slot on the avatar. Uses the 25-slot attachment system.

// Equip a sword to the right hand
this.world.avatar.equip("right_hand");

Removes whatever item is equipped in the named attachment slot.

// Unequip the helmet
this.world.avatar.unequip("head");

Toggles visibility of an attachment slot without actually equipping or removing the item. Useful for costume changes.

// Hide the cape during combat
this.world.avatar.setAttachmentVisible("spine", false);

Returns detailed info about an attachment slot: its ID, label, whether it has an item, the item's ID, and visibility state.

const slot = this.world.avatar.getAttachment("right_hand");
if (slot.hasItem) this.say(0, "Wielding: " + slot.itemId);

Returns an array of all 25 attachment slots with their current state (equipped items, visibility, labels).

const slots = this.world.avatar.getAttachmentPoints();
const equipped = slots.filter(s => s.hasItem);
this.say(0, `${equipped.length} items equipped`);

Adjusts the position offset, rotation, and scale of an item in an attachment slot for precise fitting.

// Nudge the hat forward and scale it up slightly
this.world.avatar.adjustAttachment("head",
  { x: 0, y: 0.05, z: 0 },
  undefined,
  { x: 1.1, y: 1.1, z: 1.1 }
);

Applies a continuous force vector to the object each physics frame. Use local=true for object-relative direction.

// Thrust forward in local space
this.object.applyForce({ x: 0, y: 0, z: 10 }, true);

Applies a one-time impulse force to the object. Unlike applyForce, this fires once and doesn't persist.

// Launch the ball upward
this.object.applyImpulse({ x: 0, y: 15, z: 0 });

Applies continuous rotational torque to the object around the specified axes.

// Spin the object around its Y axis
this.object.setTorque({ x: 0, y: 5, z: 0 }, true);

Pushes another object by ID with both linear and angular impulse. Useful for explosions and knockback effects.

// Knockback an enemy object
this.world.pushObject(enemyId,
  { x: 0, y: 5, z: -10 },
  { x: 2, y: 0, z: 0 }
);

Sets physics status flags on the object (STATUS_PHYSICS, STATUS_PHANTOM, STATUS_ROTATE_X/Y/Z, etc.).

// Make the object physical
this.object.setStatus(STATUS_PHYSICS, true);

Sets the amount of damage this object deals on collision with other objects or avatars.

// Projectile deals 50 damage on impact
this.object.setDamage(50);

Enables volume detection mode — the object detects collisions and fires events but doesn't physically block other objects.

// Trigger zone: detect entry without blocking
this.object.volumeDetect(true);

Configures collision filtering by object name or ID pattern. Accept=true whitelists, accept=false blacklists.

// Only collide with objects named "ball"
this.object.collisionFilter("ball", "", true);

Sets the buoyancy factor. 0 = full gravity, 1 = weightless/neutral, values above 1 cause the object to float upward.

// Make a balloon that floats gently
this.object.setBuoyancy(1.3);

Cancels an active moveToTarget operation, stopping the object at its current position.

// Abort the movement
this.object.stopMoveToTarget();
this.say(0, "Movement cancelled");

Makes the object continuously face a target position with configurable strength and damping for smooth rotation.

// Turret tracks the player
this.object.lookAt(playerPos, 3.0, 0.8);

Cancels an active lookAt constraint, freeing the object to rotate normally.

this.object.stopLookAt();

Overrides the physics collision shape used for this object. Supports box, sphere, capsule, convex hull, and triangle mesh.

// Use a sphere collider for a ball object
this.object.setPhysicsShape("sphere", { radius: 0.5 });

Registers this object as a terrain influence source that dynamically blends textures in its vicinity based on radius and falloff.

// Campfire scorches the ground around it
this.object.setTerrainInfluence({
  radius: 3, falloff: "linear",
  texture: "scorched_earth", blendMode: "overlay"
});

Returns the current terrain influence configuration for this object, or null if none is registered.

const influence = this.object.getTerrainInfluence();
if (influence) this.say(0, "Radius: " + influence.radius);

Removes this object's terrain influence, restoring the ground beneath it to its natural texture.

// Clean up when the campfire is extinguished
this.object.clearTerrainInfluence();

Returns the dominant ground texture ID at a world position. Useful for footstep sounds or movement speed modifiers.

const ground = this.world.getGroundTexture(this.object.getPosition());
if (ground === "sand") this.say(0, "Walking on sand...");

Returns all active terrain influence sources near a position within an optional radius.

const influences = this.world.getTerrainInfluences(myPos, 20);
this.say(0, `${influences.length} terrain effects nearby`);

Returns recent terrain modification events (footprints, scorches, impacts) within a radius, optionally filtered by age.

// Check for recent footprints (tracking system)
const tracks = this.world.getTerrainEvents(myPos, 10, 60);
if (tracks.length > 0) this.say(0, "Fresh tracks found!");

Permanently paints a terrain texture at a world position with a given radius. Requires Tier 3 elevated permissions.

// Paint a grass path
this.world.environment.setTerrainTexture(
  { x: 128, y: 128, z: 0 }, "grass_path", 2, 0.8
);

Applies a temporary visual terrain effect with a time-to-live. Effects fade naturally without permanent terrain changes.

// Scorch mark from an explosion (fades in 30s)
this.world.environment.applyTerrainEffect(
  impactPos, { type: "scorch", radius: 2, ttl: 30 }
);

Triggers a named VFX archetype at a world position. The archetype defines particles, shaders, and timing. Luminary integration pending.

// Fire a healing burst VFX at the player
this.world.vfx.trigger("heal_burst",
  playerPos, { paletteSource: "caster" }
);

Retrieves a read-only VFX palette snapshot containing soul color, particle style, emissive boost, and other visual identity data.

const palette = this.world.vfx.getPalette("player");
this.say(0, "Soul color: " + JSON.stringify(palette.soulColor));

Registers a custom VFX archetype in the user namespace. Archetypes define particle systems, timing, and visual parameters for reuse.

// Register a custom sparkle effect
this.world.vfx.registerArchetype("user:sparkle", {
  particles: { pattern: "explode", color: { x: 1, y: 0.8, z: 0 } },
  duration: 2.0
});