cinematic_sequence_device: Cutscenes on Cue

Overview

The Cinematic Sequence device plays a Level Sequence — the keyframed cutscenes you build in Sequencer (camera moves, character emotes, transform tracks, audio). Think of it as the cutscene player for your island: an enemy showcase, a tutorial walkthrough, a vault dramatically opening, or a vehicle pulling up to a player.

Reach for it whenever you want scripted, timed animation that you control from code instead of leaving it on auto-play. Verse lets you Play at the right moment, Pause/TogglePause for an interactive freeze, scrub to an exact SetPlaybackFrame/SetPlaybackTime, slow it down or speed it up with SetPlayRate, and react when it ends via StoppedEvent.

A key detail: every method has two overloads. The no-argument version (Play()) only works when the device's Plays For setting is Everyone. If the device is set to anything else (a single player, a team), you MUST pass the instigating agent: Play(Agent). Pick the overload that matches your device setting.

API Reference

cinematic_sequence_device

Used to trigger level sequences that allow coordination of cinematic animation, transformation, and audio tracks.

Full public surface, resolved verbatim from the live Epic digest (Fortnite.digest.verse).

cinematic_sequence_device<public> := class<concrete><final>(creative_device_base):

Events (subscribe a handler to react):

Event	Signature	Description
StoppedEvent	StoppedEvent<public>:listenable(tuple())	Signaled when the sequence is stopped.

Methods (call these to make the device act):

Method	Signature	Description
Play	Play<public>():void	Plays the sequence. This will only work when the device is set to Everyone
Play	Play<public>(Agent:agent):void	Plays the sequence. An instigating 'Agent' is required when the device is set to anything except Everyone.
PlayReverse	PlayReverse<public>():void	Plays the sequence in reverse. This will only work when the device is set to Everyone
PlayReverse	PlayReverse<public>(Agent:agent):void	Plays the sequence in reverse. An instigating 'Agent' is required when the device is set to anything except Everyone.
Stop	Stop<public>():void	Stops the sequence.
Stop	Stop<public>(Agent:agent):void	Stops the sequence. An instigating 'Agent' is required when the device is set to anything except Everyone.
GoToEndAndStop	GoToEndAndStop<public>():void	Go to the end and stop the sequence.
GoToEndAndStop	GoToEndAndStop<public>(Agent:agent):void	Go to the end and stop the sequence. An instigating 'Agent' is required when the device is set to anything except Everyone.
Pause	Pause<public>():void	Pauses the sequence.
Pause	Pause<public>(Agent:agent):void	Pauses the sequence. An instigating 'Agent' is required when the device is set to anything except Everyone.
TogglePause	TogglePause<public>():void	Toggles between Play and Stop.
TogglePause	TogglePause<public>(Agent:agent):void	Toggles between Play and Stop. An instigating 'Agent' is required when the device is set to anything except Everyone.
SetPlaybackFrame	SetPlaybackFrame<public>(PlaybackFrame:int):void	Set the playback position (in frames) of the sequence.
GetPlaybackFrame	GetPlaybackFrame<public>()<transacts>:int	Returns the playback position (in frames) of the sequence.
SetPlaybackTime	SetPlaybackTime<public>(PlaybackTime:float):void	Set the playback position (in time/seconds) of the sequence.
GetPlaybackTime	GetPlaybackTime<public>()<transacts>:float	Returns the playback position (in time/seconds) of the sequence.
SetPlayRate	SetPlayRate<public>(PlayRate:float):void	Set the playback rate of the sequence.
GetPlayRate	GetPlayRate<public>()<transacts>:float	Returns the playback rate of the sequence.

Walkthrough

The scenario: A player presses a button. We slow the cinematic down to dramatic half-speed, play a vault-reveal cutscene for that player, and when it stops we grant them entry by playing a second treasure-reveal cinematic. We also log the final playback frame.

Set the Cinematic Sequence device's Plays For to Instigator (so we use the (Agent) overloads), place a Button device, and a second Cinematic Sequence that plays the treasure reveal at the end.

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

log_vault := class(log_channel){}

vault_reveal_device := class(creative_device):

    Logger : log = log{Channel := log_vault}

    # The cutscene that plays the vault opening.
    @editable
    Cutscene : cinematic_sequence_device = cinematic_sequence_device{}

    # The button the player presses to start it.
    @editable
    StartButton : button_device = button_device{}

    # Plays the treasure reveal once the vault cutscene finishes.
    @editable
    TreasureCinematic : cinematic_sequence_device = cinematic_sequence_device{}

    OnBegin<override>()<suspends>:void =
        # React to the button press and to the cutscene finishing.
        StartButton.InteractedWithEvent.Subscribe(OnButtonPressed)
        Cutscene.StoppedEvent.Subscribe(OnCutsceneStopped)

    OnButtonPressed(Agent : agent):void =
        # Dramatic half-speed playback.
        Cutscene.SetPlayRate(0.5)
        # Start from the very beginning.
        Cutscene.SetPlaybackTime(0.0)
        # Device is set to Instigator, so pass the agent overload.
        Cutscene.Play(Agent)

    OnCutsceneStopped():void =
        # StoppedEvent is listenable(tuple()) — handler takes no payload.
        Frame := Cutscene.GetPlaybackFrame()
        Logger.Print("Vault cutscene stopped at frame {Frame}")
        # Play the treasure-reveal cinematic for everyone (its Plays For is Everyone).
        TreasureCinematic.Play()

