API Reference

Defaults to the class name. Used in logs and script event sender info.

Optional description text for tools that surface script metadata.

The object that owns this script instance.

The transform of the owning object.

Named object slots assigned by the runtime when available.

True when running in the runtime world rather than editor bootstrap mode.

Defaults to true. Override to disable automatic transform state sync at startup.

Runtime switch for automatic transform state synchronization.

Serialized scene reference with ObjectId, Id, IsNull, Exists, gameObject, transform, GetComponent<T>, GetComponents<T>, child lookup, and parent lookup helpers.

Scene object reference with SitpointId resolution for sitpoint components and settings.

Server-spawned avatar clone reference with SourceUsername, DisplayName, CloneId, and helper methods for destroy, transform, emote, sitpoint, and stand commands.

Scene object reference with a light property that resolves a Light on the object or in children.

Inventory reference with InventoryId, Kind, Id, IsNull, IsEmpty, Exists, and normalization helpers.

A texture inventory item (a picture, such as a backpack icon). Kind is Texture. Inspector fields of this type take only textures.

An emote. In the scene editor, a public Emote field (or List<Emote>) shows a dropdown of the scene author's own emotes, uploaded or bought in the Avatar Editor; pick one there. Emotes are not typed in by id. Kind is Emote; EmoteId mirrors InventoryId; check IsNull before using it.

A player: Username, ObjectName, ObjectId, PlayerObject, and where they are and how they move, updated about 10 times a second: Position (their feet), Forward (the way the body faces, level), Yaw (that way in degrees, 0 = +z, 90 = +x), Velocity, Speed (over the ground, metres a second), IsRunning, IsCrouching, IsJumping (in the air), IsSeated, IsGrounded, and PoseTime (when it was last updated, 0 = not yet). GetUsers() returns every player in the world.

Sit or stand snapshot with Username, SitpointId, ObjectName, ObjectId, Sitpoint, and PlayerObject.

Interactable callback data with Username, ObjectName, ObjectId, ScriptNetworkId, InteractionType, and Target.

Chat command callback data with Username, UserId, player object fields, room ids, FullText, Command, ParameterText, and split Args.

Sitpoint input data with MoveX, MoveY, LookX, LookY, Jump, Sprint, Username, SitpointId, and Sitpoint.

Trigger callback data with EventType, IsPlayer, username, object name/id, trigger object id, OtherObject, and TriggerObject.

Collision callback data with IsPlayer, username, collided object name/id, collision object id, OtherObject, and CollisionObject.

A player's pick in the world's backpack: Username, UserId, Index, Item, DisplayName, PlayerPosition, Forward, Yaw, SpawnPosition(distance, height). See Backpack.

Enum values: Enter, Exit.

Enum values: Standing, Falling, Sleep.

Enum values: All, Core, LeftArm, RightArm, LeftLeg, RightLeg, Head.

Fields: Strength (0.12), GravityScale (1), Damping (0.02), Friction (0.6), Bounciness (0.08). Used with SetCharacterRagdollSettings.

Adds or replaces a named event value and returns the same data object.

Checks whether the data contains a key. Keys are case-insensitive.

Gets a raw value or default.

Gets and converts a value to the requested type when possible.

Gets a typed value and reports whether the key existed.

Convenience typed accessors for common event payload values.

Returns a shallow copy of the event data.

Builds event data from alternating name/value pairs.

Contains EventName, Group, FullName, SenderScriptName, SenderObjectId, SenderObject, and Data.

Called when the script starts. Call base.Start() before custom setup.

Called as the script is destroyed. Use for cleanup such as despawning objects or stopping state.

Called when the script is enabled.

Called when the script is disabled.

Generic event hook for runtime-dispatched events.

Control automatic transform state synchronization for this script.

Advanced control for when state is applied. The base uses the update phase.

Override to run logic when a user enters.

Override to run logic when a user leaves.

Override to run logic when a user sits.

Override to run logic when a user stands.

Returns a list of active user snapshots.

Returns the active usernames known by the runtime.

Runs the callback for each active user and logs callback errors.

Builds ScriptEventData from alternating name and value arguments.

Alias for CreateScriptEventData.

Registers a callback with full sender and payload details.

Registers a callback that receives only the payload data.

Stops this script's event subscriptions. With no name, removes all subscriptions owned by this script.

Posts an event with empty data.

Posts an event with structured data.

Posts an event from alternating name and value arguments.

Shows a simple dialog with optional target, icon, and button set.

Shows an icon dialog with an OK button.

Shows a dialog with explicit icon and button configuration.

Shows a dialog and invokes the callback with ModalDialogResult.

Shows an OK dialog and invokes the callback.

None, Info, Warning, Error, Success.

OK, OKCancel, YesNo, YesNoCancel, Custom.

None, OK, Cancel, Yes, No, Custom1, Custom2, Custom3.

