Architecture

Modules

The three core modules are the shared Rolly foundation, carried whole inside the plugin under this product’s name, so all nine modules ship. Rolly Save’s runtime module uses only RollySaveCore and AIModule, includes no PCG, StateTree or Gameplay Abilities header and knows nothing of the screens: RollySavePCG, the only runtime module that links PCG, serves PCG components through the instance-source interface (IRollySaveInstanceSource), RollySaveStateTree, the only runtime module that links StateTree, holds the StateTree handler, a child of the engine state handler base, RollySaveGAS, the only runtime module that links GameplayAbilities, holds the Gameplay Abilities handler, a child of the AI state handler base, and RollySaveUI listens to its events and calls its API, so a game with its own menus can leave the screens’ settings off. The editor module’s tests use RollySaveCoreEditor’s test support. The product never depends on another Rolly product.

Folders

Every module keeps its front door in its root folder: the module header and the types several folders share. Everything else sits in a feature folder with the same name under Public/ and Private/, and code includes headers by that path (File/RollySaveFile.h). Each class’s header comment holds its details. Record/ includes Actor/ for the ACTR and COMP sections, record sections declared in the public header Actor/RollySaveActorSections.h, and Paths/ for the values saved by path, and Instances/ and Destruction/ for the INST and GCOL sections, declared in the public headers Instances/RollySaveInstanceSection.h and Destruction/RollySaveDestructionSection.h. Actor/ calls Instances/ to track, capture and apply instances; Instances/ includes no header of Actor/ and names its message sources through Paths/RollySavePathChecks.h. Paths/ reads only the public data struct FRollySavePropertyPath of Rules/, whose header stays at Rules/RollySavePropertyPath.h where buyers include it; Rules/ checks and explains paths through Paths/.

RollySave

RollySavePCG

RollySaveStateTree

RollySaveGAS

RollySaveUI

RollySaveEditor

The subsystem and its services

URollySaveSubsystem names each call for setup messages and forwards it to the service that owns the work (RollySaveSubsystemCalls.cpp); each service keeps its own state. The subsystem itself keeps its events, the restore scopes, Request Slot Screen’s checks (a local player controller of this game instance, a listener) with the answer of the request that runs (Mark Slot Screen Request Handled sets it, from a listener of the subsystem’s event or of a trigger’s own, which fires inside the request), the binding of a blocking actor’s End Play to its save blocks, and the clamp of Set Check Limits to the format’s own limits (RollySaveSubsystem.cpp).

FRollySaveGameServices, made in Initialize, builds the parts in the order the game instance’s start needs: the Global Handlers’ classes and the Save Rules first; then, once the subsystem loaded the Migrations asset and made the Game Clock, the slot state, memory slots, save blocks, groups, game objects, services, loader, profiles, level memory, streamed levels and quick keys. It wires what each tells another: a load’s end runs the waiting saves, a save to storage arms the autosave timer, the last save block’s removal runs the waiting saves on the next tick, a load that applied starts New Game+‘s next cycle or, for a whole-game load, takes the save’s play time, place, game fields, run and current slot (one from storage also drops the rewind points and the checkpoint’s memory copy), and the local players’ arrivals and departures load and drop their profiles.

Deinitialize ends the parts in the order shutdown needs (FRollySaveGameServices::Shutdown): a save that captures over frames captures the rest, while every part it writes through is there; BeginShutdown, so nothing is told from then on; every hold ends; saves that wait for their pictures go on without them; the profiles, quick keys, save blocks, streamed levels, level memory and loader go; the store flushes, so a save asked for last still reaches storage, and the read of a part save, copy, rename, import or End Rolly Run answers inside the flush and queues its write; MarkFlushed; then the held slot requests run and the remaining parts go, the thumbnail cache’s textures among them. Services reference the pointers that hold the parts the end lets go of, so they see a part go; a service that answers later is shared and its callbacks hold weak pointers, so a callback that finds its service gone ends as the game instance’s end does. The Blueprint nodes, the world part and the test hooks reach the services through URollySaveSubsystem::GetServices, whose FRollySaveInternalKey only the module can make; the world part’s GetTriggerWatch and FindGameObjects take the same key.

A part that holds objects of its own reports them to garbage collection (FGCObject). An object it reports keeps its outer alive while the part exists, so the parts whose objects are outered to the subsystem (memory slots, profiles, handlers, slot state) go in Shutdown. The world part holds its areas’ record as a property (URollySaveWorldSubsystem::ResetAreaState) and FRollySaveLevelTools only refers to it: reported from the tools, the record would keep the world part, its world and every actor in it after the world ended (Rolly.Save.LevelTools.Reset.WorldCollected).

How it works

Writing a file (FRollySaveFile::Write): the header is checked (string lengths, thumbnail size, IDs of carried fields) and encoded, known fields in a fixed order, then carried ones. Each chunk is compressed with Oodle at the chosen level when that makes it smaller and stored otherwise; a carried chunk keeps the bytes it was read with. The directory follows the header, the chunks follow the directory, and the file and prelude checksums are filled in last.

Reading a file (FRollySaveFile::Read) runs the cheapest checks first, decodes and allocates nothing before every checksum and recorded size passes, and accepts nothing Write would not write back unchanged:

1. The prelude: magic, length, its own checksum, MinReadVersion against this version’s format, the sizes.
2. The length against the recorded size, the header’s checksum, the whole file’s checksum; when that fails, the directory’s and each chunk’s checksums name the part that changed.
3. The header’s fields (printable IDs, the writer’s order, each string in the writer’s one form), then the package, licensee and custom versions against the running build.
4. The directory, with all chunks’ decoded sizes held to 1 GiB, then each chunk: decoded when its ID is known, carried when not. An unknown chunk flagged MustUnderstand, or a known one in a codec this version lacks, makes the file one of a newer version.

FRollySaveFile::ReadHeader runs steps 1 and 3 on the first 64 + HeaderSize bytes. Reads of a save share the file checks of RollySaveResults, the part save with its own shorter Game Data Version text: CheckRecordVersions (NewerVersion for newer records, Damaged otherwise, by RollySaveRecordCodec::CheckFile), CheckGameDataVersion (NewerVersion above the project’s Game Data Version) and CheckVersions (both). Loads, part saves, profiles and imports then read through FRollySaveLoadedGame::ReadChecked: the record chunks (GLOB, WRLD, LSEG, PLYR, PROF) are decoded, the rest kept as read, and every record is checked by its saved types alone (RollySaveStructureCheck::RunSavedTypes, or over several steps through FRollySaveLoadedGame::FCheckSteps), property bag layouts counted across the file.

Saving the game (URollySaveSubsystem::Save), on the game thread:

1. FRollySaveCallChecks::PassGates, shared with loads, refuses on a later tick: off the game thread, without a game world, on a client (NotAuthority), a slot name that is not 1 to 1,024 characters without NUL, a name Rolly Save keeps for itself or a slot outside the active run, each with a setup message; Busy while a load sets values or seamless travel runs. Saves the player asks for then pass PassBlockGate.
2. FRollySaveCapturer captures. FRollySaveGameObjects::Gather lists the globals with their IDs, in a fixed order: the session, the game instance and its subsystems, URollySaveWorldSubsystem::GatherGlobals (Game Mode, Game State, world subsystems, the persistent level’s Level Blueprint), registered objects by name, and a new instance of each Global Handler (FRollySaveHandlers). A global saves when its What Saves switch is on and its class declares a contract function or a SaveGame property the engine’s own classes do not declare (the engine flags AActor::bCanBeDamaged SaveGame).
3. FRollySaveGameCapture captures them with one FRollySaveRecordWriter over the resolver FRollySaveGameObjects, so a pointer between saved objects saves as an ID, and one FRollySaveCheckBudget for the whole file; then, with What Saves > Actors and Local Players on, the world’s actors and the local players in the same budget. The first refused capture ends the save with InvalidData and writes nothing.
4. FRollySaveLoadedGame::AddKeptTo adds what the last load or save held and this save did not capture (its header says which records stay), each checked as if every value were read (CheckKept) in the same budget; a record past a bound is left out with KeptRecordDropped. A capture takes the sections this version does not know from the record it replaces.
5. The records become the payloads of GLOB (empty key), the map’s WRLD chunk and the kept chunks (RollySaveRecordCodec::EncodePayload, on the game thread), beside the chunks and header fields this version does not read. The header gets this build’s versions, the slot’s name and the Game Data Version; the loaded game becomes what the save wrote. FRollySaveStorageWrites asks for the save’s picture at the call, then, in the slot’s request order (FRollySaveSlotHold), reads the title of the slot’s newest copy (URollySaveStore::ReadNewestHeader; from the store’s own knowledge of the copies, or by inspecting both, never from the slot index alone, since a crash between a save and its index write leaves the index naming the older copy), waits for the picture at most Max Wait, writes the metadata (Slot metadata below) and the picture into the header, and the store writes the file; a slot that cannot be read fails the save, so a title is never lost. Its result ends the save: the saved hooks, the playthrough’s records, the caller, then On Save Finished.

Events: the record writer tells the save of each object it captures (SetPreSaveListener), which keeps those whose class declares OnRollySaveSaved and the Rolly Save components with an On Saved binding. After a successful write the subsystem calls OnRollySaveSaved on those still alive, in capture order, then the components’ On Saved, then the caller and On Save Finished. A failed write and a level’s capture call neither.

Loading the game (URollySaveSubsystem::Load, FRollySaveLoads, FRollySaveGameLoader), on the game thread:

1. The gates of a save. The store, or the memory slots for a load from memory, reads the slot; a status other than loaded (NotFound, NewerVersion, Damaged, StorageFailed) or a refusal of CheckVersions ends the load.
2. The metadata is decoded and the run rules judge it (FRollySavePlaythrough::CheckRunLoad), waiting for the first local player’s run ledger while that profile loads. ReadChecked ends the load of a damaged file before the map changes. A lower Game Data Version goes through the Migrations asset’s steps (FRollySaveMigrationRunner; a failed step ends the load with MigrationFailed). The Session record, read into a new URollySaveSession, names the saved map, which must be in this build (MissingMap).
3. FRollySavePreloader loads the hard imports of GLOB, of the WRLD chunk of the map the values go to and of the players’ chunks, and holds them. A Level Blueprint’s class loads with its map (ClassLoadsElsewhere).
4. Keep Current Map applies at once (step 5). Open Saved Map or a given map starts a relative server travel (RollySaveTravel::Start) that keeps the URL’s options; a refused or failed travel (UEngine::OnTravelFailure) or a world of another map ends the load with TravelFailed. In the new world URollySaveWorldSubsystem::OnWorldComponentsUpdated removes the placed actors the save holds as destroyed, and the world’s OnActorsInitialized starts the apply.
5. FRollySaveGameApply prepares each record of GLOB and the world’s WRLD for the object its ID names, when its What Saves switch is on and the object is of the record’s class after Core Redirects (RollySaveRecordClass::Resolve; ClassMismatch otherwise, except for the world’s own objects in another map and a level instance’s Level Blueprint, matched by its role, its class’s name and the level asset its package came from, as a spawned instance loads its level under a new package name). RollySaveWorldApply::Run takes actors and players through FRollySaveActorApply, and Prepare and Apply run in one call. The Save Handlers of Apply Timing Before Begin Play apply, all of them with Keep Current Map. Records of registered names whose objects are not there wait until RegisterObject registers one. The file becomes the loaded game.
6. The world’s OnWorldBeginPlay broadcast, after every actor’s Begin Play, applies the records of After Begin Play actors and the After Begin Play Save Handlers and ends the load: the caller, then On Load Finished. Saves are Busy until then. CancelLoad stops a load before its travel starts, except inside a migration step or while ApplyToWorld sets the values (the game’s hooks, On Loaded events and Save Handlers’ Apply run inside it); the game instance’s end drops a running load without firing anything.

Saving actors (RollySaveActorCapture::CaptureWorld): FRollySaveWorldActors::Gather walks the actors of each level of the world once, leaving out a level being removed or whose values wait to be set, and lists the subjects that save, ordered by ID; its header gives each kind’s ID. An actor saves by its resolved Saving: always with Always, never with Never, and with With Saved State when it or a component has saved state, it has a Rolly Save component, or a value of it or a component is saved by path. Engine-made actors, players’ own pawns, registered actors, spawned actors with Respawn off and, when a level is remembered, the actors seamless travel carries on are left out; the components that save follow their actor. After a subject’s OnRollySavePreSave and its Rolly Save components’ On Pre Save, its record goes into the map’s WRLD chunk with its ACTR or COMP fields (RollySaveActorFields); a value that is not finite is left out. Records of placed actors kept destroyed follow; those of a placed actor destroyed with Keep Destroyed off and of a spawned actor destroyed in play go.

Loading actors (FRollySaveActorApply, inside the world’s apply; its header lists the steps): a map load removes the placed actors held as destroyed before the world’s actors initialize, so they run no Begin Play or End Play (a replicated one, on a server, at the world’s Begin Play, so clients hear of it). Spawned actors the world lacks are spawned again, deferred, with their GUIDs, and the second pass’s records are checked against their classes before the first pass applies (FRollySaveGameApply::CheckAhead), so a damaged file applies and removes nothing. Between the passes the spawned actors finish spawning and the components that exist only now are prepared or created; other missing components wait (FRollySaveLateComponents). After the second pass come attachments, transforms, owners and the other fields, then the loaded functions of both passes, once, and each Rolly Save component’s On Loaded.

Save Rules and values saved by path (Rules/, Paths/):

1. FRollySaveRuleSet::LoadAll loads every Save Rule asset the asset registry lists as a game instance starts; saves and loads never load a rule, and the cook hook adds them to every cook. Reload Save Rules (FRollySaveRuleReload) loads them again asynchronously and takes the new set once no load runs.
2. Each world’s FRollySaveRuleResolver resolves an actor once per save: Actor Defaults, the matching rules its component does not ignore, then the component, through class entries built once per class (its header gives the order and when entries are worked out again). An actor a load spawned again resolves with its class’s templates until FinishSpawning ran (FRollySaveActorTracker::IsRespawning). Saving Never leaves an actor, its components and its child actors out, and a load leaves their records with LeftOutByRule; the next save drops them.
3. FRollySavePathBinder binds an actor’s path steps (FRollySavePathStep) to each target class once, refusing what cannot save, each reported once. Not Saved entries remove picks, leave SaveGame variables out of PROP (FRollySaveArchive::ShouldSkipProperty) and leave whole components out (FRollySaveWorldActors::IsComponentLeftOutByName). The record writer writes the picks into PATH as tagged properties named by the joined path; a value that would hold an owned or untracked object is left out (FRollySaveCaptureTables::BeginPathValue, PathLeftOut).
4. At the apply, after PROP, a PATH tag applies only when its name is a path the object picks now, directly or after property Core Redirects (RollySavePaths::RedirectName), and its type is the property’s own; a value whose asset or saved object reads as empty keeps the live one (PathKeptLive), and any other tag is skipped (PathNotApplied). RollySavePathSetters gives the value back.
5. In a load that opens its map and on a level’s return, the records of After Begin Play actors are checked with the first pass and applied at the world’s Begin Play broadcast through RollySaveWorldApply::ApplyLater, counting on from the load’s budget; saves wait for them (FRollySaveCallChecks::IsSettingValues). Records of When Asked actors wait in FRollySaveAskedRecords until Apply Saved Values (RollySaveWorldApply::ApplyAsked); saves leave those actors out and write their records back as loaded.
6. Attached Save Handlers: FRollySaveResolvedActor::FindHandlers lists each class once with the entry of the last source listing it. An actor saves for its handlers only while one of them would write (FRollySaveAttachedHandlers::WouldAnyWrite, asked of one probe instance per entry). A save makes an instance per actor and class (FRollySaveAttachedHandlers::MakeForSave), captured after the actor’s components under <actor>|@Handler:<class path>; its pre-save hook runs CaptureState, and FRollySaveGameCapture takes back what the writer counted of a capture that gave Nothing (the loaded record is dropped) or Keep (the loaded record is written back, IsKeptBack). A load makes one per handler record whose class the live actor attaches now and runs its Apply when its timing comes and CanApplyNow allows (ApplyReady): Before Begin Play with the load’s values, After Begin Play once its own actor began play, also in a level that streams in, When Asked when the game asks; URollySaveWorldSubsystem::RetryPendingHandlers asks again. Until then the instance waits and saves keep its record as loaded (IsWaiting); waiting instances of actors garbage collection took go after it, the listener bound only while load instances are held. A record of a class no longer attached is kept. A When Asked instance whose CanApplyNow refused when the game asked applies at the next RetryPendingHandlers; an actor saves while one of its handler records waits. On a load that opens its map and on a level’s return, an AI handler’s record (URollySaveHandler::ReadsRecordWithPlayers) is read once the local players have their pawns: at the world’s Begin Play for After Begin Play, at the ask for When Asked, into the instance the load made, which waits with the record unread (FRollySaveActorApply::LeaveUnread, FRollySaveAttachedHandlers::SetUnread and TakeUnread, read in RollySaveWorldApply::ApplyAsked); seamless travel carries the unread record with its instance, and a later load of the actor replaces both. An ask that applies nothing before its world began play is noted (FRollySaveAskedRecords::NoteEarlyAsk) and asked again at the world’s Begin Play (URollySaveWorldSubsystem::HandleWorldBeganPlay).
7. Engine state handlers (EngineState/): FRollySaveEngineStateTargets meets an actor whose sources attach one at its level’s build, at its spawn or as Play In Editor’s construction pass replaces it (FRollySaveWorldActors::TrackInstances), asking a probe of each to note its targets’ design assets by component name and slot (NoteDesigns); a target first met at a save is noted then (FindDesign). A pawn met before it has an AI controller, as one spawned in play, streamed in or spawned again by a load is, gets its controller’s StateTree noted from the StateTree components of its AI Controller Class’s class defaults (FindDesignTree in RollySaveStateTree). Captures write an asset only when it differs from its note. In a load in place, RollySaveEngineStateDesigns::ApplyToUnsaved gives the targets of met actors in the load’s scope without a record their design (ApplyDesign: Material Parameters’ noted materials, Montages’ Stop Other Montages). The Audio handler’s clocks follow each taken audio component’s play state through IRollySaveAudioPlayback and estimate its position from the world’s audio time, its pauses and its pitch, or take the engine’s playback percent while Position is Reported; a play the handler starts sets its clock’s offset. Met actors, notes and clocks go with their actor, their level’s unload or garbage collection, whose listener is bound only while one is held, and move with actors seamless travel carries, taken before the leave forgets the world’s levels. Handlers report missing targets, entries past a bound and skipped values through FRollySaveAttachedHandlers::ReportIssueLine into the running load’s result, or the log; capture lines (KeyLeftOut, ParameterLeftOut) go through ReportCaptureLine into the save’s Issues (FCaptureLines). Actors tagged SequencerActor never save. The Gameplay Abilities handler (RollySaveGAS) is an AI state handler too, so its values apply through the same waits, on a tick after its timing and never inside an ability’s or the load’s own calls; each record runs every step’s guards first, then loose tags, abilities, their variables, base values, effects and base values again; a load tells each load instance whether its actor was there before it (URollySaveHandler::IsInPlaceApply, set in FRollySaveActorApply::PrepareHandler), which Not in the Save reads. The AI handlers (Blackboard, StateTree) apply only through FRollySaveAIWaits: their CanApplyNow asks it, it checks readiness on the core ticker after the apply and after the controller’s On New Pawn, which it follows through the world part’s listener of pawn controller changes, gives a pawn a load spawned again its AI Controller Class at the first check, and applies through FRollySaveAttachedHandlers::RetryPending, so no AI value is set inside the load’s own calls; a pawn still not ready after the last check reports AINotReady and waits for Apply Saved Values. Data Validation’s NoTargets and Effective Settings’ handler lines count targets with FindTargetsIn over an FRollySaveTargetView, the rule the captures use. Each map’s parameter collections are a global record of its WRLD chunk, ParameterCollections:<map> (URollySaveParameterCollections), captured and applied with the map’s other roles.

