Interactivity Tools Guide

Getting Started

Open the Creator Dashboard, go to Project Tools → Interactions, and pick a tool. Make tools modify the GameObject you have selected in the scene; Add tools drop in a new preconfigured GameObject regardless of selection. Each tool adds the components and configuration needed for its behavior, including a Collider, a Rigidbody, and a NetworkObject when those are required. Configure the result in the Inspector and test in Play mode.

Interactive Behaviors You Can Add

Object Spawner

Prefab Instantiation

The Object Spawner places a prefab instance at the spawner's scene position when triggered. Assign your prefab in the Inspector and connect an Enter Trigger or interaction event to activate it.

Networked vs Local Spawning

• Local spawn: Instantiates a standard GameObject visible only to the triggering client. Use for visual effects and non-shared props.
• Networked spawn: Sends an RPC to the host, which calls runner.Spawn() so the object appears for all connected players. Requires the prefab to have a NetworkObject component.

Grabbable Objects

Distance-Based Interaction

Grabbable objects support both touch-based grabbing and distance-based grabbing using camera direction. The system automatically detects U3D players and handles hand attachment when the interact button is pressed (R key by default).

Setup Options

• Grab Detection Radius: Use radius-based detection or precise raycast
• Distance Configuration: Set minimum and maximum grab distances
• Offset: Adjust where grabbed object appears relative to hand bone
• Hand Attachment: Specify hand bone name or use player position
• Multi-Grab: Allow multiple objects to be held simultaneously

Safety Features

Grabbable objects include automatic safety recovery. If an object falls through the world or moves too far from spawn, it automatically returns to its original position.

Throwable Objects

Composing with Grabbable

Throwable is designed to compose with Grabbable, not replace it. Applying "Make Throwable" from the dashboard adds both U3DGrabbable and U3DThrowable to the object — Grabbable handles pickup and hold, Throwable handles release physics. Both components remain active on the same object and work together. You can configure each independently in the Inspector.

Physics-Based Throwing

When released, throwable objects launch in the camera direction with configurable force and automatic physics management.

Smart Physics Management

• Auto-Sleep: Objects automatically sleep when velocity drops below threshold
• World Bounds Safety: Automatic recovery if objects go out of bounds
• Grab-Throw Cycling: Seamless transition between grabbed and thrown states
• Impact Detection: Events fire when thrown objects hit surfaces
• Auto Key Remapping: Throw key automatically remaps to avoid conflicts with grabbable and kickable components on the same object

Inspector Fields

• Drop On Release: When enabled, releasing the grab key drops the object straight down instead of throwing it. Use this for objects that should be placed rather than launched — crates you stack, puzzle pieces you set down, and similar.
• Destroy On Out Of Bounds: When enabled, a bounds violation calls RequestDestroy() on the object's U3DDestroyable component instead of respawning it. Requires U3DDestroyable on the same object — a warning logs in the Console if it's missing. See Trash Handler in the Game Systems guide for setup details.

Kickable Objects

Ground-Level Physics Interaction

Kickable objects use ground-level proximity detection so players can kick objects at their feet. The kick direction follows the camera forward vector with a configurable upward boost, creating natural arcing trajectories.

Setup Options

• Kick Force: Base force multiplier applied on kick
• Upward Boost: Additional upward force for arcing trajectories
• Max Kick Velocity: Velocity cap to prevent objects flying out of bounds
• Detection Radius: Ground-level radius for foot collision detection
• Max Kick Distance: Maximum distance the player can be from the object to kick it

Smart Physics Management

• Auto-Sleep: Objects automatically return to sleep state when velocity drops below threshold or after a configurable timeout
• World Bounds Safety: Automatic position recovery if objects fall through the floor or travel too far from origin
• Grabbable Compatibility: Can coexist with U3DGrabbable on the same object. Interaction keys are automatically remapped to prevent conflicts
• Impact Detection: Events fire when kicked objects collide with surfaces

Inspector Fields

• Destroy On Out Of Bounds: When enabled, a bounds violation calls RequestDestroy() on the object's U3DDestroyable component instead of respawning it. Requires U3DDestroyable on the same object — a warning logs in the Console if it's missing. See Trash Handler in the Game Systems guide for setup details.

Events

• OnKicked: Fires when object is successfully kicked
• OnImpact: Fires when kicked object hits something
• OnSleep: Fires when object returns to sleep after kick
• OnEnterKickRange / OnExitKickRange: Fires when player enters or leaves kick proximity
• OnKickFailed: Fires when a kick attempt fails
• OnWorldBoundsReset: Fires when object is reset due to world bounds violation

Pushable Objects

Sustained Push Interaction

