Setting Up Interactions

This node, when placed on the node graph, triggers any connected logic as soon as players enter the experience.

For example, you can link this node to a camera sequence so that when your experience begins, players view a cinematic opening before they can start exploring. The node setup would look something like this:

This node can also serve as an overall controller in your experience. For example, if your experience includes multiple 'First Person Beacons' (for setting up multiple teleportation points), the 'On Start Event' node lets you specify which beacon to activate when players first enter, determining their initial location.

Additionally, for actions triggered later in the experience—such as objects that become active in response to player interactions—you can use the 'On Start Event' node to ensure they remain inactive initially. By connecting the 'On Start Event' to these actions and setting their default states to false, you control their availability from the start. The setup might look something like this:

When added to the node graph, this node resets the experience, which is useful for scenarios like 'game failed' conditions.

For example, if a player enters a restricted area, you can trigger a game-over state and reset the experience. To set this up, place a 'Spatial Trigger' in the designated area, and connect the 'On Trigger Enter' action from the 'Spatial Trigger' to initiate the reset. The setup would look like this:

This node allows you to customize the keyboard for specific things. It will ONLY work in play mode and NOT in editor mode.

This node allows you to customize the Gamepad for specific things. It will ONLY work in play mode and NOT in editor mode.

This node, when connected to an action trigger, automatically displays the End Screen, marking the conclusion of the experience.

For instance, you could set an object to trigger this screen upon interaction, allowing players to end the experience by engaging with the object. The setup would look like this:

The End Screen is auto generated, it will contain information such as play stats, creator info, experience sharing link etc.

The Pulse node generates a steady stream of pulses at a set frequency once it’s enabled—ideal for looping effects and timed behaviors.

How It Works:

• Entry (▶️): Send a trigger here (e.g., On Start Event) to toggle the node’s Enable state.

• Output (▶️): Fires a pulse each time the interval elapses.

• Count (🔵Number): Emits the cumulative number of pulses sent so far.

Node Settings:

• Enable: When True, the node begins pulsing; when False, it stops.

• Frequency: Time in seconds between each pulse (e.g., 0.5 = two pulses per second).

Example Use Cases:

• Blinking Lights: Pulse a light’s Enable input to create a strobe effect.

• Heartbeat Audio: Drive a subtle thump every half-second.

• Periodic Spawns: Spawn pickups or enemies on a regular cadence.

The Repeater node re-fires an input signal at a set interval—either a fixed number of times or continuously—ideal for looping behaviors.

How It Works:

• Entry (▶️): Kick off the repeat cycle.

• Output (▶️): Emits one pulse per repetition.

• Count (🔵Number): Emits the current repetition index (X Amount) each time it fires.

Inspector Settings:

• Amount: Total pulses to emit after receiving Entry (set to 0 for infinite repeats).

Example Use Cases:

• Spawn Waves: Trigger enemy spawns three times by setting Amount = 3.

• Blinking Effects: Toggle lights or objects on/off a fixed number of times.

• Timed Alerts: Pair with a Delay node to send notifications or sounds at consistent intervals.

The Ramp node smoothly interpolates a numeric value from 0 → 1 (or vice versa) over a set duration whenever it receives an Entry pulse. You can use it to create gradual transitions—like fades, zooms, or progress bars—without any manual tweening.

How It Works:

• Entry (▶️): Trigger this input to start the ramp.

• Output (▶️): Fires a single pulse when the ramp completes (optional use).

• Value (🔵Number): Continuously emits the interpolated value (0…1) each frame.

Node Settings:

• Duration: Time in seconds for the value to go from 0 to 1.

• Interpolation: Choose Linear (constant speed) or eased curves for smoother transitions.

• PingPong: Toggle to reverse direction automatically once the ramp hits its endpoint, creating a back-and-forth loop.

Example Use Cases:

• Light & Audio Fades: Gradually brighten lights or fade music in/out.

• Camera Zooms & Pans: Smoothly animate camera field-of-view or position.

