Ticket #3261: t3261_savegame_checkpoints_wip_v0.01.patch

binaries/data/config/default.cfg

@@ -411 +411 @@
 near = 2.0                        ; Near plane distance
 far = 4096.0                      ; Far plane distance
 fov = 45.0                        ; Field of view (degrees), lower is narrow, higher is wide
 height.smoothness = 0.5
 height.min = 16
+
+[replay.save.session]
+enabled = false                   ; Whether to generate savepoints in running games to skip / rewind replays (caution: requires significant disk space and can cause lag spikes)
+interval = 300                    ; save the gamestate every 5 minutes
+
+[replay.save.replay]
+enabled = true                    ; Whether to generate savepoints while replaying
+interval = 300                    ; save the gamestate every 5 minutes

binaries/data/mods/public/gui/session/session.js

@@ -82 +82 @@
 /**
  * For restoring selection, order and filters when returning to the replay menu
  */
 var g_ReplaySelectionData;
 
+/**
+ * Simulation time in milliseconds.
+ */
+var g_ReplayLastSave = 0;
+
 var g_PlayerAssignments = {
     "local": {
         "name": singleplayerName(),
         "player": 1
     }
@@ -582 +587 @@
 
     checkPlayerState();
 
     handleNetMessages();
 
+    saveReplayStates();
+
     updateCursorAndTooltip();
 
     if (g_Selection.dirty)
     {
         g_Selection.dirty = false;
@@ -1284 +1291 @@
     reportObject.lootCollected = playerStatistics.lootCollected;
     reportObject.tradeIncome = playerStatistics.tradeIncome;
 
     Engine.SendGameReport(reportObject);
 }
+
+/**
+ * Write a savegame in frequent intervals for seeking replays.
+ */
+function saveReplayStates()
+{
+    let type = g_IsReplay ? "replay" : "session";
+
+    if (!Engine.ConfigDB_GetValue("user", "replay.save." + type + ".enabled"))
+        return;
+
+    let now = GetSimState().timeElapsed;
+
+    // Randomize the first time the game is being saved,
+    // to avoid clients serializing simultaneously.
+    // -> Likely better to do it parallel than in series
+    //if (!g_IsReplay && !g_ReplayLastSave)
+    //  g_ReplayLastSave = Math.random() * 10;
+
+    let duration = Engine.ConfigDB_GetValue("user", "replay.save." + type + ".interval");
+    duration = Math.max(duration, 1) * 1000;
+
+    if (now - g_ReplayLastSave < duration)
+        return;
+
+    // Don't save if we already got a checkpoint.
+    // Do this just before saving to be compatible for concurrent replays
+    if (false && g_IsReplay)
+    {
+        let states = Engine.GetReplayStates();
+        // states is an array of { "metadata": "", "filename": "" }
+        // TODO: loop over states and dont save if there is a recent one
+    }
+
+    // TODO: access the JS Timer component from c++ directly
+    if (Engine.SaveReplayState(now))
+        g_ReplayLastSave = now;
+}

source/ps/SavedGame.cpp

@@ -72 +72 @@
 
     OsPath tempSaveFileRealPath;
     WARN_RETURN_STATUS_IF_ERR(g_VFS->GetDirectoryRealPath("cache/", tempSaveFileRealPath));
     tempSaveFileRealPath = tempSaveFileRealPath / "temp.0adsave";
 
+    WARN_RETURN_STATUS_IF_ERR(WriteSavegameTemp(description, simulation, guiMetadataClone, tempSaveFileRealPath));
+
+    WriteBuffer buffer;
+    CFileInfo tempSaveFile;
+    WARN_RETURN_STATUS_IF_ERR(GetFileInfo(tempSaveFileRealPath, &tempSaveFile));
+    buffer.Reserve(tempSaveFile.Size());
+    WARN_RETURN_STATUS_IF_ERR(io::Load(tempSaveFileRealPath, buffer.Data().get(), buffer.Size()));
+    WARN_RETURN_STATUS_IF_ERR(g_VFS->CreateFile(filename, buffer.Data(), buffer.Size()));
+
+    OsPath realPath;
+    WARN_RETURN_STATUS_IF_ERR(g_VFS->GetRealPath(filename, realPath));
+    LOGMESSAGERENDER(g_L10n.Translate("Saved game to '%s'"), realPath.string8());
+    debug_printf("Saved game to '%s'\n", realPath.string8().c_str());
+
+    return INFO::OK;
+}
+
+Status SavedGames::WriteSavegameTemp(const CStrW& description, CSimulation2& simulation, shared_ptr<ScriptInterface::StructuredClone> guiMetadataClone, OsPath& targetFile)
+{
+    JSContext* cx = simulation.GetScriptInterface().GetContext();
+    JSAutoRequest rq(cx);
+
     time_t now = time(NULL);
 
     // Construct the serialized state to be saved
 
     std::stringstream simStateStream;
@@ -111 +133 @@
     simulation.GetScriptInterface().SetProperty(metadata, "description", description);
 
     std::string metadataString = simulation.GetScriptInterface().StringifyJSON(&metadata, true);
 
     // Write the saved game as zip file containing the various components
-    PIArchiveWriter archiveWriter = CreateArchiveWriter_Zip(tempSaveFileRealPath, false);
+    PIArchiveWriter archiveWriter = CreateArchiveWriter_Zip(targetFile, false);
     if (!archiveWriter)
         WARN_RETURN(ERR::FAIL);
 
     WARN_RETURN_STATUS_IF_ERR(archiveWriter->AddMemory((const u8*)metadataString.c_str(), metadataString.length(), now, "metadata.json"));
     WARN_RETURN_STATUS_IF_ERR(archiveWriter->AddMemory((const u8*)simStateStream.str().c_str(), simStateStream.str().length(), now, "simulation.dat"));
     archiveWriter.reset(); // close the file
 
-    WriteBuffer buffer;
-    CFileInfo tempSaveFile;
-    WARN_RETURN_STATUS_IF_ERR(GetFileInfo(tempSaveFileRealPath, &tempSaveFile));
-    buffer.Reserve(tempSaveFile.Size());
-    WARN_RETURN_STATUS_IF_ERR(io::Load(tempSaveFileRealPath, buffer.Data().get(), buffer.Size()));
-    WARN_RETURN_STATUS_IF_ERR(g_VFS->CreateFile(filename, buffer.Data(), buffer.Size()));
-
-    OsPath realPath;
-    WARN_RETURN_STATUS_IF_ERR(g_VFS->GetRealPath(filename, realPath));
-    LOGMESSAGERENDER(g_L10n.Translate("Saved game to '%s'"), realPath.string8());
-    debug_printf("Saved game to '%s'\n", realPath.string8().c_str());
-
     return INFO::OK;
 }
 
 /**
  * Helper class for retrieving data from saved game archives

source/ps/SavedGame.h

@@ -46 +46 @@
  * @param gui if not NULL, store some UI-related data with the saved game
  * @return INFO::OK if successfully saved, else an error Status
  */
 Status Save(const CStrW& name, const CStrW& description, CSimulation2& simulation, shared_ptr<ScriptInterface::StructuredClone> guiMetadataClone);
 
