Classes

RollySave

ARollySaveAutosaveVolume

Rolly Save Autosave Volume · derives from AVolume · #include "Level/RollySaveAutosaveVolume.h"

Requests an autosave when a player walks in. Shape it like any volume.

ARollySaveCheckpointVolume

Rolly Save Checkpoint Volume · derives from AVolume · #include "Level/RollySaveCheckpointVolume.h"

Saves a checkpoint when a player walks in. Shape it like any volume.

ARollySaveResetAreaVolume

Rolly Save Reset Area Volume · derives from AVolume · #include "Level/RollySaveResetAreaVolume.h"

The saved actors inside start as designed again when this level is next built, as Resets says. Shape it like any volume; it stays loaded in World Partition maps.

ARollySaveSavePoint

Rolly Save Point · derives from AActor · #include "Level/RollySaveSavePoint.h"

A placed object that saves when a player touches it or your game calls Trigger on its Rolly Save Trigger: by default it opens the slot screen when one exists, otherwise it saves a checkpoint. Replace its Mesh with your own.

URollySaveAIStateHandler

Rolly Save AI State Handler · derives from URollySaveEngineStateHandler, abstract · #include "EngineState/RollySaveAIStateHandler.h"

The base of Rolly Save’s engine state handlers that set AI and ability system state, such as a Blackboard, a StateTree or Ability System Components: each applies on a tick after its Apply Timing comes, once its AI is ready, never inside the caller’s stack.

URollySaveAudioHandler

Audio · derives from URollySaveEngineStateHandler · #include "EngineState/RollySaveAudioHandler.h"

Saves the actor’s audio components: whether each plays, is paused or stopped, where it is, and the sound your game set, so music and ambience go on where they were. MetaSounds start again from their beginning.

URollySaveBlackboardHandler

Blackboard · derives from URollySaveAIStateHandler · #include "EngineState/RollySaveBlackboardHandler.h"

Attach to AI pawns: saves the Blackboard values of the pawn’s AI controller, which never saves itself, and restarts its Behavior Tree with them after a load.

URollySaveBytesAction

Rolly Save Bytes Action · derives from UBlueprintAsyncActionBase · #include "Nodes/RollySaveBytesAction.h"

The Rolly Save node that gives a save as bytes: Export Rolly Slot to Bytes. It ends in Success or Failure on a later tick than the call.

URollySaveComponent

Rolly Save · derives from UActorComponent · #include "Actor/RollySaveComponent.h"

Makes its actor save, and overrides what Project Settings > Plugins > Rolly Save > Actor Defaults and the Save Rules that match the actor save for it. Its events tell the actor’s graph when the actor is saved and loaded. An actor with a variable that has SaveGame ticked saves without it.

URollySaveEngineStateHandler

Rolly Save Engine State Handler · derives from URollySaveHandler, abstract · #include "EngineState/RollySaveEngineStateHandler.h"

A Save Handler of Rolly Save for an engine system’s state on the actor it is attached to. Attach it in a Save Rule or Rolly Save component; it cannot be a Global Handler.

URollySaveGameClock

Rolly Save Game Clock · derives from UObject, abstract · #include "Level/RollySaveGameClock.h"

Tells Reset Areas your game’s own time, such as in-game days. Make a Blueprint of it, override Get Game Time Seconds, and pick it in Project Settings > Plugins > Rolly Save > Game Clock Class.

URollySaveHandler

Rolly Save Handler · derives from UObject, abstract · #include "Handler/RollySaveHandler.h"

Saves state you cannot tick SaveGame on, such as another plugin’s actor. Add variables with SaveGame ticked, set them in Gather, use them in Apply, and list the handler in Project Settings > Plugins > Rolly Save > Global Handlers, or attach it to actors in a Save Rule or Rolly Save component.

URollySaveImportAction

Rolly Save Import Action · derives from UBlueprintAsyncActionBase · #include "Nodes/RollySaveImportAction.h"

The Rolly Save node that reads a save the engine’s Save Game to Slot wrote: Import Engine Save Game. It ends in Success or Failure on a later tick than the call.

URollySaveInterface

Rolly Save Interface · derives from UInterface, abstract · #include "Record/RollySaveInterface.h"

Adds Rolly Save’s three events to a Blueprint (Class Settings > Implemented Interfaces) and makes its objects save. A custom event of the same name works without the interface; C++ classes declare the functions directly.

URollySaveJsonAction

Rolly Save Json Action · derives from UBlueprintAsyncActionBase · #include "Nodes/RollySaveJsonAction.h"

The Rolly Save node that gives a save as JSON text: Export Rolly Slot to JSON Text. It ends in Success or Failure on a later tick than the call.

URollySaveListAction

Rolly Save List Action · derives from UBlueprintAsyncActionBase · #include "Nodes/RollySaveListAction.h"

The Rolly Save nodes that list saves: List Rolly Slots and List Rolly Export Files. Each ends in Success or Failure on a later tick than the call.

URollySaveLoadAction

Rolly Save Load Action · derives from UCancellableAsyncAction · #include "Nodes/RollySaveLoadAction.h"

The Rolly Save nodes that load: Load Game from Rolly Slot, Rolly Quick Load, Load Game Part from Rolly Slot, Load Game from Rolly Memory Slot, Rewind Rolly Game, Load Rolly Checkpoint and Start Rolly New Game Plus. Their Async Action pin cancels: before the map changes the load stops and only On Load Cancelled fires; after, or while its values are being set (a cancel from On Rolly Save Loaded, an On Loaded event or a Save Handler’s Apply), the load finishes and On Load Finished fires, but these pins do not. New Game+ cannot be cancelled: its new game has begun by the time the node returns.

URollySaveMaterialHandler

Material Parameters · derives from URollySaveEngineStateHandler · #include "EngineState/RollySaveMaterialHandler.h"

Saves the dynamic materials of the actor’s meshes and decals: their parameters, the materials they were made from, and the meshes’ custom primitive data, such as a lamp’s glow your game turned up. A material your game sets with Set Material saves when you pick Override Materials in Pick Properties.

URollySaveMigrationContext

Rolly Save Migration Context · derives from UObject · #include "Migration/RollySaveMigrationContext.h"

The save a migration step changes: its saved objects, found by class, by what they were saved for or by chunk, their top-level saved values, and the values Save Rules and Rolly Save components save by path. Rolly Save makes one for each step’s Migrate.

URollySaveMigrationStep

Rolly Save Migration Step · derives from UObject, abstract · #include "Migration/RollySaveMigrations.h"

One change to saved data between two Game Data Versions. Create a Blueprint of it for a change no built-in step makes, then pick it in the Steps of your Rolly Save Migrations asset.

URollySaveMigrations

Rolly Save Migrations · derives from UDataAsset · #include "Migration/RollySaveMigrations.h"

The steps that bring saves of older Game Data Versions up to date before they load. Name this asset in Project Settings > Plugins > Rolly Save > Migrations.

URollySaveMontageHandler

Montages · derives from URollySaveEngineStateHandler · #include "EngineState/RollySaveMontageHandler.h"

Saves the montages the actor’s skeletal meshes play: each montage, its position, play rate, section order and pause, so an emote or a reload goes on after a load. The animation graph’s states are not saved.

URollySavePlayerIdProvider

Rolly Save Player ID Provider · derives from UObject, abstract · #include "Profile/RollySavePlayerIdProvider.h"

Names each local player’s profile when Profile Keys is Provider, such as by the account the platform signed in. Make a Blueprint of it, override Get Profile Key and pick it in Project Settings > Plugins > Rolly Save > Profiles > Player ID Provider. Rolly Save makes one per game instance as the game starts.

URollySaveProfile

Rolly Save Profile · derives from UObject, abstract · #include "Profile/RollySaveProfile.h"

One local player’s data outside any playthrough, such as unlocks. Make a Blueprint of it, add variables with SaveGame ticked and pick it in Project Settings > Plugins > Rolly Save > Profile Class.

URollySaveProfileAction

Rolly Save Profile Action · derives from UBlueprintAsyncActionBase · #include "Nodes/RollySaveProfileAction.h"

The Rolly Save nodes that give a local player’s profile: Load Rolly Profile and Reset Rolly Profile. Each ends in Success or Failure on a later tick than the call. They work on clients: each machine keeps its own players’ profiles.

URollySaveProfileInfoAction

Rolly Save Profile Info Action · derives from UBlueprintAsyncActionBase · #include "Nodes/RollySaveProfilesAction.h"

The Rolly Save nodes that give one named profile: Create Rolly Profile and Use Rolly Profile. Each ends in Success or Failure on a later tick than the call.

URollySaveProfilesAction

Rolly Save Profiles Action · derives from UBlueprintAsyncActionBase · #include "Nodes/RollySaveProfilesAction.h"