• Moving Objects: Animate objects to move between.

The Counter node keeps track of how many times it’s been triggered and emits both a pulse and the current count—perfect for tracking uses, scores, or progress.

How It Works:

• Entry (▶️): Each pulse here adds to the count.

• Output (▶️): Fires once each time the count increments.

• Count (🔵Number): Emits the updated count value after each Entry.

Node Settings:

• Increment: The amount added to the count per Entry (default 1).

• Reset Value: The number the counter returns to when reset.

• Reset (Boolean): When toggled True (or when a Reset input is triggered), the counter jumps back to the Reset Value.

Example Use Cases:

• Collectibles Tracking: Increment for each item picked up and display the total.

• Multi-Use Objects: Only allow a lever to be pulled 3 times before disabling.

The Sine Producer node outputs a smooth, oscillating value over time—perfect for creating natural, periodic animations or effects.

How It Works:

• Entry (▶️): When Enable is True, the node begins emitting values.

• Output (▶️): Fires continuously, updating each frame.

• Value (🔵Number): Emits a sine wave value that cycles between –1 and 1.

Node Settings:

• Enable: Toggle True/False to start or stop the oscillator.

• Frequency: How many complete cycles occur per second (e.g., 1 = one back-and-forth per second).

• Phase: Initial offset in the cycle (in radians), letting you start the wave at a specific point.

Example Use Cases:

• Breathing Effects: Subtly scale or fade objects up and down.

• Light Flicker: Create a gentle pulsing glow.

The Noise Producer node generates a stream of pseudo-random values over time—ideal for adding organic variation or subtle randomness to your world.

How It Works:

• Entry (▶️): When Enable is True, the node begins outputting noise values.

• Output (▶️): Fires continuously, updating each frame.

• Value (🔵Number): Emits a smoothly varying random number, typically in the range –1 to 1.

Node Settings:

• Enable: Toggle True/False to start or stop the noise generation.

• Frequency: Controls how rapidly the noise changes—higher values produce faster fluctuations.

Example Use Cases:

• Wobble & Jitter: Add slight, natural-looking movement to props or cameras.

• Sound Variation: Randomize audio pitch or volume for more realistic effects.

• UI Shimmer: Create an ever-changing highlight or glow on interface elements.

The Random Event node routes an incoming Entry pulse to one of several numbered outputs at random—perfect for chance-based branching in your logic.

How It Works:

• Entry (▶️): Send a trigger here to activate the node.

• On Trigger (▶️): One of the numbered outputs (1, 2, 3, …) fires each time, chosen at random.

Node Settings:

• Outputs Count: Define how many numbered outputs appear (e.g., 3 for three branches).

Example Use Cases:

• Random Loot Drops: Give players a random prize from multiple options.

• Branching Paths: Randomly choose between different level layouts or challenge routes.

• Dynamic Ambience: Trigger different sound effects or events each time a zone is entered.

The Delay Event node holds an incoming Entry pulse for a specified time before forwarding it through Delayed Out—ideal for timing offsets and sequenced events.

How It Works:

• Entry (▶️): Send a trigger here to start the delay timer.

• Delayed Out (▶️): Emits the same pulse after the configured delay.

Node Settings:

• Delay (Seconds): Time to wait before firing the Delayed Out pulse.

Example Use Cases:

• Staggered Animations: Start multiple animations in sequence by chaining Delay Event nodes.

• Timed Challenges: Give players a countdown before spawning hazards or unlocking doors.

• Audio Syncing: Delay sound effects to match on-screen actions.

The Choke node is a simple pass-through splitter: whenever it receives an Entry pulse, it forwards that same pulse out its Output port to every connected node downstream. There’s no configuration—just drop it in any time you need to fan out a single trigger into multiple branches.

How It Works:

• Entry (▶️): Send your trigger here.

• Output (▶️): Fires the same pulse to all connected nodes.

Example Use Cases:

• Fan-Out Signals: Trigger multiple actions (e.g., play a sound, open a door, start an animation) from one event.

• Keep Graph Clean: Use as a single junction point instead of wiring one node into many.

• Logic Organization: Group related branches under one choke for clarity.

The Gate node controls whether an incoming Entry pulse is allowed through to the Next port, based on its Enable setting. Think of it as an on/off switch for your signal flow.

How It Works:

• Entry (▶️): Send a trigger here.

• Enable (○): When True, the node passes the trigger through; when False, it blocks it.

• Next (▶️): Emits the pulse only if Enable is True.

Example Use Cases:

• Conditional Branches: Only fire downstream actions when certain in-game conditions are met.

• Manual Overrides: Allow designers or players to toggle entire logic chains on/off.

• State Management: Gate off interactions during cutscenes, loading screens, or paused states.

The Add node performs a simple arithmetic sum of two numbers whenever it receives an Entry pulse, then outputs both the result and a continuation trigger.

How It Works:

• Entry (▶️): Send a trigger here to execute the addition.

• Num 1 & Num 2 (🔵Number): Input fields for the two values you want to add.

• Next (▶️): Fires immediately after the sum is computed—use this to chain further logic or actions.

• Sum (🔵Number): Emits the numeric result of Num 1 + Num 2.

Example Use Cases:

• Score Tracking: Add points each time a player collects an item and pass the updated total downstream.

• Dynamic Thresholds: Combine base values and modifiers (e.g., health + bonus) before checking conditions.

• Chained Calculations: Feed the Sum into another Math or Condition node for multi-step logic.

The Subtraction node calculates the difference between two numbers when it receives an Entry pulse, then outputs both the result and a continuation trigger.

How It Works:

• Entry (▶️): Send a trigger here to perform the subtraction.

• Num 1 & Num 2 (🔵Number): Input fields—the node computes Num 1 − Num 2.

• Next (▶️): Fires immediately after the calculation, allowing you to chain further logic or actions.

• Diff (🔵Number): Emits the numeric result of the subtraction.

Example Use Cases:

• Health & Resource Management: Subtract damage from health or resource pools and check for zero to trigger “game over” or reload events.

• Countdown Timers: Decrease a timer value each second and branch logic when it hits zero.

• Distance Calculations: Compute remaining distance or difference between positions for dynamic effects.

The Multiply node multiplies two numbers when it receives an Entry pulse, then outputs both the product and a continuation trigger.

How It Works:

• Entry (▶️): Send a trigger here to execute the multiplication.

• Num 1 & Num 2 (🔵Number): Input fields for the two values you want to multiply.

• Next (▶️): Fires immediately after the calculation, allowing you to chain further logic or actions.

• Product (🔵Number): Emits the numeric result of Num 1 × Num 2.

Example Use Cases:

• Scaling Values: Increase movement speed or scale effects by multiplying base values with modifiers.

• Calculating Areas: Multiply width and height inputs for dynamic UI or world-space measurements.

• Adjusting Difficulty: Scale spawn counts or damage values based on game progression.

The Divide node divides one number by another when it receives an Entry pulse, then outputs both the quotient and a continuation trigger.

How It Works:

• Entry (▶️): Send a trigger here to perform the division.

• Num 1 & Num 2 (🔵Number): Input fields—the node computes Num 1 ÷ Num 2.

• Next (▶️): Fires immediately after the calculation, allowing you to chain further logic or actions.

• Quotient (🔵Number): Emits the numeric result of the division.

Example Use Cases:

• Averaging Values: Divide a sum by a count to compute averages (e.g., average score or speed).

• Ratio Calculations: Determine proportions (e.g., health percentage: currentHealth ÷ maxHealth).

• Dynamic Scaling: Adjust object sizes or effect strengths based on relative values.

The Mod node calculates the remainder of dividing one number by another when it receives an Entry pulse, then outputs both the remainder and a continuation trigger.

How It Works:

• Entry (▶️): Send a trigger here to perform the modulo operation.

• Num 1 & Num 2 (🔵Number): Input fields—the node computes Num 1 % Num 2.

• Next (▶️): Fires immediately after the calculation, allowing you to chain further logic or actions.

• Dividend (🔵Number): Emits the remainder of the division (Num 1 mod Num 2).

Example Use Cases:

• Looped Indexing: Cycle through a list of items (e.g., Num 1 = frame count, Num 2 = total frames) to loop animations.

• Periodic Events: Trigger an action every Nth event by checking if Dividend == 0.

• Parity Checks: Determine even/odd behavior (e.g., Num 2 = 2, Dividend = 0 for even).

The Random Number node generates a one-off random value within a specified range whenever it receives an Entry pulse, then outputs both the result and a continuation trigger.

How It Works:

• Entry (▶️): Send a trigger here to produce a new random number.

• Min & Max (🔵Number): Define the inclusive lower and upper bounds for the random value.

• Next (▶️): Fires immediately after the number is generated—use this to chain further logic or actions.

• Result (🔵Number): Emits the generated random number between Min and Max.

Example Use Cases:

• Loot Drops: Choose a random reward value or item index when a chest is opened.

• Procedural Variation: Randomize enemy stats, spawn locations, or environmental parameters.

• Dynamic Difficulty: Randomly adjust challenge parameters within a safe range.

The Remap node converts an input value from one numeric range into another—useful for normalizing or scaling values on the fly.

How It Works:

• Entry (▶️): Send a trigger here to perform the remapping.

• Output (▶️): Fires immediately after the remapped value is calculated.

• Output (🔵Number): Emits the remapped numeric value.

Node Settings:

• Input: The value you want to convert.

• Input Min / Input Max: The original range of the input value.

• Output Min / Output Max: The target range for the remapped output.

Example Use Cases:

• Normalize Signals: Convert a ramp’s 0–1 output into a 0–100 percentage for UI progress bars.

• Adjust Sensitivity: Map joystick input values into finer control ranges for camera movement.

• Dynamic Scaling: Scale health, speed, or intensity values to match gameplay variables or difficulty levels.

The Numeric Comparison node evaluates two numbers against an operator and emits a Boolean result.

How It Works:

• Entry (▶️): Send a trigger here to perform the comparison.

• Num 1 & Num 2 (🔵Number): Input fields for the two values you want to compare.

• Op (○ Dropdown): Choose the comparison operator:

  • GreaterThan (>), LessThan (<), Equal (==), NotEqual (!=), GreaterOrEqual (≥), LessOrEqual (≤).

• Next (▶️): Fires immediately after the comparison—use to chain further logic.

• Result (○ Boolean): Emits True or False based on whether the comparison holds.

Example Use Cases:

• Threshold Checks: Trigger events when a score, health, or timer crosses a critical value.

• Conditional Branching: Decide between two paths (e.g., open a door if playerGold ≥ price).

• Loop Control: Combine with Counter or Repeater to stop loops after a certain count.

The Text Search node checks whether a specified Pattern exists within an Input string and fires an On Match pulse when it does.

How It Works:

• Entry (▶️): Send a trigger to perform the search.

• Input & Pattern (○ Value):

  • Input: The text to scan (e.g., chat messages or imported strings).

  • Pattern: The substring or phrase you’re looking for.

• On Match (▶️): Fires if Pattern is found within Input.

Example Use Cases:

• Chat Commands: Listen for keywords (e.g., “!start”) in chat to trigger events.

• Content Filtering: Detect banned words or phrases to block actions.

• Dynamic Prompts: React when players type specific phrases into text panels.

The Text Regex node uses a regular-expression Pattern to search an Input string and fires an On Match pulse when it finds a match—also outputting the matched text.

How It Works:

• Entry (▶️): Send a trigger to run the regex test.

• Input & Pattern (○ Value):

  • Input: The string to evaluate (e.g., chat messages, file names).

  • Pattern: The regular-expression to apply (e.g., ^!give (\w+)).