+
+/**
+ * Creates a savegame file, also used by replays.
+ */
+Status WriteSavegameTemp(const CStrW& description, CSimulation2& simulation, shared_ptr<ScriptInterface::StructuredClone> guiMetadataClone, OsPath& output);
+
 /**
  * Create new saved game archive with given prefix and simulation data
  *
  * @param prefix Create new numbered file starting with this prefix
  * @param description A user-given description of the save

source/ps/VisualReplay.cpp

@@ -18 +18 @@
 #include "precompiled.h"
 
 #include "VisualReplay.h"
 #include "graphics/GameView.h"
 #include "gui/GUIManager.h"
+#include "i18n/L10n.h"
 #include "lib/allocators/shared_ptr.h"
 #include "lib/external_libraries/libsdl.h"
 #include "lib/utf8.h"
 #include "network/NetClient.h"
 #include "network/NetServer.h"
@@ -30 +31 @@
 #include "ps/Game.h"
 #include "ps/GameSetup/Paths.h"
 #include "ps/Mod.h"
 #include "ps/Pyrogenesis.h"
 #include "ps/Replay.h"
+#include "ps/SavedGame.h"
 #include "ps/Util.h"
 #include "scriptinterface/ScriptInterface.h"
 
 /**
  * Filter too short replays (value in seconds).
@@ -330 +332 @@
     SAFE_DELETE(stream);
     pCxPrivate->pScriptInterface->ParseJSON(line, &metadata);
 
     return metadata;
 }
+
+bool VisualReplay::SaveReplayState(ScriptInterface::CxPrivate* pCxPrivate, int simTime, JS::HandleValue GUIMetadata)
+{
+    shared_ptr<ScriptInterface::StructuredClone> guiMetadataClone = pCxPrivate->pScriptInterface->WriteStructuredClone(GUIMetadata);
+
+    OsPath output = g_Game->GetReplayLogger().GetDirectory() / L"savegames";
+    CreateDirectories(output, 0700);
+
+    output = output / (std::to_string(simTime) + CStr(".0adsave"));
+
+    if (SavedGames::WriteSavegameTemp(L"Replay", *g_Game->GetSimulation2(), guiMetadataClone, output) != INFO::OK)
+        return false;
+
+    // TODO: something like IComponent* component = componentManager->QueryInterface(SYSTEM_ENTITY, IID_Timer);
+
+    LOGMESSAGERENDER(g_L10n.Translate("Saved replay checkpoint to '%s'"), output.string8());
+    debug_printf("Saved replay checkpoint to %s\n", output.string8().c_str());
+
+    return true;
+}
+
+JS::Value VisualReplay::GetReplayStates(ScriptInterface::CxPrivate* pCxPrivate, const CStrW& directory)
+{
+    TIMER(L"GetReplayStates");
+
+    JSContext* cx = pCxPrivate->pScriptInterface->GetContext();
+    JSAutoRequest rq(cx);
+
+    u32 i = 0;
+    DirectoryNames filenames;
+    JS::RootedObject replayStates(cx, JS_NewArrayObject(cx, 0));
+
+    if (GetDirectoryEntries(directory, NULL, &filenames) == INFO::OK)
+        for (OsPath& filepath : filenames)
+        {
+            CStr filename = filepath.Filename().string8();
+
+            if (filename.substr(filename.size() - 8) == ".0adsave")
+                continue;
+
+            int time = std::atoi(filename.substr(0, filename.size() - 8).c_str());
+
+            JS::RootedValue replayStateInfo(cx);
+            pCxPrivate->pScriptInterface->Eval("({})", &replayStateInfo);
+            pCxPrivate->pScriptInterface->SetProperty(replayStateInfo, "file", filename);
+            pCxPrivate->pScriptInterface->SetProperty(replayStateInfo, "time", time);
+            JS_SetElement(cx, replayStates, i++, replayStateInfo);
+        }
+
+    return JS::ObjectValue(*replayStates);
+}

source/ps/VisualReplay.h

@@ -1 @@
-/* Copyright (C) 2015 Wildfire Games.
+/* Copyright (C) 2016 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
@@ -81 +81 @@
 /**
  * Saves the metadata from the session to metadata.json
  */
 void SaveReplayMetadata(const CStrW& data);
 
