WIRED: Move an object around randomly on floor tiles

Context

This guide was originally written for a medieval agency build, where the “orc” is part of a larger world system. That said, nothing about the wiring here is theme-specific.

At its core, this is just a clean example of separating timing from movement logic, using signals to isolate execution, and structuring selection → validation → action in a predictable way.

You could swap the orc for an NPC guard, a wandering pet, a roaming hazard, or even a puzzle element. The principles stay the same.

If you’re learning Wired, this is a useful pattern to study. If you’re building something else entirely, this movement structure can be reused with minimal modification.

Final notes:

• you do need to add 2x2 floor tiles and place the goblin on top of one for it to move around.
• This stack does not move furni on empty tiles.
• You will also need to set up a wired stack to change goblin_time from 0 to 1.
  • This can be done with a trigger + effect: change variable value → goblin_time = 1.

Big Picture

This movement system separates timing from movement logic.

• Stack A1 decides when the orc is allowed to move.
• Stack A2 decides where the orc can move.

By separating responsibilities:

• You can change timing without touching pathing.
• You can change movement rules without touching the global goblin_time logic.
• You can support multiple orcs moving independently.

How the System Thinks

1. Heartbeat fires.
2. If goblin_time is active:
3. Each orc receives its own signal.
4. The orc picks a nearby tile.
5. If valid → move.
6. If invalid → retry.

Simple separation of concerns.
Clear signal flow.
Expandable for multiple entities.

Variables

These are the variables used in this system:

• Global Variable: goblin_time — controls whether orcs are allowed to move

Stack A1 — “Is It Goblin Time?”

Purpose

Send the orc into the movement stack — but only if it's goblin time.

Trigger

Repeat Effect

• Arbitrary time interval
• Controls how often the orc attempts to move

This is just a heartbeat. Nothing moves unless conditions allow it.

Selector

Furni Picks → The Orc

Explicitly targets the orc furni.

Condition

Variable Value → goblin_time = 1

The stack only executes if goblin time is active.

This acts as your global on/off switch. If goblin_time = 0, the orc freezes.

Effect

Send Signal

• Sends signal for each furni
• Signal goes to the antenna for Stack A2

That “send for each furni” checkbox is critical.

Without it:

• All orcs would share one execution
• They would attempt identical movement
• Or interfere with each other’s conditions

With it:

• Each orc receives its own signal context
• Each movement attempt is isolated
• Multiple goblins can move independently

Stack A1 does not move anything. It only decides who is allowed to attempt movement.

Stack A2 — “Find a Valid Tile and Move”

Purpose

Move the orc to a nearby 2x2 floor tile that:

• Is walkable
• Has no furni on it
• Matches dimension rules

Trigger

Receive Signal

Furni from signal = the specific orc attempting movement.

Modifiers (Movement Feel)

Animation Time → 1s

• Default movement is 0.5s
• Increasing to 1s makes motion more fluid and less twitchy

Movement Physics

• Through furniture
• Through users
• Maintain altitude

Prevents the orc from getting stuck or stepping awkwardly.

Selection Logic

1. Furni in Neighbourhood

Ring around the furni from signal (the orc). Defines the movement radius.

2. Furni with Variable → @can_walk_on

Filter checked. Removes everything in the ring that is not walkable.

3. Filter to X Furni → 1

Selects one random furni from the remaining valid tiles.

Conditions

Has No Furni On → furni from selector

The tile must be empty.

Variable Value → dimension.x = 2

Variable Value → dimension.y = 2

These eliminate walkable oddities like desks or bars. Requiring 2x2 dimensions ensures only proper floor tiles are used.

Positive Effect (If All Conditions Pass)

Move Furni to Furni

• Movement furni → furni from signal (the orc)
• Target furni → furni from selector (the chosen tile)

Negative Effect (If Conditions Fail)

Negative Send Signal → Back to A2

If the selected tile fails any condition:

• The stack re-sends the signal
• A new random tile is selected
• The stack retries movement

Design Note

This stack currently relies on retry logic.

If the randomly selected tile fails one of the conditions, the system sends the signal back into Stack A2 and tries again.

This works, but it means the stack may iterate multiple times before finding a valid tile.

If optimizing this system, you could:

• Convert some of the conditions into additional filters
• Narrow the selection pool earlier
• Reduce or eliminate the need for negative re-signalling

The fewer invalid tiles that make it through selection, the fewer retries are needed.

For learning purposes, this version clearly demonstrates:

• Signal retry loops
• The difference between filters and conditions
• How negative effects can be used as control flow