Implementing Autosave
How do games typically handle automatic saving? Should we save after every player action?
Autosave systems need to balance data safety with performance. Here's a typical implementation:
Event-Based Saving
Save after significant events rather than every action:
class AutosaveManager {
std::chrono::steady_clock::time_point
LastSave;
bool SignificantChangeOccurred{false};
public:
void OnPlayerAction(
const Action& PlayerAction) {
if (IsSignificantAction(PlayerAction)) {
SignificantChangeOccurred = true;
TryAutosave();
}
}
bool IsSignificantAction(
const Action& PlayerAction
) {
return
PlayerAction.Type == ActionType::LevelUp ||
PlayerAction.Type == ActionType::ItemAcquired ||
PlayerAction.Type == ActionType::QuestComplete;
}
void TryAutosave() {
auto Now = std::chrono::steady_clock::now();
bool TimeElapsed =
(Now - LastSave) >
std::chrono::minutes(5);
if (SignificantChangeOccurred &&
TimeElapsed) {
SaveGame();
LastSave = Now;
SignificantChangeOccurred = false;
}
}
};Background Saving
To prevent gameplay interruption, save in a separate thread:
#include <thread>
#include <queue>
#include <mutex>
class BackgroundSaver {
std::thread SaveThread;
std::queue<SaveRequest> SaveQueue;
std::mutex QueueMutex;
bool Running{true};
public:
BackgroundSaver() {
SaveThread = std::thread([this]() {
while (Running) {
ProcessSaveQueue();
std::this_thread::sleep_for(
std::chrono::milliseconds(100)
);
}
});
}
void QueueSave(const GameState& State) {
std::lock_guard Lock(QueueMutex);
SaveQueue.push({
State,
std::chrono::steady_clock::now()
});
}
};Many games also maintain multiple autosave slots and rotate between them to prevent corruption if a save is interrupted.
The key is finding the right balance between saving frequently enough to prevent significant progress loss while not impacting performance.
Working with Data
Learn techniques for managing game data, including save systems, configuration, and networked multiplayer.