Pushable objects use a toggle interaction model. Press the interaction key to enter push mode, then walk to push the object in your camera's forward direction. Press the interaction key again or walk out of range to stop pushing. The object moves at the speed you walk; standing still in push mode applies no force.

Setup Options

• Push Resistance: Controls how heavy the object feels. Higher values make it harder to push. This directly adjusts the object's Rigidbody mass.
• Max Push Distance: How close the player must be to push. Walking beyond this distance automatically ends push mode.
• Start Active: When enabled, the object spawns with gravity and falls to the ground before becoming pushable. Useful for objects placed above ground level by spawners.

Physics Tuning

Push feel is controlled entirely through standard Unity Rigidbody properties. Increase the object's Rigidbody Mass (via Push Resistance) to make it harder to push. Increase Linear Damping on the Rigidbody to make it stop faster when released. No custom physics systems are involved.

Smart Physics Management

• Auto-Disengage: Push mode ends automatically if the player walks out of range without toggling off
• Auto-Sleep: After pushing stops, objects decelerate via damping and return to sleep state when velocity drops below threshold
• World Bounds Safety: Automatic position recovery if objects fall through the floor or travel too far from origin
• Grabbable Compatibility: Can coexist with U3DGrabbable on the same object. Interaction keys are automatically remapped to prevent conflicts
• Edge Behavior: Objects can be pushed off edges and will fall naturally with gravity

Inspector Fields

• Destroy On Out Of Bounds: When enabled, a bounds violation calls RequestDestroy() on the object's U3DDestroyable component instead of respawning it. Requires U3DDestroyable on the same object — a warning logs in the Console if it's missing. See Trash Handler in the Game Systems guide for setup details.

Events

• OnPushStart: Fires when player begins pushing
• OnPushEnd: Fires when player stops pushing (toggle off or auto-disengage)
• OnImpact: Fires when pushed object collides with something with force
• OnSleep: Fires when object returns to sleep after being pushed
• OnWorldBoundsReset: Fires when object is reset due to world bounds violation

Climbable Surfaces

Per-Surface Climbing

Each climbable surface carries its own climbing configuration. When a player walks toward a climbable wall, climbing begins automatically. Movement remaps to the wall surface: W climbs up, S climbs down, A/D moves laterally, and Space detaches with a small upward boost. Climbing state is networked so all connected players see each other climb.

Setup Options

• Max Climb Distance: How close the player must be to begin climbing this surface
• Climb Up Speed / Climb Down Speed: Separate vertical speed controls for ascending and descending
• Lateral Speed: Movement speed along the surface left and right
• Speed Multiplier: Overall speed adjustment for this specific surface. A value below 1.0 makes a surface feel like a slow, difficult climb; above 1.0 makes it feel like a fast ladder
• Surface Stick Distance: How closely the player hugs the wall while climbing
• Reattach Cooldown: Brief delay after detaching before the player can grab the wall again, preventing accidental re-attach after jumping off

Climbing Movement

• Surface-Relative Controls: Movement direction is calculated relative to the wall surface for natural traversal on walls of any angle
• Gravity Suppression: Gravity is automatically suppressed while climbing and resumes on detach
• Jump Detach: Pressing Space detaches from the wall with an upward boost so the player can jump away cleanly
• Ground Detach: Moving backward (S) while touching the ground releases the wall, letting the player step away naturally

Events

• OnClimbStart: Fires when the player attaches to this surface and begins climbing. Wire to an Animator SetBool to trigger a climb animation.
• OnClimbEnd: Fires when the player detaches from this surface for any reason (jump, walk away, or surface lost)
• OnJumpOff: Fires when the player specifically jumps off the surface, before OnClimbEnd. Use for jump-off animations or launch sounds that shouldn't play on a normal dismount
• OnPlayerEnterRange / OnPlayerExitRange: Fires when the player enters or leaves climbing range of this surface, regardless of whether they climb. Use for showing hint UI or toggling label visibility

Example: Climb Animations

Climbing animations work automatically. When a player grabs a climbable surface, the networked animation system detects the climbing state and transitions the avatar to a climbing animation. When the player detaches, the avatar returns to its normal state. This happens for all connected players without any event wiring.

The player prefab ships with a U3D Networked Animator component that drives all eight core animation states (idle, walking, running, jumping, crouching, flying, swimming, and climbing). It reads the player controller's movement state every frame and writes Animator parameters that propagate to all connected players automatically. The shipped U3DAnimatorController asset includes generic animations that work for most humanoid avatars.

Customizing Avatar Animations