The local players (Player/): own pawns (FRollySavePlayers) never save as actors. A save with Local Players runs RollySavePlayerCapture::CapturePlayers after the actors: a PLYR chunk per local player keyed Local:<index>, with the controller, the own pawn, the player state, their components and their attached Save Handlers; the controller and player state save when they hold saved properties, a saving component or an attached handler that would write (FRollySaveAttachedHandlers::WouldAnyWrite). With Open Saved Map, FRollySavePlayerLoad applies each chunk through RollySaveWorldApply::ApplyLater once the player’s own pawn is there and the Game Mode’s restart finished, and a save meanwhile writes the waiting chunk (FindWaitingChunk); only records whose root owner is the chunk’s player apply (RollySaveWorldApply::IsInOwnChunk). Keep Current Map applies the PLYR chunks in the load’s own apply, and in another map the players keep their place (FRollySaveActorApply::KeepPlayersPlace). Travel never applies them.

Remembering levels (FRollySaveLevelMemory, whose header gives the engine’s moments): leaving a map captures its WRLD chunk as a save does, without the carried actors, in a budget of its own and without saved hooks, into the loaded game, unless Remember Levels is off or a load’s own travel leaves; a refused capture forgets the level. The next map’s preload starts as travel names it and is held through the worlds on the way; at the arrival the apply waits for the preload’s own requests (FRollySavePreloader::WaitUntilLoaded) and runs as a load’s does (RollySaveWorldApply::Run). Forget Level, Forget All Levels and Clear Loaded Game remove chunks, or mark the current world so that leaving drops its chunk. A save writes every WRLD chunk the loaded game holds; a load replaces them.

Streamed levels (FRollySaveStreamedLevels, whose header gives the engine’s moments), on the server or in a standalone game, once the map’s actors initialized and while no map change runs; nothing runs while no level streams. A level that starts to unload (FLevelStreamingDelegates::OnLevelBeginMakingInvisible, bIsBeingRemoved already set, so saves leave it out) is captured as a save captures its part of the map, in a budget of its own and without saved hooks, and each record replaces the loaded game’s of its subject, found through FRollySaveRecordIndex, or joins the map’s chunk, noted as changed (FRollySaveLoadedGame::NoteRecordChanged) so a save that chose its slot meanwhile keeps it; its leave clocks and its areas’ waiting entries are kept (FRollySaveLevelTools::HandleLevelLeaving), and FRollySaveLevelAssets holds the assets and types its records name, never an object of a level. With Remember Streamed Levels off, its records and its destroyed actors are forgotten instead. A level that starts to become visible (OnLevelBeginMakingVisible, before the engine moves its actors, registers its components or calls their Begin Play) joins FRollySaveLevelScopes, which takes its actors’ Custom Save IDs, and FRollySaveLevelApply::Begin collects its records by its actors’ IDs, its Level Blueprint and the spawned actors anchored to it or to its actors (a cell’s anchors asked again for loot no partition held as the index was built), runs its Reset Areas’ step (FRollySaveLevelTools::BuildLevel) over them and its actors held destroyed, and applies its placed actors’ records (RollySaveWorldApply::RunStreamed, load kind Streamed), writing an unattached actor’s place through the inverse of the level transform the engine applies next; only then does the loaded game drop the records the step reset or that a placed actor back as placed left stale, and its actors held destroyed go, so a level the bounds refuse changes nothing. From then until LevelAddedToWorld the level is hidden from saves. A level the session captured as the same object takes nothing until a load changes the records. At FWorldDelegates::LevelAddedToWorld, after the level’s Begin Play, Finish sets the saved velocity and sleep of its simulating roots and its level instances’ saved state (FRollySaveFieldWait: the bodies exist only once its components registered, Play In Editor’s construction pass makes a Blueprint’s root again before this moment, and a level instance unloaded here never adds its level; a root that has no body yet waits in FRollySaveBodyWaits, which hears UActorComponent::GlobalCreatePhysicsDelegate only while one waits), respawns its spawned actors, applies the records that name them, its Level Blueprint’s among them, and those of After Begin Play actors, and in Play In Editor the placed records a second time without their ACTR sections and within bounds of their own; then On Area Reset and On Streamed Level Ready. After Finish, the copy FRollySaveShownAgain took as the level started to become invisible while it may return as the same objects (its engine state handlers’ captured records, its roots’ motion and its level instances’ state, which the engine tears down) applies to the actors the level’s apply set nothing for; a load drops the copies of its scope. A level instance’s level that starts to become visible as another level than its instance’s record names drops the records under the instance’s scope from the loaded game first (LevelInstanceChanged), whatever Save Level Instance State is. A load taken in between makes the level’s copies stale: Restart collects the loaded game’s records instead and applies them after its Begin Play. A level whose records name assets that are not loaded waits, hidden from saves, for one asynchronous preload and applies after it. A file’s records count once against its bounds (FRollySaveLoadedGame::GetAppliedBudget), read and written as each part applies; records this session captured apply within bounds of their own. When Asked records wait in batches (FRollySaveAskedRecords), each with its versions, bounds and a holder of what it names. The cell at a place is the runtime hash’s answer (FRollySaveLevelOwners::FindEngineCellAt), with a look through every cell when its query misses; a Spatial Hash cell holds a place by X and Y alone, as its height is only its content’s.

Instanced meshes (Instances/), on the server or in a standalone game; nothing ticks: the world part’s FRollySaveInstanceTrackers copies the design of each instanced component an actor’s Instances settings take, at the map’s actors initialized, as a streamed level starts to become visible and as it is added (a construction pass’s new component takes the design of the one it replaced), and when an actor spawns, before any saved value applies; a component first met at a save or a load, such as one the game added, starts from an empty design. As the world’s or a streamed level’s Begin Play ends, the instances Begin Play added join each tracker’s design, those it asked keys for included, so a design is what the component holds once its actor began play; a level added again only gives the components a construction pass made the designs of those they replace. With Instances off nowhere, no rule is resolved for this and nothing is kept. The engine’s instance events keep each ISM’s index map and its reverse; an Instanced Skinned Mesh component’s instances are followed by their IDs, taken by place for a design copied before registration. A capture (RollySaveInstanceCapture) writes the component record’s INST section: the design instances removed, those changed (by design index) and the ones added, each removed one with the Reset Clock time it went, read once per capture when no event gave it, or a Whole List’s every instance; a section a load kept goes beside it as INSK. An apply (RollySaveInstanceApply, from FRollySaveActorApply‘s component pass) puts a component back to its design when it is not there, then matches each entry to a design instance (FRollySaveInstanceMatcher) and sets what play changed; a section saved with Begin Play’s instances waits for the actor’s Begin Play, as an After Begin Play record does; a load in place puts every tracked component that does not hold its design back to it first. The reset step (RollySaveResetInstances) drops each instance’s entries by its own place, and an actor reset keeps its components’ INST and INSK sections.

Regrow After (FRollySaveInstanceRegrowth, owned by the trackers): removal times are saved, never due times. On Play Time one one-shot world timer wakes at the earliest due time among loaded components, its wait scaled by the world’s time dilation and at most 30 seconds of world time, and none is set while nothing waits; the timer holds one entry per removal and drops a component’s entries as its tracker goes. On a Game Clock due instances come back as their level is built and at Check Rolly Regrowth, which skips components that hold every design instance. A due instance comes back as the level designs it, unless the deciding Reset Area is set to Never with Reset Instances on, which keeps it on the timer until the areas change (HandleAreasChanged, from FRollySaveLevelTools); during a streamed level’s build (FRollySaveInstanceRegrowth::FLevelScope, from FRollySaveLevelApply::Begin) the stop places a component not registered yet by its place in the level and the level’s move, and reads the level’s own areas. On Instances Regrown fires once its actor began play.

