ProcRoom

Add a link for custom room routes.

Clear room metadata before reuse.

Build a seeded graph for a new run.

Rebuild the last run for retries.

Remove a link while tuning routes.

Set room metadata for logic and tags.

Run logic after a graph build.

Get the last biome for replay or debug.

Serialize the full graph to a JSON string; use for custom map rendering, external save formats, or debug logging.

Get the last seed for replay or debug.

Get the topology used to generate the current graph; use for conditional logic when mixing topology configs.

Get total depths for route planning.

Get total rooms for pacing or debug.

Find and store the shortest path between two rooms; read it with PathLength and PathRoomByIndex. Leave From empty to start from the current room.

True if a directed path of connections leads from one room to another. Leave From empty to start from the current room.

Shortest number of connection hops from one room to another, or -1 if unreachable. Leave From empty to start from the current room.

Number of rooms in the path stored by the last Compute Path action (0 if no path).

Get a room ID from the stored path by index (0 = start, PathLength-1 = destination).

Force at least one room of this type to exist at the given depth tier.

Attach a tag to a room type so every room of this type inherits it at generation.

Reset overrides for a fresh run.

Clear room and biome lists for reloads.

Create or replace a biome by ID without JSON. Use Set Biome Type Weight to configure it.

Create or replace a room type. Sets depth range and per-depth cap inline. Use -1 for Max Depth or Max/Depth for no limit.

Register biome weights for varied runs.

Register room types for graph generation.

Multiply a room type's spawn weight within a biome. 0 excludes it, 2 doubles its chance.

Set all generation parameters in one action. Call before Generate Graph. Topologies: Linear Tiered = one chain per depth; Branching Path = tree with reconvergence; Freeform Grid = 2D grid with horizontal links; Hub & Spoke = hub room with dead-end wings per depth; Gauntlet = single-room corridor (1 room per depth); Ring = tier connections plus a bidirectional ring at each depth; River Delta = wide opening that narrows toward the boss; Skip Lane = tier connections plus seeded depth+2 shortcuts.

Set per-run overrides before build.

Control whether two directly connected rooms can both be this type.

Restrict a room type to appear within a depth range. Use -1 for Max Depth to allow any.

Cap how many rooms of this type appear at any single depth tier. Use -1 for no limit.

Get how many biomes are registered; use with GetBiomeByIndex to build dynamic biome selection UIs.

Get how many room types are registered; use with GetRoomTypeByIndex to build dynamic room-type picker UIs.

Get a registered biome ID by index; pair with CountBiomes to iterate all biomes without hardcoding IDs.

Get a registered room type ID by index; pair with CountRoomTypes to iterate all types without hardcoding IDs.

Build a filtered, ordered list of rooms; read it with RoomListCount and RoomListItem. Use depth -1, empty type and empty tag to match everything.

Remove the object UID binding for a room.

Associate a spawned object's UID with a room. Read it back with RoomInstanceUID and pick with System: Pick by unique ID.

Compare a room's metadata value against a value. Numeric when both sides are numbers, otherwise a string comparison.

True if a room has an object UID bound via Set Room Instance.

Count available rooms for route choices.

Count exits from a room for navigation.

Total number of directed connections in the graph; pair with EdgeFrom/EdgeTo to draw every link.

Count rooms at a depth for pacing.

Count tagged rooms for theme logic.

Count room types for balancing.

Source room ID of the edge at this index; loop 0..CountEdges-1 to draw connection lines.

Target room ID of the edge at this index; loop 0..CountEdges-1 to draw connection lines.

Get an accessible room's ID by index; pair with CountAvailableRooms to build choice menus.

Get a connected room's ID by index; pair with CountConnectionsFrom to list exits.

Get a room ID at a depth tier by index; pair with CountRoomsAtDepth to iterate.

Get a room ID from the flat list of all rooms by index; pair with TotalRooms to spawn one object per room.

Get a tagged room's ID by index; pair with CountRoomsByTag to iterate tagged rooms.

Get a typed room's ID by index; pair with CountRoomsByType to iterate type rooms.

Get a room biome for theme checks.

Room ID bound to the given object UID, or empty if none. Use in an object's On clicked to find which room was picked.

Get room metadata for branching logic.

Room metadata value read as a number (0 if missing or non-numeric).