• On Match (▶️): Fires if the Pattern finds at least one match in Input.

• Result (● Text): Emits the exact substring or capture group matched by the regex.

Example Use Cases:

• Command Parsing: Extract parameters from chat commands (e.g., capture the item name in !give sword).

• Input Validation: Ensure text follows a specific format (emails, IDs, custom tags).

• Dynamic Routing: Route different patterns to different game events or dialogs.

The Text Append node concatenates two input strings into one and fires a continuation pulse once complete—ideal for building dynamic messages or labels.

How It Works:

• Entry (▶️): Send a trigger to perform the append operation.

• Input 1 & Input 2 (○ Value): The two strings you want to join.

• On Next (▶️): Fires immediately after concatenation.

• Result (● Text): Emits the combined string: Input1 + Input2.

Example Use Cases:

• Dynamic Labels: Build UI labels like “Score: “ + currentScore.

• File Paths: Construct file or URL strings dynamically based on variables.

The AND node evaluates two Boolean inputs and only passes a trigger through when both are true.

How It Works:

• Entry (▶️): Send a trigger here to perform the evaluation.

• Input 1 & Input 2 (○ Boolean): Set or connect two Boolean values.

• Next (▶️): Fires only if both inputs are True.

• Result (● Boolean): Emits True when both inputs are True, otherwise False.

Example Use Cases:

• Multi-Condition Gates: Only open a door if the player has both a key AND a password.

• Combined Triggers: Activate an event when two separate in-world conditions are met simultaneously.

• UI States: Show a “Proceed” button only when two form fields are filled out.

The OR node evaluates two Boolean inputs and passes a trigger if either input is true.

How It Works:

• Entry (▶️): Send a trigger here to perform the evaluation.

• Input 1 & Input 2 (○ Boolean): Set or connect two Boolean values.

• Next (▶️): Fires if at least one input is True.

• Result (● Boolean): Emits True when either input is True; otherwise False.

Example Use Cases:

• Flexible Conditions: Open a gate if the player has a key or has bypassed the lock via a puzzle.

• Multiple Triggers: Trigger an event if a timer runs out or a player presses a cancel button.

• Fallback Logic: Use a backup input if the primary condition fails.

The EQUAL node compares two Boolean inputs and passes a trigger if they match—both true or both false.

How It Works:

• Entry (▶️): Send a trigger here to perform the comparison.

• Input 1 & Input 2 (○ Boolean): Set or connect two Boolean values.

• Next (▶️): Fires if Input 1 == Input 2.

• Result (● Boolean): Emits True when both values match, otherwise False.

Example Use Cases:

• Mirror Conditions: Ensure two switches are in the same position before opening a door.

• State Validation: Confirm that a game state flag aligns with a player status flag.

• UI Toggles: Show or hide panels when two settings are in sync.

The NOT node inverts a single Boolean input—turning True into False and False into True—and passes the inverted value downstream.

How It Works:

• Entry (▶️): Send a trigger here to perform the inversion.

• Input (○ Boolean): The value to invert.

• Next (▶️): Fires immediately after inversion.

• Result (● Boolean): Emits the opposite of the Input value.

Example Use Cases:

• Reverse Conditions: Enable interactions when a condition is not met (e.g., allow movement when NOT paused).

• Toggle Behaviors: Invert a flag each time a button is pressed to switch between modes.

• Fallback Logic: Use with OR or AND nodes to build more complex Boolean expressions.

The Object Equals node checks whether two scene objects are the same and emits a Boolean result.

How It Works:

• Entry (▶️): Send a trigger to perform the comparison.

• Reference 1 & Reference 2 (○ Scene Object): Drag any two objects from your scene or select them via the Inspector.

• Result (▶️Boolean): Emits True if both references point to the same object, otherwise False.

Key Use Cases:

• Conditional Branching: Only proceed when a specific object is interacted with (e.g., “if hit object == key”).