Broken geometry collections (Destruction/), on the server or in a standalone game; nothing ticks: a capture asks the world actors’ FRollySaveDestructions for each geometry collection component whose actor’s Destruction is not Off: a collection whose root broke gives its pieces as RollySaveDestructionCapture reads them from the dynamic collection, with the import of its rest collection and its structure hash, computed once per asset; a section a load set is written back byte for byte while every placed piece lies within 2 cm of where the restore put it; a kept section is written back while the collection stands whole. An apply (FRollySaveActorApply‘s component pass) checks the section’s flags, then its rest collection, piece count and hash against the live ones; a registered collection is restored at once (RollySaveDestructionApply: one physics thread command releases the pieces that broke at their saved places, disables the removed ones and marks them fully decayed, with the proxy’s break and crumbling notifications off around it), and one not registered yet waits, to be checked again and restored as its physics state is made (UActorComponent::GlobalCreatePhysicsDelegate, listened to only while a section waits or is set) or as its level’s HandleLevelAdded or FinishLevel reports it shown. A section a load set ends as the collection’s physics state is made again, which builds it whole from its rest collection (Reset State, a registration). The world’s physics steps (FPhysScene_Chaos::OnPhysSceneStep), heard only from a restore until its step shows the break, give a custom renderer the restore forced off its root proxy the proxy back, so a paused game keeps it. Shutdown, from the world part’s Deinitialize, ends both listeners. A load in place first makes the broken collections of its scope whole (ResetBroken), as a streamed level’s apply does for its own when the level is the object it was before the load. As a streamed level starts to become invisible, its broken collections’ sections wait for the same objects to register again, since the engine makes them whole as they do: a level the engine keeps loaded comes back so, as does one that unloads and is asked for again before garbage collection takes it. A level the engine trashes as it unloads (ULevelStreaming::ShouldReuseUnloadedButStillAroundLevels) keeps nothing, and the sections of a collected level go as those of gone components do. A capture never carries a loaded GCOL section into a record (FRollySaveGameCapture::CarrySections knows it), and past the file’s bound on pieces it leaves out the collection’s section alone.

Hide Destroyed in HLOD (FRollySaveHLODHiding, owned by the world part): it follows the HLOD runtime subsystem’s registered and unregistered events and, as each HLOD actor registers and after each load (FRollySaveWorldEvents::HandleLoadApplied), calls Destroy Actor on each entry of its destructible HLOD components whose name, as a placed actor’s ID in the map, the actor tracker holds destroyed. With the setting off it keeps no HLOD; turned on during play, it finds the HLOD actors registered meanwhile (CatchUp) at the next registration or load. While the tracker holds no placed actor destroyed it reads no entry. The engine replicates the state from a server and applies it in a standalone game.

Actor groups (RollySaveMapSegments, RollySaveScopes): an actor’s resolved Group (FRollySaveWorldActors::ChooseGroup, a child actor taking its host’s) tags each record it and its components and handlers capture (FRollySaveRecord::Group, in memory only). In memory a map has one WRLD chunk holding every group’s records, so the record index, level memory, streamed levels and the reset step see one chunk per map; FRollySaveLoadedGame::Read merges each LSEG <map>|<group> chunk into it, refusing a duplicate subject or a key that is no map and group, and FRollySaveGameCapture::WriteChunks splits it again (RollySaveMapSegments::Split). Scopes judge a map’s records one by one (RollySaveScopes::IsInScope with the record, IsGroupInScope): World takes the records without a group, Groups those of the groups named, so part saves keep, part loads apply and loads remove unsaved spawned actors per record.

Spreading work (FRollySaveCapturer, FRollySaveSpreadCapture, FRollySaveSpreadApply): FRollySaveCapturer::Prepare captures the globals, players and handlers in the save’s first frame and, for a kind Save Kinds lists, hands the actors’ subjects to a core ticker that captures within Save Time per Frame each tick, at least one subject a tick and a tick’s end only between two actors (RollySaveActorIds::FindActorKey), skipping a tick while a Save Block is on, and capturing the rest once Max Save Frames frames have passed. At its end the records of subjects that went or whose level unloaded are dropped, the destroyed actors added and the file written; a load (FRollySaveGameLoader::SetBeforeStart), a travel (FRollySaveWorldEvents::SetBeforeLeaving) or the game’s end finishes it at once, counting that frame, and later saves wait in order; a finish asked from inside a subject’s capture ends it once that subject’s capture returns. After Begin Play records of a load that opens its map apply in batches of one actor’s records each, within Apply Time per Frame, on a core ticker, the load’s preload held until they end, charging the loaded game’s applied budget as each batch applies. The busy gate (FRollySaveCallChecks::PassBusyGate) and a travel’s leave finish them in one frame (FRollySaveGameLoader::FinishSpread); a streamed level’s unload capture, whose actors no apply finds once the level is being removed, keeps the loaded game’s records of the actors whose values wait and takes them out of the spread (TakeSpreadPending); their end runs the waiting saves on the next tick.

Holding players (FRollySaveHolds, RollySaveGround, FRollySaveWorldReady): FRollySaveWorldReady follows each load from On Load Started; at its On Load Finished it holds each player of the world whose pawn is there and whose records are set, and lists the others the Game Mode gives a pawn (Arriving), held once a possession gave the pawn and FRollySavePlayerLoad set its records (its applied callback), with a one-shot ticker of Max Hold Time ending that wait; it becomes ready once none of them is held for the load or awaited and the spread values are set, reporting Waiting for World meanwhile, and tells OnBecameReady also when a wait ends without On World Ready. A hold that waits for ground binds UWorldPartitionSubsystem::OnStreamingStateUpdated and FWorldDelegates::LevelAddedToWorld, and, outside World Partition or for a client’s level, a ticker four times a second, only while such a hold exists, and each a one-shot ticker of Max Hold Time; a possession moves the hold’s stop to the new pawn on the next tick (FRollySaveHolds::HandlePossessed); a controller that goes drops its holds; a world that goes ends the holds made in it or of its players without events.

Data layers (URollySaveDataLayerState, RollySaveDataLayers): the world part holds the record object and lists it among the map’s globals in a World Partition map with Save Data Layers on; its OnRollySavePreSave fills it from the world’s UDataLayerManager, and its OnRollySaveLoaded, in the map’s apply before Begin Play, sets the layers through SetDataLayerInstanceRuntimeState, comparing saved layers with each instance’s full name, so nothing in the file becomes a name or a path; the loader adds its Issues lines to the load’s.

Components that appear after a load (FRollySaveLateComponents, whose header gives the listener’s rules): a component record whose component is not there waits by actor and name until an object creation listener sees the component made, and applies the next frame through RollySaveWorldApply::ApplyLater. A level that starts to unload drops the records of its actors’ components (ForgetLevel), since the engine destroys its actors without telling of each; a level the engine keeps loaded while invisible keeps them.

Slot metadata (Slot/): after the captures, FRollySaveSlotState::MakeValues gives the map, the play time, the place, the kind and the game fields, and FRollySavePlaythrough::EncodeMetadata writes them through RollySaveSlotMetadataCodec::Encode as one URollySaveSlotMetadata record under the global ID SlotMetadata in the header field META; past 16,384 bytes the game fields are left out (FieldsTooLarge). FRollySaveSlotList lists slots from the headers the slot index keeps (DecodeHeader, MakeSlotInfo), decoding each entry’s metadata once per copy, sequence number and hash, and never reads a save. The metadata holds the title and whether the header holds a picture. FRollySaveSlotTitles rewrites a slot’s newest copy with a new title inside the slot’s hold, keeping a title for a slot without a save in FRollySavePlaythrough until that slot’s first write; a save to a new slot lists the slots, then reads the lowest free slot_<n> inside its hold and writes there (FRollySaveStamp::bSlotHeld, so the write goes before the slot’s waiting requests), trying the next number when the slot holds a save.

Thumbnails (Thumbnail/): FRollySaveThumbnailCapture keeps the pictures asked of the next frame, each with a weak pointer to its shot, and asks its image source for that frame: FRollySaveViewportImageSource binds UGameViewportClient::OnViewportRendered, where the world and the HUD have drawn and Slate has not, only while a frame is wanted. At the frame the capture drops the requests whose shots are gone, as when their saves went on without them, and reads the rectangle around the rest once, the one wait on the GPU; each picture’s pixels are converted from the read (also from linear colour), cut to Aspect, scaled and encoded on a worker (RollySaveThumbnailCodec::ToImage and Encode), stepping down JPEG quality, then width, within Max Size, the result coming back through RollySaveWorkerTask. A Manual or Quick save takes the picture Capture Rolly Save Thumbnail or Set Next Rolly Save Thumbnail held in the current map; a save of a kind Kinds lists asks for one otherwise, none with Max Wait 0. URollySaveSubsystem::CaptureThumbnailHold gives the shot to its caller in an FRollySaveThumbnailHold instead of holding it, so each of several menus keeps its own until UseThumbnailHold holds it for that menu’s save; LoadThumbnailHold waits for the shot’s encoding without a time limit and decodes it on a worker. FRollySaveStorageWrites counts each save from its call to its store request as one of the store’s operations (URollySaveStore::BeginWork), so Flush waits for it; the save waits through FTSTicker at most Max Wait. A flush of the game’s store or FlushAll (FRollySaveStoreCore::OnFlushStarted, IsFlushing, both by store ID, 0 for all) ends the waits whose frame has not come and answers such waits at once while it runs, since no frame draws inside it; another store’s flush leaves them; an encoding still running posts its result to the mailbox the flush runs. The game instance’s end ends every wait. FRollySaveSlotThumbnails reads a slot’s newest copy’s header with the picture (ReadNewestHeader, nothing read when the copy is the one it holds), checks the picture’s format and size before any pixel decodes (Decode) on a worker, makes the texture on the game thread and keeps it in a least recently used cache by slot key, up to Cache Size, dropping a slot whose read finds no save or no picture.