Shows the buy panel to one player, or to everybody in the world now with "*". store: the store the item is sold in, StoreKind.Scene (Scene Editor store) or StoreKind.Avatar (Avatar Editor store). item: the item’s store id, or its store link (https://…/store/scene/ITEM_ID). A private item can only be offered with its private link (Edit Store Details → Copy Private Link), which carries its key; everybody you offer it to can then buy it. message: an optional line shown above the item. onResult runs here once for each player who answers. A wrong id or link shows the player nothing; onResult gets Failed with the reason. There is also OfferStoreItem(UserInfo user, …).

The same, for every player in the world now.

Username, ItemId, Store, Status, Message (why it failed), Purchased (bought just now) and Owned (the player has the item now: bought now, put back, or already had it). Purchases are confirmed with the store before onResult is called, so a reward given for Purchased is safe.

Purchased, Redelivered (bought before, put back in their inventory for free), AlreadyOwned (already in their inventory, or it is their own listing), Declined (Not now, or closed), Failed (not enough coins, not for sale, a private item without its link…).

Scene (objects, scripts, materials, sounds… from the Scene Editor store), Avatar (bodies, clothes, hair, accessories and emotes from the Avatar Editor store).

Asks one player (or everybody with "*") whether to open url in a new browser tab. The question shows the site’s address and the full link; Open Link opens it, Cancel does nothing. Only full http:// and https:// addresses. In VR the page opens in the browser, outside VR (the player is told first). onAnswer runs here with true when they opened it. There is also OfferLink(UserInfo user, …).

Shows one player (or everybody in the world now with "*") a toast. icon: a TextureItem field (drop a texture from your inventory on it in the Inspector), or null for none. Give a title, a description, or both (up to 200 and 1000 characters). Also ShowToast(UserInfo user, ...).

The same toast for everybody in the world right now.

Blends the sky to a built-in weather over blendSeconds (0 to 600): clouds, rain or snow, lightning, rainbow and mist. WeatherPreset.Scene goes back to the scene's own weather (like ClearWeather).

Back to the scene's own weather (with its weather cycling, if it has it).

Scene, Clear, PartlyCloudy, Cloudy, Overcast, Rain, Thunderstorm, Snow, Hail, DustStorm, Foggy. A public WeatherPreset field is a dropdown in the script's Inspector.

The sky's clock jumps to hour (0 to 24, e.g. 18.5 = 6:30 pm). When the scene's time of day moves, it goes on from there at the scene's speed.

Back to the scene's own clock.

A lightning strike now, with its flash and thunder, whatever the weather.

Wind for the whole world. Every material in the scene with Foliage Wind turned on — trees, bushes, grass, terrain trees, and sails, flags or banners you gave Foliage Wind in the Material Editor — sways toward direction (degrees; the same angle as SetWaveDirection, so you can turn the waves with it). strength multiplies each material’s own sway: 0 still, 1 as authored, 2 twice as strong, up to 4. It eases over blendSeconds, the same for everyone, and players who join later get the current wind. Materials without Foliage Wind are not affected.

The same with a direction vector in script space (only X and Z are used): SetWind(Vector3.right, 2f).

Eases every foliage material back to its own Foliage Wind settings.

Starts a coroutine using the script runtime runner.

Waits inside a coroutine. For example, yield return new WaitForSeconds(0.5f); waits half a second.

Stops a coroutine started through the runtime runner.

Stops all coroutines on the runner.

Adds the offset to this script object's world position.

Rotates this script object in world space.

Rotates this script object around a world-space axis.

Sets this script object's world position, world rotation, or local scale. Inside a group the world values are kept (the object is placed where you say in the world, whatever its parent's place).

Reads this script object's world position, world euler rotation, or local scale.

Sets the emission level. 0 is off; values like 1 to 3 are useful for visible glow.

Sets the emitted color. Use a bright color while lit and Color.black when resetting.

Leave this off for normal SV Standard Lit glow through the base texture. Turn it on only when the material has a dedicated emission mask map.

Sets the target material frame.

Sets animation, frame advance interval, and looping.

Applies any combination of frame, playback, loop, and map-affecting settings. Commands are persistent for late-joining clients.

The model's animation. foreach (AnimationState s in anim) lists the takes with s.name and s.length (known once a player has loaded the scene).

Plays a take (empty = the default take). Playing the take that is already set continues from its current time; another take starts at 0.

Stops (back to the rest pose), or jumps back to 0.

Speed (0 freezes, negative plays backwards), jump to a time, and repeat mode: WrapMode.Loop, PingPong, Once (stops at the end), ClampForever (holds the last frame). anim.wrapMode sets it for the current take.

Plays the take whose name contains name (a bool of false stops it). Animator.Play("take"), Animator.speed and Animator.enabled (pause / resume) also work.

Still accepted; the state is always shared, so these only re-send it.

Sets the resting weight (0..1) of a blend shape of this object. A playing shape keeps playing around its new value.

The same, on another object.

Starts it playing from the start of a cycle (again from the start if it was already playing). loop and seconds (above 0) change those settings at the same time.

The same, on another object.

Stops it; the weight goes back to its resting value.

Turns looping on or off. Turned off while it plays, the cycle it is in finishes, then it stops.

Seconds for one cycle (at least 0.05). While it plays it stays where it is in its cycle.

Creates a canvas on this object's material number materialIndex (0 = the first) and returns it. Width and height are pixels, 8 to 512. The picture replaces the material's texture for everybody; the material's colour is set to white so the picture shows its own colours.

The same, on another object (a slot).

With true the background is see-through: only what is painted shows, and the surface's material is drawn see-through so whatever is behind it shows elsewhere (paint on glass, a decal on a wall, a sticker layer). The eraser makes it see-through again. A background colour with alpha below 1 (for example Color.clear) does the same.

