# Save and load parts of the game

> Save or load only the players, only the world, or groups of objects and actors you name, and keep the rest the slot holds, such as a co-op hero who keeps their...

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

## Pick the parts

A **Rolly Save Scope** names the parts. Tick several to take them in one write.

| Part | Takes |
|---|---|
| Players | The local players' controllers, pawns and player states, with their components |
| World | The maps with their actors and Level Blueprints, the levels kept across travel and streaming, and what saves without a group: the game instance and its subsystems, the Game Mode, the Game State, and registered objects and Save Handlers without a group. Actors with a Group are left out |
| Groups | Registered objects, Save Handlers and actors of these groups, such as `Chapter2`, in every map. Names compare with capital letters |

## Put objects in a group

- **Register Object for Saving** takes a **Group** (expand the node's advanced pins), such as `Chapter2`. Empty saves the object with the world.
- A **Save Handler** has **Group** in its Class Defaults.

A group's name has 1 to 1,024 characters. Register Object for Saving refuses a longer one with a setup message; a Save Handler with one saves with the world, and Data Validation names it.

A registered object takes its saved values from the record of its name, whatever group it registers in now, so moving it to another group keeps its saves. A part save that saves it in its new group drops its old record from the group it left.

## Put actors in a group

**Group** is the last row of What Saves in Project Settings > Plugins > Rolly Save > Actor Defaults, in a Save Rule and in a Rolly Save component's Overrides; the last source that ticks it wins, as for the other rows. A rule that matches the actors of a chapter, such as by an actor tag, puts them all in its group. Empty saves the actor with the world, so a component's ticked empty Group takes one actor out of a rule's group. The actor's components, attached Save Handlers and child actors go with it.

![Effective Settings with a group](https://rolly-docs.pages.dev/save/_files/Images/EffectiveSettings_Group.png "Effective Settings of a placed BP_Lamp: Group Chapter2 from DA_Chapter2 after Apply Timing, with the row's chain open: Actor Defaults: None. DA_Chapter2 (Priority 5): Chapter2, used.")

A placed actor's Rolly Save component shows the Group it resolves to in Effective Settings, with its source; the row's tooltip lists each source in order.

- Whole saves and loads hold the group's actors either way; part saves and loads take them only when Groups names the group.
- A map's actors of a group save into a chunk of their own, `LSEG <map>|<group>`, beside the map's `WRLD` chunk, and keep their state through travel and streaming as the map's other actors do.
- An actor whose Group a later version changes takes its values from the save as before; the next save holds it once, in its new group.
- A Group of more than 1,024 characters is no group: the actor saves with the world, with setup error BadActorGroup, which Data Validation shows too. A Group whose name, with the map's path, takes more than 1,024 characters saves its actors with the world, with setup error GroupTooLong.

## Save parts

**Save Game Part to Rolly Slot** saves the parts of **Scope** into the slot and keeps everything else the slot holds: a save of the players into a slot that holds a world keeps that world. A slot without a save gets the parts alone, with the name of the map they were saved in.

- The slot list names the map the slot's save opens and, without World in the scope, the place the slot named before; the play time and the game fields are the game's now.
- A save, delete, copy or load of the same slot asked for while a part save runs waits for its write, so it sees the part save, and the part save never writes older content over it.

- A slot that holds a damaged save, or one of a newer version of your game, is not written: the node fails with Damaged or Newer Version and a setup message, and the slot keeps its save. Delete the slot or save the whole game into it.
- A slot saved at a lower Game Data Version has what it keeps brought up to date by your Migrations asset's steps first; a step that fails ends the save with Migration Failed.
- A scope with nothing ticked and no group fails with Invalid Input and a setup message.
- A part save changes nothing the next whole save writes: the slot's other parts do not become part of the game, and the play time, the place and the game fields stay as they are.

## Load parts

**Load Game Part from Rolly Slot** sets the values of the parts of **Scope** on the objects that exist now, as Keep Current Map does, and never opens a map. Everything outside the scope stays as it is, also the play time, the place and the game fields.

- Each part the save holds nothing of adds a `MissingPart` line to the Result's Issues. A save that holds none of them fails with Not Found.
- Actors of the loaded groups that the save holds as destroyed go at once, replicated ones on a server too, and so do the spawned actors of those groups the save lacks. A group that had no actor at its save writes nothing to the slot, so a part load of it keeps the group's spawned actors.
- The next whole save keeps the loaded parts' values for objects that are not there, as after any load, when the slot's save was made by the same version of the game, the engine and its plugins as the save the last whole load read. A save of another version applies to the objects there, and the Result's Issues list `PartNotKept`: an object that registers after that load takes what the last whole load holds for it (see [Troubleshooting](https://rolly-docs.pages.dev/save/troubleshooting/)).

## From C++

```cpp
#include "Game/RollySaveSubsystem.h"

FRollySaveScope Scope;
Scope.bPlayers = true;
Scope.Groups = { TEXT("Chapter2") };
Save->SavePart(TEXT("Slot 1"), Scope);

FRollySaveLoadRequest Request; // every load of a save goes through one
Request.SlotName = TEXT("Slot 1");
Request.Scope = Scope;
Request.Map = ERollySaveLoadMap::KeepCurrentMap; // a part load needs Keep Current Map or a given map
Save->Load(Request, [](const FRollySaveResult& Result) {});
```

`FRollySaveLoadRequest::GivenMap` opens that map instead of the saved one and sets the saved values there; the local players then take theirs without their place, so their pawns stay where the Game Mode put them. `RegisterObject` takes the group as its third argument.