Part saves (FRollySavePartSaver, RollySavePartSave::Merge): the scope’s parts are captured at the call (RollySaveScopes::IsInScope) with what the loaded game keeps of them, and so are the metadata’s values. The metadata’s profile key is read once the first player’s key is known (FRollySaveStorageWrites::ReadHeld with the key). The slot is then read through FRollySaveSlotHold::RunHeld: from that read until the merge queued its write, later requests of the slot wait, so the merge never writes older content over them. The slot’s save is read with ReadChecked, migrated when its Game Data Version is lower, and its records outside the scope are kept, counted in the file’s bounds and written with this build’s versions; a damaged or newer slot is refused. The loaded game stays as it is.

Part loads (FRollySaveLoadRequest::Scope): the load reads, checks and migrates the whole file, finds the parts it lacks (RollySaveScopes::FindMissingParts), preloads and applies only the scope’s chunks in place, and FRollySaveLoadedGame::TakePart replaces those chunks in the loaded game when CanTakePart allows it (records of the same versions); otherwise the result says PartNotKept. A part load without World applies the players’ records with ERollySaveActorLoad::Part, so the last whole load’s restored marks and waiting component records stay.

Moving saves (FRollySaveTransfers): a copy holds its target with an FRollySaveSlotHold::FToken from its check to its write, and a rename holds the source too, taking the lower file key first, so two renames that swap names never each hold one slot while waiting for the other; the source’s newest copy is written under the new name, and a rename deletes the source once the write succeeded. An export writes on a worker through a temporary file moved into place (RollySaveTransfer). An import reads at most Max Import Size bytes, runs RollySaveImport::Check (kind, versions, Game Data Version, every record’s structure, and the run rules, passed in as a function), then, inside the target’s hold, stores the file only when the target holds nothing.

Memory slots (FRollySaveMemorySlots): whole-game saves on a store over a memory backend of the game instance’s own, without a slot index. Written saves are listed by serial and the oldest of its kind goes past its bound; a delete records the serial counter, so a save that began before it drops its files. Rewind loads the point Steps back from memory and drops the newer ones.

Save blocks (FRollySaveGate): blocks by weak object and reason; saves the player asks for pass PassBlockGate. The subsystem binds a blocking actor’s End Play; the gate listens to garbage collection while an object that is no actor holds a block. When the last block goes, the waiting autosave and checkpoint run on the next tick.

Autosave (FRollySaveAutosave): the game instance’s one-shot timer (FTimerManager, which pause stops) and RequestAutosave lead to one decision: dropped when autosave is off, the world is a client’s or excluded, or, for a request, Minimum Gap has not passed since the last save to storage; waiting during a load, seamless travel or a save block, until RunWaitingSaves runs it once FRollySaveCallChecks::CanRunWaitingSaves allows. The target is the run’s slot, the current slot under Current Slot, or the ring: the game is captured first (FRollySaveCapturer::Prepare), then ChooseRingSlot picks the slot after the highest autosave number, reading the headers the slot index lacks where the storage cannot list, and nothing is written when FRollySaveCapturer::HasLoadSince reports a load started since the capture (FRollySavePrepared::LoadsStarted). Every save to storage arms the timer again.

Checkpoints (FRollySaveCheckpoints): the whole game into storage (the checkpoint slot, the current slot or the run’s) and, outside a run, a retry copy into the memory slot checkpoint. It reads the save blocks itself: while one is on, the newest checkpoint waits for the last block to go.

Single-slot runs (FRollySavePlaythrough, FRollySaveRunSlots, RollySaveRuns): StartRun binds the run when its slot, inspected inside its hold, holds nothing; while bound, quick saves, autosaves and checkpoints go to the run’s slot and other targets are refused. A write into it stamps the next run number into the metadata; once written, the first local player’s ledger (URollySaveRunLedger) records it and the profile saves. Before anything of a load applies, CheckRunLoad refuses an ended run, a number outside 1 to 10^12 or one below the ledger’s; while the first player’s profile loads, loads and imports wait (FRollySaveProfiles::WhenFirstLoaded). EndRun of the active run unbinds it, clears the current slot and records the end at the call; then, through RunHeld, it loads the slot, records the end of a run it did not know, and deletes the slot or writes it back with run state Ended.

Profiles (FRollySaveProfiles): FRollySaveGameServices binds the local players’ arrivals (OnLocalPlayerAddedEvent, after their subsystems start) and departures; an arrival loads <prefix>_profile_<key>. The file must be a profile; it passes CheckGameDataVersion and ReadChecked, migrates, preloads, and its records apply by role (FRollySaveProfileObjects) to a new Profile Class instance, the local player, its subsystems and a new run ledger; records of other roles or of objects not there are kept. Where the storage keeps users apart, each other player gets a store on the backend URollySaveBackend::MakeUserBackend makes for it. Only Succeeded and Not Found make a profile usable; otherwise the file stays as it was, and saves are refused until a load succeeds or Reset Rolly Profile deletes both copies. The calls by player controller (LoadFor, SaveFor, ResetFor, FindFor) refuse a controller of no local player of the game instance; services read the first local player’s key through FRollySavePlaythrough::GetFirstProfileKey. With Profile Keys at Named, FRollySaveNamedProfileKeys resolves each player’s key before its profile loads, one player at a time in the order asked: the URollySaveProfileChoice record in the platform user’s own profile file (FRollySaveProfileChoices) names the profile; a player without one gets a new profile named after New Profile Name, or at Max Named Profiles what When Profiles Are Full says, and the choice is written back keeping what the file held (RollySaveProfileFiles), a damaged file replaced. FRollySaveProfileCatalog lists named profiles from the slot index by name, writes new ones under random keys, and claims a key from a Use Rolly Profile call or a resolution until the player’s entry holds it (claims are counted per player, so a Use call and that player’s resolution can hold one key together), so a second player’s Use, a joining player and a Delete never take it; FRollySaveProfiles::Switch and the resolution’s end refuse a key another entry holds. Use Rolly Profile switches a player’s entry to another key as a joining player’s load does, after FRollySaveProfileObjects::ResetPlayerObjects set the player’s and its subsystems’ SaveGame properties back to their class defaults; loads and preloads find their entry by the load’s number, never by key. Saves to storage and part saves made while the first player’s key is being found wait for it (FRollySaveProfiles::WhenFirstKeyKnown) outside a flush. A Use Rolly Profile call on a player whose key is being found ends the resolution: BeginSwitch gives the entry a new load number, which the resolver checks before each write (it deletes a profile it made for nobody and writes no choice), Switch runs the waiting saves with the new key, and a Use that fails resumes the resolution (EndSwitch).

New Game+ (FRollySaveNewGames::StartNewGamePlus): after every check, FRollySaveCapturer::CaptureCarry captures Carry’s parts with the loaded game’s kept records of them and a Session record whose map no world has, so the players take their values without their place, and AddNeverAreas adds the levels whose Never areas New Game+ keeps (Level tools, step 5). The file goes to the memory slots’ carry store; the loaded game, kept levels, current slot, run, checkpoint copy and rewind points are dropped; and the loader loads the file into the given map as a part load of the parts it holds. FRollySaveGameServices starts the next cycle once that load applied, so a map that does not open leaves the cycle as it was.

Migrating a save (FRollySaveMigrationRunner::Run), in a load after the records’ check and before the preload:

1. The steps whose To Version is above the save’s Game Data Version and not above the project’s, sorted stably by To Version, then list order.
2. Each step runs in its own Migrate call with a new serial and context; URollySaveMigrationContext::FRunScope points the context at the save’s FRollySaveMigrationRun for that call. The run owns the edit rules: find a live record, remove (flagged until the step ends, so handles keep their meaning; a handle of another serial is stale, StaleRecord), touch, add and fail.
3. Reads compare the saved tag’s type name with the property’s (UE::FPropertyTypeName) and read through the save archive over a values-only apply table, where pointers to saved, owned or unloaded objects and texts of unloaded string tables read as empty: such a read fails with PointerNotRead, since writing the value back would lose them, and copies nothing. Writes encode one tag through the record’s own capture tables (FRollySaveCaptureTables::BeginEdit), so indexes stay; a write the archive stops or CheckRecord refuses restores the record and fails the step.
4. After Migrate, a step fails on Fail Migration, a refused edit, a Blueprint script exception (FBlueprintCoreDelegates::OnScriptException), or a changed or added record that fails the check by saved types (FRollySaveMigrationRun::CheckTouched), bag layouts counted across the changed records.

Level tools (Level/), on the server or in a standalone game; nothing ticks:

1. A Rolly Save Trigger binds its shapes’ overlap events at Begin Play. An actor that appears inside while saved values are set (URollySaveSubsystem::IsRestoring, counted by URollySaveSubsystem::FRestoreScope, which RollySaveWorldApply’s applies open too), during seamless travel or in the frame it was spawned (FRollySaveTriggerWatch, which records spawns only while a trigger is registered) is recorded without triggering; with Trigger on Appear it is checked once the restore ended, the world’s Begin Play ended or on the next frame.
2. A trigger that passes its checks (Enabled, Trigger By, Players, Filter, Except, Triggers, Cooldown, Can Trigger Rolly Save) sets Triggered, fires On Triggered and runs its action (FRollySaveTriggerActions); a failed save clears Triggered for Once and Once per Visit.
3. Reset Areas register with the world’s FRollySaveLevelTools. At OnWorldComponentsUpdated, before level memory or a load removes or applies anything, FRollySaveWorldEvents::BuildResetAreas reads the clocks once (FRollySaveAreaClocks) and takes the map’s area record out of the load’s or the remembered level’s chunk (RollySaveResetAreaRecord); on a return it first waits for the arrival’s preload. RollySaveResetStep then drops from the chunk the records of every saved actor a due area resets, so the level builds it as designed.
4. Areas take their state as they register; On Area Reset fires after the world’s Begin Play. Leaving a level sets every area’s leave times, and a save or a leave captures the record (URollySaveResetAreaState) into the map’s WRLD chunk, with snapshots of the areas on spawned actors.
5. New Game+ (FRollySaveNewGames::AddNeverAreas, FRollySaveLevelMemory::CollectForNewGamePlus) carries the WRLD chunk of the current level when its tools hold an enabled Never area (FRollySaveLevelTools::HasNeverArea) and, with Remember Levels on, of each remembered level whose record lists one. RollySaveResetAreaRecord::MarkForNewGamePlus marks the record (bKeepOnlyNeverAreas), so every other area starts as designed and the next build keeps only the records the Never areas decide for.