Makes the background see-through (or solid again) and clears the picture; TransparentBackground tells whether it is see-through.

Fills the picture with the background colour. With a colour, that becomes the new background (what Clear() and the eraser paint with).

One pixel.

One dab of a brush: a dot, a blob of ink.

A straight line drawn with a brush of that size.

One brush stroke through all the points (x1, y1, x2, y2, …). A see-through colour stays even where the stroke crosses itself.

A rectangle, filled or as an outline.

An ellipse or circle around (cx, cy), filled or as an outline.

A polygon through the points, filled or outlined.

Paint bucket: fills the area of the same colour around (x, y). Tolerance 0 to 255 also fills colours that are close.

Spray paint: dots scattered within the radius. The same seed gives the same pattern.

The eraser: paints the background colour through the points.

Text with its top left at (x, y); size is the letter height in pixels; \n starts a new line. Fonts: Sans, Bold, Serif, Mono, Pixel. Up to 200 characters per call.

A frame round the edge of the picture.

A rectangle shaded from one colour to another.

Draws a picture (a texture from your inventory, usually a public TextureItem field the scene author fills in) with its centre at (x, y), width × height pixels, turned angle degrees clockwise. tint multiplies its colours (white or null = as it is) and its alpha makes it fainter; flipX / flipY mirror it. The picture's own see-through parts stay see-through. Each picture is loaded once per scene (made at most 128 pixels a side; up to 8 different pictures per scene); drawing that uses it waits until it has loaded. Stamps, footprints, decals, stickers, icons. There is also Blit(string inventoryId, …).

Draws one frame of a sprite sheet, like Blit. A sprite sheet is a texture whose frames are all the same size, laid out in columns × rows and numbered left to right, top to bottom from 0. It is loaded once per scene (up to 1024 frames; each made at most 48 pixels a side) and counts as one of the scene's 8 pictures.

A grid of columns × rows tiles, each tileWidth × tileHeight pixels, its top left at (x, y), showing frames of a sprite sheet: a tile map, a character display, an LED board. Returns a CanvasTileGrid. Only tiles that really change are sent, so a big grid stays cheap; the sheet's frames are made exactly tile-sized (when 48 pixels or less), so they stay sharp.