The Rolly Save node that lists the named profiles players make under Named profile keys: List Rolly Profiles. It ends in Success or Failure on a later tick than the call, and works on clients: each machine keeps its own.

URollySaveReloadRulesAction

Rolly Save Reload Rules Action · derives from UBlueprintAsyncActionBase · #include "Nodes/RollySaveReloadRulesAction.h"

The Reload Save Rules node. It ends in Completed on a later tick than the call.

URollySaveRemoveRecordsStep

Remove Records of Class · derives from URollySaveMigrationStep · #include "Migration/RollySaveMigrationSteps.h"

Removes every saved object of a class, such as one of a plugin the game no longer uses.

URollySaveRemoveValueStep

Remove Saved Value · derives from URollySaveMigrationStep · #include "Migration/RollySaveMigrationSteps.h"

Removes a top-level saved value from saved objects of the classes listed, so the old-save check stops reporting it as dropped.

URollySaveRenameMapStep

Rename Map · derives from URollySaveMigrationStep · #include "Migration/RollySaveMigrationSteps.h"

Moves a save made in a map that was renamed or moved to the map’s new name: the map the save opens, the map’s saved Level Blueprint and everything saved inside it. The step fails on a save that already holds the new map.

URollySaveRenameNameStep

Rename Registered Name · derives from URollySaveMigrationStep · #include "Migration/RollySaveMigrationSteps.h"

The object saved under a registered name, and every saved pointer to it, takes a new name. Names compare with capital letters. The step fails on a save that already holds an object under New Name.

URollySaveRenameValueStep

Rename Saved Value · derives from URollySaveMigrationStep · #include "Migration/RollySaveMigrationSteps.h"

In saved objects of the classes listed, the top-level saved value Old Name becomes New Name.

URollySaveReplaceClassStep

Replace Class · derives from URollySaveMigrationStep · #include "Migration/RollySaveMigrationSteps.h"

Every reference to Old Class Path, in every saved object, becomes New Class: saved objects of that class load into objects of New Class, and pointers to the class follow.

URollySaveResetAreaComponent

Rolly Save Reset Area · derives from UActorComponent · #include "Level/RollySaveResetAreaComponent.h"

The saved actors inside its actor’s shape start as designed again when its level is next built: on a return by travel, a load that opens the map, or New Game Plus, as Resets says. With Reset Instances, so do the instances inside. Add it to any actor with a Box, Sphere or Capsule Collision; placed volumes and Blueprints spawned during play both work.

URollySaveRule

Rolly Save Rule · derives from UDataAsset · #include "Rules/RollySaveRule.h"

Decides what a group of actors saves: match them by class, interface, tag or map, then set ticks, pick properties and attach Save Handlers. Every Save Rule in the project applies while Enabled is on.

URollySaveSequenceHandler

Level Sequence · derives from URollySaveEngineStateHandler · #include "EngineState/RollySaveSequenceHandler.h"

For a Level Sequence Actor: saves its time and whether it plays, is paused or stopped, so a cutscene or a moving platform goes on where it was.

URollySaveSlotAction

Rolly Save Slot Action · derives from UBlueprintAsyncActionBase · #include "Nodes/RollySaveSlotAction.h"

The Rolly Save nodes that write: Save Game to Rolly Slot, Rolly Quick Save, Save Game to New Rolly Slot, Set Rolly Slot Title, Set Rolly Title for Next Save, Delete Rolly Slot, Copy Rolly Slot, Save Game Part to Rolly Slot, Save Game to Rolly Memory Slot, Save Rolly Rewind Point, Save Rolly Checkpoint, Start and End Rolly Run, Rename Rolly Slot, Export Rolly Slot to File, Import Rolly Slot from File and from Bytes, Save Rolly Profile, and Rename and Delete Rolly Profile. A write that started cannot be undone, so they have no Cancel. Each ends in Success or Failure on a later tick than the call. The game instance holds the node until then, so the operation finishes when the Blueprint that called it is gone, whose pins then do not run.

URollySaveStorageSpaceAction

Rolly Save Storage Space Action · derives from UBlueprintAsyncActionBase · #include "Nodes/RollySaveStorageSpaceAction.h"

The Rolly Save node Check Rolly Storage Space. Ends in Done on a later tick than the call.

URollySaveSubsystem

Rolly Save Subsystem · derives from UGameInstanceSubsystem · #include "Game/RollySaveSubsystem.h"

Saves and loads the game for one game instance. Bind On Save Finished and On Load Finished here; the Rolly Save nodes call it for you.

URollySaveThumbnailAction

Rolly Save Thumbnail Action · derives from UBlueprintAsyncActionBase · #include "Nodes/RollySaveThumbnailAction.h"

The Rolly Save node that gives a save’s picture: Load Rolly Slot Thumbnail. It ends in Success or Failure on a later tick than the call, and works on clients: each machine shows its own saves.

URollySaveThumbnailHoldLibrary

Rolly Save Thumbnail Hold Library · derives from UBlueprintFunctionLibrary · #include "Nodes/RollySaveThumbnailHoldLibrary.h"

The Rolly Save nodes for pictures that menus keep: Capture, Use and Release Rolly Thumbnail Hold, for a save menu of your own in split screen, where each player’s menu keeps the picture of that player’s view until its save. Capture Rolly Save Thumbnail keeps one picture for the next save instead, which both players’ menus would share.

URollySaveTimelineHandler

Timelines · derives from URollySaveEngineStateHandler · #include "EngineState/RollySaveTimelineHandler.h"

Saves each timeline of the actor’s Blueprint: its position, whether it plays or reverses, its play rate and looping, so a half-open door stays half-open after a load.

URollySaveTriggerComponent

Rolly Save Trigger · derives from UActorComponent · #include "Level/RollySaveTriggerComponent.h"

Saves when a player walks into its actor’s collision or your game calls Trigger: a checkpoint, an autosave, a save to a slot, or the slot screen. Add it to any actor with a Box, Sphere or Capsule Collision, such as a campfire or a bed. Acts on the server or in a standalone game.

URollySaveTriggerInterface

Rolly Save Trigger Interface · derives from UInterface, abstract · #include "Level/RollySaveTriggerInterface.h"

Lets an actor refuse its Rolly Save Triggers, such as a bonfire while enemies are near. Add it in Class Settings > Implemented Interfaces and return false from Can Trigger Rolly Save.

URollySaveWaitWorldReadyAction

Rolly Save Wait World Ready Action · derives from UBlueprintAsyncActionBase · #include "Nodes/RollySaveWaitWorldReadyAction.h"

The Wait for Rolly World Ready node.

RollySaveStateTree

URollySaveStateTreeHandler

StateTree · derives from URollySaveAIStateHandler · #include "RollySaveStateTreeHandler.h"

Saves the StateTree components of the actor and, for an AI pawn, of its AI controller: their parameters, whether each tree runs, and the states it is in, which it enters again after a load. Tasks start again.

RollySaveGAS

URollySaveGASHandler

Gameplay Abilities · derives from URollySaveAIStateHandler · #include "RollySaveGASHandler.h"

Saves the actor’s Ability System Components: attribute base values, the abilities given to them, active gameplay effects with their remaining time, and loose gameplay tags, and sets them again after a load. Abilities active at the save do not resume.

RollySaveUI

URollySaveLoadingOverlay

Rolly Save Loading Overlay · derives from URollySaveCoreUIUserWidget · #include "Feedback/RollySaveLoadingOverlay.h"

The loading overlay: covers every player’s view from a load’s start until its values are set, with the loaded save’s picture, a progress bar, its title and place in the middle, and Loading with a spinner in a corner. It draws above the Rolly screens and stays through the map change, where the window keeps the last frame.

Parts a Blueprint layout can provide (by name): Backdrop (Border), Picture (Image), ProgressBar (Rolly Progress Bar), TitleText and LocationText (Text Blocks), Spinner (Rolly Spinner), StatusText (Text Block).

The parts a Blueprint layout binds, by the names of its widgets:

URollySaveProfileRow

Rolly Save Profile Row · derives from URollySaveCoreUIRow · #include "Profiles/RollySaveProfileRow.h"

A row of the profiles panel: a named profile’s name and, at its trailing end, Active with a check for the player’s own, or another local player’s badge and In use (the row then shows unavailable). The New Profile row has a plus before its name. Accept, a click or a tap chooses the row.

Parts a Blueprint layout can provide (by name), besides the core row’s: StateIcon (Rolly Icon), StateBadge (Rolly Player Badge), StateText (Text Block), PlusIcon (Rolly Icon).

The parts a Blueprint layout binds, by the names of its widgets:

URollySaveProfilesScreen

Rolly Save Profiles Screen · derives from URollySaveCoreUIPanelScreen · #include "Profiles/RollySaveProfilesScreen.h"