In the editor, each placed tool class makes an editor-only sprite and label (RollySaveToolLook), the sprite’s transient texture coming through RollySaveToolSprites::Find, so a map saves no reference to it. The details customizations act for the actor or for the component the panel was opened on (IDetailLayoutBuilder::GetSelectedObjects), never both.

The old-save check (RollySaveOldSaveCheck::Check, editor builds only, since it blocks while it preloads) runs a load’s steps on a stored file without a world: CheckVersions, CheckRecords, the steps, the saved map, a preload that waits, then per record its class (MissingClass) and the structure check against the class’s default object, with findings (FRollySaveCheckFindings). The editor module’s RollySaveOldSaveCases reads each case through URollySaveFolderBackend. FRollySaveBuildCheck runs the same steps (FRollySaveOldSaveSteps) without blocking: the preload asynchronously, then each record against its class in slices of an FRollySaveSlicedJob, with the blocking check’s report.

Inspecting and editing a save (Inspect/): URollySaveStore::LoadCopy reads one copy through the file’s queue, writing nothing, and FRollySaveFile::Diagnose reports every checksum of its bytes. FRollySaveInspectFile::Make splits a file into chunks and records on a worker; RollySaveValueCodec::Decode runs a record’s structure check by saved types, then reads PROP, PATH and INLN into values as the walker read them (RollySaveSavedTypes), ACTR and COMP into their fields, and keeps everything else as bytes; each top-level value and each section is encoded again into a matcher that compares in place, so a decoded record always encodes to its own bytes, and a value that would not is kept as bytes and counted in Fallbacks. FRollySaveRecordDecode does it in steps: the structure check one top-level tag per step (RollySaveStructureCheck::FSavedTypesSteps over FRollySaveValueWalker::BeginObject and CheckNextTag, 1,024 elements of a large top-level array, set or map per step), then a top-level value per step (512 elements or entries of a large top-level container per step, each compared with its bytes as it is read), and each copy of more than 64 KiB (packed elements, bytes kept as saved) made 1 MiB per step through FRollySaveByteFills, whose sources the matcher accepts without reading them again. FRollySaveStagedEdits stages each change on a copy of its state and refuses it (ERollySaveEditRefusal) before it changes anything; each change names its value by FRollySaveValueIds, so a revert replays the others on their own values. Values are written only when FRollySaveInspectFile::HasRunningValueVersions holds: the package version and every custom version the file records are this build’s, and it records the text and record versions the value forms read; an archive answers a version it lacks as -1, but a version only this build registers belongs to no type the file’s values can hold. Build encodes the changed records into their own tables, appending what they lack, refuses one whose ACTR or COMP fields a section would leave out (RollySaveActorSections::FindLeftOut), checks every record of the file as a load does under one budget, writes the title and Game Data Version, marks the file edited (EDIT) and holds it to the format’s limits. The caller writes it with URollySaveStore::Save and the opened sequence number, so a save made meanwhile ends it with Changed. RollySaveFileDiff::Compare matches header fields, chunks, records and values by key through maps, compares matched records’ bytes 1 MiB per step and decodes only records whose bytes differ; a large top-level container compares 256 elements or entries per step, and chunks that hold no records compare, then when they differ are checksummed, 1 MiB per step; a packed container’s differences become runs, 1,000 per container and 128 per step at most, the rest counted, and a record’s entries stop at its value limit with one entry counting the rest.

The Save Inspector (Inspector/ of the editor module): the model reads every source through RollySaveInspectTransfers on a store of its own whose index upkeep is off, so opening a slot writes nothing; a slot’s two copies are read with URollySaveStore::LoadCopy and diagnosed, and the copy a load would take is shown. Rows are made from the model on demand, values a page of 1,000 at a time. Staged changes live in an FRollySaveStagedEdits per open source; a write passes the sequence number the slot had when it was opened, so a save made meanwhile ends it with Changed. The record checks, Check Against This Build, comparisons and exports run as FRollySaveSlicedJobs within the Editor Preferences’ Time per Frame, and a job of a source shown before reports nothing. A comparison reads the right file once and builds a RollySaveFileDiff whose entries carry both value paths, which Use Right Value and Use Right Record stage through SetValueFrom and UseRecord. The running game’s source is the loaded game the play world’s subsystem holds, copied by an FRollySaveDebugSnapshotBuild in a sliced job and moved into the source’s file, read-only; Refresh and Follow Saves take it the same way. Each copy and file is diagnosed once per open, on the opener’s worker beside its split into records, and the side panel’s sizes come from the prelude; the copy marked Loads is the one URollySaveStore::FindLoadedCopy names; texts that read the model are made again only when it broadcasts a change (RollySaveInspectorWidgets::MakeModelText), and the export dialog checks its file name when it changes. A change staged while a write runs is refused with Writing.

The Gameplay Debugger category (Debug/): while the category is on, the server collects the game’s snapshot and the debug actor’s every half second, and the debugger replicates the lines to the client; RollySaveDebugLines turns a snapshot into lines, so the category and the tests draw the same text; the Save Inspector’s Running Game section lists the snapshot’s own fields. FRollySaveDebugRecorder keeps the debug actor’s record facts with the loaded game’s stamp, so a record is decoded again only after a change. The instance, destruction and PCG lines (RollySaveDebugParts) count each tracked component with the capture’s own code in a mode that changes nothing, so they show what a save would write; the world’s lines read every live tracker, work linear in the tracked instances, twice a second only while the category shows.

Saves as JSON (Json/): RollySaveJson::Write writes the header, every chunk and every record, each value readable when FRollySaveJsonValueWriter::IsExact holds and HasRunningValueVersions holds for the file, otherwise its bytes in Base64, streamed in UTF-8 to an archive in blocks. RollySaveJson::Read takes the engine’s token reader one token at a time through FRollySaveJsonCursor, which counts nesting, keys and bytes as each token arrives; FRollySaveJsonRecordReader charges each value, table entry and byte array against what is left of the decoded save’s limit before making it, and encodes each record as its JSON closes, names found in its table by how they show; keys compare case-sensitively through RollySaveJsonReading::IsKey. FRollySaveJsonTransfers reads a slot in its request order, splits it on a worker, decodes and renders one record at a time in slices on the game thread, keeping only the rendered text (RollySaveJsonRender), writes the file on a worker through a temporary file, and for an import reads the file within Max JSON Import Size on a worker, writes and reads the file it holds, then hands it to the import’s checks (FRollySaveTransfers::StoreImported) marked as edited by a JSON import.

Importing an engine save (FRollySaveEngineImports, FRollySaveEngineSlotImport, whose header gives the order): the platform save system’s calls run on the platform backend’s queue; RollySaveEngineSlotHeader::Parse reads the header within bounds; the saved class is checked against the expected one before anything loads or is created, and a Blueprint class the asset registry knows as its child (GetAncestorClassNames) loads asynchronously. The properties are read through FRollySaveEngineSlotArchive once to find the assets they name, which are preloaded, and again into a new save game; what is still missing reads as empty, listed in Issues.

A load reports its start (On Load Started) and its phases (On Load Progress): Reading at its start, Migrating before the steps, Loading Assets at 0, after each preloaded package and at 1, Opening Map before the travel and Setting Values before the apply; each report checks that the load still runs after the game’s code ran. A load Cancel stops raises On Load Cancelled instead of On Load Finished, and the services run what waited for it as after a finished load: the autosaves due meanwhile and the triggers’ end of restore.

The Blueprint nodes (Nodes/): the game instance holds each node until its result, which arrives on a later tick through a weak pointer and fires Success or Failure by its Status; Activate starts the subsystem’s call with the node’s display name for setup messages. A node without a game instance fails with Invalid Input on the next tick. Load nodes cancel by the load’s number, so a refused node never stops another load.

The quick keys (FRollySaveQuickKeys) bind the game viewport’s OnInputKey once the viewport exists (UGameViewportClient::OnViewportCreated), read Project Settings at each press and call Quick Save or Quick Load; the gates refuse a client.

Capturing an object (FRollySaveRecordWriter::Capture, whose header gives what saves and how each reference is written): the subject’s OnRollySavePreSave runs (RollySaveHooks), a class a Blueprint compile or Live Coding replaced is refused, and the save archive (FRollySaveArchive: save-game, without deltas, persistent and filtering editor-only data, so the editor writes what a packaged game does) serializes it, through SerializeScriptProperties for actors and scene components and Serialize for other objects. Names, imports and references go into the record’s tables (FRollySaveCaptureTables), names by display index, so names that differ in case stay apart; each object the subject owns gets one INLN entry, written after its outers’ with its own OnRollySavePreSave. The bytes become PROP and INLN, and the record passes the structure check a load runs, in the budget the caller gives every capture of the file; a refused record leaves the budget as it was.

