Rolly Docs

Changelog

Sheet
03 of 03
Rev
0.1.0
Updated
On this sheet

Format: Keep a Changelog. Versions: SemVer in VersionName; bump the integer Version on every release.

[0.1.0] - Unreleased

Added

  • Plugin created from the Rolly template, with three modules: RollySettings (Runtime), RollySettingsUI (ClientOnly: the settings screen) and RollySettingsEditor (Editor), plus the shared core with the Rolly UI design system (RollySettingsCore, RollySettingsCoreUI, RollySettingsCoreEditor) under the product’s name. No content assets.

  • Setting kinds: Toggle, Choice (own options or options from the binding), Slider (range, step, display format and multiplier, and an optional logarithmic track for multipliers: equal track distances are equal ratios, the saved value and display unchanged; Blueprint Value To Track Position and Track Position To Value), Key Binding (stores and shows keys, or one Enhanced Input key through its binding), Key Mappings (no value; the player’s key list, Per Player only) and Action. Culture-invariant text form of every value, strict parsing, comparison on parsed values.

  • Bindings: the URollySettingBinding base (read, apply, default, support check, options, saved-elsewhere flag, store-for-next-start, has-saved-value, value proposals for Actions, finish-applying once per group, assets to cook; every call receives the player it works for and the values of the other settings of its scope as the player sees them, and GetWorld works during a call), Stored Only, and URollySettingCustomBinding for bindings written in Blueprint, with a Blueprint event for each call (Store Value For Next Start, Has Saved Value, Propose Values, Reset Values and Finish Applying included) and Get Other Setting Value. A Reset calls the binding of a setting without a value (ResetOwnValues, Blueprint Reset Values), so such a setting can reset the data it stands for.

  • Built-in engine bindings, all for Shared settings: Window Mode, Screen Resolution (options for the window mode and monitor the player has chosen, before Apply too), Monitor (the 5.8 display API), VSync, Frame Rate Limit, Resolution Scale (engine presets, Default resets the screen percentage), HDR Output and HDR Brightness (paper white), Overall Graphics Quality (Custom detected by Rolly Settings), Scalability Group (the 11 groups), Anti-Aliasing Method and Console Variable (Game Override priority; Default removes the player’s choice), Graphics Auto-Detect (proposes values that wait for Apply), Brightness (display gamma), Main Volume (main submix; when a game instance ends, each device gets back the main volume in effect before it, also when game instances share a device), Sound Class Volume (a runtime sound mix with class overrides, owned by the new URollySettingsAudioSubsystem), Subtitles, Colour Vision Deficiency and its severity, UI Scale (UUserInterfaceSettings::ApplicationScale). Unsupported settings hide themselves (no HDR display, one monitor, a fixed-resolution platform, a missing sound class or console variable, colour correction on iOS and Android).

  • The engine’s user settings are changed without applying; each group of values applies each kind of change once (window, frame rate, scalability) and saves GameUserSettings.ini once, never in the editor. Display changes are not applied in the editor (one log line) nor while the game exits, and a window created by the loading movie is resized once the game viewport exists.

  • URollySettingsCollection data asset with categories; IsDataValid checks every setting itself and explains each problem with its fix, including Requires Restart settings whose binding cannot keep a value for the next start, and slider conditions off the slider’s steps or outside its range. The same rules report at game start in development builds.

  • Built-in library built in code, used when Project Settings name no collection or the named one cannot be loaded (with a setup error): Display (Window Mode, Resolution, Monitor, VSync, Frame Rate Limit, Resolution Scale, HDR, HDR Brightness), Graphics (Overall Quality, the 11 scalability groups, Anti-Aliasing Method, Auto-Detect), Picture (Brightness), Audio (Master, Music, Effects, Voice with the engine’s Music, SFX and Voice classes), Controls (Key Bindings, Mouse Sensitivity and Gamepad Sensitivity from 10 % to 500 % on a logarithmic track, Invert Vertical Look, Controller Prompts; all Per Player), Accessibility (Subtitles, Subtitle Size, Colour Vision Deficiency, Correction Strength, Interface Size) and Gameplay (Field of View, stored only). Its defaults come from the project’s configuration; engine bindings supply defaults only for Resolution and Monitor.

  • Project Settings > Plugins > Rolly Settings: collection, storage class, confirmation timeout, start-up validation; for the controls, the mapping contexts to register with their conflict groups, the reserved keys (Escape and the gamepad’s menu button by default). The device-family name table and the gamepad analog switch threshold are under Project Settings > Plugins > Rolly Settings Core, with the input device tracking.

  • URollySettingsSharedSubsystem (game instance) for Shared values, applied once; URollySettingsSubsystem (local player) for Per Player values and the Blueprint API by Gameplay Tag (category Rolly|Settings) with events. The typed Get and Set nodes check the setting’s kind and report another kind.

  • Flows: Immediate, On Apply, Requires Restart (also for bindings that save the value themselves: the binding stores it for the next start, or Rolly Settings keeps it until then and applies it through the binding), Apply, Confirm with a real-time countdown on the core ticker, Revert by call, by timeout and on leaving, Discard, Reset all or one category, Visible When and Enabled When conditions, platform lists, per-platform defaults.

  • Confirmation results Confirmed, Reverted, TimedOut, Cancelled and Superseded (another player applied Shared changes first; nothing is reverted and that player’s answer decides).

  • Values the engine changes itself (Alt+Enter, window drags, scalability commands, the engine’s video mode revert) are read again, with On Setting Changed, after every group and on the Blueprint node Refresh Values; values waiting for Apply or confirmation are left alone. An unchanged value is not checked against its options again.

  • Options that follow other settings: the model notes which settings a binding reads while it builds its options; when the player changes one of them, a value the new options no longer offer becomes the dependent setting’s default. A Reset computes the defaults of such settings again once every setting it covers is back at its default (Resolution after Monitor with two monitors), and a chain deeper than four settings, or a circle, is cut off with a setup warning instead of silently.

  • First start: settings whose binding saves the value itself get the collection’s defaults when the binding reports no saved value (for the engine bindings: no GameUserSettings.ini at start). The built-in library leaves the project’s engine configuration in place.

  • Unconfirmed values: before applying a confirmation that covers values a binding saves itself, the values to go back to are written and flushed to [RollySettings.Shared.Unconfirmed] (and the per-player equivalent); Confirm and Revert remove them, and the next start applies what a crash or kill left behind as recorded (a size recorded with its monitor is not checked against the monitor in use) and removes it. On a normal quit the revert saves GameUserSettings.ini again during shutdown.

  • The running models hold their collection, settings and storage as garbage collector references, so editing the collection during Play In Editor cannot pull a setting away from a running session.

  • Saving to RollySettings.ini (sections [RollySettings.Shared] and [RollySettings.Player.<platform user index>], only non-default values, format stamp [RollySettings] FormatVersion=1) through a replaceable storage class; Memory Only storage. Saved values no setting owns are kept; a file of a newer format is read but never written; the storage is written when a mobile app goes to the background or the system ends it.

  • Console commands rolly.settings.dump, .set, .apply, .reset, .confirm and .revert.

  • Cook hook in the editor module that adds the assets named in Project Settings to every cook (the collection and the controls’ mapping contexts), and the assets the active collection’s bindings load by path (the volume settings’ sound classes; the built-in library’s when no collection loads).

  • Editor tools: an asset definition (Content Browser > Add > Rolly > Rolly Settings Collection) and factory, Tools > Rolly > Create Settings Collection from Defaults… (the built-in library as an editable asset, undoable edits), and checks on save through Data Validation. The editor module records the engine values the bindings change when Play In Editor starts and puts them back when it ends (scalability, frame cap, display gamma, subtitles, interface scale, colour correction, the engine’s user settings and every console variable the bindings set).

  • Validation rules for the built-in bindings: wrong setting kind, engine binding on a Per Player setting, options supplied without Options From Binding, colour vision option Ids, Console Variable and Sound Class Volume bindings without a target.

  • Native tags for every built-in setting and category under Rolly.Settings.*.

  • Controls (Enhanced Input): a per-player controls service (FRollySettingsControls) that is ready once Enhanced Input has made the player’s user settings (after the first controller, never in Initialize), registers the Project Settings mapping contexts, and builds one row per player-mappable name of the registered contexts with a keyboard and mouse column and a gamepad column. A column exists only where a context has a default key of that kind and takes only keys of that kind (buttons and keys, no axes); axis and composite rows are read-only; keys cannot be cleared. Key checks with reasons: conflicts inside conflict groups on the active key profile, reserved keys (Project Settings list, F11 while it toggles fullscreen, console keys outside Shipping), keys of mappings that are not player mappable, actions with Reserve All Mappings, wrong column, keys that cannot be bound. Swap when exactly one other row uses the key; row and full resets; a query for keys several rows share. Rebinds pass the exact slot and device, never create slots or defer the change notice, and are verified by reading the key back. Each change is saved synchronously in Enhanced Input’s key file, only while the player has a player input; otherwise the save waits for the next controller.

  • Bindings for the controls: Key Mappings (a Reset of the setting resets the player’s keys; hidden while Enhanced Input’s user settings are off), Enhanced Input Key for a Key Binding setting (mapping name and column, default from the context, saved by Enhanced Input, no next-start values so Requires Restart is refused, hidden with a setup warning when its column does not exist) and Controller Prompts (Auto, Xbox, PlayStation, Nintendo, Generic). All three are Per Player; validation reports a Shared one, the wrong setting kind, a missing mapping name, an unused Default Key and prompts options not taken from the binding.

  • Input modifiers Rolly Settings Sensitivity (a Slider setting times an optional factor per axis) and Rolly Settings Invert (negates the chosen axes while a Toggle setting is on): they reach the player through the player input’s owning local player, cache the value until the player’s values revision changes, let buttons and input without a Rolly Settings subsystem pass unchanged, and report a missing setting once for all copies Enhanced Input makes.

  • Input device tracking per player through the core’s URollySettingsCoreInputDeviceSubsystem (fed by a Slate input processor that consumes nothing): keyboard and mouse, gamepad or touch, switching at once on buttons and keys, on analog input only past Gamepad Analog Switch Threshold (stick drift is ignored) and on mouse moves over 3 pixels; the gamepad family from the device’s names through the Project Settings table, or from the Controller Prompts setting, which overrides it; Ignore Next Mouse Move for cursor warps; change events for C++ and Blueprint, which the Rolly Settings subsystem forwards.

  • Blueprint API for the controls (category Rolly|Settings|Controls): Are Controls Ready, Get Control Rows, Find Control Row, Check Key, Rebind Key, the key capture (Begin Key Rebind, Finish Key Rebind, Confirm Key Swap, Cancel Key Rebind, Is Key Rebind Active), Reset Control Row, Reset All Controls, Find Key Conflicts, Get Keys For Action, Get Prompt Key For Action, Get Reserved Keys, Get Input Method, Get Gamepad Family, Get Input Device Names, Ignore Next Mouse Move; events On Controls Changed and On Input Method Changed.

  • Optional player input class Rolly Settings Player Input that gives every local player but the first a key file of their own (<slot>_<platform user index>), and a setup warning in development builds when local players share one key file.

  • Runtime setup reports for the controls: Enhanced Input’s user settings off, a player input that is not Enhanced Input’s, a mapping context that cannot be loaded, no registered context or no player-mappable key, a missing display name, several keys of one kind under one name, different defaults for one name in two contexts.

  • Settings screen (URollySettingsScreen), built in C++ with no assets on the Rolly UI design system of the core (RollySettingsCoreUI), in the Ember theme and the Tabs layout of the design spec: a tab per category with something to show, between the glyphs of the tab keys; one row per kind (a switch for Toggle, chevrons for Choice, a slider with its value for Slider, a button for Action, a key cap for Key Binding, and the key list for Key Mappings with a Keyboard & Mouse and a Gamepad column, grouped by category and headed by the column titles; the settings after it get an Options heading of their own); a detail panel with the focused setting’s name, description and facts with icons (unavailable and why, waiting for Apply, restart, confirmation time, default); a restart notice; and a footer with the count of changes waiting for Apply and prompts that follow the player’s device and gamepad family. Gamepad, keyboard and mouse navigation: up and down between rows, going around at the ends with the theme’s Wrap Navigation; Home, End, Page Up and Page Down; left and right change values (a logarithmic slider by the same ratio each time; right turns a switch on, left off) or pick a key column; Accept acts on the row; shoulders or Q and E switch tabs (each tab remembers its row); X or F applies; View or Backspace drops waiting changes; Y or R resets the tab after a question; B, Escape or the gamepad’s menu button close and ask before dropping waiting changes; hover focuses rows and buttons only on a real mouse move while the player uses keyboard and mouse. The screen pauses a standalone game while it is open. The layout fits its area: short areas drop the title and shrink the margins, areas under 1280 units wide drop the detail panel, tabs scroll and prompts wrap. Every part a Blueprint layout binds has a tooltip; the row, tab and prompt classes and the keys are class defaults of the screen.

  • Open and Close Settings API that works from any menu (UMG, Common UI or none): URollySettingsUISubsystem (per local player: Open Settings, Close Settings, Is Settings Open, Get Settings Screen) and the nodes Open Rolly Settings, Close Rolly Settings, Is Rolly Settings Open and Get Rolly Settings UI (category Rolly|Settings|Screen). The screen goes on the player’s Rolly screen stack (the core’s URollySettingsCoreUIStackSubsystem), which handles focus, the player’s input, the cursor, the pause and split screen, and puts input back however the screens close; the optional menu input mode tag marks a player whose input a screen takes.

  • Keep-or-revert dialog (a Rolly Settings Core UI dialog) opened whenever a confirmation starts (Project Settings can turn it off), with wording that fits any setting: Revert focused, the runtime’s seconds left shown with a shrinking bar, closed on every end of the confirmation. A map change or the removal of the screens does not answer it: the countdown runs on and the dialog comes back with the player’s next controller (or the next frame); closing the screens from code answers Revert.

  • Key capture screen for the key list and for Key Binding settings: a Slate input pre-processor, active only while it runs, takes the next key before the screens and the game (releases swallowed; a trigger or stick direction, which a pad reports at a small value, is taken once it passes half or 80 % of its travel while held, and a drifting stick never is); Escape, the gamepad’s menu button, a countdown or a switch to another window cancel, and keys held at a window switch are forgotten so their later release reaches the game; a refused key keeps it open with the reason; a key one other row uses asks whether to swap (Swap) or change nothing (Cancel). The capture closes without a change when the screens close (a map change).

  • Customizing: the look comes from the core’s Rolly Settings Core UI Theme asset (Project Settings > Plugins > Rolly Settings Core UI; Ember when none is set), which restyles open screens in place when it changes, and from high contrast and reduced motion; Widget Blueprint layouts for the settings screen, key capture and dialogs, and row, tab and prompt classes, bind parts by name (BindWidgetOptional; parts left out turn their feature off).

  • Project Settings > Plugins > Rolly Settings Screen: the settings screen and key capture screen classes, the confirmation dialog, the menu input mode tag and the key capture timeout. The cook hook adds the classes named there; missing ones are reported with their fix, and at run time a missing one falls back to the built-in one with a setup error.

  • Key capture as its own component (FRollySettingsKeyCapture, URollySettingsSubsystem::GetKeyCapture); the subsystem’s key capture nodes forward to it.

  • Docs/ARCHITECTURE.md: the modules and their folders, the path of a value from the collection to the engine and the screen, the extension points and where the tests live.

  • The settings screen in the design system’s five layouts (F6b1), picked by id in Project Settings > Rolly Settings Core UI > Layout, in the theme or with Set Layout while the game runs: Tabs, Side Rail (a rail with category icons, two levels), Centered Panel (a card over the dimmed game), Couch Hub (tiles with category icons and live summaries of their values, then a page per category with a preview column and a description band; Large density by default) and Side Drawer (docked to the edge over the running game, which is not paused). Switching layout while the screen is open keeps the category, the focused row and its scroll position, and every change that waits for Apply. Each layout works with gamepad, keyboard, mouse and touch, in split screen (2 and 4 players, the drawer at the outer edge) and from 16:10 to 32:9 (a centred region at most 21:9 wide) at every Interface Size.

  • The six theme presets of the core (Ember, Paper, Tactical, Neon, Glass, High Contrast) for the settings screen, its dialogs and key capture.

  • Detail as a panel, a strip or a band: below 1600 units wide the description becomes a strip under the list instead of disappearing, with the facts in one line; a setting’s optional Preview picture (a texture or a material) shows with its description, and a category’s Preview stands in for settings without one.

  • Row Classes (Project Settings > Rolly Settings Screen, and a settings screen’s class defaults): a row class per setting kind, the nearest parent class’s entry winning, so a setting kind of your own gets a row of your own without changing the plugin; a row that cannot show its kind is reported and the next one is used. Replaces the six row class properties of the screen (Toggle Row Class and the others, unreleased).

  • One name per key on the whole screen: the caps, the Default facts of the key list and of Key Binding settings, a Key Binding’s value and every refusal and swap question name a key as its cap does, for the player’s pad (“Left Click”, “Space”, “RT” or “R2”), from the core’s FRollySettingsCoreKeyNames.

  • Long texts (long translations, narrow areas): a setting’s name wraps to a second line before it reaches the value, a value too long for its column ends with an ellipsis and the detail says it in full first (“Current: …”), and the buttons of the questions wrap to a second line when their labels do not fit.

  • Collection categories can name an Icon (the Rolly category icons: Display, Graphics, Picture, Audio, Controls, Accessibility, Gameplay, Camera, Interface) and a Summary for their hub tile; without one the tile lists the category’s first values, with the setting’s name where the value alone says nothing (a toggle, a slider, a choice showing On or Off, an option shown twice). The built-in library names an icon for every category.

  • Open Rolly Settings At (and URollySettingsUISubsystem::OpenSettingsAt, URollySettingsScreen::OpenCategoryWithTag): opens the screen at a category, in the couch hub on its page.

  • Built-in library: High Contrast Interface and Reduce Motion in Accessibility (Toggles, Immediate, starting from the system’s preferences on Windows; the bindings High Contrast Interface and Reduce Motion drive every Rolly screen), and Interface Size up to 200 %.

  • A toast after the player’s Apply (“Settings applied.”, or that some take effect after a restart), unless the keep-or-revert question asks already.

  • Tests (F6b1 audit round): Rolly.Settings.UI.Screen.KeyNames (a cap, its Default fact and a refusal name Left Click, Space and the right trigger alike, for Xbox and PlayStation pads), .RowClasses (a kind of the project’s own with its row, nearest parent, the screen over Project Settings, a wrong row reported), .Chevrons (an inactive chevron is not disabled, draws in Text Disabled and ignores clicks), Rolly.Settings.UI.Screenshots.Matrix (every layout at R1 to R9, checked in every run) and contrast samples of an inactive chevron and a dimmed prompt in .Presets.

  • Tests (F6b1): Rolly.Settings.UI.Templates.* (the built-in library in every layout, Open Rolly Settings At, the Apply toast, dialogs centred in the drawer, touch on rows), Rolly.Settings.UI.Look.AccessibilitySettings (the accessibility settings driving the theme), Rolly.Settings.UI.Screen.CompactLayout and .Pause extended (split-screen shares of 16:9 to 32:9 screens, the drawer that does not pause, a layout switch while open), Rolly.Settings.Library.Accessibility, and rendered screenshots of every layout and size and every preset (Rolly.Settings.UI.Screenshots.Templates, .Presets).

  • 149 automation tests (Rolly.Settings.*), 37 of them for the settings screen (Rolly.Settings.UI.*) driven through a virtual window and a virtual Slate user: the built-in library screen and its rows, navigation with wrap, Home, End and paging, value changes, tabs, mouse hover, clicks on rows, prompts and tabs, apply, revert, back with the discard question, reset, the detail facts and the pending counter, keep-or-revert (also across a map change and after the screens were removed), key capture (rebind, cancel, refused key, swap, a cancelled swap, trigger and stick presses in a real pad’s event order, a drifting stick, timeout, mouse button, close during capture, a window switch), switch direction, the hover gate, the Options heading after the key list, the logarithmic slider row, the pause, the Blueprint nodes, the Ember look, row and screen classes from Project Settings and class defaults, a Widget Blueprint layout, the compact layouts, cooking, every screen in the LEET test language, the alignment of key caps with their words, row names with their values and dialog button labels in their buttons (from the layout, for keyboard and gamepad), and rendered PNG screenshots of every tab, a pad’s prompts, high contrast, split screen, the dialogs and key capture in a rendering run, which also checks in the pictures that the prompts’ and tab keys’ caps sit level with their words. The other 112 cover the theme previews’ presenter and its safety (no binding called, GameUserSettings untouched), the Interface Theme recipe, the logarithmic slider mapping both ways, two local players without Play In Editor, the subsystem’s Blueprint events, a new player controller, the Blueprint events of the Custom binding, every built-in binding read, applied and restored behind one engine state guard (GameUserSettings.ini is never saved), support checks, resolution and monitor options, the built-in library’s validation, the unconfirmed-value recovery (also with options that depend on another recorded value), options that follow another setting before Apply, the resolution-scale reset from a known start and with a Project Settings value, engine-driven refresh, one engine apply and save per group, the editor tools, a real save that runs the Data Validation checks, the Play In Editor restore, and the controls: rows after Enhanced Input’s user settings appear, rebind, conflicts (same group, other group, reserved key, fixed mapping, reserved action), swap, row and full reset through the collection, persistence through an isolated key file, a save without a player input, Enhanced Input’s remap rules the columns rely on, the Enhanced Input Key setting, validation, per-player key files, modifier maths (1D, 2D, 3D, per-axis invert, pass-through), prompts, and the reset of dependent defaults with two monitors. The stack, dialogs, pause rules, theme and device tracking are tested in the core (RollySettingsCore.UI.*, RollySettingsCore.Input.*).

  • One look for every installed Rolly product (F6b2): High Contrast Interface and Reduce Motion write the shared console variables rolly.ui.contrast and rolly.ui.motion at the Game Override priority, so they restyle the screens of every Rolly product, and Play In Editor puts them back like any console variable Rolly Settings sets. The Themes section of the README describes the shared theme ([RollyUI] Theme, Theme Source, rolly.ui.theme) and the recipe for an Interface Theme setting (a Choice with the Console Variable binding on rolly.ui.theme).

  • The theme editor of the embedded core (F6b2): Create Theme from Preset with a picture of every preset, thumbnails, a live preview of the settings screen in the theme’s details with its toolbar and checks strip, a preview window, Use as the Rolly UI Theme for All Rolly Products and Reset to Preset. The editor module feeds the preview with the built-in library through a read-only presenter (FRollySettingsPreviewContent: static defaults and options only, sample key rows for Key Mappings; no binding is called).

  • A theme’s Glyph Overrides rename a key in its Default fact, refusals and questions too, not only on its cap (F6b1 R2-a).

  • Tests (F6b2): Rolly.Settings.Editor.PreviewContent, Rolly.Settings.Editor.PreviewSafety (a collection of spy bindings previewed in every layout, size, prompt and contrast: no binding called, GameUserSettings unchanged; AC-39), Rolly.Settings.Recipes.InterfaceTheme, relabelled keys in Rolly.Settings.UI.Screen.KeyNames, Row Classes in Rolly.Settings.UI.Look.CookAssets (F6b1 N9), Glass over the running game in Rolly.Settings.UI.Screenshots.Presets (F6b1 N13), and the matrix’s R5 as a player of a two-player split (F6b1 R2-b).

