Fix: Unreal Sequencer Animation Not Playing at Runtime

Here is how to fix Unreal sequencer animation not playing runtime. You built a cinematic camera sweep or a door-opening animation in the Sequencer, previewed it in the editor, and everything looked perfect — but when you hit Play, nothing happens. The Level Sequence sits there silently while your gameplay runs around it. Sequencer is a powerful cinematic and animation tool, but its runtime playback pipeline has several configuration points that can quietly prevent your sequences from ever starting during actual gameplay.

The Symptom

You have an ALevelSequenceActor placed in your level with a Level Sequence asset assigned. In the Sequencer editor, the animation previews correctly: cameras move along spline paths, skeletal meshes play their animations, and material parameters interpolate smoothly. But when you enter Play In Editor or launch a standalone build, the sequence does not play. The actors that should be animated remain frozen in their initial positions.

In some cases, the sequence plays once during the first PIE session but does not play on subsequent runs unless you restart the editor. In other cases, the sequence begins playing but the bound actors are not affected — the camera track runs but the in-game camera does not follow it, or the skeletal mesh track plays but the character stays in its idle pose. You might also see the sequence play correctly in PIE but fail completely in a packaged build, with no errors in the output log.

A particularly confusing variant occurs when you spawn the Level Sequence Actor at runtime via C++. The actor spawns, the sequence player reports that it is playing, but the visual result is that nothing in the world moves. The sequence is technically running against unbound tracks, animating nothing.

What Causes This

1. Auto Play is not enabled on the ALevelSequenceActor. By default, a Level Sequence Actor placed in the level does not automatically start playback when the game begins. The Auto Play checkbox in the Details panel must be explicitly enabled. Without it, the sequence loads into memory but the player never receives a Play command. This is the single most common cause of sequences not playing at runtime.

2. Actor bindings are not resolved at runtime. Sequencer tracks are bound to specific actors via possessable bindings. These bindings are editor-time references that resolve the track to a particular actor in the level. If you move the sequence to a different sub-level, delete and re-place the bound actor, or try to animate a dynamically spawned actor, the bindings break silently. The sequence player starts but each track finds no target actor and produces no visible result.

3. The sequence player’s play rate is zero or the sequence is paused. If you have Blueprint or C++ logic that modifies the sequence player before playback starts, an accidental SetPlayRate(0) call or a Pause() call without a corresponding Play() will prevent any visible animation. The sequence player’s state will report as “playing” in some cases even when the effective play rate is zero.

4. Camera cut tracks do not affect the player controller camera. Sequencer camera cuts only take over the player’s view if the sequence player has SetDisableCameraCuts set to false (the default) and the player controller is not explicitly overriding the view target. If your game logic calls PlayerController->SetViewTargetWithBlend to a different camera during the sequence, the Sequencer camera track loses control.

The Fix

Step 1: Set up the ALevelSequenceActor correctly and trigger playback from C++. This covers both auto-play configuration and manual C++ control for gameplay-triggered sequences.

// CinematicManager.h
#pragma once
#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "LevelSequenceActor.h"
#include "LevelSequencePlayer.h"
#include "CinematicManager.generated.h"

UCLASS()
class ACinematicManager : public AActor
{
    GENERATED_BODY()

public:
    UPROPERTY(EditAnywhere, Category = "Cinematic")
    ALevelSequenceActor* DoorSequenceActor;

    UPROPERTY(EditAnywhere, Category = "Cinematic")
    ULevelSequence* IntroSequenceAsset;

    void PlayDoorSequence();
    void SpawnAndPlayIntroSequence();

protected:
    virtual void BeginPlay() override;
};

// CinematicManager.cpp
#include "CinematicManager.h"
#include "LevelSequencePlayer.h"

void ACinematicManager::BeginPlay()
{
    Super::BeginPlay();

    // Option A: play a level-placed sequence actor on game start
    if (DoorSequenceActor)
    {
        ULevelSequencePlayer* Player =
            DoorSequenceActor->GetSequencePlayer();
        if (Player)
        {
            Player->Play();
            UE_LOG(LogTemp, Log, TEXT("Door sequence started"));
        }
    }
}

// Called from gameplay, e.g. when the player enters a trigger
void ACinematicManager::PlayDoorSequence()
{
    if (!DoorSequenceActor) return;

    ULevelSequencePlayer* Player =
        DoorSequenceActor->GetSequencePlayer();
    if (!Player) return;

    // Reset to the beginning and play
    Player->SetPlaybackPosition(
        FMovieSceneSequencePlaybackParams(
            0.f, EUpdatePositionMethod::Jump));
    Player->SetPlayRate(1.0f);
    Player->Play();
}