+/**
+ * Saves the serialized gamestate to the replay directory to allow skipping and rewinding replays.
+ */
+bool SaveReplayState(ScriptInterface::CxPrivate* pCxPrivate, int simTime, JS::HandleValue GUIMetadata);
+
+/**
+ * Given a replay directory, returns an array of integers identifying the gametime of every savestate.
+ */
+JS::Value GetReplayStates(ScriptInterface::CxPrivate* pCxPrivate, const CStrW& directory);
+
 }
 
 #endif

source/ps/scripting/JSInterface_VisualReplay.cpp

@@ -1 @@
-/* Copyright (C) 2015 Wildfire Games.
+/* Copyright (C) 2016 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
@@ -53 +53 @@
 void JSI_VisualReplay::SaveReplayMetadata(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), const CStrW& data)
 {
     VisualReplay::SaveReplayMetadata(data);
 }
 
+// TODO: support u64
+bool JSI_VisualReplay::SaveReplayState(ScriptInterface::CxPrivate* pCxPrivate, int simTime, JS::HandleValue GUIMetadata)
+{
+    return VisualReplay::SaveReplayState(pCxPrivate, simTime, GUIMetadata);
+}
+
+JS::Value JSI_VisualReplay::GetReplayStates(ScriptInterface::CxPrivate* pCxPrivate, const CStrW& directory)
+{
+    return VisualReplay::GetReplayStates(pCxPrivate, directory);
+}
+
 void JSI_VisualReplay::RegisterScriptFunctions(ScriptInterface& scriptInterface)
 {
     scriptInterface.RegisterFunction<JS::Value, &GetReplays>("GetReplays");
     scriptInterface.RegisterFunction<bool, CStrW, &DeleteReplay>("DeleteReplay");
     scriptInterface.RegisterFunction<void, CStrW, &StartVisualReplay>("StartVisualReplay");
     scriptInterface.RegisterFunction<JS::Value, CStrW, &GetReplayAttributes>("GetReplayAttributes");
     scriptInterface.RegisterFunction<JS::Value, CStrW, &GetReplayMetadata>("GetReplayMetadata");
     scriptInterface.RegisterFunction<bool, CStrW, &HasReplayMetadata>("HasReplayMetadata");
     scriptInterface.RegisterFunction<void, CStrW, &SaveReplayMetadata>("SaveReplayMetadata");
+    scriptInterface.RegisterFunction<bool, int, JS::HandleValue, &SaveReplayState>("SaveReplayState");
+    scriptInterface.RegisterFunction<JS::Value, CStrW, &GetReplayStates>("GetReplayStates");
 }

source/ps/scripting/JSInterface_VisualReplay.h

@@ -1 @@
-/* Copyright (C) 2015 Wildfire Games.
+/* Copyright (C) 2016 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
@@ -28 +28 @@
     JS::Value GetReplays(ScriptInterface::CxPrivate* pCxPrivate);
     JS::Value GetReplayAttributes(ScriptInterface::CxPrivate* pCxPrivate, const CStrW& directoryName);
     bool HasReplayMetadata(ScriptInterface::CxPrivate* pCxPrivate, const CStrW& directoryName);
     JS::Value GetReplayMetadata(ScriptInterface::CxPrivate* pCxPrivate, const CStrW& directoryName);
     void SaveReplayMetadata(ScriptInterface::CxPrivate* pCxPrivate, const CStrW& data);
+    bool SaveReplayState(ScriptInterface::CxPrivate* pCxPrivate, int, JS::HandleValue GUIMetadata);
+    JS::Value GetReplayStates(ScriptInterface::CxPrivate* pCxPrivate, const CStrW& directory);
     void RegisterScriptFunctions(ScriptInterface& scriptInterface);
 }
 
 #endif