Like every UE4 Plugin, the SSGE Plugin will appear in your Library ➔ Vault in the Epic Games Launcher, from where you can install it to your Engine, after that you can enable it in your project.

No Setup is required after enabling the plugin.

Simple SaveGame Extension is built to be as easy to use as possible, the only knowledge required is how SaveGames work in UE, the rest will be done by the plugin. The plugin gives access to an extended SaveGame object that can handle saving and loading of Objects and Actors.

The example project shows all features currently available in the plugin.

All content can be found in the folder Content/SSGE/.

There are two tutorials, the first explaining the functionality of the SaveGame, the second explaining the functionality of the WorldSave.

The project is currently outdated and will be updated in the near future.

Please try to refrain from stop Play-In-Editor or let players exit the game while Saving/Loading is in progress. Small saves are almost never a problem, but using the WorldSave and saving large amounts of data can take a couple of seconds, especially if the save is running in the background. This will almost never corrupt save files, but can crash the game/editor while exiting and create file artefacts.

All major features are exposed to Blueprints and no C++ knowledge is required to use the plugin. You can obviously use the plugin from C++ as well, but the Documentation will be limited to only Blueprints at this time, since the workflow is the same in C++ as it is in Blueprints.

To create a SaveGame, use the existing UE4 Function, all you need to do is, to use a subclass of SSGE_SaveGame as the SaveGame Class. After that, the created SaveGame Object will have Functions for Saving and Loading Objects or Actors.

These are the basic Save/Load Functions:



Pins of all functions contain an explanation for what they are used for.

When Saving/Loading Objects or Actors the variables marked as SaveGame are automatically handled by the Plugin, supported types include all basic types and structs.

The plugin includes 4 interfaces:

SSGE_InterfaceObject can/should only be added to Objects, it will be used in Object functions for additional options on how to handle that specific Object, it also includes callbacks

SSGE_InterfaceActor can/should only be added to Actors, will be used in Actor functions for additional options on how to handle that specific Actor, it also includes callbacks

SSGE_InterfaceComponent can/should only be added to Components, will be used in Component functions for additional options on how to handle that specific Component, it also includes callbacks

SSGE_InterfaceWorldSaveActor required for Actors that the WorldSave will automatically track, includes additional options required for the WorldSave

To Save/Load Components when Saving/Loading an Actor, the Actor needs an Interface called SSGE_InterfaceActor which has two Functions that need to be Overridden 

Both Functions take in an Array of Components that should be Saved or Loaded.

Default Components that are automatically handled by the SaveGame are SceneComponent (Only Transform), StaticMeshComponent, SkeletalMeshComponent and ChildActorComponent.

If you want other default Components to be supported, feel free to contact me.

Saving and Loading works the same way the existing SaveGame works.

To Save, first call Create Save Game Object or load an existing SaveGame, store all needed Data inside, call the appropriate functions to save Objects or Actors and then call Save Game to Slot to save all the data stored in that SaveGame.

To Load, first call Load Game from Slot, retrieve all stored variables and call the appropriate functions to load Objects or Actors and that's it. 

If you want to clear Objects or Actors stored in the SaveGame, you can use the ClearObject, ClearActor or ClearAll functions.

You should refrain from creating and loading multiple SaveGame Objects from the same Slot at the same time, since that could create multiple instances with different changes in the SaveGame, this may lead to the SaveGame only saving part of the actual changes to the persistent storage.

The Plugin has a couple of Settings which can be found under

Project Settings ➔ Plugins ➔ Simple SaveGame Extension

Settings contain things like Logging or whether Data should be compressed.

The Plugin supports the compression of Data, which can greatly decrease the size of the cached data in the SaveGame, meaning less ram usage and of course the size of the files stored on the user's drive. But keep in mind that compression will impact the performance of the game.

During testing, the performance of the game was decreased by about 10% (Single threaded) while the size of the SaveGame files were decreased by about 70%. These numbers will vary depending on your game.

Compression is enabled by default and can be turned off in the Settings.

Compressed and uncompressed Data are stored in separate files, and will result in different SaveGames when switching between them, therefore it cannot be changed at runtime.

The Plugin supports Single- and Multithreaded Saving/Loading, which can greatly increase performance. But keep in mind that calling non Async Functions in combination with Async Functions can potentially freeze the Game while a non Async Function waits for the Async Function to release needed Data.

You can use the existing Async functions or use the SSGE_Async functions to use multithreading.

The Plugin supports dynamic saving for Objects/Actors, which means it will only save data if it has changed, improving performance while saving large amounts of data.

To Save/Load multiple actors in a level automatically, you can create a Blueprint version of the SSGE_WorldSave and place it in the world. All actors that implement the interface SSGE_InterfaceWorldSaveActor will be Saved/Loaded automatically when calling Save/Load on the WorldSave, the interface exposes some functions to customize how the WorldSave handles specific actors.

The WorldSave can spawn actors on Load if needed (disabled by default) or delete those that were deleted prior to saving. The WorldSave can Save/Load in foreground (blocking the game) or in background (slower but none blocking).

If a WorldSave is present in the level at runtime, it can be accessed from anywhere using the node GetWorldSave.

You can check if the WorldSave is currently Saving/Loading by calling IsSaving/IsLoading on the WorldSave, this can be used to for example display the status on your UI.

If you want to use a custom or even generated Slot (Filename) for the SaveGame you can override the GetSlotID function in the WorldSave

To clear the data stored in the WorldSave use the Clear function.

If you bought the plugin, please leave a review on the marketplace.

If you have comments, questions, bugs, ideas or just want to show a project that uses SSGE, feel free to contact me any time. 

Email

Simple Save Game Extension (C) 2023 by Qygon

Special Thanks

Daniel Ravanelli