The profiles panel (Open Rolly Profiles, the slot screen’s profile chip) of Named profile keys: the named profiles, the player’s own marked Active, another local player’s shown unavailable with their badge and In use, then New Profile (or, at Max Named Profiles, a line that says so). Choosing a profile offers Use This Profile, Rename and Delete; New Profile asks for a name and switches to it. Deleting a profile also deletes its saves while each profile sees only its own, and says so first.

Replace the layout with a Blueprint subclass (Project Settings > Plugins > Rolly Save Screens > Profiles Screen Class): widgets named like the parts are driven by the panel (TitleText, MessageText for the explainer, ProfileList, LimitText, PromptBar).

The parts a Blueprint layout binds, by the names of its widgets:

URollySaveSavingIndicator

Rolly Save Saving Indicator · derives from URollySaveCoreUIUserWidget · #include "Feedback/RollySaveSavingIndicator.h"

The saving indicator: a plate in a corner of the saving player’s part of the screen, inside the safe area, that says Saving with a turning spinner, then Saved with a check, and Loading with the spinner while Rolly Save holds the player for ground. It draws over every player’s view, above the Rolly screens, and stays across map changes; the spinner turns only while it shows.

Parts a Blueprint layout can provide (by name): Plate (Border), Spinner (Rolly Spinner), DoneIcon (Rolly Icon), StatusText (Text Block).

The parts a Blueprint layout binds, by the names of its widgets:

URollySaveSlotRow

Rolly Save Slot Row · derives from URollySaveCoreUIRow · #include "Screens/RollySaveSlotRow.h"

A row of the slot screen: the save’s picture with its kind on the corner, its title on one line (an ellipsis cuts a long one), pills (Run, Ended, Imported, NG+ 2, a profile) and fields (place, play time) under it, and the save time at the trailing end. New, Empty, Import rows and a numbered slot another profile’s save takes show a placeholder and their words. An unavailable row (a newer version’s save, an ended run, saving blocked) keeps focus so its reason is read; while its own work runs, a spinner and the word take the save time’s place. Accept, a double click or a tap on the focused row chooses it.

Parts a Blueprint layout can provide (by name), besides the core row’s (BusySpinner, LeadingPicture and the others): KindPlate (Border), KindIcon (Rolly Icon), Pills (Horizontal Box), TimeText (Text Block).

The parts a Blueprint layout binds, by the names of its widgets:

URollySaveSlotScreen

Rolly Save Slot Screen · derives from URollySaveCoreUICategoryScreen · #include "Screens/RollySaveSlotScreen.h"

The slot screen: a player’s saves to save over, load, start a new game in or import, laid out in the Rolly layout the theme or Project Settings > Plugins > Rolly Save Core UI pick. Rows show each save’s picture, title, place, play time and save time; the detail shows the large picture and the facts. One list by default (no category navigation), or groups by kind or by profile.

Gamepad and keyboard: Accept saves, loads, continues or starts; X (F2) renames, or opens More while Copy or Export is on and on a run that goes on; Y (Delete) deletes after a question; RT (S) changes the order; LT (P) opens the profiles panel with Named profile keys; the right stick button (Ctrl+F) searches from Search From saves; B (Escape) goes back. A click focuses a row and a double click acts; a tap focuses and a tap on the focused row acts. Questions ask before anything that cannot be undone, and an answer acts only while its row still shows the save the question named.

Open it with Open Rolly Slot Screen, or let Save Points and Request Slot Screen open it. Replace the layout with a Blueprint subclass (Project Settings > Plugins > Rolly Save Screens > Slot Screen Class): widgets named like the parts are driven by the screen (the category screen’s, plus SortChip and ProfileChip), and rows come from Slot Row Class.

The parts a Blueprint layout binds, by the names of its widgets:

URollySaveUILibrary

Rolly Save UI Library · derives from UBlueprintFunctionLibrary · #include "RollySaveUILibrary.h"

The nodes that open and close Rolly Save’s slot screen and profiles panel, and preview the saving indicator.

URollySaveUISubsystem

Rolly Save UI Subsystem · derives from UGameInstanceSubsystem · #include "RollySaveUISubsystem.h"

Rolly Save’s screens for one game instance: it opens the slot screen when Save Points or Request Slot Screen ask (Show Slot Screen), and shows the saving indicator, notices and loading overlay as the game saves, loads and holds its players. Each piece is a class of its own that this subsystem hands the game’s events to. Not on dedicated servers.

RollySaveCore

URollySaveCoreInputDeviceSubsystem

Rolly Save Core Input Device Subsystem · derives from ULocalPlayerSubsystem · #include "Input/RollySaveCoreInputDeviceSubsystem.h"

Which input method one local player uses right now (keyboard and mouse, gamepad or touch) and which gamepad family its button prompts show. Every Rolly system reads it, so prompts, glyphs, the cursor and mouse hover follow the device the player holds.

A Slate input pre-processor feeds the player’s tracker (FRollySaveCoreInputDeviceTracker) and consumes nothing. A stick that drifts at rest never switches to the gamepad (Project Settings > Plugins > Rolly Save Core > Gamepad Analog Switch Threshold), and device names map to families through the Device Families table there. A game or a player setting can force a family (Set Gamepad Family Override), for pads the engine cannot identify.

RollySaveCoreUI

URollySaveCoreUIBackdrop

Rolly Backdrop · derives from URollySaveCoreUICanvasWidget · #include "Widgets/RollySaveCoreUIBackdrop.h"

The layer behind a screen, over the game: the theme’s Backdrop colour, its optional vertical gradient (Backdrop Gradient To), vignette and blur (Backdrop Blur, with the backdrop at 90 % where blur cannot run). It takes the pointer, so clicks never reach the game below. Transparent parts draw nothing. A plain widget: it never ticks.

URollySaveCoreUIButton

Rolly Button · derives from URollySaveCoreUIUserWidget · #include "Components/RollySaveCoreUIButton.h"

A button every input method works: it takes focus, Accept (the confirm face button, Enter, Space) presses it on key down, a click or tap presses it, and a pointer moving over it gives it focus while the player uses keyboard and mouse. Four variants: Primary (the Accent fill, for the main answer; keep one per screen), Secondary (outlined), Danger (outlined in the Danger colour, for destructive answers) and Quiet (no fill or outline). Focus shows the theme’s focus style; a pressed button shrinks a little. An optional icon sits before the label (a back arrow). While busy (Set Busy) it says “Working” beside a spinner and ignores presses.

The parts a Blueprint layout binds, by the names of its widgets:

URollySaveCoreUICanvasWidget

Rolly Save Core UICanvas Widget · derives from UWidget, abstract · #include "Widgets/RollySaveCoreUICanvasWidget.h"

Base of the plain Rolly widgets drawn in code (dividers, focus frames, progress bars, switches, sliders): a UMG widget over one Slate leaf that never ticks. Subclasses keep their state and hand the leaf a desired size and a painter whenever the state or the theme changes.

URollySaveCoreUICardTemplate

Rolly Save Core UICard Template · derives from URollySaveCoreUITemplate, abstract · #include "Templates/RollySaveCoreUICardTemplate.h"

The shared shape of the Centered Panel and the Side Drawer: everything in one raised card over the game, top to bottom an overline, the switcher, a hairline, the list, the detail strip and the prompts. A screen with one category that hides its navigation (Hide Single Category) shows its title in the Title role in the switcher’s place, without the overline. The subclasses place and size the card.

URollySaveCoreUICategoryNav

Rolly Save Core UICategory Nav · derives from URollySaveCoreUIUserWidget, abstract · #include "Navigation/RollySaveCoreUICategoryNav.h"

The base of the category navigations of the layout templates: tabs, the side rail, the switcher and the hub tiles. It holds the categories and the selected one and tells its owner what the player did; the owner decides what shows. Set Selected Category only moves the highlight and fires nothing.

• On Category Chosen: the player picked a category (a click, a tap, a switch key or a chevron). Show it.
• On Category Focused: focus moved onto a category inside the navigation (a rail item, a tile).
• On Category Opened: the player went into a category (Accept or Right on a rail item, Accept on a tile).

Subclass it for a navigation of your own; the category screen drives it through this interface.

URollySaveCoreUICategoryScreen

Rolly Save Core UICategory Screen · derives from URollySaveCoreUIScreen, abstract · #include "Screens/RollySaveCoreUICategoryScreen.h"

A screen of categories of rows, laid out in the layout template the theme or Project Settings name: a settings screen, and later a codex, a controls list, an options page. The screen builds its parts (title, category navigation, list, detail, footer) and puts them into the template’s named slots; the template arranges them for the area and says how they behave (Get Traits). Switching the template at run time keeps the category, the focused row and its level, and scrolls that row into view.

What it does for every product:

• Categories: tabs, a side rail, a switcher or hub tiles, per template; the previous and next category keys (the shoulder buttons, Q and E) from any level; a click or tap on a tab, rail item, chevron or tile.

