Puppet the Kraken: Animation up to CONTROL RIG

The animation arc you have climbed since South Shores ends here, at the bottom of the sea. Every rung taught you to move something: MoveTo and TeleportTo slid whole props (south-shores), ease curves made that motion feel alive (north-jungle), the prop_mover device did it with zero code (east-volcano), the animate-to-targets component swam your banked relics along splines (lesson 12), and the sequencer lesson (lesson 15) handed Verse the transport controls for a whole authored shot. But all of those move objects as rigid pieces. The kraken guardian of the Sunken Athenaeum does not slide — it performs. Its tentacles flex bone by bone, and the tool for a bone-level performance is Control Rig: a rig you build on the guardian's skeleton, keyframe in Sequencer, and fire from Verse with the exact cinematic_sequence_device pattern you already own.

What you will build

Two Control-Rig-driven performances for the Athenaeum Depths capstone:

• The idle sway — a slow, looping tentacle undulation the guardian plays in-world, so it reads as a living creature while it patrols the drowned library.
• The tentacle sweep — the big keyframed flourish that stars in the victory cutscene when the final relic is banked.

One Verse device runs both: it loops the idle sway from OnBegin, and when the capstone's victory trigger fires it stops the idle, rolls the sweep, and hands the guardian back to its sway when the show ends. This is the exact piece athenaeum-depths (the zone capstone) imports for its finale.

Why Control Rig, and not the tools you already know

Quick honesty check before we rig anything — the whole arc, one line each:

If the thing that needs to move is a bone inside a skeletal mesh — a tentacle, a jaw, a tail — none of the first three can touch it. That is Control Rig's job, and only Control Rig's job.

Walkthrough

Step 1 — Start from the guardian's skeletal mesh

You imported the kraken guardian's skeletal mesh back in the scene-graph-skeletal-animation lesson (lesson 16), where it played baked swim/idle clips. Baked clips are fixed — you cannot re-pose them. Today you take control of the skeleton itself. In the Content Browser, find the guardian's Skeletal Mesh asset.

Step 2 — Create the Control Rig asset

Right-click the Skeletal Mesh → Create → Control Rig. This opens the Control Rig editor with the guardian's bone hierarchy in the Rig Hierarchy panel.

For each tentacle you want to animate, add a control:

1. In the Rig Hierarchy, right-click the tentacle's root bone → New → Add Control. Name it clearly: tentacle_L1_ctrl, tentacle_R1_ctrl, and so on. A control is the handle an animator grabs — the bone is the thing it drives.
2. In the Rig Graph (Forward Solve), wire each control to its bone: drag in a Set Transform - Bone node, set its target to the tentacle bone, and feed it the control's transform via a Get Transform - Control node. Now moving the control moves the bone.
3. For a tentacle chain (several bones), repeat down the chain, or use a Basic FABRIK node targeting the chain's tip control so one handle bends the whole tentacle — one control, whole-tentacle flex.

Compile the rig (the Compile button in the Control Rig editor toolbar), grab a control in the viewport, and pull. The tentacle should follow. That is the whole trick: Control Rig turns a skeleton into handles.

Step 3 — Keyframe the two performances in Sequencer

You know Sequencer from lesson 15 — same timeline, new track type.

Create two Level Sequences in the Content Browser:

• KrakenIdleSway (~8 seconds): drag the guardian into the sequence, right-click its track → Add Control Rig → pick your rig. Keyframe a gentle S-curve on the tentacle controls at 0s, 4s, and 8s, with the 8s pose matching the 0s pose so the loop is seamless.
• KrakenTentacleSweep (~4 seconds): same setup, but keyframe the big flourish — tentacles coil back over the first second, then sweep across the frame and settle.

Scrub the timeline. The rig interpolates between your keys exactly the way ease curves interpolated your prop positions in north-jungle — same idea, now applied to bones.

Step 4 — Wrap each sequence in a Cinematic Sequence device