• Dynamic Linking: Verify that the player is using the correct item or tool before triggering an event.

• Cleanup Logic: Compare spawned objects against templates to determine which ones to destroy or reset.

The Move Object node animates a scene object from its current position to a new location over a single frame when triggered, then fires an On Complete pulse.

How It Works:

• Entry (▶️): Send a trigger to perform the move.

• Reference (○ Scene Object): Select the object you want to move.

• X / Y / Z (● Number): Target coordinates for the object’s new position.

• Object Space (○ Boolean):

  • False: Use world-space coordinates.

  • True: Use the object’s local-space axes.

• On Complete (▶️): Fires once the object has been repositioned.

Example Use Cases:

• Teleportation: Instantly move players or props to a new spot (e.g., doorways, checkpoints).

• Dynamic Layouts: Rearrange scenery or puzzles in response to events.

• Spawn Positioning: Place newly spawned objects at specific coordinates.

The Rotate Object node instantly sets a scene object’s rotation to specified Euler angles and then fires an On Complete pulse.

How It Works:

• Entry (▶️): Send a trigger to perform the rotation.

• Reference (○ Scene Object): Select the object to rotate.

• X / Y / Z (● Number): Rotation angles in degrees around each axis.

• Object Space (○ Boolean):

  • False: Apply rotations in world-space axes.

  • True: Apply rotations relative to the object’s local axes.

• On Complete (▶️): Fires once the rotation is applied.

Example Use Cases:

• Orientation Changes: Immediately face an object toward a player or target.

• Puzzle Mechanics: Snap rotating platforms or switches to exact angles.

• Reset Transforms: Return objects to their default orientation at runtime.

The Scale Object node instantly sets a scene object’s uniform scale and then fires an On Complete pulse.

How It Works:

• Entry (▶️): Send a trigger to perform the scaling.

• Reference (○ Scene Object): Select the object you want to resize.

• U (● Number): Uniform scale multiplier (e.g., 1 = original size, 2 = double size).

• On Complete (▶️): Fires once the scale is applied.

Example Use Cases:

• Growth Effects: Instantly enlarge items when picked up or powered up.

• Pop-In Transitions: Quickly scale objects from 0→1 for an “appear” effect.

• Dynamic Feedback: Visually emphasize changes (e.g., button presses or goal completions).

The Set Enable State node toggles an object’s active behaviors—turning its interactive scripts on or off—and fires an On Complete pulse when done.

How It Works:

• Entry (▶️): Send a trigger to update the enable state.

• Scene Object (○ Scene Object): Select the target object.

• Enable (○ Boolean):

  • True: Activates the object’s scripts and interactions.

  • False: Deactivates the object—its behaviors won’t run.

• On Complete (▶️): Fires once the enable state has been applied.

Example Use Cases:

• Pause Mechanics: Temporarily disable traps or puzzles during cutscenes.

• Conditional Unlocks: Enable new interactive elements only after certain criteria are met.

• Performance Optimization: Turn off off-screen or idle objects to save resources.

The Set Visible State node shows or hides a scene object and fires an On Complete pulse when the change is done.

How It Works:

• Entry (▶️): Send a trigger to update visibility.

• Scene Object (○ Scene Object): Select the object you want to show or hide.

• Enable (○ Boolean):

  • True: Makes the object visible in the scene.

  • False: Hides the object (but it remains in the hierarchy).

• On Complete (▶️): Fires once the visibility state is applied.

Example Use Cases:

• Pop-Up UI Elements: Show messages or hints when needed, then hide them afterward.

• Dynamic Scenery: Reveal secret passages or hide obstacles during gameplay.

• Performance Tweaks: Temporarily hide off-screen props without destroying them.

The Object Queue node lets you enqueue scene objects at runtime and dequeue them one by one—useful for ordered sequencing of object-based actions.

How It Works:

• Entry (▶️): Each pulse here triggers a dequeue operation.