• Levels: two-level templates (the rail, the hub) open on the categories; Accept (or Right on the rail) goes into the list and Back comes out of it. Back at the top level closes the screen, asking first while changes wait for Apply.

• Focus memory: each category remembers its focused row for the session; the list keeps focus in view.

• Detail: the focused row’s title, description, preview and facts, as a panel, a strip or a band.

• Footer: the count of changes waiting for Apply and prompts that follow the player’s device, dropping the least important ones when the footer runs out of room.

• Search: an entry in the header (the right stick button, Ctrl+F, a click or a tap) finds rows across categories by what the player types, on the on-screen keyboard for gamepad and touch players; results are the real rows, editable in place, and Accept goes to a row in its category.

• Products add footer prompts of their own (Collect Product Prompts), chips in the header that answer their keys (a Rolly Chip among the header’s actions), a line in the list’s place (Set List Message) and a texture as the detail’s preview.

A product derives from it and supplies the data: its categories (Collect Categories), a category’s rows (Build Rows), the focused row’s detail (Collect Detail), its searchable rows (Collect Search Entries, Build Search Row) and what Apply, Revert, Reset and Discard do. A Blueprint subclass with a designer layout of its own keeps working without a template: parts are bound by name and parts left out turn their feature off.

The parts a Blueprint layout binds, by the names of its widgets:

URollySaveCoreUIChip

Rolly Chip · derives from URollySaveCoreUIUserWidget · #include "Components/RollySaveCoreUIChip.h"

A header control that shows a choice and the key that changes it: an icon, a label (the sort order, the profile’s name) and the key of the player’s device (none for touch). Its key, a click or a tap fire On Chip Activated once. It keeps the width of its widest label, so it never moves as the label changes; a label wider than Max Label Width ends with an ellipsis. Compact shows the icon and the key only. Among a category screen’s header actions it answers its keys from anywhere on the screen. It takes no focus unless Set Chip Focusable says so (a layout whose header is reached by moving focus); focused, Accept activates it.

Parts a Blueprint layout can provide (by name): Background (Border), FocusFrame (Rolly Focus Frame), Icon (Rolly Icon), LabelText (Text Block), KeyGlyph (Rolly Glyph).

The parts a Blueprint layout binds, by the names of its widgets:

URollySaveCoreUIChoiceDialog

Rolly Choice Dialog · derives from URollySaveCoreUIPanelScreen · #include "Screens/RollySaveCoreUIChoiceDialog.h"

A question with any number of answers, as buttons in a row (right-aligned, wrapping when narrow; three answers take the wider panel) or in a column (a list of actions). Back answers the cancel answer. The core’s dialog has a confirm and a cancel button only; this one serves the questions that need more (Keep as Ended, Delete, Cancel) and lists of actions on a row.

URollySaveCoreUIDialog

Rolly Save Core UIDialog · derives from URollySaveCoreUIScreen · #include "Screens/RollySaveCoreUIDialog.h"

A question with a confirm and a cancel button over the screen below (dimmed by the Scrim, inactive). The safe answer (cancel) comes first and has focus unless the options say otherwise; Back answers it. An optional countdown answers by itself when it runs out, in real time (it keeps counting while the game is paused), with the seconds left in words and a bar that empties over the full time.

The parts a Blueprint layout binds, by the names of its widgets:

URollySaveCoreUIDivider

Rolly Divider · derives from URollySaveCoreUICanvasWidget · #include "Widgets/RollySaveCoreUIDivider.h"

A hairline in the Outline colour role between parts of a screen, horizontal or vertical.

URollySaveCoreUIDots

Rolly Save Core UIDots · derives from URollySaveCoreUICanvasWidget · #include "Widgets/RollySaveCoreUIDots.h"

A row of small dots, one per item, the current one in its own colour: a stepper’s options (Control) or a switcher’s categories (Accent). Other dots are Outline Strong, so the current one reads by position and shape of the row as well as colour. A plain widget: it never ticks.

URollySaveCoreUIDrawerTemplate

Rolly Side Drawer Template · derives from URollySaveCoreUICardTemplate · #include "Templates/RollySaveCoreUIDrawerTemplate.h"

The Side Drawer layout: a drawer 560 wide docked to the right (or left) edge, 24 units in, full height, over a backdrop that only darkens the game near it, so the game stays visible and keeps running (it never pauses). Inside: the overline, the switcher, the list (its rows stack), the detail strip and the prompts. Regular areas keep it at most 45 % of the width, Narrow ones make it max(480, 50 %), Tiny widths full width. In split screen it docks to the outer edge of the player’s part of the screen, and dialogs over it centre in the drawer.

URollySaveCoreUIEdgeFade

Rolly Edge Fade · derives from UContentWidget · #include "Widgets/RollySaveCoreUIEdgeFade.h"

Fades the edges of the Scroll Box it holds where more content continues: a gradient from the colour of what lies under the scroll box to transparent, so a cut-off tab or row reads as “there is more”. The fades follow the scroll position as it is drawn, without ticking. Rolly Lists fade their own edges; wrap other scroll boxes (a row of tabs) in this. A plain widget.

URollySaveCoreUIEditableText

Rolly Save Core UIEditable Text · derives from UWidget · #include "Widgets/RollySaveCoreUIEditableText.h"

The line a physical keyboard types into, inside a Rolly Text Field: the engine’s editable text (with the platform’s input method editor for languages typed through one), without its blinking caret, which the field replaces with a still one. The field drives it; layouts rarely need it on its own.

URollySaveCoreUIFocusFrame

Rolly Focus Frame · derives from URollySaveCoreUICanvasWidget · #include "Widgets/RollySaveCoreUIFocusFrame.h"

Draws the theme’s focus indicator around the widget it covers (a layer over the element): a ring in the Focus colour that follows the element’s corners (the Ember default, and always in high contrast), a bar at the leading edge, or four corner brackets. The Fill style is drawn by the element itself (its background turns Accent). Shown only while the element has focus.

URollySaveCoreUIGlyph

Rolly Glyph · derives from UWidget · #include "Glyphs/RollySaveCoreUIGlyph.h"

A key or gamepad button drawn as a cap: keyboard keys and mouse buttons as rounded keys, face buttons as circles (Xbox and Nintendo letters, the PlayStation shapes drawn), shoulders, triggers and system buttons as pills, directions as drawn icons. Labels use the KeyCap text role. The theme’s Glyph Overrides replace single keys. A keyboard key prints what it types on the keyboard layout in use and follows a layout change. A plain widget: it never ticks.

URollySaveCoreUIHost

Rolly Save Core UIHost · derives from URollySaveCoreUIUserWidget · #include "Screens/RollySaveCoreUIHost.h"

Holds one local player’s screens, one above the other. While a menu screen is open it keeps the player’s input away from the game: keys and sticks the screens do not use stop here instead of reaching the game, and the pointer cannot click through. It also catches Back when focus fell back to it, and tells the stack when something removed it from the screen (a map change, Remove All Widgets), so the stack can close and put input back.

Its toast layer shows the player’s toasts above the screens, also while no screen is open.

While menu narration speaks through the player’s screen reader, the host hides its screens from that screen reader, so the screen reader does not read each focused element a second time beside the narration’s lines.

The parts a Blueprint layout binds, by the names of its widgets:

URollySaveCoreUIHubTemplate

Rolly Couch Hub Template · derives from URollySaveCoreUITemplate · #include "Templates/RollySaveCoreUIHubTemplate.h"

The Couch Hub layout: big targets and big type (Large density by default). Two levels, one at a time: the hub, a grid of category tiles with live summaries (4, 3 or 2 columns by width, a list on Tiny widths), and a page per category with an “All settings” link, the category’s name, the previous and next keys with “1 / 7”, the list, a preview column on Wide areas and a description band above the prompts. Accept on a tile opens its page; Back returns to the tile.

A page shorter than a Tall area at its density (800 units at Standard, 1040 at Large) is compact, so its list keeps room for rows: the category’s name in the Title role (the “All settings” link only for touch), a band of one line without facts, one line of prompts and half the gaps between them. On Tiny heights a page also drops its title (the switcher keeps the position), shows a strip instead of the band, lays its rows on the backdrop without a panel, drops the option dots, keeps a quarter of the gaps and names Back “Back”, so a stacked row still shows whole.

A screen with one category that hides its navigation (Hide Single Category) has no hub level: its page opens with the screen’s title and without the “All settings” link, the position or the keys, and Back closes the screen.

URollySaveCoreUIIcon

Rolly Icon · derives from UWidget · #include "Icons/RollySaveCoreUIIcon.h"

An icon drawn in code (chevrons, check, close, arrows, info, warning, lock, restart, the PlayStation shapes, the directional pad and sticks) in a colour role. A plain widget: it never ticks. The theme’s Icon Overrides can replace any icon with your own brush.