Any animation in the U3D avatar system can be replaced — climb, idle, walk, run, jump, crouch, fly, swim. The workflow is the same regardless of which animation you're swapping. Do it once and you have a safe customization seam for every animation in your project.

The Safe Workflow

Don't edit the shipped U3DAnimatorController directly — template updates will overwrite your changes. Duplicate it once, edit the duplicate, and assign the duplicate to your prefab:

1. In the Project window, navigate to Assets/U3D/Scripts/Runtime/Avatar/U3DAnimatorController and press Ctrl+D (Cmd+D on Mac) to duplicate it.
2. Move the duplicate out of the Assets/U3D/ and Assets/Settings/ folders — for example, into a folder you own like Assets/MyProject/Animation/. Rename it something distinctive like MyAnimatorController. Template updates only touch files inside Assets/U3D/ and Assets/Settings/, so anything outside those folders is yours to edit safely.
3. Double-click your duplicate to open the Animator window. Click any state in the graph (Climbing, Idle, Walking, Running, Jumping, Crouching, Flying, Swimming) and drag your replacement clip into the Motion field in the Inspector. You can swap as many or as few as you like — the rest keep using the shipped clips.
4. Select the U3D_PlayerController prefab. In the Inspector, find the U3D Networked Animator component. Drag your duplicate controller into the Animator Controller field, replacing the default reference. This is a prefab override on your project — it survives future U3D template updates.

The networked animation system writes the same parameters (IsMoving, IsClimbing, IsSwimming, IsCrouching, IsFlying, IsGrounded, IsJumping, MoveSpeed, MoveX, MoveY, JumpTrigger) regardless of which controller you assign, so your duplicate works as long as it keeps those parameters and the transitions wired to them. The shipped controller already has them — duplicating preserves them. Don't rename or remove these parameters.

When to Customize

• Stylized avatars: A cartoon character might need exaggerated motion instead of the default realistic animations
• Non-humanoid avatars: A robot, animal, or fantasy creature needs animations that match its rig and proportions
• Themed experiences: A horror game might use slow, tense motion across the board while an action game uses fast athletic movement
• Multiple avatar options: If your experience offers avatar selection, each can have its own duplicate controller with animations suited to that character

The "Example: Climb Animations" subsection above shows this workflow in context, but the same steps apply to any of the eight animations.

Using Events for Non-Avatar Responses

The OnClimbStart, OnClimbEnd, and OnJumpOff events on U3DClimbable are designed for environmental responses, not avatar animation (which is handled automatically). Wire these to scene objects that should react when someone climbs:

• A wall that plays a dust particle effect when grabbed
• Handholds that glow while a player is climbing
• A sound effect that plays on attach and stops on detach
• A door at the top of a climbing wall that opens when OnPlayerEnterRange fires near the ledge

To connect an event: expand the Events section on the U3DClimbable component, click + on the event you want, drag in the target scene object, and pick the function to call. This is the same pattern used by every interaction tool's events throughout the system.

Swimmable Volumes

Trigger-Volume Water

Make Swimmable turns any collider into a volume the player can swim through. Place a Box, Sphere, or Mesh collider — including concave meshes — sized to where you want swimming to engage. While inside, the player swims; when leaving, normal walking and falling resume. The collider's shape defines the navigable space, so a single Box can cover a rectangular pool, a Sphere can bubble out a spherical zone, and a Mesh collider can wrap an irregular river or coral reef.

Apply Make Swimmable from the Creator Dashboard and the tool sets Is Trigger on the collider for you and adds a NetworkObject so multiplayer sync works correctly.

How Swimming Works

Swimming reuses the player controller's flying locomotion model — gravity turns off, movement becomes full 3D following the camera direction, and the swim animation plays automatically as part of the eight-state avatar controller. The bindings are the same ones flight uses: WASD for movement in the camera's plane, Space for up, the crouch key for down. Players who already know how to fly will know how to swim.

The "swim is flight with a different animation" model means anything the avatar customization system can do to flight, it can do to swim. Re-skin the swim animation via the workflow in the Climbable section above to make a non-water volume feel theme-appropriate — an anti-gravity chamber, a quicksand pit, or a magical fog all use the same mechanic underneath.

Inspector Fields

• Require Tag: When enabled, only objects with the specified tag fire OnEnterWater and OnExitWater events. Locomotion (the local player swimming) is unaffected by tag filtering — only the events care about tags.
• Required Tag: The tag to check when Require Tag is enabled. Defaults to "Player".

There's no swim speed, buoyancy, or detection range to configure — swimming inherits everything from the player controller's flight settings. If you want faster swimming, tune flight speed in the player controller; the same number drives both.

Events

