Make Props Dance: Positioning and Choreography

Have you ever watched a music video? The dancers move in perfect sync. They step left, then right, all at the same time. In Fortnite, you can make your props do the same thing! You can make crates float, signs spin, and lights blink in a pattern. This is called choreography. It is like directing a play, but with code.

What You'll Learn

• How to pick a spot in the world using coordinates.
• How to tell a prop to move smoothly.
• How to make multiple props move together.

How It Works

Imagine your Fortnite island is a giant grid. It has three directions. Forward and backward. Left and right. Up and down. In Verse, we use a Vector to describe a spot. Think of a Vector like a treasure map. It tells you how many steps to walk forward, how many to step sideways, and how many to jump up.

When you want a prop to move, you do not just snap it to a new spot. That looks jerky. Instead, you use a Move command. This command says, "Go from here to there over a set amount of time." This is called Animation. It makes the movement look smooth and natural.

To make a choreography, you need a plan. You need to know where each prop starts. Then you tell each one where to go. If you tell them all to move at the same time, they dance together. If you tell them to move one after the other, they take turns. This is the heart of programming a scene.

Let's Build It

We will build a simple dance floor. We will place three crates. When the game starts, they will all slide to the center of the island at the same time. This is a simple choreography.

First, place three Creative Crates in your island. Name them Crate1, Crate2, and Crate3.

Next, add a Trigger Volume. This is a box that detects when a player walks in. Inside the Trigger Volume, add a Verse Device. This is the brain that runs your code.

Here is the code for your Verse Device. Copy it carefully.

using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }
using { /UnrealEngine.com/Temporary/SpatialMath }

# This is our dance floor script.
DanceFloor := class(creative_device):

    # These are our props. They are like actors on a stage.
    @editable
    crate_1: creative_prop = creative_prop{}
    @editable
    crate_2: creative_prop = creative_prop{}
    @editable
    crate_3: creative_prop = creative_prop{}

    # This function runs when the device starts up.
    OnBegin<override>()<suspends>: void =
        # We subscribe to the trigger's agent-entered event elsewhere,
        # but here we drive the dance directly on begin for simplicity.
        RunDance()

    # Moves all three crates to the center at the same time.
    RunDance()<suspends>: void =
        # We define the target spot. Let's use the center of the island.
        # vector3 is a point in 3D space.
        target_spot := vector3{X:=0.0, Y:=0.0, Z:=50.0}

        # We set the duration. 1.0 second is a good start.
        Duration := 1.0

        # Now we tell each crate to move smoothly using MoveTo.
        # sync{} runs all three moves at the same time so they dance together.
        sync:
            # MoveTo takes a target transform, duration, and easing type.
            # We build a transform that keeps the prop's rotation but changes position.
            block:
                crate_1.MoveTo(target_spot, crate_1.GetTransform().Rotation, Duration)
            block:
                crate_2.MoveTo(target_spot, crate_2.GetTransform().Rotation, Duration)
            block:
                crate_3.MoveTo(target_spot, crate_3.GetTransform().Rotation, Duration)

        # All three moves are now done because sync{} waits for every branch.
        # This is important for timing!```

### Walkthrough of the Code

1.  **`using` statements**: These are like opening your toolbox. We need tools for devices, animation, and math.
2.  **`crate_1`, `crate_2`, `crate_3`**: These are **Variables**. A variable is a box that holds a value. Here, the box holds a reference to a specific crate in your island. You must link these in the device properties in UEFN.
3.  **`OnBegin<override>()<suspends>`**: This is an **Event**. An event is something that happens in the game. Here, it happens automatically when the game session begins and the device wakes up.
4.  **`vector3{X:0.0, Y:0.0, Z:50.0}`**: This is a **Literal**. It is a fixed value written directly in the code. It defines the target position.
5.  **`MoveTo`**: This is a **Function**. A function is a set of instructions. This function tells the prop to move to a new position smoothly over the given duration.
6.  **`sync`**: This keyword runs all of the code branches inside it at the same time and waits until every branch finishes before moving on. That is what makes the crates move together.

## Try It Yourself

You have made the crates slide to the center. Now, make them dance!

**Challenge:** Change the code so that Crate1 moves to the center first. Then, Crate2 moves to the center. Then, Crate3 moves. They should not move at the same time. They should take turns!

**Hint:** You can use the `wait()` function between each `MoveTo` call. Try waiting for 0.5 seconds between each crate.

## Recap

You learned how to use **Vectors** to find spots in the world. You used **Functions** like `MoveTo` to make props move smoothly. You used **Events** to start the action. Now you can choreograph your own scenes!

## References

*   https://dev.epicgames.com/documentation/en-us/fortnite/animating-prop-movement-6-combining-movement-rotation-and-scale-in-verse
*   https://dev.epicgames.com/documentation/en-us/fortnite/animating-prop-movement-3-translating-props-in-verse
*   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/uefn/animating-prop-movement-3-translating-props-in-verse
*   https://dev.epicgames.com/documentation/en-us/uefn/animating-prop-movement-2-moving-props-with-animations-in-verse