# Give players a slot screen

> Rolly Save's slot screen lets players save, load, start a new game and manage their saves, with a pad, a keyboard and mouse, or touch, in the layout and look...

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

![The slot screen in Load](https://rolly-docs.pages.dev/save/_files/Images/SlotScreen_Tabs.png "Load in the Tabs layout: eight saves newest first, each with its picture, kind mark, pills, place, play time and save time; the run that ended and the save of a newer version dimmed; the focused save's large picture and facts in the detail panel; the sort chip in the header and the keys in the footer.")

## Open the slot screen

The screen opens in one of three modes: **Save**, **Load** and **New Game**.

- **Save Points** and **Rolly Save Trigger** components with Action Automatic or Open Slot Screen open it for the player who uses them (see [Place save points, checkpoints and reset areas](https://rolly-docs.pages.dev/save/guides/place-level-tools/)).
- **Request Slot Screen** on the Rolly Save Subsystem asks for it from your own code; Rolly Save's screen answers while Project Settings > Plugins > Rolly Save Screens > **Show Slot Screen** is on.
- **Open Rolly Slot Screen** opens it whatever Show Slot Screen says, such as from your pause menu's Save and Load buttons or your main menu's Load and New Game.

The screen opens for the player whose controller you give, on that player's part of the screen. It pauses the game while it shows, except in the Side Drawer layout, and a second request while it is open does nothing. Opening Save outside a map of **Menu Maps** takes the picture the save will hold before the screen draws over the game; the detail of New Save and of an empty slot shows it. Each player's Save screen keeps its own picture, so two players saving at once each save their own view.

![Save with the picture the save will hold](https://rolly-docs.pages.dev/save/_files/Images/SlotScreen_NewSave.png "Save in the Tabs layout: New Save has focus, and the detail panel shows the picture taken of the game as the screen opened, which the new save will hold.")

### Blueprint

In your pause menu, connect the Save button to **Open Rolly Slot Screen** with **Player** set to Get Owning Player and **Mode** Save; do the same for Load. **Close Rolly Slot Screen** closes it with its dialogs, and **Is Rolly Slot Screen Open** tells whether it shows.

### C++

```cpp
#include "RollySaveUISubsystem.h"

URollySaveUISubsystem* Screens = URollySaveUISubsystem::Get(this);
Screens->OpenSlotScreen(PlayerController, ERollySaveSlotScreenMode::Load);
```

The screens' module, `RollySaveUI`, runs on clients and standalone games; a dedicated server has none of it. Add `RollySaveUI` to your module's dependencies to call it.

## Pick a slot style

Project Settings > Plugins > Rolly Save Screens > Slot Screen > **Slot Style**:

| Style | Save | Load | New Game |
|---|---|---|---|
| Free Slots | New Save first, then the saves to overwrite; a new save asks for a title | every save | starts at once, without a screen |
| Numbered Slots | Slot 1 to **Number of Slots** (1 to 99), each empty or holding a save | every save | the numbered slots; the new game saves to the one picked |
| Playthroughs | saves at once to the playthrough's slot, without a screen | every save; Accept reads Continue | New Playthrough first, then the playthroughs to replace |
| Runs | saves at once to the active run's slot; New Run otherwise | every save; a run that goes on reads Continue, an ended run is locked | New Run first, then the runs to replace |

Numbered slots are shared by every profile. While each profile sees only its own saves (**Slots Shown**, below), a slot that holds another profile's save reads "Another profile's save" and is unavailable, so no profile replaces another's save.

**Max Slots** (0 to 999, 0 for no limit) caps the manual saves, playthroughs or runs a player can have: at the limit, New Save, New Playthrough or New Run says how many there are and is unavailable until one is deleted.

**Grouping** splits Load into groups: One List, By Kind (Saves, Autosaves, Checkpoints) or By Profile (each named profile, the player's first, then Other). Groups without saves are left out.

## Pick its layout and look

The slot screen lays out in the layout Project Settings > Plugins > Rolly Save Core UI > **Layout** picks, or the theme's, with the theme's colours, type and density (see [Choose a layout](https://rolly-docs.pages.dev/save/guides/layouts/) and [Themes](https://rolly-docs.pages.dev/save/guides/themes/)). The layout guide is shared by every Rolly product: on the slot screen a category is a group of saves (**Grouping**, above) and a row is a save.

| Layout | What the slot screen looks like |
|---|---|
| Tabs | the list with row pictures beside a detail panel with the large picture; groups as tabs |
| Side Rail (`Rail`) | groups in a rail at the left, the list, and the detail at the right |
| Centered Panel (`Panel`) | a card over the dimmed game with compact chips and a detail strip under the list |
| Couch Hub (`Hub`) | large type; with groups, a tile per group with its count and newest save, then the group's page with a picture column |
| Side Drawer (`Drawer`) | a drawer docked at the side over the running game |

![The Side Rail with groups by kind](https://rolly-docs.pages.dev/save/_files/Images/SlotScreen_Rail.png "Load in the Side Rail layout with Grouping By Kind: the rail lists Saves, Autosaves and Checkpoints, the list shows the Saves group, and Back reads Groups.")

![Save in the Centered Panel](https://rolly-docs.pages.dev/save/_files/Images/SlotScreen_Panel.png "Save in the Centered Panel over the game: New Save has focus, and the strip under the list says a title comes next.")

![Load in the Couch Hub](https://rolly-docs.pages.dev/save/_files/Images/SlotScreen_Hub.png "Load in the Couch Hub at Large density: the group's page with its rows and the focused save's picture in the preview column.")

![Save in the Side Drawer](https://rolly-docs.pages.dev/save/_files/Images/SlotScreen_Drawer.png "Save in the Side Drawer docked at the right over the running game.")

## Choose what each save shows

Rows show the save's picture with a mark of its kind (a bolt for a quick save, the autosave mark, a flag for a checkpoint, a heart for a run's save), its title on one line (an ellipsis ends one too long for the row), pills (Run, Ended, Imported), its place, its play time and when it was saved. The detail adds the long date and time, the map, the New Game+ cycle, the profile and your game fields. Under Project Settings > Plugins > Rolly Save Screens > **Rows**:

| Setting | Default | What it does |
|---|---|---|
| Fields | place, play time, save time, kind marks on | each part a row and the detail show; Map, New Game+ Cycle and Profile are off |
| Game Fields | none | members of your Slot Fields Struct, each with its words, such as `Day {Value}`, in rows and the detail |
| Row Pictures | on | each row shows its save's picture; the detail always does |
| Save Time | Relative Day | Relative Day: Today 14:32, Yesterday 21:05, the weekday within a week, then the date; Date and Time: as the language writes them |
| Default Sort | Newest first | Newest first, Oldest first, Title or Play time |
| Player Can Sort | on | the sort chip and its key change the order for the session; numbered Save and New Game lists keep their order |
| Max Rows | 100 | 10 to 1,000 rows are built after sorting; a line under the last row says how many saves are not shown, and search finds every save |
| Search From | 20 | search shows from this many saves, 0 to 1,000; 0 turns it off |

Game Fields show a Text as it is, numbers as the player's language writes them (1,234.5), a Boolean as Yes or No, an enum by its display name, and a String or Name as written. A C++ enum shows its name in a packaged game, which keeps no display names of C++ enums; a Blueprint enum keeps its own. A member of another type, such as a struct, shows nothing, and the setup warning GameFieldType says so.

A save shows its picture once it is read (see [Show save thumbnails](https://rolly-docs.pages.dev/save/guides/thumbnails/)); pictures are read for the rows in view and a page below, and the screen holds at most 64 at a time. A save over a listed slot, or a new save in a slot one was deleted from, shows its own picture. A save whose run ended, whose Game Data Version is above the project's, or that a save block, a load or another player's save keeps from being used stays listed, dimmed, with the reason in the detail.

## Change titles and texts

**Titles** (Project Settings > Plugins > Rolly Save Screens > Titles) name saves without a typed title: New Save `Save {Number}`, Numbered `Slot {Number}`, Playthrough `Playthrough {Number}`, Run `Run {Number}`, Quick `Quick Save`, Autosave `Autosave {Number}`, Checkpoint `Checkpoint: {Checkpoint}`, Unnamed Checkpoint, Imported, and Copy `Copy of {Title}`. {Number} is the slot's number, {Checkpoint} the checkpoint's name and {Title} the copied save's title. **Title Entry** decides when players type a title: Style Default (Free Slots only), Ask (every new save) or Automatic (never). **Max Title Length** is 8 to 128 characters, 40 by default.

**Texts** holds the screens' words: the screen titles, the New rows, the empty list ("No saves yet."), the client and first-player notices and the indicator's Saving, Saved and Loading. **Block Reasons** gives words to the reasons of **Add Save Block**: a block named `BossFight` with the words "You cannot save during this fight." shows them on the rows of Save. These texts live in `Config/DefaultGame.ini`: add `*.ini` to your localization target's Gather Text From Source paths to translate them.

## Choose actions and questions

| Key | Gamepad | Keyboard | Mouse and touch |
|---|---|---|---|
| Save, Load, Continue, Start, Import | A | Enter, Space | double-click a row, or tap the focused row |
| Rename, or More | X | F2 | the prompt |
| Delete | Y | Delete | the prompt |
| Sort | right trigger | S | the sort chip |
| Profiles | left trigger | P | the profile chip |
| Search | right stick button | Ctrl+F | the search entry |
| Move between rows | D-pad, left stick | arrows; Page Up, Page Down, Home, End | hover, or drag to scroll |
| Previous, next group | LB, RB | Q, E | a tab, rail item or chevron |
| Back | B | Esc | the prompt |
| Close from any level | Menu | | |
| Repeat or stop narration | left stick button | Ctrl+Space | |

S and P keep their place on other keyboard layouts. The keys are class defaults of the slot screen (**Rename Keys**, **Delete Keys**, **Sort Keys**, **Profile Keys**); change them in a Blueprint subclass.

Under **Actions**: **Allow Rename** and **Allow Delete** are on; **Allow Copy** adds Copy, and **Allow Export** adds Export on Windows, Mac and Linux. With either, and on a run that goes on, X opens **More**, a list of what the save allows: Rename, Copy, Export, Abandon Run, Delete and Cancel. **Allow Import** ends Load with **Import a Save**, which lists the export folder's files (see [Rename, export and import saves](https://rolly-docs.pages.dev/save/guides/share-saves/)).

Under **Confirmations**, questions ask before what cannot be undone, the safe answer focused:

| Setting | Default | Asks |
|---|---|---|
| Confirm Overwrite | on | before a save replaces another, and before a new game takes a slot that holds one |
| Confirm Delete | on | before a save is deleted |
| Ask Before Loading | When Progress Is Unsaved | before a load when more than **Unsaved After** (60 seconds) of play since the last save or load would be lost, saying how much; Never or Always |
| Menu Maps | none | maps where loading never asks, such as your title screen |

![The overwrite question](https://rolly-docs.pages.dev/save/_files/Images/SlotScreen_Overwrite.png "Save over a save: Overwrite Before the cellar? The save from Today 2:32 PM is replaced. Cancel has focus, Overwrite is the danger button.")

An answer acts on its save only while the save is still the one the question named. An answer given while another player's save or a load runs waits for it to end, then checks the save again. If another player's save, or an autosave under the Side Drawer, replaced it meanwhile, the list shows the new save, a notice says "{Title} changed, so nothing was done." and nothing happens; ask again to act on it.

New saves and renames ask for a title in the name dialog, which opens on its confirm button: A, then A again saves with the title offered. Up focuses the field, and A on it opens the on-screen keyboard for pad and touch players; Menu confirms from the keyboard, B ends typing and keeps the text. Export names allow letters, digits, spaces, `_` and `-`, 1 to 64.

![Typing a title on the keyboard](https://rolly-docs.pages.dev/save/_files/Images/SlotScreen_TitleKeyboard.png "New Save's title typed with a pad on the on-screen keyboard, the Xbox glyphs on Shift, Space, Delete and Done, the counter at 11 of 40.")

A save, load, delete, rename, copy, export or import that fails opens a dialog with the reason. A load of a damaged save, an ended run's save or an older copy of a run offers Delete beside Close while Allow Delete is on. **Close After Saving** (on) closes the screen once a save from it succeeds; off, the screen stays with focus on the saved row.

## Start a new game from the screen

New Game clears the loaded game, sets the slot the new game saves to (Numbered Slots and Playthroughs, with a title when Title Entry asks for one, which the new game's first save takes: a save the slot holds keeps its own title until then) or starts a run in it (Runs, deleting the run's old save first when the player picked one), closes the screen and fires **On New Game Chosen** on the **Rolly Save UI Subsystem** with the player, the slot name and the title. In Free Slots the event fires at once, without a slot. Then **New Game Map** (Project Settings > Plugins > Rolly Save Screens > New Game) opens, with **Open Options** such as `listen`. With New Game Map empty, open your start map in the event; a setup warning says so when nothing binds it.

## Let players use profiles

With Project Settings > Plugins > Rolly Save > Profiles > **Profile Keys** at Named, Load and New Game show a profile chip with the player's profile, and the left trigger or P opens the **profiles panel**. **Open Rolly Profiles** opens it from your own menu.

![The profiles panel](https://rolly-docs.pages.dev/save/_files/Images/SlotScreen_Profiles.png "The profiles panel: Anna active with the check, Kim, Sam in use by player 2 and unavailable, and New Profile.")

- Choosing a profile offers Use This Profile (not for the active one or one in use), Rename, Delete (not for one in use or the only one) and Cancel. Use This Profile closes the panel, says "Now using {Name}." and lists that profile's saves.
- New Profile asks for a name, offering `Player {Number}` with the lowest free number, on the keyboard first; the profile is made and used. Names are 1 to **Max Profile Name Length** (8 to 64, 24 by default) characters, and two profiles never share a name, whatever the case.
- Delete asks first. While each profile's saves show alone, its saves go with it; otherwise they stay. Deleting the player's own profile switches to the first other one.
- At **Max Named Profiles**, a line says so in place of New Profile.
- An action that fails, such as a name the storage cannot write, says why in a dialog.

**Slots Shown** (Project Settings > Plugins > Rolly Save Screens > Profiles) decides whose saves the list shows: Auto (every save with Platform User keys, the player's profile's saves with Named or Provider keys), All Profiles, or Current Profile. Imported saves show for every profile. See [Keep each player's profile](https://rolly-docs.pages.dev/save/guides/profiles/).

While the list shows the player's profile's saves alone, a screen opened before that profile is found, as in the first frames after the player joins with Named keys, reads Reading saves until the profile loads, then lists its saves. A profile Use Rolly Profile gives the player while the screen shows gets its saves listed in place.

## Continue and abandon runs

In Runs, Load shows each run's save; a run that goes on reads **Continue**, and an ended run is locked with the reason. X on a run that goes on opens More with **Abandon Run**, which ends it by **Abandoned Runs**: Ask (Cancel, Keep as Ended or Delete), Keep as Ended (the save stays listed as ended) or Delete. Deleting a run that goes on ends it too. See [Play single-slot runs](https://rolly-docs.pages.dev/save/guides/single-slot-runs/).

## Share saves between machines

Allow Export adds Export to More: it asks for a file name, cut from the title, writes the save to the export folder of Project Settings > Plugins > Rolly Save > Sharing Saves, and says "Exported to {File}." Allow Import ends Load with Import a Save: a second screen lists the export folder's files, Accept imports one into a new slot and says "Imported {Title}.", and back in Load the new save has focus. Both need a platform that can write files, which Windows, Mac and Linux can. See [Rename, export and import saves](https://rolly-docs.pages.dev/save/guides/share-saves/).

## Split screen and Steam Deck

Each local player opens a slot screen on their own part of the screen; saves and loads are the game's. While one player's save or a load runs, the other's open screen marks its rows unavailable ("Another player is saving.", "A save is loading."), and a load's travel closes every screen. The game's own saves, such as autosaves and checkpoints, leave the rows as they are. A row that cannot act shows what Accept does, dimmed. **Who Can Load** keeps Load and New Game to player 1 with First Player and tells the others "Only Player 1 can load."; Save stays open to everyone. A client refuses Save, Load and New Game with "Only the host can save and load." and the setup warning ClientScreen: its own files hold none of the host's world. Open Rolly Profiles works on clients.

At the Steam Deck's 1280 x 800, which lays out about 1730 x 1080 units at the Deck's DPI scale, Tabs and Side Rail keep the side detail panel; the Couch Hub at Large density suits Deck-first games.

![Load on a Steam Deck](https://rolly-docs.pages.dev/save/_files/Images/SlotScreen_Deck.png "Load in the Tabs layout on a Steam Deck's 1280 x 800 screen: the list and the side detail panel with the large picture, and the pad's prompts in the footer.")

## Show it in VR on a widget component

1. Make an actor with a Widget Component: Space World, Draw Size 1920 x 1080, Receive Hardware Input off, Window Focusable on. Its widget holds an Overlay.
2. In Begin Play, Get Rolly Screen Stack for the player and call **Set Host Panel** with that Overlay. Do it again after each map change: the component dies with its world.
3. Set Project Settings > Plugins > Rolly Save Screens > World Space > **Input Mode** to Overlay, so the game's input still reaches your Widget Interaction component.
4. Use the Centered Panel (`Panel`) at Large density, which reads at arm's length.

Use it with the pointer: gamepad focus inside a widget component is not covered yet. See [Host screens in your own widget](https://rolly-docs.pages.dev/save/guides/hosting-screens/).

## Replace parts of the screen in Blueprint

Each piece has a class setting under Project Settings > Plugins > Rolly Save Screens > **Classes**: **Slot Screen Class**, **Slot Row Class**, **Profiles Screen Class**, **Saving Indicator Class** and **Loading Overlay Class**. Make a Blueprint subclass of the built-in class and name widgets like its parts; the code drives them, and parts you leave out are built for you.

| Class | Parts |
|---|---|
| Rolly Save Slot Screen | the category screen's parts (see [Choose a layout](https://rolly-docs.pages.dev/save/guides/layouts/)), plus `SortChip` and `ProfileChip` |
| Rolly Save Slot Row | the row's parts, plus `KindPlate`, `KindIcon`, `Pills` and `TimeText` |
| Rolly Save Profiles Screen | `ProfileList`, `LimitText`, `PromptBar` |
| Rolly Save Profile Row | `StateIcon`, `StateBadge`, `StateText`, `PlusIcon` |

Classes start loading as the game starts; a screen opened before its class finished loading waits for that class once. A class that cannot be loaded falls back to the built-in one with a setup error. The cook keeps every class and New Game Map these settings name.

### C++

`URollySaveSlotScreen` (`Screens/RollySaveSlotScreen.h`) draws its rows from an `IRollySaveSlotSource` (`Model/RollySaveSlotSource.h`); `FRollySaveSlotScreenModel` (`Model/RollySaveSlotScreenModel.h`) builds rows, groups, order and what each row's prompts can do from a list of saves, with no widgets, so a screen of your own reads the same rules. `FRollySaveSlotFlows` runs what a row does: the saves, loads and questions.

## Use your own menu instead

Turn **Show Slot Screen** off, or pick Your own menu for Slot screen in **Tools > Rolly Save > Set Up Project...**: nothing listens to **On Slot Screen Requested**, so bind it on the Rolly Save Subsystem to open your menu, and call **Mark Slot Screen Request Handled** in that event before it returns. Until a listener marks the request, Save Points on Automatic save a checkpoint. **List Rolly Slots**, **Load Rolly Slot Thumbnail** and the other nodes give your menu what the screen shows (see [Show saves in a slot list](https://rolly-docs.pages.dev/save/guides/list-slots/)). The saving indicator, notices and loading overlay work with either menu (see [Show when the game saves and loads](https://rolly-docs.pages.dev/save/guides/save-feedback/)).