Applying records (FRollySaveApplySession, or FRollySaveRecordReader::Apply one at a time; the session’s header gives the passes and their rules): RollySaveRecordCodec::CheckFile decides once per file whether its versions hold records. Prepare runs the structure check (RollySaveStructureCheck): the tables, INLN and the subject’s bytes walked against the target class as the engine reads them (FRollySaveValueWalker), with what property bags, instanced structs and texts (FRollySaveTextWalker) would allocate counted against the file’s bounds before anything is created; a failing record damages the file, and nothing of it applies. Apply reads PROP through the save archive with the file’s versions. Imports resolve after Core Redirects (RollySaveRecordRules::RedirectImport) among loaded objects only; owned objects are recreated when a property first refers to them, their classes checked first; the archive’s guards stop at a text nested more than 32 levels, a value nested more than 64 and a seek outside the bytes. Once every record applied, OnRollySaveLoaded runs on each record’s owned objects, innermost first, then on its target.

Preloading (FRollySavePreloader, whose header gives the asset registry’s checks): each hard import, at its path after Core Redirects, loads asynchronously through the preloader’s own FStreamableManager, held until Release, within FRollySavePreloadLimits (16,384 packages, 1 GiB on disk). The callback runs on the tick after the loads ended.

Records in bytes (RollySaveRecordCodec): a chunk payload is a record count, then each record’s size and bytes; a record is its kind, subject, class import, name, import and reference tables and sections. The decoder accepts only what the encoder writes, so a decoded payload encodes to the same bytes; record kinds and sections it does not know are kept whole.

Storing (URollySaveBackend): only FRollySaveFileName names reach a backend (ForSlot, ForProfile, ForIndex or parsed), so files of other names are never touched. Write, Read, Exists, Delete and List wrap the callback, pass on only the statuses the operation promises, run the callback once and count the operation for WaitUntilIdle, and call the subclass’s Start function. URollySaveGameSystemBackend runs the platform’s blocking calls one after another on one task queue (RollySaveGameSystemPipe) off the game thread; on iOS every write is read back and compared.

Keeping two copies (URollySaveStore, whose header gives the copy rules): each file has one queue (FRollySaveSlot) per storage ID for the whole process. A save is encoded on a worker as soon as it is asked for; at its turn it reads and verifies both copies when this session has not, and writes to the copy that does not hold the newest valid save; until the backend reports, that copy counts as damaged. A load verifies both copies on a worker (FRollySaveFile::Verify) and decodes the newest valid one, falling back to the other. Backend reports only post steps to the mailbox (FRollySaveMailbox), which the core ticker runs on the game thread each frame and Flush runs while it waits. A save, load or delete tells the slot index of its prefix (FRollySaveIndex::Record), which writes its own pair through the same queue. The module flushes every store when the game goes to the background (3 seconds at most) and before the engine exits (10 seconds for the stores, later saves and the platform’s save system together).

A load holds both copies’ bytes and the decoded chunks of the copy that loads, so twice the file size plus the decoded size: a 4 MiB save that decodes to 10 MiB needs about 18 MiB while it loads, which matters on mobile. A save holds the decoded file until its worker has encoded it, then only the encoded bytes.

Leaving the game (FRollySaveLifecycleDispatcher, Platform/): the module binds the engine’s background, foreground, world teardown, login and window focus events once per process, so their reverse call order cannot flush before a capture. At each, the dispatcher tells every registered game instance (FRollySaveLifecycleSaves), which, where a game is in play (FRollySaveGameInPlay: from a whole-game load or save in the map, in the map opened after a new game, through seamless travel; the game’s own change to another map ends it), captures in that frame and queues an autosave, then runs one URollySaveStore::FlushAll within Background Time Limit or Quit Time Limit: the platform stops ticking the engine after a background event, and an exit resets the core ticker, so the writes are driven through the store’s mailbox inside the event. The game thread waits here, bounded by those limits, since no frame follows that it could spoil. A quit saves at the teardown of the game world while the engine exits, before the game instance removes its local players, whose profiles hold the run ledger. A store flush also ends every platform preparation (URollySaveGameSystemBackend::PrepareStorage), whose answer would come on a later tick. Each user index has a sign-in generation (RollySaveUserGenerations), advanced at its sign-out; a game system backend is bound to one generation, checks it on the storage queue before each platform call, and puts it in its storage ID, so an operation queued before a sign-out never runs on the next sign-in’s storage.

Extension points

Tests

Named Rolly.Save.<Area>.<Case>, all headless. No name extends another test’s name after a dot: the automation tree would make the shorter one a group, which never runs, and TestNames fails then. Golden tests read fixture files that every later version must keep loading, from the project’s TestData/RollySaveFixtures folder; in a project without that folder they have no cases.