Shows a frame of the sheet in one tile (or every tile), its colours multiplied by tint (white or null = as it is; darker = dimmer). Frame -1 = an empty tile (the canvas's background colour). Redraw() draws every tile again, for example after canvas.Clear(). Columns, Rows, TileWidth, TileHeight, X and Y describe the grid.

How many times a second the drawing is sent: 1 to 20 (4 when not set). Updates that change nothing are not sent, so a still picture costs nothing. Faster suits animation such as an LED board; slower is lighter for everybody.

Makes the picture glow: it is also used as the material's emission map, at this strength (0 = no glow, the material's own emission again; 1 = the picture's colours at full brightness; up to 10). Dark parts of the picture stay dark. Players who join later get it too.

Drawing is sent automatically, up to 4 times a second. Present() sends it now if the last update was at least a quarter of a second ago (returns true), otherwise it goes with the next update.

Stops the canvas: the material shows its own texture again, for everybody, and the scene can make another canvas.

The picture's size, its background colour, the drawing commands waiting to be sent, and whether it was released.

Brush shapes for Dot, Line and Stroke. Soft fades towards its edge; Spray scatters dots.

Spawns an inventory item for everyone and returns it as a SceneObject; players who join later see it too. The item can be a mesh, a prefab or a system object (light, sitpoint, water, particles, media screen…), whichever was dropped on the script's InventoryItem field. A mesh spawns solid (a collider shaped like it). A prefab (Hierarchy → Save to Inventory) spawns with everything saved in it: rigidbodies fall and can be grabbed and thrown (simulated on the server), and scripts on it run on the server, one copy per spawned prefab. Each player downloads an item's model, textures and scripts once per visit, however often it is spawned.

Removes a spawned object for everyone, with all its parts, their physics and the scripts that ran on them.

Queues a teleport command for one username.

Turns that player's camera (the 3rd-person orbit camera, and the 1st-person view) to look along yaw, in degrees, the same as TeleportPlayer's facing (0 = toward −Z, 90 = +X), blended over blendSeconds (0 = at once). pitch: degrees, + looks down; leave it out (NaN) to keep the current pitch. Only that player's screen changes. Nothing happens in VR (the head is the view) or in the free / static camera. Seated, the yaw is still a world heading. E.g. after TeleportPlayer(user, spot, new Vector3(0, 90, 0)), SetPlayerCamera(user, 90) puts the camera behind them.

Puts that player's view in CameraMode.FirstPerson or CameraMode.ThirdPerson (CameraMode.Default = release). With lockMode their own zoom / view change is held off until you release it. ReleasePlayerCameraMode puts back exactly what they had (1st person, or their own zoom distance). Nothing happens in VR. For anything that poses the avatar (lining up a putt, a bowling run-up, sitting at a piano): SetPlayerCameraMode(user, CameraMode.ThirdPerson, true) when it starts, ReleasePlayerCameraMode(user) when it ends.

The view the player is in now: FirstPerson, ThirdPerson, VR, Free (F4) or Static (F2); Default until the first camera update. Kept up to date with CameraYaw / CameraForward. In 1st person an emote no longer moves the view: the eye stays where the head was when it started.

keepCamera = true: the player's camera keeps exactly the same world view (yaw and pitch) while the avatar moves and turns: turn a player around a spot every time their aim changes without the camera and the aim fighting. false: the camera also turns to look the way the new facing (eulerAngles.y) does. Without it (the 3-argument version) the camera is left as it is.

The player's live camera, kept up to date about 10 times a second while it moves (read it in your own loop; the same UserInfo objects as GetUsers() and OnUserJoin). CameraYaw: degrees, as TeleportPlayer / SetPlayerCamera (0 = looking −Z, 90 = +X). CameraPitch: degrees, + looks down. CameraForward: unit vector where the camera looks (world). CameraPosition: where the camera is. CameraIsVR: it is a headset (the head is the view). HasCamera: false until the first update. CameraAge: seconds since the server sent these values (normally under 0.2 s).

Plays the emote chosen in an Emote field on one user (everyone in the instance sees it). Nothing happens, with a warning in the log, if no emote was chosen.

Plays the emote on every user in the instance.

Stops the emote one user, or everyone, is playing.

Sets uniform scale for one user.

Sets non-uniform scale for one user.

Sets player scale for everyone.

Shows or hides a player's name tag — the floating username that appears when you hover, tap or point at them — for everybody in the world. "*" = every player in the world now. This overrides the scene's Show player name tags setting for the current world; it is cleared when the player leaves or the scene changes.

Shows or hides every player's name tag in the world now (same as SetPlayerNameTag("*", show)).

Colours a player's whole avatar (body, clothes, hair, everything they wear) for everybody in the world, also players who join later. strength: 0 = not at all, 1 = solid colour, as if dipped in paint (light and shade still show). emission: 0 = no glow; above 0 the avatar glows in that colour (1 = full brightness, up to 10). Calling it again changes the colour. It lasts until ResetPlayerTint, or until the player leaves the world (they come back looking normal) or the scene changes. "*" = every player in the world now. There is also TintPlayer(UserInfo user, …).

The player's avatar looks as normal again, for everybody. "*" = every player.

Hides (false) or shows (true) a player's whole avatar (body, everything they wear, their name tag and voice meter) for everybody in the world, also players who join later. hideFromSelf: false = the player still sees themselves (faded, like a ghost, so they know the others cannot see them), only the others do not. It stays when they change outfits, until the script shows them again, or until they leave the world (they come back visible) or the scene changes. A hidden player cannot be pointed at or clicked; objects they hold stay visible. "*" = every player in the world now. There is also SetPlayerVisible(UserInfo user, …).

The same, shorter (also with a UserInfo).

False while a script keeps that player hidden.

Sets all media screens to a URL.

Sets one media screen id, or * for all media screens.

Sets all media screens to a URL only for the named user. Stored database rows are ignored for that user until a live public media update arrives. The override is not restored after rejoining.

Sets one media screen, or * for all screens, only for the named user. A public SetMediaScreenUrl or /media update releases the matching private override.

Returns the current scene instance EventID for the server script. This is useful for logs and instance-specific script behavior.

Sets up the world's backpack for every player (and players who join later). Entry i of each list belongs together: items[i] is the item, icons[i] a texture for its picture and names[i] the name under it. An empty icon uses the item's own thumbnail; an empty name, the item's own name. onItemSelected runs on the server when a player picks an entry: your script decides what happens, usually SpawnInventoryItem in front of that player. One backpack per world: the latest call replaces it. Up to 200 entries.

Takes the backpack away: the button leaves every player's control bar and an open panel closes.

What a player picked: Username, UserId, Index (the entry), Item, DisplayName, PlayerPosition (their feet), Forward (the flat direction their avatar faces), Yaw (that direction in degrees, for a spawn rotation of new Vector3(0, Yaw, 0)) and PlayerObject.

A point distance metres in front of the player and height metres above their feet.

Drag items from the Inventory panel onto the field. InventoryItem fields take things that can be spawned (prefabs, meshes and system objects); TextureItem fields take textures; other kinds are refused. In a list, drop on an entry to replace it or on the box at the end to add one. Lists are numbered from #0 so entries of different lists line up. List<string> fields get one text box per entry.

Spawns a clone of the named user's avatar at a world position and returns an AvatarClone reference.

Spawns a clone with a world position and rotation.

Spawns a clone with an explicit rotation and scale. The clone wears the user's outfit named outfitName (the name they gave it in the Avatar Editor; capitals do not matter), or the outfit they are wearing when outfitName is blank or they have no outfit by that name. The clone's OutfitName keeps the name asked for.

Destroys a spawned clone. Clients remove it when the server stops sending clone packets.

Moves a clone to a world position.

Sets clone world rotation in Euler angles.

Sets clone scale.

Sets clone position, rotation, and scale in one command.

Makes the clone play the emote chosen in an Emote field. The resulting bones are serialized to clients like player bones.

Stops the clone's forced emote.

Slots the clone into a slotted Sitpoint.

Sits a real player down on a slotted Sitpoint, as if they had clicked it (their OnUserSit follows). If they are already sitting somewhere else they move over. Without force, nothing happens when someone else is in the seat; with force, that player is stood up first (their OnUserStand runs) and the seat goes to username.

The same as SeatPlayer(username, sitpoint, true): always seats them, standing up whoever was there.

Makes that player leave their sitpoint: they step out at the seat’s exit point and OnUserStand runs. Pass "*" to stand up everyone who is sitting. Players who aren’t sitting are not affected.

The same as StandPlayer("*").

Stands up whoever is sitting in that sitpoint (nothing happens if it is free). Handy for vehicles: empty a seat without knowing who is in it.

Removes the clone from its current sitpoint.

Same as DestroyAvatarClone(clone).

Convenience methods for controlling the cached clone reference.

Convenience methods for forcing or stopping server-side clone emotes.

Turns the clone into a ragdoll (it falls onto whatever is below, like a player) and gets it back up where the body lies. Also SetAvatarCloneRagdoll(clone, true / false). Sitting, moving or destroying the clone ends the ragdoll.

Hits the clone (it becomes a ragdoll if it is not one yet): power metres per second in direction. Also ApplyAvatarCloneImpact(clone, …).

Convenience methods for sitpoint slotting.

Falling: ragdoll with the current ragdoll settings (use it for fall trigger zones). Sleep: a completely limp ragdoll. Standing: get up, blending back to normal animation over transitionSeconds. Set autoStandAfterSeconds above 0 to get up automatically.

Gets the player up from a ragdoll: they stand where the body lies, and the pose blends back to normal over transitionSeconds (0 = at once).

How that player's ragdoll behaves from now on (also while already ragdolled): Strength (muscles: 0 = limp, 1 = stiff as a statue; about 0.1–0.2 looks like a person falling), GravityScale (1 = normal), Damping (air drag, 0–0.95), Friction (0 = slides, 1 = stops where it lands), Bounciness (0–1).

Hits the player: power is the speed (metres per second) added in direction, spread over durationSeconds, to the body part (or the whole body). With fall = true the player becomes a ragdoll (or is pushed further if already one); with fall = false a standing player is only pushed. direction = Vector3.zero, power = 0, fall = true simply collapses the player.

Listens for every non-system slash command that was not handled by the game client command list.

Listens for one custom slash command such as /roll. The leading slash is optional. Built-in commands (/yt, /media, /help, /alert, /kick, /ban and the other admin and recording commands) are handled by the viewer and cannot be registered: the script log says so and the command is skipped.

Removes this script's chat command listener for one command, or all chat command listeners when omitted.

Inserts a room chat history entry from the fake username [Script].

Makes the script object interactable and calls the callback when activated.

Makes a target object interactable. highlight = false keeps it clickable without the hover highlight; raycastDistance is how close (in metres) a player must be to select it. With targetUsername only that player can use it; players who join later get it too.

Switches the script object's interaction off or on again, for everyone or only for targetUsername. Off: it cannot be selected or clicked (no highlight, no hint, no callback) by those players. On: back as MakeInteractable set it up, or a plain interactable if it never was. Players who join later get the current state.

The same for another object. Example: SetInteractable(door, false); SetInteractable(door, true, "alice"); lets only alice use the door.

Registers trigger callbacks on the script object.

Registers trigger callbacks on a target object.

Registers a server-side collision callback on the script object. The callback receives the collided object's ObjectName and ObjectId.

Registers a server-side collision callback on a target object or its child colliders.

Registers a callback for input from the sitpoint associated with this script's network id.

Gives a player (or "*", everybody) a button. key is the desktop key ("F", "G", "1", "Space"...). Showing it again changes its label or key. It stays until HideActionButton, the player leaves, or the scene changes.

Takes the button away again.

Called when a player presses this script's button (State Down), keeps holding it (Held, about 15 times a second) and lets go (Up). Only the script that showed the button hears it.

Username, UserId, ButtonId, State (ActionButtonState.Down / Held / Up), IsDown, AimOrigin and AimDirection; what the aim hits: HasHit, HitPoint, HitNormal, HitObjectId / HitObject, HitRootObjectId, HitObjectIds (the hit object and every object it is part of, innermost first), Hits(SceneObject) (true when the aim hits that object, a part of it, or something it is part of), HitMaterialIndex, HitUV with HasUV (the texture position, 0 to 1; on a script canvas the pixel is x = HitUV.x * canvas.Width, y = (1 - HitUV.y) * canvas.Height) and HitDistance (metres from the held object, or the eye, to the hit); HeldObjectId, what the player holds.

The controller buttons a script may use, the others already have a job: RightStickClick (pressing the right stick), LeftGrip, LeftTrigger, RightTrigger (careful: the trigger also holds what you grab), or None.

Called when a player grabs or lets go of this object (or another one). GrabInfo: Username, UserId, ObjectId / Target, Hand, IsGrabbed.

The username of whoever holds this object (or another one) now; empty when nobody does.

Puts a Grabbable object in a player's hand, as if they had clicked it. hand: "Left", "Right", "Both", or "" = the object's own Grabbable handedness. ListenForGrab fires (IsGrabbed = true, Username = that player) and every player sees it held, with the object's Hold Pose and Grip. If somebody else holds it, it is taken from them (they get a release event first). If that hand is already holding something, that is let go. Returns false and does nothing if the player is not in the world or the object is not Grabbable.

Whoever holds obj lets go of it. ListenForGrab fires (IsGrabbed = false). It stays where it was dropped (where the hand had it); the script can move it afterwards (a move right after ReleaseObject wins, e.g. sending it home). Does nothing if nobody holds it.

Puts a Grabbable object on a player's body instead of in a hand: AttachSlot.Head (a hat), Back (a backpack, a parachute pack), Chest or Hips (AttachSlot.Hand is the same as GrabObject). It follows that bone in every pose (walking, seated, ragdoll, VR), scales with the player, uses the object's Grabbable Slot Offset / Rotation / Scale, and its children ride along (e.g. a canopy child a script grows with LerpLocalScale). It takes no hand and is never thrown. Whatever the player wore on that slot before is taken off. ListenForGrab fires with IsGrabbed = true and Slot set. Returns false if the player is not in the world or the object is not Grabbable.

Takes it off whoever wears (or holds) it; it stays where it was. The same as ReleaseObject, and it works even when the player can't release it themselves.

true: players can't let go of this object, worn or held. The drop key (X), the VR trigger and throwing don't release it, and nobody can take it from them; only a script does (DetachFromSlot / ReleaseObject). false: back to normal. Off by default; the Grabbable's Player Can't Release setting turns it on for an object from the start, and a script's setting wins. It works whether or not someone has the object right now.

Where the object is: "Hand" (held), or "Head", "Back", "Chest", "Hips" (worn). IsWorn is true for the body slots.

// Clicking a Grabbable set to Attach To: Back straps it on by itself; a script can do it too (here: /pack).
// SetScriptOnlyRelease: the player can't take it off (X, VR trigger); only the script does (/unpack).
public SceneObject Pack;
public override void Start()
{
    ListenForGrab(Pack, g => { if (g.IsGrabbed && g.IsWorn) Log(g.Username + " is wearing the pack"); });
    SetScriptOnlyRelease(Pack, true);
    RegisterChatCommand("pack", c => AttachToSlot(c.Username, Pack, AttachSlot.Back));
    RegisterChatCommand("unpack", c => DetachFromSlot(Pack));
}

Called when a held object touches an object that has a Rigidbody. Held objects push things by themselves, no script needed: a stick, bat, paddle or broom knocks a moving (dynamic) Rigidbody away, or keeps pushing it while it keeps moving into it. These calls are for reacting to the touch (a score, a sound, damage), and for targets that physics does not move (kinematic ones a script moves). The holder's own viewer checks it every frame (in VR at the headset's frame rate), swept from last frame to this one so a fast swing cannot pass through; the server checks each report (the sender holds it, the target is near them, a sane speed). A held object touches with its whole length; Grabbable Custom Hit Point (with its Hit Point, in its own local space, and Hit Radius) makes only that spot touch, e.g. a club head. ListenForHeldHits hears every held object.

