Stop Moving the Camera: Build an Isometric Battle Royale with Verse

Forget everything you know about third-person shooters. What if your island didn’t let players look around? What if they were stuck looking down at their character from a fixed, isometric angle like a classic strategy game or Diablo? You can’t just click-and-drag the camera anymore. You have to program the view.

In this tutorial, we’re going to use Verse to create a Fixed Angle Camera system. This overrides the default Fortnite camera, locking the player into a specific perspective (like top-down or isometric) while they still move their character. It’s the foundation for tower defense, dungeon crawlers, and puzzle games. We’ll build a system where the camera follows your hero but never lets them rotate it.

What You'll Learn

• Fixed Angle Cameras: How to lock the player’s view to a specific angle using Verse.
• Targeting: How to tell the camera what to look at (your player).
• Camera Smoothing: How to make the camera follow the player without looking like it’s on a jittery rollercoaster.
• The Scene Graph: Understanding how the Camera Device, Player Character, and Verse Script interact as a hierarchy.

How It Works

In standard Fortnite, the camera is controlled by your mouse. You look left, the camera looks left. It’s a direct input.

In Verse, we’re going to break that link. We’re going to create a "Cinematographer" script. This script doesn’t care about your mouse. It cares about two things:

1. The Target: Who are we filming? (Usually the Player).
2. The Angle: Where is the camera sitting, and what direction is it facing?

Think of it like a Prop Mover. A Prop Mover moves a wall when you hit a switch. Here, our "Switch" is the player moving. As the player walks, the script calculates where the camera should be to keep the player in frame, and then moves the camera there.

We’ll use a Fixed Angle Camera device. Unlike a "Fixed Point Camera" (which stays in one spot like a security cam), a Fixed Angle Camera moves with the target. It keeps the same relative distance and angle, no matter where the target goes. It’s like having a drone flying behind you at a constant height and distance, but you can’t steer the drone.

Let's Build It

We need three things in our island:

1. A Player Character (to move around).
2. A Fixed Angle Camera device (placed in the world, usually high up).
3. A Third Person Controls device (so the player can actually move).

Now, we write the Verse script to tie them together.

The Verse Code

Create a new Verse file in your project. Let’s call it IsometricCamera.verse.

// We are defining a script that will run on the Camera Device.
// Think of this as the "Brain" of the camera.
IsometricCamera = script():
    // 1. DEFINE THE TARGET
    // This is the "Look-At Target." In Fortnite terms, this is the actor
    // the camera is obsessed with following.
    Target := struct():
        Actor: Actor
        // We need to know where the target is in the world.
        // 'Get Actor Location' is like asking "Where is the Storm Center?"
        // but for a specific player.
        Location: () -> vector

    // 2. DEFINE THE CAMERA MOVEMENT
    // This function moves the camera.
    // 'Lerp' (Linear Interpolation) is like a healing potion.
    // It doesn't jump from 0 HP to 100 HP instantly. It fills the bar smoothly.
    // Here, it smooths the camera movement so it doesn't jitter.
    MoveCamera := func(Camera: Camera, TargetLoc: vector, DeltaTime: float):
        // Calculate where the camera *should* be based on the target.
        // We want the camera to be behind and above the target.
        DesiredPosition := TargetLoc + vector(0, 0, 500) // 500 units up
        DesiredPosition := DesiredPosition + vector(0, -200, 0) // 200 units back

        // Move the camera towards DesiredPosition smoothly.
        // The camera's current position is 'Camera.Get Location'.
        // We blend between current and desired based on time.
        CurrentPos := Camera.Get Location()
        // Simple smoothing: move 10% of the way there every frame.
        // (In a real game, you'd use a proper Lerp function, but this illustrates the concept).
        NewPos := Lerp(CurrentPos, DesiredPosition, DeltaTime * 5.0)

        // Apply the new position.
        Camera.Set Location(NewPos)

    // 3. THE MAIN LOOP
    // This runs every frame (like every tick of the storm timer).
    Run := func():
        loop:
            // Get the current location of our target (the player).
            TargetLoc := Target.Location()

            // Get the DeltaTime. This is the time between the last frame and this one.
            // Think of this as "how much time passed since the last loot drop?"
            // It ensures the camera moves at the same speed regardless of FPS.
            DeltaTime := Get Delta Time()

            // Move the camera to follow the target.
            // We need a reference to the camera itself. In UEFN, the script
            // is attached to the camera device, so we use 'Self' or a reference.
            // For this simple example, we assume the script controls the camera it's attached to.
            // Note: In actual UEFN Verse, you often use 'Camera' component from the device.
            // Here we simplify: The script *is* the camera controller.
            
            // Move the camera (assuming 'Self' refers to the camera device instance)
            // In real UEFN, you'd call the camera component's movement function.
            // Let's use a standard device method for clarity:
            Self.Set Location(Lerp(Self.Get Location(), TargetLoc + vector(0, -200, 500), DeltaTime * 5.0))
            
            // Wait for the next frame.
            Wait(0)

Wait, hold up. The above code is a conceptual simplification. Verse in UEFN works with Components and Events. Let’s write the REAL, working version using the actual devices and Verse patterns you’ll use in the editor.

The Real Verse Implementation

In UEFN, you don’t just write raw logic; you attach a script to a Camera component. Here is the actual pattern:

Walkthrough: What Just Happened?

1. Player := struct()...: We created a blueprint for our "Target." It’s like a loot box that holds the player’s location. We defined a function Location() that asks the player, "Where are you?"
2. Initialize := func()...: This is the "Game Start" event. It finds the player and tells the camera, "Hey, you’re going to follow this guy."
3. Update := func()...: This is the heartbeat. Every frame, it asks the player for their location. It calculates a new camera position (offset from the player). It uses Lerp to smooth the movement. If you didn’t use Lerp, the camera would snap instantly to the new position, which looks like a glitchy teleport. Lerp makes it glide.
4. Camera.Set Location(NewCamLoc): This is the actual command. It moves the Fixed Angle Camera device to the new spot.

Try It Yourself

Challenge: Make the camera "chase" the player faster when they sprint, but stay smooth when they walk.

Hint: Look at the Lerp function in the Update loop. The third parameter is the "speed" or "mix" factor. Currently, it’s 0.1. Try making it a variable that changes based on a condition. You’ll need to detect if the player is moving fast. (Look up Player.Get Is Sprinting or check the player’s velocity).

Bonus Challenge: Add a "Reset" button. When a player steps on a trigger volume, the camera should snap back to a default position (like a top-down view at Z=1000, Y=0) instead of following the player.

Recap

• Fixed Angle Cameras let you override the default camera to create unique genres like isometric or top-down games.
• Verse is the tool that tells the camera where to look and how to move.
• Targets are the actors the camera follows.
• Lerp is your best friend for smooth camera movement, preventing jittery snaps.
• Scene Graph: The Camera Device is the parent, the Verse script is the brain, and the Player is the target. They all work together in a hierarchy.

References

• https://dev.epicgames.com/documentation/en-us/fortnite-creative/using-fixed-angle-camera-devices-in-fortnite-creative
• https://dev.epicgames.com/documentation/en-us/fortnite/using-fixed-angle-camera-devices-in-fortnite-creative
• https://dev.epicgames.com/documentation/en-us/fortnite-creative/using-fixed-point-camera-devices-in-fortnite-creative
• https://dev.epicgames.com/documentation/en-us/fortnite/using-fixed-point-camera-devices-in-fortnite-creative
• https://dev.epicgames.com/documentation/en-us/fortnite-creative/designing-with-cameras-and-controls-in-fortnite-creative