# Save materials, timelines, sequences, montages and sounds

> A lamp's glow, a half-open door, a paused cutscene, an emote halfway through and music at its place come back after a load, travel and streaming: attach Rolly...

Product: Rolly Save 1.0.0 | Sheet: guide | Updated: 2026-10-31 | HTML: https://rolly-docs.pages.dev/save/guides/engine-state/

## Attach engine state handlers

1. Open the Save Rule that matches the actors, or the actor's Rolly Save component (see [Choose what saves](https://rolly-docs.pages.dev/save/guides/choose-what-saves/)).
2. Under **Handlers**, add an entry, click its class button and pick the handler under **Engine State**: **Material Parameters**, **Timelines**, **Level Sequence**, **Montages** or **Audio**. **Blackboard** and **StateTree** save AI (see [Save Blackboards and StateTrees](https://rolly-docs.pages.dev/save/guides/save-ai/)), and **Gameplay Abilities** saves Ability System Components (see [Save Gameplay Ability System state](https://rolly-docs.pages.dev/save/guides/gameplay-abilities/)).
3. Expand the entry to set what it saves; every setting has a default that works without a change.

![The Handlers menu](https://rolly-docs.pages.dev/save/_files/Images/Picker_Handlers.png "The class menu of DA_Guards' fourth Handlers entry: under Engine State the eight handlers with the first sentence of what each saves, Montages, Blackboard and StateTree disabled since the rule's other entries hold them, and under Your Handlers the search box and the game's BP_SkyHandler.")

A row's tooltip holds the rest of what its handler saves. A handler another entry of the same list holds is disabled. **Your Handlers** lists your own Save Handler classes, Blueprints not loaded yet included, with a search box; choosing a Blueprint loads it. **Clear**, on an entry that holds a handler, empties it with its settings. Each choice is one step of Edit > Undo.

| Handler | Attach it to | It saves |
|---|---|---|
| Material Parameters | Actors with meshes or decals | Dynamic material instances: their parameters and the material they were made from; meshes' custom primitive data |
| Timelines | Blueprints with timelines | Each timeline's position, whether it plays or reverses, its play rate and looping |
| Level Sequence | Level Sequence Actors | The sequence's time, whether it plays, is paused or stopped, its direction and rate, and a sequence your game set |
| Montages | Actors with skeletal meshes | The montages each mesh plays: position, play rate, pause and section order |
| Audio | Actors with audio components | Whether each sound plays, is paused or stopped, where it is, its volume and pitch, and a sound your game set |

- **Components**, on each handler but Level Sequence, narrows the components it takes by name, class or component tag; with every list empty it takes all of them.
- An actor gets one handler of each class. When several rules or the component attach the same class, the settings of the source that applies last are used; **Removed Handlers** drops a class an earlier source attaches.
- **Apply Timing** is After Begin Play by default: the handler sets its values once the actor's own Begin Play ran, also in a level that streams in, so a Begin Play that plays an idle montage or starts a timeline does not undo them. Material Parameters also offers **Before Begin Play**; the others need registered components, which a streamed level does not have before Begin Play, so the entry shows that value disabled and Data Validation warns (TimingNotOffered) where one is set anyway. **When Asked** waits for Apply Saved Values (see [Choose what saves](https://rolly-docs.pages.dev/save/guides/choose-what-saves/#set-values-after-begin-play-or-when-asked)).
- Engine state handlers save the actor they are attached to, so Global Handlers does not offer them, and one listed there anyway is skipped (GlobalNotAllowed).
- Material Parameters and Montages save nothing for an actor at its design, so lamps nobody lit and guards that play nothing add no record. Timelines, Level Sequence and Audio save whenever the actor has a target: a position and a play state are state.

![A Material Parameters entry](https://rolly-docs.pages.dev/save/_files/Images/RuleEditor_Materials.png "DA_Lamps in the rule editor: its Material Parameters entry open with Components, Save Parameters, Parameter Names with one entry, Save Parent Materials, Save Custom Primitive Data and Apply Timing at After Begin Play.")

## Save dynamic materials and custom primitive data

Material Parameters saves each slot that holds a dynamic material instance: the scalar, vector, double vector, texture, texture collection, runtime virtual texture, sparse volume texture and font parameters your game set on it, such as with **Set Scalar Parameter Value on Materials**, and, with **Save Parent Materials** on, the material it was made from when that is not the slot's material from the editor. A decal saves its decal material. **Save Custom Primitive Data** saves each mesh's custom primitive data where it differs from the values set in the editor.

- **Parameter Names** saves only the parameters it lists, such as Glow; empty saves every parameter the instance holds.
- The engine sets double vectors and sparse volume textures by name only, so those of material layers are not saved.
- A dynamic instance made from another dynamic instance saves its first parent that is an asset, with its own parameters.
- One actor saves at most 256 components a handler takes, 256 slots per component, 1,024 parameters per slot and the engine's 36 custom primitive data values; a setup warning names the actor past a limit (TooMany).

**Begin Play that makes dynamic materials.** When the slot already holds a dynamic instance made from the saved parent, such as one your Begin Play made, the saved values go onto that instance, so a variable your game keeps to it stays valid. An instance of another parent is replaced by a new instance of the saved parent, and a variable to the old one no longer changes the lamp. A Begin Play that sets a parameter on every lamp makes every lamp hold state, so every lamp saves; set those values in a material instance asset instead.

**Set Material.** A plain material your game sets with Set Material is no dynamic instance: pick **Override Materials** of the mesh in Pick Properties to save it (see [Choose what saves](https://rolly-docs.pages.dev/save/guides/choose-what-saves/)). Override Materials applies first and Material Parameters after it. While one slot of a mesh holds a dynamic instance, the path save leaves the mesh's whole Override Materials out, with PathLeftOut in the save's Issues: Material Parameters saves the dynamic slot, and a plain material your game set on another slot of that mesh is not saved. Make that slot a dynamic instance too, or give the plain material its own mesh.

At a load, a slot whose dynamic instance held no saved state gets its editor material back, and a mesh without saved custom data its editor values; a load with Keep Current Map does the same on lamps whose handler saved nothing. An instance made from the editor material, such as one your Begin Play made, stays and takes the editor material's values, so a variable your game keeps to it stays valid; an instance of another material gives way to the editor material. A plain material in a slot stays.

## Save timelines

Timelines saves each timeline of the actor by the name your Blueprint gives it, such as DoorTimeline: its position, whether it plays or reverses, its play rate and whether it loops. A position past the timeline's length, as after an update shortened it, goes to its end.

- **Run Update** (on) runs the timeline's **Update** output once after the position is set, so what it moves, such as a door, is where it was. The track variables take their values at the position either way.
- **Fire Events** (off) fires the event track's keys between the start and the restored position, such as one that turns a light on halfway.
- A timeline your C++ makes during play with NewObject and no name gets a number from the engine, which differs next session: the load lists HandlerTargetMissing and it keeps its design. Give it a name.
- A saved play rate faster than 1,000 either way, as only an edited save holds, is not set (HandlerValueSkipped): the engine's looping tick never ends at such rates.

## Save Level Sequences

Attach Level Sequence in a rule that matches **Level Sequence Actor** or your children of it. It saves the time, whether the sequence plays, is paused or stopped, its direction and its play rate, and with **Save Sequence Asset** the sequence your game set with Set Sequence when it is not the one placed in the editor. **Save Play State** off sets only the time, and the sequence plays as Auto Play and your Begin Play leave it.

- **Fire Events** (off) plays from the start to the saved time, so event keys in between fire; off jumps there and none fire.
- **The end of a sequence.** A sequence saved playing at its last frame, or its first when it played backwards, ends there as the player ends one: paused with **Pause at End**, otherwise stopped, which gives its actors back what it set as the player's own end does. A saved time past the end, as after an update shortened the sequence, goes to its last frame.
- **A stopped sequence** goes to its saved time without setting its actors, so one never played and one that ended leave their actors as their own records hold them. Only a sequence your game jumped to a frame while stopped, which holds that frame's values, sets them again. A stopped sequence keeps the direction the player has: Play and Play Reverse set one as your game calls them.
- **Create Level Sequence Player.** The actor it makes is one your game holds a variable to, and that variable is gone after a load. Place a Level Sequence Actor and play it instead.
- **Sequencer's own actors**, the spawnables a sequence spawns (tagged SequencerActor), never save: their sequence makes them again, so a load does not double them.
- **Restore State** returns the actors a cutscene moved to their state at the load, not to their state before the cutscene. Add a save block while a cutscene plays (see [Block saving during a fight](https://rolly-docs.pages.dev/save/guides/block-saving/)), or untick Restore State.

## Save montages

Montages saves the montages each skeletal mesh plays: each montage, its position, play rate, pause and the section links your game changed with Montage Set Next Section. A montage that blends out at the save is left out. A position past the montage's length goes to its end.

- **Blend In** (0 s) is how long restored montages take to blend in; 0 shows them at full weight at once.
- **Stop Other Montages** (on) stops the montages that play when the handler applies and that the save does not hold, such as an idle montage Begin Play started. A load with Keep Current Map also stops the montages of a mesh that played none at the save.
- A saved montage the mesh plays already, such as one its Begin Play starts, takes the saved position, rate and pause where it plays, so it does not play twice.
- A mesh saves at most 32 montages, the first 32 it plays (TooMany).

**What restarts.** The animation graph's states are not saved: a state machine starts at its entry. Notifies before the saved position do not fire again; a notify state that spans it begins. Latent waits, such as Play Montage's pins or an ability task, do not resume. Montages of Leader Pose followers and of linked anim layers are not saved.

## Save sounds and music

Audio saves each audio component of the actor, apart from those that destroy themselves when done: whether it plays, is paused or stopped (fading in counts as playing, fading out as stopped), where its sound is, its volume and pitch multipliers with **Save Volume and Pitch**, and the sound your game set when it is not the component's sound from the editor. A position past a looping wave's length goes round it; past any other sound's end, to its end.

- **Stop Saved Stopped** (on) stops a sound that was stopped at the save, also one Auto Activate started again as the actor loaded.
- A world without an audio device, such as a dedicated server's, keeps the sound states it loaded and sets none; the log says so once (NoAudioDevice). Each player's machine plays its own sounds.

### Estimated and Reported

**Position** picks how the handler knows where a playing sound is.

| Position | How | Use it when |
|---|---|---|
| Estimated (the default) | From when the sound started, its pauses and its pitch now, at no cost while it plays | Music and ambience that keep one pitch |
| Reported | The engine reports each playing sound wave's position, at a small cost per playing sound and audio frame | The pitch changes while it plays, or the sound plays through game pauses, as UI sounds do |

Reported starts with the sound's next play: a sound that played before Rolly Save met it, such as an Auto Activate sound's first play, uses the estimate until then.

### MetaSounds and waves that cannot seek

A MetaSound, and a sound wave whose compression format or loading cannot seek, starts from its beginning after a load; a setup message names it once per sound (NotSeekable). That suits loops and ambience. For music that must resume, play a sound wave that seeks, and check it in a packaged build. Positions inside sound cues with random or concatenated nodes are not exact.

### Auto Destroy

Components that destroy themselves when done (**Auto Destroy**), such as those **Spawn Sound Attached** makes, never save: they are not there to set after a load.

## Keep resting bodies at rest

**Save Physics Sleep** (What Saves, on) saves whether an actor's simulating root sleeps, so a crate that came to rest stays at rest after a load instead of falling or jittering; it is set after the root's velocity. A body touching a moving one wakes. In the map's own levels it is set before Begin Play, so your Begin Play acts on the restored body; in a level that streams in, after it, so the saved state replaces what Begin Play did. See [Save actors and their components](https://rolly-docs.pages.dev/save/guides/save-actors/).

## Save Material Parameter Collections

List the collections in Project Settings > Plugins > Rolly Save > Levels > **Saved Parameter Collections**, such as MPC_Weather with a wetness value a storm raised. Each map saves its own values of them with the map's other state, and a load and a return to the map set them again. The list is empty by default.

![Saved Parameter Collections](https://rolly-docs.pages.dev/save/_files/Images/ProjectSettings_Levels.png "Project Settings > Plugins > Rolly Save > Levels, ending with Save Run-Time Levels and Saved Parameter Collections holding MPC_Weather.")

- Only values that differ from the collection's defaults save, so a default you change in an update reaches old saves. A load, Keep Current Map included, sets every other value of the listed collections back to its default.
- A map saves at most 64 collections of 1,024 values each, scalars first. Data Validation of Project Settings reports an entry that is empty, cannot be loaded or is listed twice (BadCollectionEntry), and more than 64 entries (TooManyCollections).
- A parameter a save names that its collection no longer has, as after an update removed it, keeps its default: the load's Issues list CollectionParameterMissing, and the next save drops it. A value that is not a finite number, as only an edited save holds, is not set, and the log says so.
- A value that follows the player across maps, such as the time of day, belongs in a Global Handler of your own, which sets it in its Apply (see [Save what is not a variable](https://rolly-docs.pages.dev/save/guides/save-handlers/)), and its collection stays off the list: a listed collection keeps each map's values, and a load sets every value the map's record lacks back to its default.

## Change content after release

Rolly Save notes the asset each target shows when it first meets the actor, at its level's build or its spawn: a slot's material (for a dynamic instance, the material it was made from), the actor's sequence and each component's sound. A save writes an asset only when it differs from that note, so an update that gives a placed lamp, cutscene or radio another material, sequence or sound reaches old saves, while an asset your game chose comes back.

- For an actor your game spawns, the note is what the actor holds after its spawn, and a load that spawns it again makes it from its class. Set assets your game picks after the spawn, such as with Set Sound or Set Sequence, so the save holds them.
- A target Rolly Save first meets at a save, such as a mesh your game added during play, takes what it holds then as its design.
- When the actor no longer has a component, slot, parameter, timeline or montage a save names, the load lists HandlerTargetMissing once per record, naming one of them; the others keep their design, and the next save drops what is gone.
- A value no target takes, as an edited or damaged save can hold, is skipped with HandlerValueSkipped in the load's Issues; a record with more entries than a save holds sets the first ones, with HandlerEntriesDropped.

## Play with several players

Only the server or a standalone game sets engine state. Clients see what the engine replicates: a timeline with **Replicated** ticked and a Level Sequence Actor with **Replicate Playback** ticked reach them. Materials, montages, sounds and parameter collections are set on the server only in this version, so clients see them as designed after a load.

## What is not saved

- The animation graph's states and linked anim layers.
- Montages Play Slot Animation as Dynamic Montage makes during play, which are no assets: the load lists HandlerTargetMissing for them.
- Loop progress of a sequence with a finite loop count, and camera cuts of a restored cinematic.
- A timeline length your game changed; the position goes to the length the timeline has.
- Fades in progress, and positions inside sound cues with random or concatenated nodes.
- Niagara and widget materials.
- C++ FTimeline structs outside timeline components.

## See engine state while you test

- **Effective Settings** of a Rolly Save component lists each attached engine state handler with what it finds on the actor, such as "Material Parameters · 1 mesh or decal" or "Timelines · 2 timelines: DoorTimeline, LidTimeline", and the source of its settings; its tooltip lists the settings, with the Apply Timing the handler uses. One that finds nothing shows a warning icon with "finds nothing" and why, the problem Data Validation reports (see [Check your save setup](https://rolly-docs.pages.dev/save/guides/check-save-setup/#find-handlers-that-save-nothing)). Save Physics Velocity and Save Physics Sleep read as not used where the actor's root does not simulate physics, and Save Level Instance State where the actor is no level instance that loads a level while playing.
- The **Save Inspector** names a handler's record by its actor and handler, such as `/Game/Maps/Tavern:BP_Lamp_3 › Material Parameters`, and shows what it saved under Properties. An actor's Actor group shows Physics Sleep and Level Instance (see [Inspect, compare and edit saves](https://rolly-docs.pages.dev/save/guides/inspect-saves/)).
- The Gameplay Debugger's **RollySave** category shows, for the actor you look at, whether its root sleeps, its level instance's state and each attached handler with whether the last load restored it or what it waits for, under it up to two lines of what its engine system shows now, such as `Lamp slot 0: 2 parameters, made from M_LampLit` (see [See what an actor saves while you play](https://rolly-docs.pages.dev/save/guides/debug-while-playing/)).

![A Material Parameters record](https://rolly-docs.pages.dev/save/_files/Images/Inspector_Materials.png "BP_Lamp_3's Material Parameters record in the Save Inspector: the mesh Lamp's slot Glass with its parent M_LampLit, Glow at 4 and a warm Tint.")