Room metadata value read as a string (empty if missing).

Get a room depth for progression logic.

UID bound to a room via Set Room Instance, or -1 if none. Feed into System: Pick by unique ID.

Number of rooms in the list built by the last Build Room List action.

Get a room ID from the list built by Build Room List by index; loop 0..RoomListCount-1 to iterate the filtered set.

Get all tags on a room as a comma-separated string (type tags then runtime tags); use for display or text-based matching.

Get a room type for event logic.

Add a runtime tag to a room; use to mark rooms dynamically (e.g. 'has_key', 'boss_spawned').

Move to a connected room for play.

Jump to any room for debug or cutscenes.

Block a room until a condition clears.

Flag a room visited for custom flow.

Remove a runtime tag from a room; use to clear dynamic markers when a room state changes.

Clear visited, revealed, and locked state for one room; use for challenge rooms that respawn.

Clear traversal state for a new route.

Show a room for map or fog logic.

Set the start room for a run.

Allow entry after a lock clears.

Hide a room again for fog control.

Check room data for branching logic.

Check if a room has a specific tag (from its type or added at runtime); use instead of iterating CountRoomTags.

True if no graph has been generated yet; use as a guard before any traversal or query action.

Check if a graph can be used.

True if a room is reachable and unlocked; use to gate player movement or dim UI.

True if a direct one-way connection exists between two rooms; use to validate routes without iterating exits.

Check if a room is blocked.

Check if a room is visible.

Check if a room was visited.

Trigger when a depth is fully cleared.

Trigger when a room is entered.

Fires when the player leaves a room; use to save state, close UI, or run cleanup logic on departure.

Trigger when a room type is entered.

Fires when a room is unlocked via Unlock Room; use to play door animations or show map indicators.

Fires when a room entry fails; use to show locked-door feedback or a warning.

Get the blocked room's ID; use for feedback or custom block handling.

Get why the last move was blocked; use to display player feedback text.

Get the last fully-cleared depth tier; use in OnAllRoomsAtDepthCleared events.

Get how many rooms have a connection leading into a room; use for 'convergence point' logic or map display.

Get how many rooms are currently locked; use for key/puzzle tracking or a lock counter HUD.

Get how many rooms are revealed; use for map or exploration completion UI.

Get the total number of tags on a room (type tags + runtime tags); use with GetRoomTagByIndex to iterate.

Get how many rooms the player has not yet visited; use for 'rooms remaining' UI or completion tracking.

Get how many rooms at a depth have not been visited; use for per-floor 'rooms left' counters without manual subtraction.

Get how many rooms were visited; use for exploration stats or progress bars.

Get how many rooms at a depth tier the player has visited; use for per-depth clear progress bars.

Get the active room's depth tier; use for progression checks and difficulty scaling.

Get the active room's biome; use for dynamic theming or loot table decisions.

Get the active room's ID; use for queries, data reads, or UI binding.

Get the active room's type; use for on-enter event branching (shop, boss, etc.).

Get the last entered room's biome; use inside OnRoomEntered for theming.

Get the last entered room's depth; use inside OnRoomEntered for progression logic.

Get the last entered room's ID; use inside OnRoomEntered for data reads or UI.

Get the last entered room's type; use inside OnRoomEntered for event branching.

Get the biome of the room that was just left; use inside On Room Exited to handle biome-transition effects.

Get the depth of the room that was just left; use inside On Room Exited to check if the player is descending.

Get the ID of the room that was just left; use inside On Room Exited to know the departure room.

Get the type of the room that was just left; use inside On Room Exited to trigger type-specific departure logic.

Get a room ID that connects into a room by index; pair with CountConnectionsTo to list all incoming routes.

Get a tag on a room by index (type tags first, then runtime tags); pair with CountRoomTags to iterate all tags.

Get the room ID the player was in before the current one; use for back-button UI or narrative transitions.

Get the ID of the room set as the start via Set Start Room; use to highlight spawn on a map.

Number of rooms in the same depth tier as this room; use to centre a tier when positioning.

Zero-based index of a room within its depth tier; use with RoomLaneCount to lay out a map screen.

Room position along the depth axis as 0-1 (start=0, deepest tier=1); multiply by map width and add an origin to place it.

Room position across its depth tier as 0-1, evenly spaced and centred; multiply by map height and add an origin to place it.