Changed

  • A chevron with nothing in its direction is inactive rather than disabled: it keeps Text Disabled at full strength (Slate’s disabled look faded it to 1.7:1 in Ember and 2.5:1 in High Contrast) and ignores clicks. Key cells without a key work the same way.
  • On the smallest areas (640 x 360, a 4-player split at 150 %) the footer keeps to one line of prompts and the panel and drawer tighten, and on short areas the hub’s tiles without summaries are shorter, so the focused row or tile always shows whole (AC-24).
  • In a line of facts (strips and bands) the default value comes first, so a short line never cuts it; a band without a description says its facts in its line, as a strip does, so the default always shows (AC-25).
  • The settings screen is a category screen of the core (F6b1): the categories, rows, detail and flows stay in Rolly Settings, and the core lays them out in the layout templates, with the navigations, levels, footer, touch and split screen. Its parts for Blueprint layouts are the category screen’s (D-028): PlayerBadge, TouchBackButton, RailList, CategorySwitcher, HubTiles, CategoryTitle, DescriptionLine and DescriptionPreview are new, TabDivider is a part of the Tabs template now, and SettingsList keeps its name. The screen’s title comes from its Screen Title. The rendered screenshots test is Rolly.Settings.UI.Screenshots.Screens.
  • The footer drops prompts by priority when it runs out of room, after wrapping to a second line (Reset, then Revert Changes, Category and Apply; Accept and Back always show), and prompts sit 24 units apart by what they show.
  • Settings screen rebuilt on the Rolly UI design system of the core (F6a): the stack, dialogs, buttons, tabs, prompts, glyphs, the theme and the input device tracking moved into the core (RollySettingsCoreUI, RollySettingsCore), and the product keeps the settings screen, its rows, its dialogs’ wording, key capture and the Open and Close Settings API. Layouts made for the pre-release screens need their parts renamed or retyped (for example FocusBar became FocusFrame, PendingMarker became PendingDot, DescriptionStatus became a panel of fact lines, the slider and switch parts became one Rolly Slider and one Rolly Switch).
  • Project Settings: the Rolly Settings Menus page became Rolly Settings Screen; the dialog class, screen layer, viewport Z order, Input After Screens (was Input After Menus) and pausing moved to Project Settings > Plugins > Rolly Settings Core UI with the new Theme; Device Families and Gamepad Analog Switch Threshold moved to Project Settings > Plugins > Rolly Settings Core. Blueprint category Rolly|Settings|Screen replaces Rolly|Settings|Menus; the stack’s nodes are the core’s (Get Rolly Screen Stack, Push Rolly Screen, Pop Rolly Screen, Close Rolly Screens, Is Rolly Screen Open, Show Rolly Dialog; category Rolly Settings Core|UI).
  • The settings screen now pauses a standalone game, goes around at the ends of the list, closes on the gamepad’s menu button, names its reset prompt Reset Tab and shows the reason for a refused key in the Danger colour.
  • Controls (from the F4 review): a swap is offered only when the key is free in the other row’s other conflict groups too; a swap is one change (one change notice, the first key restored if the second write fails); every key of a read-only composite row counts as taken; refusal messages name actions by their display names, never by asset names; the six controls nodes that rebuilt every row (Get Control Rows, Find Control Row, Check Key, Find Key Conflicts, Get Keys For Action, Get Prompt Key For Action) are callable nodes instead of pure ones; Enhanced Input Key settings that need confirmation are refused by validation; tooltips on the Blueprint-visible control fields that lacked them.
  • Ignore Next Mouse Move expires after two frames, so a cursor warp that produces no move never swallows the player’s first real move.
  • A setting its binding does not support on this machine (hidden) is no longer reported for offering no options (a monitor list while the game renders off screen).
  • The settings screen’s tabs row and footer are the core’s Rolly Tab Strip and Rolly Prompt Bar (F6a review): the parts TabStrip and PromptBar replace TabScroll, TabBar, PreviousTabGlyph, NextTabGlyph and FooterBar, whose names move into the strip and the bar, and the screen hands its Tab Class and Prompt Class to them. The keys that switch tabs stay in view at both ends while the tabs scroll.
  • Source files sit in feature folders (Kinds, Model, Bindings, Library, Controls, Storage, Subsystems; Screens, Rows; Assets, Cook, PlayInEditor), and C++ includes them by path, for example #include "Subsystems/RollySettingsSubsystem.h" and #include "Screens/RollySettingsUISubsystem.h". The module header, the Project Settings classes, the Blueprint libraries, RollySettingsTypes.h and RollySettingsTags.h stay at the top.

Removed

  • Before release, the main menu, pause menu, menu list screen, menu definition asset and loading screen hook left the product, with their nodes (Open Rolly Main Menu, Open Rolly Pause Menu, Toggle Rolly Pause Menu, Show and Hide Rolly Loading Screen) and Project Settings: Rolly Settings brings the settings screen, which opens from any menu of the game’s own.
  • Before release, the Rolly Settings UI Style and Rolly Settings Glyph Set assets: the Rolly Settings Core UI Theme replaces both (the widget classes of the style are class defaults of the settings screen, the glyph labels and icons are the theme’s Glyph Overrides).

Fixed

  • Key caps sat 3 to 5 units lower than their words in the footer prompts, beside the tabs and in key capture (F6a review): Rolly text keeps no line spacing under its last line and no room for a shadow nobody sees, and a key cap beside larger type moves by the difference between the two fonts’ capital heights, so caps and words share one centre.