URollySaveCoreUIInlineText

Rolly Save Core UIInline Text · derives from UWidget · #include "Widgets/RollySaveCoreUIInlineText.h"

A title in bold that runs on into its text, in the Body role: “Music Raises or lowers the soundtrack.” The detail strip of narrow layouts uses it, limited to one or two lines that end with an ellipsis; the full text shows elsewhere. Markup characters in the text are shown as they are. A plain widget: it never ticks.

URollySaveCoreUIKeyboard

Rolly Keyboard · derives from URollySaveCoreUIUserWidget · #include "Widgets/RollySaveCoreUIKeyboard.h"

The on-screen keyboard for players without a physical keyboard (a gamepad, or touch on a computer). Its letter rows follow the interface language (Rolly Save Core UI Keyboard Layouts), with the digits on top and the function keys at the bottom. It types into a Rolly Text Field.

• Gamepad: the directional pad and the stick move between keys (no wrapping; between rows of different lengths to the nearest key), A types, X deletes (held, it repeats after 400 ms, then every 80 ms), Y types a space, LT is Shift (names), B ends typing (Set Done Button picks another button, which the Done key then shows).
• Mouse and touch: click or tap a key (touch on release).
• Keys are 64 x 56 units, 8 apart; a narrow area narrows them (never under 44, the gap then 4), and Tiny heights make them 44 high.

Parts a Blueprint layout can provide (by name): Panel (Border), KeyRows (Vertical Box the character rows go into), FunctionRow (Horizontal Box the function keys go into).

The parts a Blueprint layout binds, by the names of its widgets:

URollySaveCoreUIKeyboardKey

Rolly Save Core UIKeyboard Key · derives from URollySaveCoreUIUserWidget · #include "Widgets/RollySaveCoreUIKeyboardKey.h"

One key of the Rolly Keyboard: a character, or a function (Space, Delete, Clear, Done, Shift) with its word and, when it has room, the gamepad button that does it anywhere on the keyboard. Accept, a click or a tap (on release) presses it. The keyboard lays the keys out and moves focus between them.

Parts a Blueprint layout can provide (by name): Background (Border), FocusFrame, LabelText (Text Block), Glyph (Rolly Glyph).

The parts a Blueprint layout binds, by the names of its widgets:

URollySaveCoreUILibrary

Rolly Save Core UILibrary · derives from UBlueprintFunctionLibrary · #include "RollySaveCoreUILibrary.h"

Blueprint nodes that open and close Rolly screens for a player (the player of the given player controller; a split-screen game passes each player’s own). They reach the player’s screen stack, which manages focus, input, the cursor and the pause.

URollySaveCoreUIList

Rolly List · derives from UScrollBox · #include "Widgets/RollySaveCoreUIList.h"

A vertical list of rows styled by the theme: a thin scroll thumb in Surface Sunken (Text Muted under the pointer, Control while dragged) that shows only when the list overflows, no edge shadows but a 24-unit fade at each edge where more rows continue, and focus that stays in view with a row to spare above and below where the list is tall enough (focus the pointer gives only with Project Settings > Rolly Save Core UI > Scroll Lists on Hover). A fade never covers the focused row, so its focus ring shows whole even in a list one row tall. It scrolls to the focused row with an animation, or jumps there with reduced motion. The list itself never takes focus; its rows do.

URollySaveCoreUIListMessageWidget

Rolly List Message · derives from URollySaveCoreUIUserWidget · #include "Components/RollySaveCoreUIListMessage.h"

Shows a list message (Set Message) centred in the place it is given, in the Body role and Text Muted: an icon or, while busy, a spinner before the text, and an optional button under it; a long text wraps within the place’s width. A busy message waits Busy Delay before it shows; one that takes the place of a message already shown shows at once. A category screen puts one over its list (Set List Message); any screen can use one for a list of its own.

Parts a Blueprint layout can provide (by name): Spinner (Rolly Spinner), MessageIcon (Rolly Icon), MessageText (Text Block), ActionButton (Rolly Button).

The parts a Blueprint layout binds, by the names of its widgets:

URollySaveCoreUINameDialog

Rolly Name Dialog · derives from URollySaveCoreUIPanelScreen · #include "Screens/RollySaveCoreUINameDialog.h"

A question for a short text (a profile’s name, a save’s title): a text field with its counter and error line, the on-screen keyboard for gamepad and touch players (keys narrowed to the panel), then Cancel and the confirm button.

• A physical keyboard types into the field with the text selected; a pad or a finger types on the keyboard, whose name mode capitalizes the first letter and each one after a space (Shift flips the next one).
• Errors from the validator show under the field as the player types (“Type a name.”); while one shows, the confirm button is dimmed, and Enter, Done or Accept on it play the Error sound and say the error.
• Enter, the keyboard’s Done key (the menu button on a pad) and the confirm button confirm. Escape and B cancel, except while a dialog that starts on Confirm is typing: there they end the typing, keep the text and go back to the confirm button.
• Control characters, brackets and quotes never type, and the text never grows past its longest. Languages typed without keys (Chinese, Japanese, Korean) show “Connect a keyboard to type.” to a pad player instead of the keyboard.
• Tiny areas drop the title, and so do areas under 800 units high while the on-screen keyboard shows.

Parts a Blueprint layout can provide (by name), besides the panel’s: NameField (Rolly Text Field), Keyboard (Rolly Keyboard), NoKeyboardText (Text Block), CancelButton and ConfirmButton (Rolly Buttons).

The parts a Blueprint layout binds, by the names of its widgets:

URollySaveCoreUINarrationProvider

Rolly Save Core UINarration Provider · derives from UObject, abstract · #include "Narration/RollySaveCoreUINarrationProvider.h"

The game’s own voice for menu narration: recorded lines, a speech engine of your own, a platform service. Make a Blueprint subclass, implement Speak, Stop and Is Speaking, and name it in Project Settings > Rolly Save Core UI > Narration Provider Class. Narration then offers it as the Game Voice and picks it under Auto when no screen reader runs and no Windows voice or engine speech exists. One provider serves every local player of the game.

URollySaveCoreUINarrationSubsystem

Rolly Save Core UINarration Subsystem · derives from UGameInstanceSubsystem · #include "Narration/RollySaveCoreUINarrationSubsystem.h"

Menu narration for every Rolly screen of the game: it reads what the player focuses, values as they change, screens and dialogs as they open, and messages, through one voice for the whole game. The player’s choices (on or off, voice, speed, volume, Full or Brief) are the shared narration console variables, so every installed Rolly product follows them; a product’s player settings write them, and so can a game (Rolly Save Core Accessibility). While the screen reader speaks the lines, each player’s host hides its screens from it, so nothing is read twice.

Voices, picked by the choice (Auto takes the first that works here):

• Screen Reader: the player’s own screen reader (Narrator, NVDA, JAWS, VoiceOver), with its voice and speed.
• Windows Voice: an installed Windows voice played through the game’s audio (Windows).
• Built-in Voice: the engine’s Text To Speech plugin, while the project enables it.
• Game Voice: the project’s own provider (Project Settings > Rolly Save Core UI > Narration Provider Class).

Players repeat the focused item, or stop the voice, with the left stick button, Ctrl+Space (Ctrl alone stops), the middle mouse button or a two-finger tap, on any Rolly screen while narration is on.

URollySaveCoreUIPanelScreen

Rolly Panel Screen · derives from URollySaveCoreUIScreen, abstract · #include "Screens/RollySaveCoreUIPanelScreen.h"

A dialog-width panel over the Scrim, centred in the player’s part of the screen (in the drawer over a side drawer), with a title and an optional message: the base of panels and questions over a screen (a profiles panel, the choice and name dialogs). The screen below stays visible, dimmed.

Width: the theme’s Dialog Width (Wider Panel Width for a question with three answers), never wider than the area less 48 units (24 on short narrow areas); on tiny areas it fills the area less the tiny margins. Height: never taller than the area less the same margins; a list a subclass adds with a filling slot scrolls inside.

Parts a Blueprint layout can provide (by name): Backdrop (Border), Panel (Border), TitleText and MessageText (Text Blocks).

The parts a Blueprint layout binds, by the names of its widgets:

URollySaveCoreUIPanelTemplate

Rolly Centered Panel Template · derives from URollySaveCoreUICardTemplate · #include "Templates/RollySaveCoreUIPanelTemplate.h"

The Centered Panel layout: a card 880 wide in the middle of a dimmed game, 85 % of the area tall and at most 820, the same for every category (the list scrolls inside, and a short category leaves room above the detail strip): the overline, the switcher with position dots, the list, the detail strip and the prompts. One level. Narrow areas give the card all but 24 units a side, Tiny widths all but 12; short areas make it all but 24 units tall with a lower switcher.