Step 2: Spawn a Level Sequence Actor at runtime and bind actors dynamically. This is essential when you need to animate actors that do not exist in the level at edit time, such as spawned enemies or procedurally placed objects.

void ACinematicManager::SpawnAndPlayIntroSequence()
{
    if (!IntroSequenceAsset) return;

    // Create the sequence actor and player at runtime
    FMovieSceneSequencePlaybackSettings PlaybackSettings;
    PlaybackSettings.bAutoPlay = false;
    PlaybackSettings.LoopCount.Value = 0; // Play once
    PlaybackSettings.PlayRate = 1.0f;

    ALevelSequenceActor* SeqActor = nullptr;
    ULevelSequencePlayer* Player =
        ULevelSequencePlayer::CreateLevelSequencePlayer(
            GetWorld(),
            IntroSequenceAsset,
            PlaybackSettings,
            SeqActor);

    if (!Player || !SeqActor) return;

    // Bind a runtime-spawned actor to a track tagged "HeroMesh"
    // (Set the tag in the Sequencer editor on the possessable track)
    AActor* HeroActor = GetHeroActor(); // your game logic
    if (HeroActor)
    {
        FMovieSceneObjectBindingID BindingID;
        TArray<FMovieSceneObjectBindingID> Bindings;

        // Resolve binding by tag name set in the Sequencer editor
        Player->GetSequence()->FindBindingsByTag(
            "HeroMesh", GetWorld(), Bindings);

        for (const auto& Binding : Bindings)
        {
            Player->SetBinding(
                Binding,
                TArray<AActor*>{ HeroActor });
        }

        UE_LOG(LogTemp, Log,
            TEXT("Bound %s to HeroMesh track"),
            *HeroActor->GetName());
    }

    // Now start playback
    Player->Play();
}

Step 3: Debug sequence playback state and fix camera cut issues. When the sequence appears to be running but produces no visible result, use these diagnostic patterns to identify the failure point.

// Diagnostic: check sequence player state every frame
void ACinematicManager::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);

    if (!DoorSequenceActor) return;

    ULevelSequencePlayer* Player =
        DoorSequenceActor->GetSequencePlayer();
    if (!Player) return;

    // Log the current playback status
    UE_LOG(LogTemp, Verbose,
        TEXT("Seq: Playing=%s Rate=%.2f Time=%.2f Duration=%.2f"),
        Player->IsPlaying() ? TEXT("Y") : TEXT("N"),
        Player->GetPlayRate(),
        Player->GetCurrentTime().AsSeconds(),
        Player->GetDuration().AsSeconds());
}

// Fix: ensure camera cuts take effect during gameplay
void ACinematicManager::PlayCinematicWithCamera()
{
    ULevelSequencePlayer* Player =
        DoorSequenceActor->GetSequencePlayer();
    if (!Player) return;

    // Enable camera cuts so Sequencer can control the view
    Player->SetDisableCameraCuts(false);

    // Optional: disable player input during the cinematic
    APlayerController* PC = GetWorld()->GetFirstPlayerController();
    if (PC)
    {
        PC->SetCinematicMode(
            true,  // bInCinematicMode
            true,  // bHidePlayer
            true,  // bAffectsHUD
            true,  // bAffectsMovement
            true); // bAffectsTurning
    }

    // Listen for sequence completion to restore control
    Player->OnFinished.AddDynamic(
        this, &ACinematicManager::OnCinematicFinished);
    Player->Play();
}

void ACinematicManager::OnCinematicFinished()
{
    APlayerController* PC = GetWorld()->GetFirstPlayerController();
    if (PC)
    {
        PC->SetCinematicMode(
            false, false, false, false, false);
    }
}

Related Issues

If your Sequencer animation plays but the character’s skeletal mesh does not blend back to gameplay animations after the sequence ends, check our guide on animation montages not playing for tips on AnimInstance slot node restoration. If the camera cut track runs but the viewport shows nothing, the issue may be a UMG widget blocking the view — see UMG widgets not showing on screen for layer ordering solutions.

Sequence previews fine in the editor but does nothing at runtime? Check Auto Play on the Level Sequence Actor, or call GetSequencePlayer()->Play() from your own code.