The Ultimate Hide-and-Seek Hack: Mastering Prop O Matic Pings with Verse

You know that feeling when you’re hiding as a flower pot in a bush, and you can see the enemy running right past you, but they just can’t find you? Or maybe you’re the hunter, and you’re staring at a field of bushes, praying the little ping icon pops up so you know where the loot goblins are hiding.

In UEFN, we call this Prop O Matic. It’s the game mode where players turn into props (chairs, crates, plants) to sneak around. But here’s the problem: without Verse, you’re flying blind. The ping system is either always on (giving away your position if you’re careless) or always off (making it impossible to find enemies).

Today, we’re going to write a tiny bit of Verse code to control the Prop Ping. We’ll build a "Fair Play" zone where pings are disabled inside the base (so you can hide safely) but enabled outside (so the hunt is on). We’ll learn about Functions (actions you take) and Logic (on/off switches) along the way.

What You'll Learn

• Functions: How to tell a device to do something (like flipping a switch).
• Logic Variables: Understanding On and Off as simple true/false states.
• Device Interaction: How to use Verse to change the settings of a Prop O Matic Manager.
• Scene Graph Basics: Connecting your script to the actual game device.

How It Works

Imagine you’re building a hide-and-seek map. You want players to feel safe inside their base, but exposed in the open world. In Fortnite, we use devices to make things happen. The Prop O Matic Manager is the brain that controls all the props.

In Verse, we don’t just "set" a variable like we do with a static value (like a wall color). Instead, we call a Function.

What is a Function?

Think of a function like a Trap Trigger.

• The trap itself is the device.
• The trigger is the function call.
• The result is the explosion.

When you call a function, you are telling the game: "Hey, execute this specific action right now."

What is Logic?

In programming, Logic (or boolean) is just a fancy word for a light switch. It has two states:

1. On (True/1): The light is on. The ping is active.
2. Off (False/0): The light is off. The ping is hidden.

The function we’re using is called SetPingProps. It takes one argument: a Logic value. If you pass On, the game shows pings. If you pass Off, it hides them. It’s that simple.

Let's Build It

We are going to create a Verse script that turns pings Off when a player enters a specific zone (your base) and On when they leave.

Step 1: Set Up Your Devices

1. Open UEFN and create a new Prop O Matic island (or add a Prop O Matic Manager device to an existing one).
2. Draw a large square zone around your "Base" area. Let’s call this the Safe Zone.
3. Add a Trigger Volume (you can use a simple invisible box or a specific trigger device) inside this Safe Zone.
4. Add a Prop O Matic Manager device. Name it BaseManager.

Step 2: The Verse Code

We need to write a script that listens for the player entering the zone and then tells the BaseManager to turn pings off.

Create a new Verse file in your project. Here is the code:

using { /Fortnite.com/Devices }

# This is our main script. Think of it as the "Game Rules" book.
PingControl = script:
    # We need a reference to our Prop O Matic Manager.
    # This is like plugging a controller into the console.
    BaseManager: prop_o_matic_manager_device = prop_o_matic_manager_device{}

    # This event fires when the game starts.
    OnBegin<override>()=initial:
        # When the game begins, let's make sure pings are ON by default.
        # This is our "Reset" button.
        BaseManager.SetPingProps(On=On)

    # This event fires when a player enters our trigger zone.
    # We'll connect this to a Trigger Volume later in the editor.
    PlayerEnteredTrigger = event (Player: player_device):
        # "Player" is the person who walked in.
        # We want to turn pings OFF so they can hide safely.
        # SetPingProps is the function. (On=Off) is the setting.
        BaseManager.SetPingProps(On=Off)

    # This event fires when a player leaves the zone.
    PlayerLeftTrigger = event (Player: player_device):
        # Now that they are in the dangerous open world, turn pings BACK ON.
        # This makes the game fair and challenging.
        BaseManager.SetPingProps(On=On)

Walkthrough: What Just Happened?

1. using { /Fortnite.com/Devices }: This line is like loading the Loadout. It tells Verse, "I want to use the standard Fortnite devices, like Prop O Matic Managers." Without this, Verse wouldn’t know what a prop_o_matic_manager_device is.
2. BaseManager: prop_o_matic_manager_device = prop_o_matic_manager_device{}: This creates a Variable. Think of it as naming a specific box in your inventory. We named our box BaseManager and told it it holds a prop_o_matic_manager_device.
3. OnBegin<override>(): This is a special event. It runs automatically when the match starts. We use it to ensure the game starts with pings On, so players aren’t confused at spawn.
4. BaseManager.SetPingProps(On=Off): This is the magic line.
   • BaseManager: The device we are controlling.
   • .SetPingProps: The Function (the action).
   • (On=Off): The Parameter (the setting). We are passing the value Off to the On parameter. It sounds weird, but it just means "Set the Ping State to Off."

Step 3: Connecting It in the Editor

Code is useless if it doesn’t talk to the devices.

1. In the Verse Editor, select your PingControl script.
2. In the Details Panel on the right, look for the BaseManager property. Click the eyedropper and select your Prop O Matic Manager device in the world.
3. Now, add a Trigger Volume in your Safe Zone.
4. Select the Trigger Volume. In its details, find the On Player Enter event.
5. Link it to the PlayerEnteredTrigger event in your Verse script.
6. Add another Trigger Volume (or use the same one with an exit condition) for On Player Exit. Link it to PlayerLeftTrigger.

Note: Depending on your specific UEFN version, you might use a simple Trigger Volume device that has Verse events attached, or you might use a Zone Trigger device. The key is linking the "Enter" and "Exit" events to the functions in your script.

Try It Yourself

You’ve got the basics! Now, try to make this map even more chaotic:

Challenge: Add a "Loot Goblin" twist. When a player picks up a specific item (like a golden banana), use Verse to Force Ping All Props for 5 seconds, revealing everyone’s location.

Hint: Look for a function called PingPlayerProps() in the Prop O Matic Manager device. You’ll need to call that function instead of SetPingProps. You’ll also need a way to track time (like a Timer device) to turn the pings back off after 5 seconds.

Recap

• Functions are actions you call on devices (like SetPingProps).
• Logic is a simple On/Off switch used to control settings.
• Variables hold references to devices so your script can talk to them.
• By combining these, you can create dynamic game modes where the rules change based on where the player is.

Now go build some traps, hide some props, and keep your pings hidden until it’s time to strike!

References

• https://dev.epicgames.com/documentation/fortnite/verse-api/fortnitedotcom/devices/prop_o_matic_manager_device/setpingprops
• https://dev.epicgames.com/documentation/en-us/fortnite/verse-api/fortnitedotcom/devices/prop_o_matic_manager_device/setpingprops
• https://dev.epicgames.com/documentation/en-us/uefn/animating-prop-movement-6-combining-movement-rotation-and-scale-in-verse
• https://dev.epicgames.com/documentation/en-us/fortnite/26-00-release-notes-in-unreal-editor-for-fortnite
• https://dev.epicgames.com/documentation/en-us/uefn/26-00-release-notes-in-unreal-editor-for-fortnite