URollySaveCoreUIPlayerBadge

Rolly Save Core UIPlayer Badge · derives from URollySaveCoreUICanvasWidget · #include "Widgets/RollySaveCoreUIPlayerBadge.h"

Says whose screen this is in split screen: “P1” to “P4” on the player’s colour (the theme’s Player Colours), a pill 28 units high. The number is always there, so colour is never the only cue. Screens show it while more than one local player exists. A plain widget: it never ticks.

URollySaveCoreUIPointerButton

Rolly Pointer Button · derives from UButton · #include "Widgets/RollySaveCoreUIPointerButton.h"

A button only the pointer presses (mouse or touch): it never takes focus, so the row or control around it keeps focus and gamepads and keyboards reach the same action through it (left, right, Accept). Used for the chevrons of a stepper and the key cells of a key list. It shows the theme’s Hover Fill under the pointer and Focus Fill while pressed, in a radius role.

URollySaveCoreUIPortal

Rolly Portal · derives from UWidget · #include "Widgets/RollySaveCoreUIPortal.h"

Draws another widget here without moving it in the widget tree (the widget lives on a Rolly Shelf): a layout shows a part in one place or another, or in a template’s named slot, and the part keeps its Slate widgets and their state (scroll position, focus, running motion). A widget is drawn by one portal at a time: pointing a portal at a widget another portal draws takes it from there.

URollySaveCoreUIProgressBar

Rolly Progress Bar · derives from URollySaveCoreUICanvasWidget · #include "Widgets/RollySaveCoreUIProgressBar.h"

A thin bar that fills from the left: countdowns, timeouts, progress. A Surface Sunken track with an Accent fill by default, rounded at both ends. A plain widget: it never ticks; its owner sets the fraction.

URollySaveCoreUIProgressRing

Rolly Progress Ring · derives from URollySaveCoreUICanvasWidget · #include "Widgets/RollySaveCoreUIProgressRing.h"

A ring that fills clockwise from the top: hold prompts, cooldowns, progress the player caused. An Outline track and an Accent fill, 3 units thick by default. A plain widget: it never ticks; its owner sets the fraction (the fill is information, so it moves with reduced motion too).

URollySaveCoreUIPrompt

Rolly Prompt · derives from URollySaveCoreUIUserWidget · #include "Components/RollySaveCoreUIPrompt.h"

A button prompt: the key or button of an action and what it does (“A Select”), in the device family the player uses; an action with a pair of keys shows both (“LB RB Category”). A click or tap does the same as the key, so a footer of prompts doubles as pointer buttons. An unavailable prompt stays in place, dimmed, so players learn the controls and the footer does not jump. While the player uses touch it becomes a labelled button without keys.

The parts a Blueprint layout binds, by the names of its widgets:

URollySaveCoreUIPromptBar

Rolly Prompt Bar · derives from URollySaveCoreUIUserWidget · #include "Components/RollySaveCoreUIPromptBar.h"

The prompt bar of a screen’s footer: a Rolly Prompt per entry, in the order given (Back last), 24 units apart, right-aligned, wrapping to a second line when the area is narrow. Given the width it may use (Set Available Width), it wraps at that width and, when the prompts still need more lines than it may use, drops the prompts of lowest priority first (never those marked Always Shown). Each prompt keeps the width of its widest Reserved Label, and an entry marked Keep Place holds its place while its label is empty, so a screen that lists every prompt it uses keeps each prompt where it is. It follows the owning player’s device on its own: keyboard keys for keyboard and mouse, the buttons of the player’s gamepad family for a pad, labelled buttons without keys for touch. A click or tap on an available prompt fires On Prompt Clicked with the prompt’s Id, so the bar doubles as pointer buttons.

Give it prompts with Set Prompts whenever what they say or allow changes; prompts that keep their Id keep their widget, so the pointer’s hover and the bar’s layout stay calm.

The parts a Blueprint layout binds, by the names of its widgets:

URollySaveCoreUIRail

Rolly Rail · derives from URollySaveCoreUICategoryNav · #include "Navigation/RollySaveCoreUIRail.h"

The side rail of the Side Rail layout: every category in a column, the selected one marked with a bar. The rail is the first of two levels: while it has focus, up and down move between categories (wrapping with the theme’s Wrap Navigation) and the owner shows the focused one once focus rests; Accept or Right goes into the list (On Category Opened). A click selects a category; hovering never does. It scrolls when the categories do not fit.

The parts a Blueprint layout binds, by the names of its widgets:

URollySaveCoreUIRailItem

Rolly Rail Item · derives from URollySaveCoreUIUserWidget · #include "Navigation/RollySaveCoreUIRailItem.h"

A category of the side rail: its icon and name in the Tab role, wrapping to two lines. The selected category has a Surface Raised fill and an Accent bar at its leading edge; the focused one also shows the theme’s focus style; a category with changes waiting for Apply shows a Pending dot at its trailing edge. It takes focus while the rail has it: up and down move between items (wrapping with the theme’s Wrap Navigation), Accept and Right go into the category, a click selects it. The pointer resting on it never selects it.

The parts a Blueprint layout binds, by the names of its widgets:

URollySaveCoreUIRailTemplate

Rolly Side Rail Template · derives from URollySaveCoreUITemplate · #include "Templates/RollySaveCoreUIRailTemplate.h"

The Side Rail layout: every category in a rail at the left, the list in the middle with the category’s name above it, the detail at the right, in a centred block at most 1976 wide. Two levels, both visible: focus opens in the rail, Accept or Right goes into the list, Back returns to the rail. Regular widths narrow the rail to 260 and move the detail under the list; Narrow widths turn the rail into a switcher over the list (one level). Short areas drop the title and use 48-unit rail items. A screen with one category that hides its navigation (Hide Single Category) shows no rail and has one level: the title over the list, and on Wide areas the list and the detail share the block.

URollySaveCoreUIRegion

Rolly Region · derives from UContentWidget · #include "Widgets/RollySaveCoreUIRegion.h"

The region a layout template lays its body out in: all the room it gets, at most Max Aspect times as wide as high and centred on wider screens (the backdrop fills the rest), and never smaller than Floor Size: in less room the body lays out at that size and is scaled down to fit, the only case where text gets smaller. It works from the room it really gets, inside the safe zone.

URollySaveCoreUIRow

Rolly Save Core UIRow · derives from URollySaveCoreUIUserWidget, abstract · #include "Components/RollySaveCoreUIRow.h"

One line of a list: a name on the left, a value on the right. Rows take focus (up and down move between them); left and right change the value by one step; Accept (the confirm face button, Enter, Space) does the row’s action; a click or tap on the row acts when it is released over the row. A press that moves more than 12 units first is a drag: it scrolls the list and changes nothing, and rows never capture the pointer on a press, so a finger can scroll a list of rows. Moving the pointer over a row focuses it while the player uses keyboard and mouse; a cursor at rest never does.

States, each told apart by shape or icon as well as colour: hover (the Hover Fill), focus (the theme’s focus style: in Ember a ring and the Focus Fill; hidden while the player uses touch), unavailable (Text Disabled and a lock after the name, no hover fill; it stays focusable so its reason can be read), pending (a dot in the leading space), restart needed and error (an icon after the name). A preview draws its current row focused without it holding focus (Set Shown As Focused).

Narrow lists stack their rows: the name on top, the control below across the row. Kinds whose control stays beside the name (a switch) say so with Can Stack.

Busy (Get Row Busy Text): while the row’s own work runs (a save, a delete), a spinner and the busy text take the value’s place and the row refuses Accept, steps, clicks and taps. A leading picture (Set Leading Picture: a save’s thumbnail) sits before the name at Leading Picture Size, with a placeholder until the texture comes; the row never changes height when it does. The busy and picture parts of the default layout are made the first time a row needs them.

Subclass it for a kind of value: build the value widget in BuildValueWidget, draw it in RefreshValue and ApplyValueStyle, and answer HandleStep, HandleAccept, HandleRowClicked and HandleRowTapped. Parts a Blueprint layout can provide (by name): Background (Border), FocusFrame (Rolly Focus Frame), PendingDot and StatusIcon (Rolly Icons), NameText (Text Block), ValueBox (Size Box that holds the value widgets), BusySpinner (Rolly Spinner), BusyText (Text Block), LeadingPicture (Image), LeadingPlaceholder (Border) and LeadingPictureIcon (Rolly Icon).

The parts a Blueprint layout binds, by the names of its widgets:

URollySaveCoreUIScreen

Rolly Save Core UIScreen · derives from URollySaveCoreUIUserWidget, abstract · #include "Screens/RollySaveCoreUIScreen.h"