• File.*: round trips at every compression, damage at every byte, every truncated length, unknown and newer data, limits and invalid input. Forged, WriteBack and Mutations (4,000 seeded edits) recompute the checksums after their edits, so the parsers behind them see forged sizes, strings and fields; Golden reads the fixture files.
• Record.*: the codec’s round trips, truncations and forged counts, strings, imports and sections; Golden applies the manifest’s records to new objects and captures their content into the same bytes. Rename.* applies records written before a rename (properties, struct members, enum values, struct types, Blueprint variables and struct members, gameplay tags, classes, moved assets) with and without redirects.
• Archive.*: each saved type, the archive’s flags and versions, references and pointer kinds, soft paths, names that differ in case, replaced classes, owned objects (Inline, InlineClassChecks, InlineForgedChain), preloads (Preload, PreloadClassCheck, PreloadHoldsLoaded), NoSyncLoad, GCDuringApply, PropertyBag, IssueCap, the archive’s guards and CaptureCost.
• Check.*: a test per bound of the structure check, WholeFile (a file refused for one record), CaptureRefuses (a capture refuses what a load would) and Mutations (3,000 records edited at seeded bytes, each refused before anything applies or applied without stopping). Contract.*: the two functions’ forms, order and threads, Blueprint hooks, and ForeignProduct, which needs the stand-in product Tools/Fixtures/RollyStandIn installed beside Rolly Save and otherwise only says so.
• Api.*: the subsystem in a standalone game made without Play In Editor (FTestGame): globals, authority, the file budget, captures refused, registration, and loads whose travel FRollySaveLoadTesting replaces and whose next world is made as UEngine::LoadMap makes it (LoadGlobals, InPlace, LoadRefused, LoadCancel, Carried, KeptBudget, ClassRedirect, SameFrame, LoadRequest).
• Actors.*: actors placed as a map load places them, in loads that open the map again: IDs and their guards, Custom Save IDs, spawned and destroyed actors, respawn and create guards, DamagedSecondPass, attachments, child actors, late components, owners, control rotations, RemovedByLoadQuery, replication, and Golden over the golden actors fixtures.
• Rules.*, Paths.*, Timing.*, AttachedHandlers.*: matching, class entries, precedence, discovery, explain and reload of Save Rules made in memory; values saved by path, their setters, guards, members and redirects; After Begin Play and When Asked; attached handlers, their IDs, renames and index.
• Events.*, Players.*, Levels.*: the order of every call; local players logged in as the engine logs them in (a Game Mode Base, a match-based Game Mode, vehicles, another map, chunk guards); travel between test maps as UEngine::LoadMap and seamless travel do, with forgetting, restarts and carried actors.
• Async.*, QuickKeys, Handler.*, Cook.Rules, Commands.*: each node’s pins and statuses, Cancel, CallerGone, GameInstanceShutdown, NoGameInstance, ThenBeforeResult and Names; the quick keys on a game viewport; Save Handlers whose graphs are built as the editor builds them; the cook hook; the console commands (List and Dump write nothing).
• Thumbnails.*: pictures from a test’s frames (FRollySaveLoadTesting::SetTestPictures, frames drawn at once or when the test draws one, each read counted) and, with rhi, from a game viewport’s frame (Real); the wait, reads per frame, late frames, flushes, the kinds, a client and a dedicated server, split screen regions, the cache and every bound of the codec and the settings; the pictures menus hold (HoldNewSlots, HoldRelease, HoldNodes, HoldFailures: a client’s and a dedicated server’s empty holds, a frame that never came, a map change, player 2’s region).
• Slots.*, Scopes.*, Memory.*, Gate.*, Autosave.*, Checkpoints.*, Runs.*, Profiles.*, NewGamePlus.*, Transfer.*: slot metadata, titles, new slots, the current slot, its guards, play time and Golden; titles that wait (PendingTitle, NextTitle); named profiles (Named, NamedGuards, NamedRaces with two players at once, NamedChoices over forged and damaged choice files, NamedBounds, SwitchResets); part saves and loads, their Overlap with other requests of the slot and the game instance’s end (Shutdown); memory slots and rewind; save blocks; autosave, checkpoints, runs (Import, LedgerLoading, EndOverlap, EndShutdown), profiles (PerUser, FileGuards), New Game+ (KeepNever and its variants) and moving saves (Overlap, Shutdown, export listings, imports of Max Import Size and one byte more); each guard is fed its bound and one past it.
• Hold.*, Spread.*, Groups.*, DataLayers.*: holds over a test answer for the ground (FRollySaveHoldTesting::FGroundScope) and over the world’s own trace with a floor streamed in or spawned, stopping a character, a Floating Pawn Movement and a simulating root, following a possession and a seamless travel, a match-based Game Mode’s late pawn, with a client’s levels answered by the test (FClientLevelsScope), since a connection needs a server’s net driver; spread captures and applies on a test clock (FClockScope), with a Save Block, Max Save Frames, a load, a travel, a pre-save function’s load and the game’s end, and saves, autosaves and travel during spread values; groups through whole and part saves and loads, a listen server’s part load, level memory, the reset step, streaming, New Game+, a child actor, a later build’s change and the segment key’s guards; data layers through the engine’s Data Layer manager on its World Partition test map /Engine/WorldPartition/UnitTests/FourCubes opened as an editor world, where every layer starts Unloaded, since only a game world starts them in their start states, and through real saves, loads and travel with that manager given to the test’s game world (FRollySaveLoadTesting::FDataLayerManagerScope). Streaming.Scale.RoundTrip streams, saves and loads 2,000 actors in 50 levels.
• Storage.*, Store.*, Index.*, Settings.*: the key rule against a separate XXH3 implementation, each backend’s statuses, GenericFiles on real files in Saved/SaveGames beside other files that stay byte for byte as they were; the store on a fault-injecting backend (copies, damage, killed writes, queue order, results from worker threads, flush limits) and Store.Fixtures; the slot index with and without listing; each setting’s fallback and setup error.
• LevelTools.*: triggers and Reset Areas with walkers moved as walking moves them and volumes given brushes as the editor gives them: checkpoints, appearing actors, who triggers, modes, Triggers.RestoreScope, Triggers.SpawnTracking, resets on a return, seamless travel, game time and loads, the guards of the area record, snapshots, clocks, the grid and saved entries, and that garbage collection frees a world once it ended.
• Migration.*, OldSaveCheck.*, Commandlet.ExitCodes, Import.*, Globals.Golden: step order, exact types, pointers and string table texts not read, bounds, built-in and Blueprint steps, Data Validation, and Chain over the chain’s fixture files at Game Data Versions 1 to 3; the old-save check and commandlet over folders of saves written for one test; engine save imports from a fake platform save system, Fixtures among them; the golden globals fixture.
• Editor.Checks.*: each check over the editor’s map with level tools placed as the editor places them, or over World Partition data made from placed actors; severity rows, ignore rules and the validator’s use cases; the Message Log’s order, tokens and fixes; the checks after a save of maps and rules saved to disk under a mount point of the test; the commandlet’s exit codes and lines; the config writer on a scratch file; Checks.Streaming, StreamingIds, StreamingFacts, StreamingScope and StreamingHidden: Reset Area in a Streamed Level and the IDs of level instances, from facts and from sublevels on disk, unloaded or loaded hidden. StartSlot.*: the command line, with FRollySaveLoadTesting::FStartSlotScope.
• Editor.Outliner.*, Editor.Markers.*, Editor.Setup.*, Editor.PlayFromSlot.*, Editor.UserSettings: the column’s states, sorting, filters and updates, the marker picker over a fake screen and the marked actors of the editor’s map, the setup model and its rows (Setup.Rows) over a scratch config file, the slot list over files in memory and the load at Play In Editor start in a test game; PicturesSetup with rhi.
• Inspect.*, Json.*, Debugger.*: the value codec’s exactness over every saved type, packed arrays, edits and their refusals, field edits, reverts, the record checks in slices, the build check and diffs; JSON round trips, the golden exports, every guard at its bound and one past, compact output, exports streamed and ended by the game’s end, imports and their messages; the category’s lines and the game’s snapshot, held players included (Debugger.Holds), and the lines of instances, broken collections and PCG components on a server and a client (Debugger.Instances, Debugger.Destruction, Debugger.PCG).
• Editor.Inspector.*: the inspector’s model and views over files in memory: Registration (the tab and menus), Sources (slots, profiles, the index, Open by Name, files, copies, Recent Files), Contents, Values (pages of 1,000 and one more), Edits and ReadOnly, Compare (Use Right Value and Use Right Record), Locator, JsonDialogs, RunningGame, StreamedLocator, StreamedNotLoaded and StreamedLocatorPlay (sublevels and level instances in the editor’s and a game’s world), StreamedRows, RunningGameStreamed and RunningGameGone (real streaming: kept levels, loot that waits for its level or owner, loot destroyed in play); PicturesInspector with rhi.
• UI.*: the screens in a test game whose players’ screens draw in virtual windows, driven by a virtual Slate user, mouse and touch, with save times worded against a fixed clock: the model’s rows, groups, order and actions, every flow, the list’s states, requests, clients, keys and narration, the layouts’ sizes, split screen, the indicator’s timeline over the tween runner (Indicator.States) and its one Saved line (Indicator.SavedOnce), notices, the overlay through a test travel (Overlay.LoadProgress) and a seamless one (Overlay.SeamlessTravel), its wait for the world (Overlay.WaitForWorld, Overlay.WaitEnds), the held players’ plates (IndicatorHeld.States, SplitScreen, Settings, SeamlessTravel, ControllerGone, PlayerRemoved, UnderScreens), answers that wait for another player’s save and say when a save changed (Flows.Changed.Waits), the profiles panel, the setup rows, the settings’ bounds, and Pictures, drawn with rhi.
• Lifecycle.<Kind>.<Path>: the shared harness (Tests/Lifecycle/): each kind (Actors, Instances, Destruction, PCG, TestHandler, PhysicsSleep, LevelInstanceState, DynamicLevels, MaterialParameters, Timelines, LevelSequence, Montages, Audio, Blackboard, StateTree, ParameterCollections, ParameterCollectionsUnlisted, GAS) registers its places, Make, Change, Describe and its rules’ expectations, and runs the 14 paths of a level, a load or a travel (map load, Keep Current Map, hard and seamless travel, streamed back as new objects, shown again, reused, part load, respawn, construction pass, Begin Play, Reset Area, the designer’s change, listen server), compared with what Make and Change left; it checks the project’s settings at its start and prints its fakes and the paths a kind skips with the reason. Its sublevel ticks, as a streamed level does. After the sublevel leaves it lets the world’s streaming run, as a game’s next frames do, so the levels of its level instances leave too; FTestGame clears the editor’s standalone flag of the worlds its streaming loads, as Play In Editor does, and collects garbage when a world that streamed levels ends, as a map change does. HandlerTiming.*: Apply Timing in streamed levels and Play In Editor, capture decisions, waiting records, timing and Global Handler refusals, collection and unloading, shown-again copies, carried instances, the load paths and reloaded rules, on the test handler. PhysicsSleep.*, LevelInstanceState.*, DynamicLevels.*: sleep, level instance state and run-time levels on their paths, with their guards and messages; the spikes PhysicsSleep.Spike, LevelInstanceState.Spike, Sequences.Spike and Montages.Spike. Blackboard.*, StateTree.*, AI.*: the AI handlers on test pawns, controllers and trees made in memory, the spike StateTree.ForceTransition, the AI waits and their counters, E13 to E16 at their bounds and one past (AI.Guards, one case per guard group), each AI message with its fill-ins (AI.Messages) and the AI records through JSON (AI.Json); FTestGame gives its worlds their AI system as UEngine::LoadMap does. Materials.*, Timelines.*, Sequences.*, Montages.*, Audio.*: the built-in handlers on their paths, the audio ones on the named audio fake (FRollySaveLoadTesting::FAudioFakeScope) apart from Audio.NoDevice, the real path under rolly test, and Audio.Device, which needs rolly test ... audio; EngineState.Guards and EngineState.Messages: E1 to E9 and E19 to E21 at their bounds and one past, and each message with its fill-ins; HandlerTiming.* runs its cases on a built-in too.
• Destruction.*, HLOD.*: geometry collections made in memory (RollySaveDestructionTests: a bridge of 19 pieces, broken, reshaped and read on the physics thread) through every way a level comes back, each guard of the GCOL section at its bound and one past, and Hide Destroyed in HLOD on HLOD actors given destructible components as an HLOD build gives them, read through the replicated state; worlds call themselves listen servers by their URL while those HLODs begin play. Destruction.ListenServer and HLOD.ListenServer play a listen server and a client in Play In Editor (RollySaveNetworkTests::FPlaySession, on a new editor map), and HLOD.Standalone needs rhi.
• Editor.*: the editor over a fixture made in memory (RollySaveEditorTests::FFixture): the Content Browser entry, the rule editor, Pick Properties, SaveGame flags, Effective Settings with the Takes line (Precedence.Instances), the level tools’ labels, details, sprites, Place Actors and class icons, the Handlers menu and the handlers’ setup checks and texts (Handlers.*), and Pictures, PicturesLevelTools, PicturesSetup and PicturesInspector, drawn with rhi.
• HandlerTiming.*, Materials.*, Timelines.*, Sequences.*, Montages.*, Audio.*, PhysicsSleep.*, LevelInstanceState.*, DynamicLevels.*, Blackboard.*, StateTree.*, ParameterCollections.*, EngineState.*, AI.*: engine state and AI over actors, test pawns and controllers made in memory in a test game whose worlds get their AI system as a map’s do; the four engine spikes (PhysicsSleep.Spike, LevelInstanceState.Spike, Sequences.Spike, Montages.Spike) and StateTree.ForceTransition; audio on the named fake (FRollySaveLoadTesting::FAudioFakeScope), with Audio.Device on the machine’s audio device under rolly test <filter> audio; each guard at its bound and one past (EngineState.Guards, AI.Guards, ParameterCollections.Guards).
• GAS.*: Ability System Components on test actors, Player States and bots whose AI controllers hold them, with attribute sets, effects and abilities made in C++ (Tests/GAS/); the six engine spikes first (TimerSpike, PeriodicSpike, StreamedSpike, TagSpike, ClampSpike, PlayerStateSpike); the test tags exist only in the host project; each guard at its bound and one past (GAS.Guards); the client’s view on a listen server (GAS.ListenServer); the fixture v1_gas_state.sav in Actors.Golden.