• Add Object (○ Scene Object): Send an object reference into this port (via logic or direct connection) to enqueue it.

• Clear (○ Boolean): When True, empties the entire queue immediately.

• On Dequeue (▶️): Fires whenever an object is removed from the queue.

• Object (○ Scene Object): Outputs the dequeued object reference for downstream actions.

Example Use Cases:

• Staggered Spawning: Queue multiple spawn points, then dequeue one at a time to place enemies or props in sequence.

• Ordered Events: Enqueue cutscene cameras or waypoints, then step through them one by one.

• Task Lists: Build a list of interactive objects (switches, buttons) and process them in a defined order.

The On Collision node detects when a specified scene object collides with another object and fires an On Hit pulse.

How It Works:

• Entry (▶️): Send a trigger to start monitoring collisions (e.g., on “On Start”).

• Monitor (○ Scene Object): Select the object whose collisions you want to watch.

• Clear (○ Boolean): When True, resets the collision history so future hits will re-trigger.

• On Hit (▶️): Fires each time the monitored object collides with another.

• Hit Object (○ Scene Object): Outputs the reference of the object that was hit.

Example Use Cases:

• Damage Zones: Detect when a player enters a hazard and apply damage or knockback.

• Interactive Props: Trigger sounds or animations when objects hit each other (e.g., balls bouncing).

• Puzzle Mechanics: Check when a key object collides with a target area to advance the puzzle

The Text Constant node provides a fixed string value to use anywhere in your graph.

How It Works:

• Value (○ Text): Enter any static text (e.g., "Hello, Player!", "!start", "username").

• Output (● Text): Emits the entered string whenever downstream nodes request it.

Example Use Cases:

• Chat Commands: Supply the exact keyword to match in a Text Search or Text Regex node.

• Default Inputs: Provide baseline values for Remap, Math, or other nodes requiring text input.

The Numeric Constant node supplies a fixed number to your graph.

How It Works:

• Value (● Number): Enter any numeric value (e.g., 5, 3.14, -10).

• Output (● Number): Emits the entered number whenever downstream nodes consume it.

Example Use Cases:

• Thresholds & Limits: Provide static bounds for Condition or Remap nodes.

• Offsets & Increments: Use as a constant addend in Add or Multiply nodes.

• Default Settings: Seed values for Ramp, Counter, or Random Number nodes.

The Bool Constant node provides a fixed true/false value to your graph.

How It Works:

• Value (○ Boolean): Choose True or False.

• Output (● Boolean): Emits the selected value whenever downstream nodes consume it.

Example Use Cases:

• Initial States: Set default conditions for Gate, Choke, or other logic nodes.

• Static Flags: Provide a constant True or False input for testing or one-off branches in your graph.

• Configuration Toggles: Control features (e.g., enable/disable tutorial hints) without external triggers.

The Object Constant node holds a reference to a specific scene object for use anywhere in your graph.

How It Works:

• Value (○ Scene Object): Select any object from your scene via the Inspector.

• Output (○ Scene Object): Emits the chosen object reference whenever downstream nodes consume it.

Example Use Cases:

• Fixed Targets: Provide a static reference for nodes like Move Object, On Collision, or Object Equals.

• Shared References: Use one constant node to feed the same object into multiple interactions, keeping your graph tidy.

• Preset Configurations: Embed frequently used objects (e.g., a main door or key item) as constants for easy reuse

The Open Website node opens a specified URL in the user’s default web browser whenever it receives an Entry signal—ideal for linking out to help docs, live dashboards, or external resources.

How It Works:

• Entry (◆): Send a trigger here (e.g., a button press or chat command) to launch the URL.

• URL (○ Text): Enter any valid web address (e.g., https://docs.mtion.xyz/interactions).

Key Use Cases:

• In-Game Help: Provide direct links to relevant documentation or tutorials.

• Live Data: Connect players to leaderboards, stats pages, or external APIs.

• Community Engagement: Link to your Discord server, forum threads, or social media.