A screen on a local player’s screen stack (Rolly Save Core UI Stack Subsystem): a product’s screens (the settings screen), dialogs, and screens of your own (make a Blueprint subclass and open it with Push Rolly Screen). The stack shows the top screen, gives it focus and the player’s input, handles Back, pauses when the screen asks for it and puts input back when the last screen closes, whichever way it closes.

Back (Escape, the gamepad’s back face button) closes the screen by default; override On Back to ask first or to refuse. Focus goes to the widget Get Focus Target names (the layout’s Desired Focus Widget, else the screen). A screen fades in and rises a little when it opens (no movement with reduced motion).

URollySaveCoreUIShadow

Rolly Shadow · derives from UContentWidget · #include "Widgets/RollySaveCoreUIShadow.h"

A soft shadow under what it holds (a card, a drawer, a dialog, a toast), in the theme’s Shadow Colour, drawn from a texture made in code. Wrap the panel in it: the shadow reaches outside the panel’s bounds without taking room. High contrast draws no shadow (panels get outlines instead). A plain widget: it never ticks.

Elevation levels: 0 and 1 draw nothing (rows, panels on a backdrop); 2 is for dialogs, cards and drawers over the game; 3 for toasts and popups.

URollySaveCoreUISharedSubsystem

Rolly Save Core UIShared Subsystem · derives from UGameInstanceSubsystem · #include "Stack/RollySaveCoreUISharedSubsystem.h"

What the screen stacks of all local players share: the game’s input while screens are open (an input handler you can replace) and the pause. One per game instance, never on a dedicated server. The players’ stacks (Rolly Save Core UI Stack Subsystem) use it; games rarely need it directly.

URollySaveCoreUIShelf

Rolly Shelf · derives from UPanelWidget · #include "Widgets/RollySaveCoreUIShelf.h"

Keeps widgets in a widget tree without drawing them: they stay bound by name, alive and found by Find Widget, while Rolly Portals draw them wherever a layout wants them (a template’s slot, one of two places).

Why: moving a widget from one panel to another makes UMG release its Slate widgets, and when something still holds them at that moment (the input event that caused the move holds the focused widget’s path) the widget is left without its Slate objects and stops updating. A widget on a shelf never changes panel; portals move only what is drawn, and the widget keeps its state (scroll position, focus, running motion).

URollySaveCoreUIShowDialogAction

Rolly Save Core UIShow Dialog Action · derives from UBlueprintAsyncActionBase · #include "RollySaveCoreUILibrary.h"

Shows a dialog and waits for the answer: Confirmed or Cancelled fires once (Back and a close from outside count as Cancelled).

URollySaveCoreUISlider

Rolly Slider · derives from URollySaveCoreUICanvasWidget · #include "Widgets/RollySaveCoreUISlider.h"

The track of a slider value: a thin pill track, a Control fill from the minimum (or from zero for a range across zero) and a round knob; while its row has focus the knob gets a ring in the Focus colour. The pointer drags it (the whole height the row gives it is the hit area). A plain visual: it never takes focus, and the row around it owns the keys and turns track positions into values.

URollySaveCoreUISpinner

Rolly Spinner · derives from URollySaveCoreUICanvasWidget · #include "Widgets/RollySaveCoreUISpinner.h"

Shows that something the player started is running (Auto-Detect, a save): a quarter arc turning once a second. With reduced motion it stands still as a partial ring; say “Working” beside it (Rolly Button’s busy state does). It animates only while it is shown, through a Slate active timer that a hidden or collapsed spinner does not keep, so it costs nothing until shown. A plain widget: it never ticks.

URollySaveCoreUIStackSubsystem

Rolly Save Core UIStack Subsystem · derives from ULocalPlayerSubsystem · #include "Stack/RollySaveCoreUIStackSubsystem.h"

One local player’s screen stack: the screens the player has open, one above the other. Get it with Get Rolly Screen Stack from a player controller, or use the Rolly Save Core UI nodes (Push Rolly Screen, Show Rolly Dialog and the others).

• Push, Pop, Replace, Close and Back work on the stack; Back asks the top screen first.
• The top screen has focus and the player’s input. Screens below are hidden, or dimmed behind a dialog. Split-screen players each have their own stack in their part of the screen.
• When the first screen opens, the game’s input and the cursor are recorded; when the last one closes they come back, whichever way it closed: Back, a close call, a map change, the widgets being removed, the player leaving (the input handler of the Rolly Save Core UI Shared Subsystem decides the details).
• Screens that ask for it pause a standalone game (never a networked one).
• A map change or the widgets being removed close every screen; On External Close tells products first, so a question that must outlive the screens (the settings’ keep-or-revert) can step aside without answering.

URollySaveCoreUISurface

Rolly Surface · derives from UBorder · #include "Widgets/RollySaveCoreUISurface.h"

A panel styled by the theme: a fill colour role, a corner radius role and an optional outline, drawn in code (no texture). It restyles by itself when the theme changes, and in high contrast every filled surface gets a 2-unit outline. Use it for panels, cards, plates and backdrops; the Brush of the border is overwritten by the roles.

URollySaveCoreUISwitch

Rolly Switch · derives from URollySaveCoreUICanvasWidget · #include "Widgets/RollySaveCoreUISwitch.h"

The switch of an on/off value: a pill track with a round knob. On: a Control track with an On Accent knob at the right; off: a Surface Sunken track with a Text knob at the left. The knob slides in Duration Fast (it jumps with reduced motion). A plain visual: the row around it owns focus and input.

URollySaveCoreUISwitcher

Rolly Switcher · derives from URollySaveCoreUICategoryNav · #include "Navigation/RollySaveCoreUISwitcher.h"

Shows one category at a time and switches to the previous or next one: the switch keys of the player’s device at the ends, chevrons either side of the category’s name in the Title role, and a dot per category below (the current one Accent), or “3 / 14” past twelve categories. The chevrons are clickable and tappable; the owner switches with its keys through Choose Category. It never takes focus, so the list below keeps it. Height 72, 56 in short areas.

The parts a Blueprint layout binds, by the names of its widgets:

URollySaveCoreUITab

Rolly Tab · derives from URollySaveCoreUIUserWidget · #include "Navigation/RollySaveCoreUITab.h"

A tab of a tab bar: a category’s name in the Tab text role, Text Muted until it is the selected one, which turns Text with an Accent underline (a shape as well as a colour). Tabs never take focus, so up and down stay in the list; they change with their screen’s keys (the shoulder buttons, Q and E), a click or a tap.

The parts a Blueprint layout binds, by the names of its widgets:

URollySaveCoreUITabStrip

Rolly Tab Strip · derives from URollySaveCoreUICategoryNav · #include "Navigation/RollySaveCoreUITabStrip.h"

A strip of tabs: a Rolly Tab per category, the selected one underlined, and the keys that switch tabs (the shoulder buttons, Q and E) at both ends, drawn for the owning player’s device. When the tabs do not fit, they scroll sideways, keep the selected tab in view with room to spare and fade out at an edge where more tabs continue, while the keys stay at the ends.

Tabs never take focus, so up and down stay in the owner’s list. The owner switches tabs with its keys (Select Previous Tab, Select Next Tab); the player can also click or tap a tab. Both fire On Tab Selected (and On Category Chosen), and the owner answers by showing that tab’s content. Set Selected Tab only moves the highlight.

When TabScroll (or TabFade around it) sits in a Horizontal Box, the strip sizes it to its tabs while they fit and lets it shrink and scroll when they do not; it applies that rule whenever it is built or its properties are synchronised, so a Blueprint layout keeps it.

The parts a Blueprint layout binds, by the names of its widgets:

URollySaveCoreUITabsTemplate

Rolly Tabs Template · derives from URollySaveCoreUITemplate · #include "Templates/RollySaveCoreUITabsTemplate.h"

The Tabs layout: everything at once. A centred column at most 1640 wide: the title and restart notice, tabs across the top over a hairline, the list with the detail panel at its right (a strip under the list below 1600 units), and the footer. One level: focus stays in the list. Short areas drop the title; Tiny heights get lower tabs; Narrow widths give the value 45 % of a row. A screen with one category that hides its navigation (Hide Single Category) shows no tab row: the body starts 24 below the title line. The default for new projects.

URollySaveCoreUITemplate

Rolly Save Core UITemplate · derives from URollySaveCoreUIUserWidget, abstract · #include "Templates/RollySaveCoreUITemplate.h"

A layout template: the arrangement of a category screen’s regions, as named slots the screen puts its parts into. Backdrop covers the whole area; everything else sits inside the safe zone, in a centred region at most 21:9 wide, laid out at 640 x 360 and scaled down below that floor. The slots: Backdrop, Header, Navigation, Content, Detail, Footer, and Preview (the Couch Hub’s preview column).