Place two Cinematic Sequence devices near the guardian. On each, set Sequence to the matching Level Sequence, and set Plays For to Everyone — that is what makes the no-argument Play() calls below legal (lesson 15's rule, unchanged).

Step 5 — The Verse conductor

One device runs the guardian's whole performing life. This is the complete, compilable file:

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

# Conducts the kraken guardian's Control-Rig performances:
# loops the idle sway in-world, fires the tentacle sweep on victory.
kraken_guardian_animator := class(creative_device):

    # Cinematic Sequence device wrapping the KrakenIdleSway Level Sequence.
    @editable
    IdleSway : cinematic_sequence_device = cinematic_sequence_device{}

    # Cinematic Sequence device wrapping the KrakenTentacleSweep Level Sequence.
    @editable
    TentacleSweep : cinematic_sequence_device = cinematic_sequence_device{}

    # Fired by the capstone when the final relic is banked.
    @editable
    VictoryTrigger : trigger_device = trigger_device{}

    # true while the sweep owns the guardian, so the idle loop stays quiet.
    var SweepPlaying : logic = false

    OnBegin<override>()<suspends> : void =
        VictoryTrigger.TriggeredEvent.Subscribe(OnVictory)
        # StoppedEvent is a listenable(tuple()) -- handlers take NO parameters.
        IdleSway.StoppedEvent.Subscribe(OnIdleStopped)
        TentacleSweep.StoppedEvent.Subscribe(OnSweepFinished)
        # The guardian starts alive: roll the idle sway immediately.
        IdleSway.Play()

    # Relaunch the idle sway every time it reaches its natural end --
    # that is what makes an 8-second sequence loop forever.
    OnIdleStopped() : void =
        # StoppedEvent fires on EVERY stop, including our own Stop() call
        # in OnVictory. The flag keeps the idle from restarting mid-sweep.
        if (not SweepPlaying?):
            IdleSway.Play()

    OnVictory(Agent : ?agent) : void =
        set SweepPlaying = true
        IdleSway.Stop()
        Print("The guardian rises -- tentacle sweep!")
        TentacleSweep.Play()

    # When the sweep's sequence stops, hand the guardian back to its sway.
    OnSweepFinished() : void =
        set SweepPlaying = false
        IdleSway.Play()

What each piece is doing:

• Two cinematic_sequence_device slots — one per Level Sequence. The Verse type has no idea Control Rig is inside; it just drives the transport. That is the same Play() / Stop() / StoppedEvent trio you learned in lesson 15, reused verbatim — the summit of the arc is mostly skills you already have, pointed at a rig.
• The loop is StoppedEvent + Play() — a Cinematic Sequence device does not loop by itself from Verse, so we subscribe to StoppedEvent and re-roll the idle each time it ends. Seamless because the first and last keyframes match (Step 3).
• The SweepPlaying flag — the one genuinely new trick. StoppedEvent fires on every stop: natural end, our Stop(), anything. Without the flag, calling IdleSway.Stop() in OnVictory would instantly re-trigger OnIdleStopped, which would restart the idle on top of the sweep. The flag makes the stop intentional and the handoff clean.
• OnVictory(Agent : ?agent) — trigger_device.TriggeredEvent is a listenable(?agent), so the handler takes an optional agent (a trigger can fire with no instigator). We don't need the agent; we just need the cue.

Step 6 — Wire it in the editor

1. Place the kraken_guardian_animator device in the Athenaeum.
2. IdleSway → the Cinematic Sequence device holding KrakenIdleSway.
3. TentacleSweep → the Cinematic Sequence device holding KrakenTentacleSweep.
4. VictoryTrigger → the trigger your relic-banking logic fires when the last pedestal fills (the capstone wires this from its ledger — for testing, just step on it).

Launch a session: the guardian sways on loop. Fire the trigger: the sway halts, the sweep performs, and the sway resumes. That is a living guardian.

Common patterns

Slow-motion finale

The victory cutscene hits harder at half speed. SetPlayRate scales the sequence's playback — set it before Play():

# Inside OnVictory, before TentacleSweep.Play():
    OnVictorySlowMo(Agent : ?agent) : void =
        set SweepPlaying = true
        IdleSway.Stop()
        TentacleSweep.SetPlayRate(0.5)  # half-speed drama
        TentacleSweep.Play()

SetPlaybackFrame(0) is the companion tool: it rewinds a sequence to a specific frame, useful if a sweep can be re-triggered and you want it to always start from the top.

Baked clips for the background cast

Not every creature earns a rig. For background fish that just need a swim cycle, the Animated Mesh device plays a baked animation asset with three calls and zero rigging:

# Background creatures: baked clips, no rig, no Sequencer.
    @editable
    BackgroundFish : animated_mesh_device = animated_mesh_device{}

    StartAmbience() : void =
        BackgroundFish.Play()   # Pause() and PlayReverse() also available

Rig the star, bake the extras — that is how real productions budget animation, and it is how the Athenaeum should too.

Where this goes next

This device is the guardian's soul, and athenaeum-depths (the zone capstone, next lesson) imports it whole: the capstone's relic ledger fires VictoryTrigger when the final pedestal fills, the tentacle sweep stars in the vault-reveal cutscene alongside the cinematic-sequence-device shot from lesson 17, and the idle sway runs whenever the npc-behavior patrol brain (lesson 19) has the guardian standing watch. You have now climbed the island's entire animation ladder — props, curves, splines, sequences, and finally bones. Every moving thing on this island, you know how to move.