For games that save, from a linear game with checkpoints to a World Partition open world: actors save the variables you tick SaveGame on, their place and whether they were destroyed, Save Rules decide what groups of actors keep, and placed save points, checkpoint, autosave and reset area volumes save and reset places without a graph. Players save, load and manage their saves on a slot screen in five layouts, with a gamepad, a keyboard and mouse, or touch.
Quick start
About 10 minutes, all in the editor, in a project with a player character, such as the First Person template:
- Enable Rolly Save in Edit > Plugins and restart the editor. The engine plugins it needs turn on with it.
- Press Set Up Project in the notification that shows after the restart, or choose Tools > Rolly Save > Set Up Project…. Set Quick save keys to On (F5 saves, F9 loads) and press Remove Them in the note under it, so F5 and F9 stop running the engine’s debug commands as well. Type a File prefix for your game, such as
mygame, keep the other answers and press Apply. - In Edit > Project Settings > Plugins > Rolly Save Core UI > Look, set Theme Source to Preset and Theme Preset to Tactical. The slot screen and every other Rolly Save screen take this look.
- Open Window > Place Actors, find the Save category and drag a Save Point onto the floor a few metres from the Player Start. As it comes (Action Automatic, Slot Screen Save), it opens the Save screen for the player who walks into it.
- Drag a second Save Point farther away. In its Details under Rolly Save, set Action to Open Slot Screen and Slot Screen to Load.
- Drag a Cube from Place Actors > Shapes near the Player Start. In its Details set Mobility to Movable, tick Simulate Physics, press Add and add Rolly Save. Press Ctrl+Shift+S to save everything.
- Press Play. Push the cube, walk into the first save point, choose New Save and confirm its title. Push the cube somewhere else, then walk into the second save point and pick your save, choosing Load if it asks about unsaved play: the map opens again, with you at the first save point and the cube where it was when you saved. F5 and F9 do the same through the slot
quick, anywhere.
A variable you tick SaveGame on in a Blueprint (its Details, the Variable section’s advanced options) saves with no component, in actors, the Game Mode and the Game Instance alike.
A load opens the map the save was made in, so the widgets and actors of the map before it, the menu that asked for the load included, are gone when it ends: react to it in On Load Finished of the Rolly Save Subsystem, bound in Begin Play of an actor of the map. Your pause menu’s Save and Load buttons call Open Rolly Slot Screen with Mode Save or Load (Give players a slot screen). In the editor, Show > Developer > Rolly Save Markers draws a pin over each actor that saves, and the outliner’s Rolly Save column says why (Set up your project and test saving in the editor).
Guides
Start
| Guide | For |
|---|---|
| Save and load your game | What saves with no setup, the nodes and when their pins run, loading into the saved map or the current one, the quick keys |
| Set up your project and test saving in the editor | The setup questions, the outliner column, viewport markers, Play from Slot, -RollySaveLoad |
| Give players a slot screen | Opening it, slot styles, layouts and looks, rows, titles, actions, profiles, split screen, your own menu |
| Place save points, checkpoints and reset areas | Saving when a player walks in or uses an object, and places that start as designed again |
| Autosave and save checkpoints | The autosave timer and requests, autosave slots, checkpoints that retry from memory |
Decide what saves
| Guide | For |
|---|---|
| Save actors and their components | Which actors save and what they keep, their saved and loaded events, destroyed and spawned actors, Custom Save IDs |
| Choose what saves | Save Rules by class, interface, tag or map; Pick Properties for engine properties such as a light’s intensity |
| Save the player | The local player’s pawn, controller and player state, vehicles, what crosses maps |
| Save what is not a variable | Save Handlers in Blueprint for state you cannot tick SaveGame on |
| Save materials, timelines, sequences, montages and sounds | The built-in engine state handlers and what each saves |
| Save Blackboards and StateTrees | AI keys, StateTree parameters and states |
| Save Gameplay Ability System state | Attributes, abilities, effects with their time left, loose tags |
| Make your plugin’s objects save | What another plugin’s object declares to save without depending on Rolly Save |
Save levels and open worlds
| Guide | For |
|---|---|
| Remember levels across travel | Levels kept as the player left them, resetting a level or the world, seamless travel |
| Save streamed levels and World Partition worlds | Levels and cells that stream out and in, level instances, runtime Data Layers, saves spread over frames |
| Save harvested foliage and instanced meshes | Removed, moved and added instances, regrowth, Reset Areas |
| Keep broken destructibles broken | Geometry collections and their pieces |
| Save PCG worlds | Seeds, graph parameters and generated output |
| Hold players until the ground has loaded | Holding players after a load, the world-ready event, your own loading screen |
Shape the game’s saves
| Guide | For |
|---|---|
| Show saves in a slot list | What each save records: titles, the place name, fields of your own, play time |
| Show save thumbnails | The picture each save holds, pictures of your own, split screen |
| Show when the game saves and loads | The saving indicator, notices, the loading overlay, the screen while a map loads |
| Save and load parts of the game | The players, the world or named groups, saved into a slot that keeps the rest |
| Keep snapshots in memory | Memory slots for a quick retry, rewind points |
| Block saving during a fight | Save blocks and how a menu shows them |
| Play single-slot runs | One save per ironman or roguelike run |
| Keep each player’s profile | A profile per local player for unlocks, named profiles, profiles keyed by account |
| Start New Game+ | A new game that keeps the players and chosen groups |
Keep saves safe
| Guide | For |
|---|---|
| Check that saves survive a crash | The two copies of every save, what a load reports, the console commands that test it |
| Keep old saves loading after an update | Game Data Version, migration steps, checking released builds’ saves in CI |
| Rename saved data without losing saves | Renames that survive on their own and the redirects the others need |
| Protect saves from editing | Tamper resistance, keys, what a load does with a changed save |
| Set where saves are kept | The file prefix, storage, compression, file names, the slot index |
| Save when the game closes or goes to the background | Saves on quit, on focus loss and when the system sends the game away |
| Keep saves with each player’s account | Whose storage holds the slots, sign-outs, the warning before storage runs out |
| Save a multiplayer game | What the server saves, what clients see after a load, what version 1.1 adds |
| Sync saves with Steam Auto-Cloud | The Steamworks root, pattern and quotas for Rolly Save’s files |
Move and inspect saves
| Guide | For |
|---|---|
| Rename, export and import saves | Renaming slots, save files to send, saves as bytes for your own cloud |
| Export and import saves as JSON | A save as text to read, attach to a bug report or edit, imported as a new slot |
| Bring saves over from Save Game to Slot | Reading a save of the engine’s Save Game to Slot once |
| Inspect, compare and edit saves | The Save Inspector: which copy loads, comparing saves, writing changed values back |
| Check your save setup | The checks after each map save, Check Project, CI, how strict each check is |
| See what an actor saves while you play | The Gameplay Debugger category RollySave |
| Use Rolly Save from C++ | The modules, the subsystem’s calls, save files, records, storage backends, the automated tests |
The Rolly UI design system that draws the slot screen is shared by every Rolly product, and so are these guides:
| Guide | For |
|---|---|
| Choose a layout | The five layouts, how they fit an area, layouts and pieces of your own |
| Make a theme of your own | Presets, theme assets, the live preview and checks, widgets that follow the theme |
| Share one look across Rolly products | One theme for every product, players’ high contrast and reduced motion |
| Open screens on the screen stack | Screens, dialogs, toasts, tabs and prompts of your own |
| Host screens in Common UI or your own layers | Common UI games, presenters and input handlers |
| Search a category screen | Search, the text field and the on-screen keyboard |
| Menu narration | The voices, what screens say, speaking from your game and your widgets |
| Find and fix setup problems | Where setup messages appear |
Reference
Generated from the code, so it always matches it:
- Blueprint nodes, classes, structs and enums
- Project Settings, console commands and variables and gameplay tags
- Setup messages
Troubleshooting lists problems by what you see. CHANGELOG.md lists the changes of each version, and ARCHITECTURE.md shows how the code is organised.
Dependencies
Engine modules: Core, CoreUObject, Engine, AssetRegistry, Chaos, DeveloperSettings, GameplayTags, GeometryCollectionEngine, ImageCore, ImageWrapper, InputCore, Json, LevelSequence, MovieScene, NetCore, Projects, Slate, SlateCore, UMG, and GameplayDebugger where the build has the debugger (and in the editor: UnrealEd, ApplicationCore, AssetDefinition, BlueprintGraph, ClassViewer, DesktopPlatform, DeveloperToolSettings, Foliage, Kismet, KismetCompiler, LevelEditor, MessageLog, MovieSceneTracks, PlacementMode, PropertyEditor, RenderCore, SceneOutliner, Settings, SharedSettingsWidgets, StateTreeEditorModule, ToolMenus, ToolWidgets, WorkspaceMenuStructure). AIModule, which gives game worlds their AI system, for the Blackboard handler. Engine plugins: Data Validation, which Rolly Save enables for its editor checks; PCG, which it enables for the RollySavePCG module, which saves PCG components and their output; StateTree and GameplayStateTree, with PropertyBindingUtils (Beta), which StateTree needs, for the RollySaveStateTree module, which saves StateTree components (modules StateTreeModule, GameplayStateTreeModule and PropertyBindingUtils); and Gameplay Abilities, which brings Data Registry (Beta), for the RollySaveGAS module, which saves Ability System Components (modules GameplayAbilities, GameplayTags and GameplayTasks). Every project with Rolly Save has these plugins on, unused until a Save Rule lists their handler. No other user-made plugin is required: the shared foundation code, the Rolly UI design system included, ships inside the plugin.