A template decides, per area and level, which navigation shows and how the detail, the title and the footer look (Get Traits), and arranges its slots (Arrange). Five ship: Tabs, Side Rail, Centered Panel, Couch Hub and Side Drawer, picked by id in Project Settings or the theme. Rearrange one in the UMG designer with a Blueprint subclass that places named slots of the same names (and adjusts in On Arrange), then pick it for its id in Project Settings > Rolly Save Core UI > Template Classes.

URollySaveCoreUIText

Rolly Text · derives from UTextBlock · #include "Widgets/RollySaveCoreUIText.h"

A text block styled by the theme: it takes its font, size, letter spacing, case and line height from a text role and its colour from a colour role, and restyles by itself when the theme, high contrast or the density change. Use it wherever a Rolly screen shows text; the Font and Color and Opacity of the text block are overwritten by the roles.

URollySaveCoreUITextField

Rolly Text Field · derives from URollySaveCoreUIUserWidget · #include "Widgets/RollySaveCoreUITextField.h"

A one-line text field in the Rolly look: a sunken box with an optional search icon, the text or a placeholder, a still caret while it is active, and at its trailing end the key that opens it (while empty and inactive) or a clear button. A physical keyboard types into it (with the platform’s input method editor), and the Rolly Keyboard types into it for gamepad and touch players. Search uses it; so can screens of your own (profile names, a seed, a filter).

States: default; hover (Hover Fill); focused (the theme’s focus style, where the field takes focus as an entry); active (typing: a 2-unit outline in Text and the caret, no focus ring); error (a 2-unit Danger outline and the error line under it). The caret does not blink.

Parts a Blueprint layout can provide (by name): Box (Border), FocusFrame, LeadingIcon (Rolly Icon), Editable (Rolly Editable Text), Placeholder (Text Block), Caret (Border), KeyGlyph, SecondKeyGlyph (Rolly Glyphs), ClearButton (Rolly Button), CounterText and ErrorText (Text Blocks).

The parts a Blueprint layout binds, by the names of its widgets:

URollySaveCoreUITheme

Rolly Save Core UI Theme · derives from UDataAsset · #include "Theme/RollySaveCoreUITheme.h"

The Rolly UI theme: every colour, font, size, shape, motion and sound the Rolly widgets draw with. Widgets ask the theme for roles (Surface, Accent, the Title text role), never for literal values, so one asset restyles every screen of every Rolly product, live.

The class defaults are the Ember preset (Rolly Save Core UI Presets has the others): the brand palette (near-black 0F1012, off-white F0EFF2, orange FF6000), with the orange kept small (focus, primary actions, selection). To change the look, create a data asset of this class (Content Browser > Miscellaneous > Data Asset), edit its tokens and assign it in Project Settings > Plugins > Rolly Save Core UI > Theme; it is always cooked. Saving the asset checks it: contrast pairs, text sizes and focus width, each with its fix.

Token names are persistent and append only: new tokens can be added, none renamed or removed.

URollySaveCoreUIThemeAware

Rolly Theme Aware · derives from UInterface, abstract · #include "Theme/RollySaveCoreUIThemeListenerExtension.h"

For widgets of your own that follow the Rolly theme: add this interface in a Widget Blueprint’s Class Settings and call Listen To Rolly Theme once (in Event Pre Construct), and On Rolly Theme Changed runs whenever the theme, its contrast, density or motion change while the widget is on screen, and once more when it shows again after a change. Read the theme there with Get Rolly Theme Color and the other nodes.

URollySaveCoreUIThemeLibrary

Rolly Save Core UITheme Library · derives from UBlueprintFunctionLibrary · #include "Theme/RollySaveCoreUIThemeLibrary.h"

Blueprint nodes for widgets of your own that match the Rolly theme: read a colour, a font or the motion scale by role, make a surface brush, and listen for theme changes. Values follow high contrast and the density in effect.

URollySaveCoreUIThemeListenerExtension

Rolly Theme Listener · derives from UUserWidgetExtension · #include "Theme/RollySaveCoreUIThemeListenerExtension.h"

Lets any Widget Blueprint follow the Rolly theme without polling: while the widget is on screen it calls On Rolly Theme Changed on the widget (when the widget has the Rolly Theme Aware interface) and fires On Theme Changed, once per change. Add it with Listen To Rolly Theme. It never ticks.

URollySaveCoreUIThemeSubsystem

Rolly Save Core UITheme Subsystem · derives from UEngineSubsystem · #include "Theme/RollySaveCoreUIThemeSubsystem.h"

The theme every Rolly widget draws with, for all local players (one look, one layout, one density, one contrast, one motion setting). It resolves the theme of Project Settings > Plugins > Rolly Save Core UI: by default the theme every installed Rolly product shares (rolly.ui.theme while it is set, else the project’s [RollyUI] Theme, else the built-in Ember), another product’s theme copied through the reflection bridge. It raises one event when anything changes: another theme or preset, an edit of the theme asset in the editor (Play In Editor restyles live), another layout or density, high contrast on or off, reduced motion on or off. Every Rolly widget listens and restyles itself without rebuilding; screens built on templates move into the new template.

High contrast and reduced motion follow the Rolly accessibility preferences (Rolly Save Core Accessibility), which live in the shared console variables rolly.ui.contrast and rolly.ui.motion, so every installed product follows them.

Previews (the editor’s theme preview, thumbnails) set a preview look for the object at their top: widgets under it draw with that look, the rest keep the game’s.

URollySaveCoreUITile

Rolly Tile · derives from URollySaveCoreUIUserWidget · #include "Navigation/RollySaveCoreUITile.h"

A category of the Couch Hub: a Surface card of the theme’s Tile Size with the category’s large icon at its top, and from its bottom up a live summary of two lines at the theme’s Tile Summary Size (“Fullscreen, 2560 x 1440”) and its name in the Title role. Changes waiting for Apply show a Pending dot and “1 change” at its top-right. Focus shows the theme’s focus style and grows the tile a little (not with reduced motion); a preview draws its current tile so without it holding focus (Set Shown As Focused). Accept, a click or a tap opens the category’s page. On Tiny widths it becomes a full-width entry of a list.

The parts a Blueprint layout binds, by the names of its widgets:

URollySaveCoreUITiles

Rolly Tiles · derives from URollySaveCoreUICategoryNav · #include "Navigation/RollySaveCoreUITiles.h"

The hub of the Couch Hub layout: a grid of category tiles with live summaries, the first of its two levels. The directional pad and stick move in the grid without wrapping; Accept, a click or a tap opens a category’s page (On Category Opened). Columns follow the width (the Couch Hub sets them: four on Wide areas, three on Regular, two on Narrow) and Tiny widths get a list. It scrolls when the tiles do not fit.

The parts a Blueprint layout binds, by the names of its widgets:

URollySaveCoreUIToast

Rolly Toast · derives from URollySaveCoreUIUserWidget · #include "Toasts/RollySaveCoreUIToast.h"

A message that appears for a while without stopping the player: a status icon (a check in Success, a warning in Warning, info in Accent) and up to three lines of text on a raised panel with a shadow. It never takes focus. It stays at least the theme’s Toast Seconds, longer for long text, and waits while the pointer is over it. Show one with Show Rolly Toast; the player’s toast layer places it.

The parts a Blueprint layout binds, by the names of its widgets:

URollySaveCoreUIToastLayer

Rolly Save Core UIToast Layer · derives from URollySaveCoreUIUserWidget · #include "Toasts/RollySaveCoreUIToastLayer.h"

Where a player’s toasts appear, newest on top, at most three, 8 units apart, above the player’s screens, inside the safe area. They keep out of the parts the shown screens report (a header, a drawer’s or a panel’s card), in the first of these places that overlaps none: the top right; the top centre of the widest part beside those parts, narrower when that part is (down to 240); otherwise just below the header at the top right. It keeps time in real time (toasts wait while the game is paused only if the player points at them) and holds a ticker registration only while toasts show.

The parts a Blueprint layout binds, by the names of its widgets:

URollySaveCoreUIUserWidget

Rolly Save Core UIUser Widget · derives from UUserWidget, abstract · #include "Components/RollySaveCoreUIUserWidget.h"

Base of every focusable or replaceable Rolly widget (screens, rows, buttons, tabs, prompts, dialogs).

• Default tree: the first time the widget initializes it builds its layout in C++, but only when it has no tree of its own. A Blueprint subclass with a designer layout keeps its layout, and its widgets named like the C++ parts (BindWidgetOptional) are driven by the C++ code; a part the layout leaves out turns that feature off.
• Theme: ApplyStyle runs before the widget shows, whenever the theme, high contrast or motion change while it is on screen, and when it shows again after a change. Parts are styled by roles, never by literal values, so a theme switch restyles the widget in place: nothing is rebuilt, focus and state stay.
• Input: it answers the Slate user of its local player, gives subclasses simple clicks and hover, plays the theme’s sounds, and focuses on hover only while the player uses keyboard and mouse.