Username, UserId, Hand, HeldObjectId / HeldObject, TargetObjectId / Target; in world space: Point (where they touched, on the target's surface), Normal (from the target's centre towards the held object: the target is pushed along -Normal), Velocity (how fast and which way the hit point was moving, metres per second, at most 15). Speed = its length; SpeedAlongNormal = how fast it was moving into the target; IsFirstContact: a new touch (false: still pushing it, every 0.1 s).

What that player is holding right now (an empty array: nothing).

Makes a HUD (width in pixels; height 0 = as tall as its items need). Nobody sees it until Show. Creating one with an id that exists replaces that one.

This script's HUD with that id (null: none) / takes it away from everybody.

Gives the HUD to a player ("*" = everybody). openHudView: their HUD view opens to show it. Showing it again to a player who has it opens their HUD view again.

Takes it away from a player or everybody (it can be shown again), whether a player has it now, or removes it for good.

Players can close a HUD themselves with the × in its corner (on by default); OnClose hears about it. A closed HUD is hidden for that player until it is shown to them again.

A title across the top ("" = none).

A picture centred at the very top, above the title.

The background (colours can be see-through: alpha). HudImageFit: Cover (fills it, cut to fit), Contain (all of the picture shows), Stretch, Tile.

Lettering for the whole HUD. HudFont: Default (the platform's), Sans, Serif, Mono, Rounded, Condensed, Heavy, Handwriting. A public HudFont field is a dropdown in the Inspector.

The colours every button starts with (a button's own SetColors wins), and the colour of sliders, toggles and progress bars.

Items go top to bottom, columns side by side per row (1 = a list); gap between them and padding around them in pixels; align: where items sit across their column (Left, Center, Right, or Stretch = full width). Also one at a time: SetColumns, SetGap, SetPadding, SetAlign.

Size, rounded corners and a border.

Text (several lines with \n).

A button, with a picture above its text if you give one ("" text = picture only). button.OnClick(callback) sets or changes what it does.

A slider (step 0 = smooth); the number shows next to the label (SetShowValue(false) hides it). While a player moves it the script hears about it about 8 times a second, and always the last value. slider.GetValue(username), SetValue(float value, string username = null), SetRange(min, max, step), OnChange.

A list to pick from (up to 100 entries). dropdown.GetSelected(username) (the index), GetSelectedText(username), SetSelected(int index, string username = null), SetOptions(List<string> options, int selected = 0), OnChange.

An on / off switch. toggle.IsOn(username), SetOn(bool on, string username = null), OnChange.

A text field; onSubmit runs when the player presses Enter (or leaves the field after changing it), with the text in Text. input.GetText(username), SetValue(string text, string username = null), SetPlaceholder, SetMaxLength.

A picture (it keeps its shape).

A bar filled from 0 (empty) to 1 (full), with optional text over it: bar.SetValue(float value, string username = null). Good for cooldowns, health, scores.

Empty space / a thin line.

An item by its Id, removing one (or item.Remove()), removing all of them (the HUD and its look stay), all of them.

All but SetSpan take an optional username (that player only). SetEnabled(false) greys it out: it cannot be used. SetSpan: how many columns it takes up. SetTooltip: a hint shown when the pointer rests on it. Each item also has Id, Kind (HudItemKind), Hud and IsRemoved.

What a player did: Username, UserId, User (their UserInfo: where they stand and face), EventType (HudEventType.Click, Change, Submit, Close), Hud, HudId, Item, ItemId, and the new Value (slider), Index and Text (dropdown), IsOn (toggle) or Text (text field).

Makes a panel (width in pixels of its own surface; height 0 = as tall as its items need). Nobody sees it until Show. Creating one with an id that exists replaces that one.

This script's panel with that id (null: none) / takes it away from everybody.

Where it lives: PanelMode.Overlay (a flat window on the screen, behind the platform's UI) or PanelMode.WorldSpace (a window standing in the world; best for VR). Switch any time. A public PanelMode field is a dropdown in the Inspector.

Overlay. Hugs a corner or edge, nudged inward by the pixel offsets. PanelAnchor: TopLeft, TopCenter, TopRight, MiddleLeft, Center, MiddleRight, BottomLeft, BottomCenter, BottomRight. A public PanelAnchor field is a dropdown in the Inspector.

Overlay. Free placement: pins the panel's pivot point at xPercent of the screen width and yPercent of its height (0–100). E.g. SetScreenPosition(70, 6) sits it near the top, 70% across. SetAnchor switches back to corner-hugging.

Overlay. SetScreenScale draws it bigger or smaller. SetModal floats it in the middle over a dimmed screen until it is closed.

World-space. Float it above an object (it follows the object) or stand it at a spot, in metres; billboard turns it to face each viewer. Also SetWorldWidth(float) and SetBillboard(bool).

Gives the panel to a player ("*" = everybody; players who join later get it too).

Takes it away from a player or everybody (it can be shown again), whether a player has it now, or removes it for good.

Players can close a panel themselves (on by default); OnClose hears about it. A closed panel is hidden for that player until it is shown again.

A title across the top ("" = none) and a picture above it.

The background (colours can be see-through), rounded corners, a border and the size. PanelImageFit: Cover, Contain, Stretch, Tile.

Lettering for the whole panel (PanelFont: Default, Sans, Serif, Mono, Rounded, Condensed, Heavy, Handwriting), the colours buttons start with, and the colour of sliders, toggles and progress bars.

Items go top to bottom, columns side by side per row. Also SetColumns, SetGap, SetPadding, SetAlign. PanelAlign: Left, Center, Right, Stretch.

Text, or a counter: a little icon with a label beside it (e.g. coins). Update with SetText / SetImage.

A button, with a picture above its text if you give one. button.OnClick(callback).

A slider (step 0 = smooth). slider.GetValue(username), SetValue(value, username), SetRange(min, max, step), SetShowValue(bool), OnChange.

A list to pick from: clicking it opens the options and clicking one picks it (works on desktop, mobile and VR). GetSelected(username), GetSelectedText(username), SetSelected(index, username), SetOptions(...), OnChange.

An on / off switch. IsOn(username), SetOn(on, username), OnChange.

A text field; onSubmit runs when the player presses Enter. GetText(username), SetValue(text, username), SetPlaceholder, SetMaxLength.

A picture, or a live mirror of an object a script canvas (CreateCanvas) is painted on: it updates as the canvas is painted. item.SetCanvas(...) re-points it.

A bar filled from 0 to 1, with optional text over it: bar.SetValue(value, username).

A grid of cells (icon + label + count badge). Fill it with grid.SetCells(IEnumerable<PanelCell>, username) (new PanelCell(label, icon, count)); clicking a cell fires onPick with Index (and Text = its label). Also SetColumns, SetCellSize, OnPick.

Empty space, a thin line, and managing items (item.Remove(), or Clear to remove all while the panel and its look stay).

All but SetSpan take an optional username. SetEnabled(false) greys it out. Each item also has Id, Kind (PanelItemKind), Panel and IsRemoved.

What a player did: Username, UserId, User (their UserInfo), EventType (PanelEventType.Click, Change, Submit, Close), Panel, PanelId, Item, ItemId, and the new Value (slider), Index + Text (dropdown, inventory cell), IsOn (toggle) or Text (text field).

Offers the quest: the player sees it with Accept / Not now (a quest set not to ask starts at once). Nothing happens when they have it already, or finished it and it cannot be done again.

Starts it without asking.

Adds to a task that is under way (for tasks "Done by a script"; any kind works). The task is done when it reaches the number needed; the quest when all its tasks are.

Completes a task that is under way.

Finishes the whole quest for a player who has started it.

As if the player never started it (their completed count on profiles stays).

NotStarted, Offered, Active, ReadyToFinish (tasks done, to be finished at its object or area) or Completed. A public QuestState field is a dropdown in the Inspector; states can be compared (state >= QuestState.Active).

A player's quest (null: no such quest) or all of the scene's quests for them. QuestInfo: Id, Title, State, IsActive, IsCompleted, Tasks and GetTask(string task). QuestTaskInfo: Id, Title, Progress, Needed, IsActive, IsDone.

Called for everything that happens with players' quests (any quest, or that one). QuestEvent: Username, UserId, User, QuestId, QuestTitle, TaskId / TaskTitle (task events), State (the quest's state now), Progress / Needed, IsTaskEvent, IsQuest(string), IsTask(string), and EventType: Offered, Declined, Started, TaskProgress, TaskCompleted, ReadyToFinish, Completed, Reset, or Joined: the player is in the world and their quests are known (once per quest) — the moment to set up what they see.

Float this script’s object. sinkDepth: metres it sits below the surface line (higher = heavier, sits lower; negative rides on top). bob: how much it follows the wave height (1 = fully, 0.5 = a heavy ship). tilt: how much it leans with the wave slope (0 = stays flat). responsiveness: how quickly it settles (per second). Call it again to change the values.

The same for another object (slot it as a SceneObject field).

Stop floating; the object keeps the position the script gives it.

Turn the Water System’s waves on or off.

Change the waves live. Applied on every viewer, and buoyant objects follow the new waves straight away.

Apply a look preset: "Open Ocean", "Tropical Lagoon", "Calm Lake", "River", "Pool", "Swamp".

Start simulating hose between start (the anchor) and end. Call it again to change the settings or the ends. An end that is not set (or not found) hangs free.

The same, with each end on a local point of its object (e.g. the back of the nozzle, the spout of a tap).

Move the start end to another object.

Move the other end to another object: from a hook to the nozzle a player picked up, and back.

Let go of the end: it drops and hangs from the start, or lies on the ground.

Stop simulating; the mesh goes back to its modelled shape.

Turns the hose like a jump rope around the line between its two ends: it is driven around a turning loop, the same on every viewer, and is still a real rope (it bends, lies on and slaps the floor at the bottom, slides over it). turnsPerSecond > 0 = forward (over the head, down in front, under the feet, up behind); < 0 = backward. phaseDegrees: where it starts: 0 = straight up (overhead), 90 = in front, 180 = under the feet, 270 = behind. facingUsername: “in front” is that player's facing (the jumper); "" = the side to the right of start → end. strength 0–1: how hard the rope is pulled onto the loop each step (1 = exactly on it; 0.5–0.6 = looser, more natural). The loop is sized from the rope's length and stays at least 0.7 m wide (hands crossed). Timing: while the facingUsername player has an emote playing, the rope's clock is that emote's playback time (angle = phaseDegrees + 360 · turnsPerSecond · emote time), so it is locked to the jump on every screen, also while the emote downloads at a different speed on each. Make each jump-rope clip hold a whole number of turns (a 0.5 s clip at 2 turns a second) and its loop wraps seamlessly. With no emote playing (before it has loaded, or no facing player), the angle counts from when that viewer received the command; switching between the two eases over 0.15 s. Call it again to switch speed or phase. Players who join later get it at the right angle. Also SpinHose(hose, tps, phase, UserInfo facing, strength).

Stops turning: the hose is plain hanging physics again and keeps its speed, so it flops down naturally.

Length (metres; 0 = automatic: the model’s length, or Slack × the gap between the ends if that is longer) · Slack (default 1.3: how much longer than the gap between its ends the hose is, so it hangs and curls; 1 = taut) · Radius (metres, 0 = from the model) · Segments 4–96 (smoothness, default 24) · Stiffness 0–1 (resists bending, default 0.3; 0 = limp rope, 1 = stiff pipe) · Stretch 0–1 (how rubbery when pulled, default 0.3: pulled past its length it stretches like rubber and still sags with its own weight, going taut only at MaxStretch; 0 = does not stretch, pulls straight) · MaxStretch (how far it may stretch at most, default 2 = double) · Gravity (1 = normal) · Damping 0.9–1 (lower settles faster, default 0.985) · Friction 0–1 on the ground (default 0.6) · Collision (default true) · Axis "auto"/"x"/"y"/"z" · StartDirection / EndDirection: a local direction the hose leaves that end in (Vector3.zero = free), e.g. new Vector3(0, 0, -1) = out of the back of a nozzle.

Store a value under key. Overloads take int, long, float, double and bool too. onDone(true) when it was written. Keys up to 255 characters; values up to about 1 MB.

The stored text, or "" if the key was never saved. Also LoadData(key, string fallback, onValue) to choose what you get when it is missing.

The value parsed as a whole number, or fallback if it is missing or unparseable. Likewise LoadLong, LoadFloat, LoadDouble and LoadBool.

Remove a key from the store.

Queues a raw client command for this script object's network id.

Queues a raw client command for a target object id.

Writes a normal log message prefixed with the script name.

Writes a warning prefixed with the script name.

Writes an error prefixed with the script name.