Line by line:

• log_vault := class(log_channel){} declares a log channel so our debug output is tagged. Logger : log = log{Channel := log_vault} creates a logger using it.
• The three @editable fields are how Verse reaches placed devices. Without an @editable field, Cutscene.Play() would fail with Unknown identifier — you can never call a bare device.
• OnBegin runs once at game start. We subscribe OnButtonPressed to the button and OnCutsceneStopped to the cinematic's StoppedEvent.
• InteractedWithEvent hands us the agent who pressed the button — already unwrapped because button events are non-optional.
• SetPlayRate(0.5) halves the speed. Note 0.5 is a float — Verse won't convert an int for you, so never write SetPlayRate(1).
• SetPlaybackTime(0.0) rewinds to the start (in seconds).
• Play(Agent) is the agent overload, required because the device's Plays For is Instigator.
• OnCutsceneStopped takes no parameters — StoppedEvent is listenable(tuple()), an empty tuple. We read the final frame with GetPlaybackFrame() and log it, then Play() the treasure cinematic for everyone.

Common patterns

Interactive pause toggle (freeze-frame a cutscene). A button that pauses and resumes the same sequence using TogglePause.

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

pause_toggle_device := class(creative_device):

    @editable
    Cutscene : cinematic_sequence_device = cinematic_sequence_device{}

    @editable
    PauseButton : button_device = button_device{}

    OnBegin<override>()<suspends>:void =
        PauseButton.InteractedWithEvent.Subscribe(OnPausePressed)

    OnPausePressed(Agent : agent):void =
        # Device set to Instigator -> agent overload toggles Play/Stop for that player.
        Cutscene.TogglePause(Agent)

Rewind / reverse and jump to a frame. Play the sequence backwards, or scrub instantly to a known keyframe.

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

rewind_device := class(creative_device):

    @editable
    Cutscene : cinematic_sequence_device = cinematic_sequence_device{}

    @editable
    RewindButton : button_device = button_device{}

    OnBegin<override>()<suspends>:void =
        RewindButton.InteractedWithEvent.Subscribe(OnRewind)

    OnRewind(Agent : agent):void =
        # Jump straight to frame 30, then play backwards from there.
        Cutscene.SetPlaybackFrame(30)
        Cutscene.PlayReverse(Agent)

Everyone overload + stop on a timer. When the device's Plays For is Everyone, use the no-argument overloads. Here we auto-stop after letting it run.

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

intro_cutscene_device := class(creative_device):

    @editable
    Intro : cinematic_sequence_device = cinematic_sequence_device{}

    OnBegin<override>()<suspends>:void =
        # Plays For = Everyone, so the no-arg overload is valid.
        Intro.SetPlayRate(1.0)
        Intro.Play()
        # Let it run for 5 seconds, then jump to the end and stop.
        Sleep(5.0)
        Intro.GoToEndAndStop()
        Rate := Intro.GetPlayRate()
        Time := Intro.GetPlaybackTime()

Gotchas

• Two overloads, one rule. If the device's Plays For is Everyone, call Play()/Stop() with no args. For any other setting you MUST pass the instigating agent: Play(Agent). Calling the wrong overload won't crash but the action will silently do nothing.
• StoppedEvent carries no payload. It is listenable(tuple()), so the handler signature is OnStopped():void — do not add an (Agent : ?agent) parameter, that's only for listenable(?agent) events like ReceivedTransmitEvent.
• Floats are floats. SetPlayRate and SetPlaybackTime take a float. Write 1.0, 0.5, 0.0 — never 1 or 0. Verse does not auto-convert int↔float.
• SetPlaybackFrame takes an int. Conversely, frames are integers: SetPlaybackFrame(30), not 30.0.
• You must declare an @editable field. A bare cinematic_sequence_device{} used inline isn't a placed device — only an @editable field bound in the editor reaches the real cutscene in your level. A missing/unbound binding is a common cause of "nothing happens."
• GoToEndAndStop vs Stop. Stop halts at the current position; GoToEndAndStop snaps to the final frame first (useful when you want the end-state pose to persist, e.g. a fully-open vault).
• No Show()/Hide() on this device. cinematic_sequence_device has no visibility members — its surface is playback control only (Play, Stop, Pause, PlayReverse, GoToEndAndStop, plus frame/time/rate getters and setters). To reveal a hidden prop, animate its visibility inside the Level Sequence itself, or drive a prop/device that actually supports hiding.