• OnEnterWater: Fires when a qualifying object enters the swimmable volume. Wire to splash particles, audio, screen fades, ambient sound swaps — anything that should happen at the moment of entry.
• OnExitWater: Fires when a qualifying object leaves. Wire to a different splash sound, water-drip particles, or any "back on dry land" responses.

How Events Differ from Locomotion

This is worth understanding before wiring effects to OnEnterWater or OnExitWater. Make Swimmable has two responsibilities that are handled separately:

• Locomotion runs on every client independently. When you walk into the water, your client engages swimming for your local player. The other players' clients do the same thing for their own players when they enter. No network sync is needed because each player controls their own swimming state on their own machine, and the IsSwimming animator parameter propagates through the U3D Networked Animator so everyone sees everyone else swim.
• Events fire only on one client — the authority client — to prevent duplicate fires. If you wire OnEnterWater to a particle effect using a standard Unity particle system, only the authority client sees that particle. For effects that should appear for all players, the wired-up component needs to be network-aware itself — an RPC call, a networked state change, or a component with its own NetworkObject doing its own sync.

Practically: a splash sound that plays via standard AudioSource will only play for one player. To make it audible to everyone, route the audio trigger through an RPC or use a component that broadcasts the play call. The same applies to particles, score updates, and any other "everyone should see this" response. Local-only effects (a UI message on the entering player's screen) work fine without any network plumbing.

Composing with Other Tools

• Pair with Make Enter Trigger on the same volume if you need additional tag-filtered events with different settings (cooldowns, one-time activation). The two triggers fire independently and don't interfere with each other.

Check Your Work

• The collider must be set to Is Trigger. The dashboard tool sets this when applying; if you toggle it off later, swimming stops working entirely — both locomotion and events go silent.
• The volume can be any shape or size. A single Box collider can cover an entire ocean as long as the visual mesh matches. For irregular shapes, a Mesh collider with the navigable interior modeled in low-poly is the right tool.
• The swim animation comes from the avatar system, not from this component. If the swim animation isn't playing as expected, inspect the controller assigned to U3D Networked Animator on the player prefab — not U3DSwimmable. The "Customizing Avatar Animations" workflow in the Climbable section above covers how to replace it safely.
• If a volume gets disabled while a player is inside, that player stops swimming cleanly. No stuck-swimming state. This matters if you're toggling water volumes on and off as part of a puzzle or scripted event.
• Effects wired to OnEnterWater don't automatically reach all players. See "How Events Differ from Locomotion" above — for shared effects, the receiving component needs its own network sync.

Enter/Exit Triggers

Flexible Player Detection

Trigger systems can detect U3D players specifically, objects with specific tags, or any colliding object. Each offers separate UnityEvents for different detection types.

Advanced Trigger Features

• Cooldown Timers: Prevent rapid re-triggering with configurable delays
• One-Time Triggers: Fire only once per session
• Multiple Event Types: Separate events for players, tagged objects, and general objects
• Authority Management: Proper multiplayer state synchronization

Make Interact Trigger

Proximity and Click Interaction

Interact Triggers fire when a player presses the Interact key while near the object, or clicks on it with the mouse. The component plugs into the standard U3D interaction system, so it respects the same interaction range, priority, and prompt display used by Grabbable, Pushable, and other interaction tools. Mouse click uses a camera raycast as a secondary input path for desktop and WebGL users.

Configuration Options

• Require Tag: Only fire for players with a specific tag, matching the Enter/Exit Trigger pattern
• Required Tag: The tag to check when Require Tag is enabled (defaults to "Player")
• Trigger Once: Deactivates after first successful interaction
• Cooldown Time: Minimum seconds between activations
• Interact Key: Key shown in the interaction prompt (R by default, remappable)
• Max Interact Distance: How close the player must be for the Interact key to work
• Max Click Distance: How far the player can be when using mouse click (0 = unlimited)
• Allow Mouse Click: Enable or disable the mouse click input path
• Optional Label: Assign a U3DWorldspaceUI to show a label near this object, matching the Grabbable and Pushable pattern

Events

• OnInteractTriggered: Fires on each successful interaction
• OnInteractFailed: Fires when interaction is blocked by cooldown, one-time limit, or tag mismatch
• OnPlayerEnterRangeEvent: Fires when a player enters interaction range
• OnPlayerExitRangeEvent: Fires when a player leaves interaction range

Scripting

Call ResetTrigger() on the component at runtime to clear the triggered state and re-arm a one-time trigger. The component also exposes HasTriggered, IsOnCooldown, and IsInRange for scripting logic.

Make Trigger Zone

Stateful Occupancy Detection

Trigger Zone tracks how many qualifying objects are currently inside it and fires events when that count crosses zero in either direction. Use it when you need to know whether the zone is occupied right now — not just that something entered or left.

Use Enter/Exit Triggers when you want a fire-and-forget event on each entry or exit. Use Trigger Zone when the state of the zone itself matters — a door that should stay open while anyone is standing in it, or a pressure plate that needs all objects removed before it resets.

Inspector Fields

• Require Tag: Only count objects with this tag toward occupancy. Leave blank to count all colliders.
• Trigger Once: When enabled, OnZoneOccupied fires only the first time the zone is occupied. OnZoneCleared still fires normally.

Events

• OnZoneOccupied: Fires when occupancy goes from zero to one — the zone just became occupied.
• OnZoneCleared: Fires when occupancy returns to zero — the zone is now empty.

Scripting

Call ResetZone() on the component at runtime to clear the occupant count and re-arm a one-time trigger. This is useful for puzzle resets where you need the zone to be re-triggerable after a sequence completes.

Example: Pressure Plate Puzzle

A classic use case — a stone slab that activates a gate while a player stands on it and deactivates the gate when they leave.

1. Select the pressure plate mesh and apply Make Trigger Zone from the dashboard.
2. In the Inspector, set Require Tag to Player so only player characters count.
3. Connect OnZoneOccupied → your gate's Animator.SetBool("Open", true) (or equivalent).
4. Connect OnZoneCleared → your gate's Animator.SetBool("Open", false).

The gate opens the moment a player steps on and closes as soon as the last player leaves. No scripting required beyond wiring the UnityEvents.

Make Collectable

Make Collectable turns any object into a source of inventory items. It's a paired tool — it lives in the Interactions tab of the Creator Dashboard, but it does nothing on its own. It needs an Inventory in the scene to put items into, and applying Make Collectable automatically adds one if your scene doesn't have one yet.

Because Inventory and Collectable are designed as a pair, full setup, configuration, and the "two GameObjects to think about" pattern (the dispenser vs. the prefab it dispenses) are covered in the Game Systems guide alongside Inventory itself:

Read the Make Collectable setup in the Game Systems guide →

Make Rideable

How It Works

Make Rideable adds a U3DRideableController to your object. When a player steps onto the rideable surface, they are carried with it automatically. Movement is driven inside Fusion's deterministic tick so all clients stay in sync — the platform moves and the player rides it within the same frame, with no jitter or lag compensation needed.

Platform Setup

1. Select your platform mesh in the scene and apply Make Rideable from the Creator Dashboard Interactions tab, under Movement.
2. A RideableTrigger child and a Waypoint_0 child are created automatically. The trigger detects when players step on and off. The waypoint marks the starting position.
3. To create a moving platform, duplicate Waypoint_0, rename it Waypoint_1, and move it to the destination. Assign both to the Waypoints array on the U3DRideableController component in the Inspector.
4. Set Loop Mode to Loop or PingPong, adjust Speed, and optionally set a Pause At Waypoint duration.

Movement Modes

• Waypoints — moves between Transform markers you place in the scene. Markers should be children of the rideable so they move with it if you reposition it in the editor. Their world-space positions are cached at runtime so they don't chase the platform as it moves.
• Rotation — spins the object continuously around a configurable local axis at a fixed speed. No waypoints needed. Use for ferris wheels, turntables, and revolving doors.
• Static — the object doesn't move on its own. Players can still ride it, and Make Steerable will use this mode to take over movement via player input.

Planned Interactive Features

Movement Tools

Make Steerable will extend Make Rideable so player movement input drives the object directly — W/S for acceleration, A/D for yaw, with a ground-check toggle for wheeled versus free-moving vehicles. Add Seat will place snap points on any object, static or moving, triggering avatar sit animations that players exit by resuming movement input. Together with Make Rideable, these three tools cover everything from park benches to hot air balloons.

Logic and State Tools

Randomized GameObject activation and mutually exclusive selection groups will enable more sophisticated interactive logic without custom scripting.

Object Management

A Player Reset Trigger for returning the player to their spawn point is planned for the Interactions tab. Object destruction and out-of-bounds recovery for physics props are handled today by Trash Handler in the Game Systems category.

Portals

Scene portals will transition players to a different Unity scene. Within-scene portals come in two flavours: one-way portals that teleport players from a source point to a destination, and two-way linked portals that allow travel in either direction between two points.

Automatic Key Remapping

When multiple interaction components share the same object, interaction keys are automatically remapped to prevent conflicts. For example, if both Grabbable and Kickable use the R key, Grabbable remaps to F. If Throwable and Kickable share a key, Throwable remaps to G. Console messages confirm any remapping at startup.