VerseIsland Sign in
Reference Verse compiles

prop_manipulator_device: Show, Hide, and Animate Island Props

The prop_manipulator_device (and its sibling prop_mover_device) lets you show, hide, and move static props placed on your island entirely from Verse code. Whether you want a treasure chest to appear when a player reaches a dock, a cannon to slide into firing position on a pirate ship, or a hidden cove entrance to reveal itself on cue — these devices are your go-to tools for bringing the world to life.

Updated Examples verified on the live UEFN compiler
Watch the Knot — prop_show_hide in ~90 seconds.

Overview

Props are the visual building blocks of every UEFN island — barrels on a dock, lanterns on a clifftop, cannons on a pirate ship. By default they just sit there. The prop_manipulator_device and prop_mover_device give you Verse-level control over those props: you can show or hide them on demand, move them to new positions, reverse their travel, and listen for events like direction changes or collisions.

Reach for these devices when you need to:

  • Reveal or conceal scenery props in response to player actions (a hidden cove door swinging open).
  • Animate props along a path (a ship's gangplank lowering onto a dock).
  • React to prop collisions to trigger game events (a boulder rolling down a clifftop hits a wall and fires a trap).

API Reference

(API surface could not be resolved for this device.)

Walkthrough

Scenario — The Pirate Ship Cannon Reveal

Your 2D cel-shaded pirate island has a cannon hidden behind a wooden hatch on the ship's deck. When a player steps on a pressure plate near the ship's bow, the hatch prop hides (disappears) and the cannon prop slides forward into firing position using a prop_mover_device. When the cannon finishes moving (direction-change event fires after it reaches its target), a second hatch re-hides to seal the scene.

Place in your level:

  • One trigger_device (the bow pressure plate)
  • One prop_manipulator_device wired to the hatch prop
  • One prop_mover_device wired to the cannon prop
using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }
using { /UnrealEngine.com/Temporary/Diagnostics }

# Pirate ship cannon reveal — hatch hides, cannon slides forward.
pirate_cannon_reveal := class(creative_device):

    # The pressure plate near the ship's bow.
    @editable BowPlate : trigger_device = trigger_device{}

    # prop_manipulator_device controlling the wooden hatch prop.
    # In UEFN: place a Prop Manipulator device, assign the hatch prop to it.
    @editable HatchManipulator : prop_manipulator_device = prop_manipulator_device{}

    # prop_mover_device controlling the cannon prop.
    # In UEFN: place a Prop Mover device, assign the cannon prop to it,
    # set Target Distance to 3 m and Speed to 1.5 m/s in device settings.
    @editable CannonMover : prop_mover_device = prop_mover_device{}

    # Called once when the game session starts.
    OnBegin<override>()<suspends> : void =
        # Subscribe to the pressure plate so we know when a player steps on it.
        BowPlate.TriggeredEvent.Subscribe(OnBowPlateTriggered)

        # Subscribe to the cannon mover's direction-change event.
        # This fires when the prop reaches its destination and reverses,
        # which we use as a "cannon is in position" signal.
        CannonMover.MovementModeChangedEvent.Subscribe(OnCannonInPosition)

    # Fires when any player steps on the bow pressure plate.
    OnBowPlateTriggered(Agent : ?agent) : void =
        # Hide the hatch so the cannon is exposed.
        HatchManipulator.HideProps()

        # Start the cannon sliding forward into firing position.
        # SetTargetSpeed lets us override the speed at runtime if needed.
        CannonMover.SetTargetSpeed(1.5)
        # (The mover starts automatically if "Auto Start" is enabled in
        #  device settings, or call Enable() to start it.)
        CannonMover.Enable()

    # Fires when the cannon prop reaches its destination and changes direction.
    OnCannonInPosition(Ignored : tuple()) : void =
        # Cannon is now in firing position — stop it from bouncing back.
        CannonMover.Disable()```

### Line-by-line explanation

| Lines | What's happening |
|---|---|
| `@editable BowPlate` | Exposes the trigger_device slot in the UEFN details panel so you can drag your placed device in. |
| `@editable HatchManipulator` | Exposes the prop_manipulator_device. Assign your hatch prop to this device in UEFN. |
| `@editable CannonMover` | Exposes the prop_mover_device. Set Target Distance and Speed in its UEFN settings. |
| `BowPlate.TriggeredEvent.Subscribe(OnBowPlateTriggered)` | Registers our handler — called every time a player steps on the plate. |
| `CannonMover.MovementModeChangedEvent.Subscribe(OnCannonInPosition)` | Listens for the mover reaching its destination (direction flip). |
| `HatchManipulator.Hide()` | Instantly makes the hatch prop invisible in-world. |
| `CannonMover.SetTargetSpeed(1.5)` | Overrides the mover speed at runtime (meters per second). |
| `CannonMover.Enable()` | Starts the prop mover if it wasn't set to auto-start. |
| `CannonMover.Disable()` | Stops the mover so the cannon stays in firing position. |

---

## Common patterns

### Pattern 1 — Toggle a hidden cove entrance on a timer

A lagoon cove entrance is hidden at game start. After 30 seconds the entrance prop appears, giving latecomers a chance to find the secret area.

```verse
using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }

cove_entrance_reveal := class(creative_device):

    # prop_manipulator_device assigned to the cove entrance prop.
    @editable CoveEntranceManipulator : prop_manipulator_device = prop_manipulator_device{}

    OnBegin<override>()<suspends> : void =
        # Hide the entrance immediately at round start.
        CoveEntranceManipulator.Hide()

        # Wait 30 seconds, then reveal the secret cove entrance.
        Sleep(30.0)
        CoveEntranceManipulator.Show()

Key calls: Hide() to conceal the prop at start, Show() to reveal it after the delay. Sleep(30.0) suspends the coroutine without blocking other game logic.

Pattern 2 — Reverse a gangplank when a player leaves the dock

A gangplank prop slides out to meet the dock when a player arrives, then reverses back when they leave (trigger exits).

using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }

dock_gangplank := class(creative_device):

    # Trigger on the dock — fires when a player enters or exits.
    @editable DockTrigger : trigger_device = trigger_device{}

    # prop_mover_device controlling the gangplank prop.
    @editable GangplankMover : prop_mover_device = prop_mover_device{}

    # Track whether the gangplank is extended.
    var GangplankExtended : logic = false

    OnBegin<override>()<suspends> : void =
        # Set the gangplank's travel distance (5 m) and speed (2 m/s) at runtime.
        GangplankMover.SetTargetDistance(5.0)
        GangplankMover.SetTargetSpeed(2.0)

        # Subscribe to the dock trigger.
        DockTrigger.TriggeredEvent.Subscribe(OnDockTriggered)

    OnDockTriggered(Agent : ?agent) : void =
        if (GangplankExtended?):
            # Gangplank is out — reverse it back to the ship.
            GangplankMover.Reverse()
            set GangplankExtended = false
        else:
            # Gangplank is retracted — start it moving toward the dock.
            GangplankMover.Enable()
            set GangplankExtended = true

Key calls: SetTargetDistance() and SetTargetSpeed() configure the mover at runtime; Reverse() flips the travel direction; Enable() starts movement.

Pattern 3 — Reset a prop mover when the round ends

After a round ends, reset the cannon mover back to its original position so the next round starts fresh.

using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }

cannon_reset_on_round_end := class(creative_device):

    # End-of-round trigger (e.g. wired to a Class Designer or End Game device).
    @editable RoundEndTrigger : trigger_device = trigger_device{}

    # prop_mover_device for the cannon.
    @editable CannonMover : prop_mover_device = prop_mover_device{}

    # prop_manipulator_device for the hatch that covers the cannon.
    @editable HatchManipulator : prop_manipulator_device = prop_manipulator_device{}

    OnBegin<override>()<suspends> : void =
        RoundEndTrigger.TriggeredEvent.Subscribe(OnRoundEnd)

    OnRoundEnd(Agent : ?agent) : void =
        # Move the cannon prop back to its starting position.
        CannonMover.Reset()

        # Re-show the hatch so the cannon is hidden again for the next round.
        HatchManipulator.Show()

Key calls: Reset() returns the mover prop to its origin; Show() makes the hatch visible again — ready for the next round.

Gotchas

1. You MUST use @editable fields — bare device references won't compile

You cannot write prop_manipulator_device{}.Hide() inline. Every device must be declared as an @editable field inside your class(creative_device) and assigned in the UEFN details panel. A bare identifier or default-constructed device has no connection to a placed object and will silently do nothing (or fail to compile).

2. MovementModeChangedEvent hands you a tuple(), not an agent

The prop mover's direction-change event signature is listenable(tuple()). Your handler must accept (Ignored : tuple()) — you cannot get an agent from it. Don't try to unwrap a player from this event.

3. TriggeredEvent hands you ?agent, not agent

The trigger_device's event is listenable(?agent). Your handler receives (Agent : ?agent). If you need the actual player, unwrap it:

OnPlateStep(Agent : ?agent) : void =
    if (A := Agent?):
        # A is now a valid agent — cast to player if needed
        if (P := player[A]):
            # do something with P

Forgetting the ? unwrap is the #1 compile error beginners hit with trigger events.

4. Show() / Hide() are on prop_manipulator_device, not prop_mover_device

These are two different devices. prop_mover_device handles movement (SetTargetSpeed, SetTargetDistance, Reverse, Reset). prop_manipulator_device handles visibility (Show, Hide). Place both if you need both behaviors, and wire them to the same prop in UEFN.

5. Sleep() requires a <suspends> context

Sleep(30.0) can only be called inside a function marked <suspends>. OnBegin is already suspending, so timed reveals work there. Event handler methods (like OnBowPlateTriggered) are NOT suspending — if you need a delay inside a handler, spawn a new async task with spawn { MyDelayedFunction() }.

6. Verse does not auto-convert int to float

SetTargetSpeed(2) will fail — you must write SetTargetSpeed(2.0). All distance and speed parameters are float.

Build your own lesson with prop_show_hide

Generate a personalized, step-by-step lesson plan built around this object — grounded in this exact reference and our compile-verified knowledge base.

Build a lesson →