// 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)