Ticket #3433: 3433_replay_cache_v1.6_wip.patch

binaries/data/mods/public/gui/replaymenu/replay_actions.js

@@ -127 +127 @@
     });
 }
 
+function reloadCache()
+{
+    Engine.ReloadReplayCache();
+
+    let selected = Engine.GetGUIObjectByName("replaySelection").selected;
+    Engine.SwitchGuiPage("page_replaymenu.xml", selected > 0 ? 
+    { "replaySelectionData": createReplaySelectionData(g_ReplaysFiltered[selected].directory) } : "");
+}
+
 /**
  * Callback.
  */

binaries/data/mods/public/gui/replaymenu/replay_menu.xml

@@ -240 +240 @@
                 <action on="Press">deleteReplayButtonPressed();</action>
             </object>
 
+            <!-- Reload Cache Button -->
+            <object type="button" style="StoneButton" size="40%+25 0 57%+25 100%">
+                <translatableAttribute id="caption">Reload Cache</translatableAttribute>
+                <action on="Press">reloadCache();</action>
+            </object>
+
             <!-- Summary Button -->
             <object name="summaryButton" type="button" style="StoneButton" size="65%-50 0 82%-50 100%">
                 <translatableAttribute id="caption">Summary</translatableAttribute>

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

@@ -526 +526 @@
 
     Engine.EndGame();
 
+    // After game is ended
+    if (!g_IsReplay)
+        Engine.AddReplayToCache(replayDirectory);
+
     if (g_IsController && Engine.HasXmppClient())
         Engine.SendUnregisterGame();
 

source/ps/scripting/JSInterface_VisualReplay.cpp

@@ -52 +52 @@
 {
     return VisualReplay::GetReplayMetadata(pCxPrivate, directoryName);
 }
+ 
+void JSI_VisualReplay::AddReplayToCache(ScriptInterface::CxPrivate* pCxPrivate, const CStrW& directoryName)
+{
+    VisualReplay::AddReplayToCache(*(pCxPrivate->pScriptInterface), directoryName);
+}
 
+/*void JSI_VisualReplay::ReloadReplayCache(ScriptInterface::CxPrivate* pCxPrivate)
+{
+    VisualReplay::ReloadReplayCache(*(pCxPrivate->pScriptInterface));
+}*/
+
 void JSI_VisualReplay::RegisterScriptFunctions(ScriptInterface& scriptInterface)
 {
     scriptInterface.RegisterFunction<JS::Value, &GetReplays>("GetReplays");
@@ -61 +71 @@
     scriptInterface.RegisterFunction<JS::Value, CStrW, &GetReplayAttributes>("GetReplayAttributes");
     scriptInterface.RegisterFunction<JS::Value, CStrW, &GetReplayMetadata>("GetReplayMetadata");
     scriptInterface.RegisterFunction<bool, CStrW, &HasReplayMetadata>("HasReplayMetadata");
+    scriptInterface.RegisterFunction<void, CStrW, &AddReplayToCache>("AddReplayToCache");
+    //scriptInterface.RegisterFunction<void, &ReloadReplayCache>("ReloadReplayCache");
 }

source/ps/scripting/JSInterface_VisualReplay.h

@@ -29 +29 @@
     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 AddReplayToCache(ScriptInterface::CxPrivate* pCxPrivate, const CStrW& directoryName);
+    //void ReloadReplayCache(ScriptInterface::CxPrivate* pCxPrivate);
     void RegisterScriptFunctions(ScriptInterface& scriptInterface);
 }
 

source/ps/VisualReplay.cpp

@@ -62 +62 @@
 }
 
 /**
- * Load all replays found in the directory.
- *
- * Since files are spread across the harddisk,
- * loading hundreds of them can consume a lot of time.
+ * Load the replay cache and check if there are new/deleted ones
+ * If so, update their data.
  */
 JS::Value VisualReplay::GetReplays(ScriptInterface& scriptInterface)
 {
@@ -73 +71 @@
     JSContext* cx = scriptInterface.GetContext();
     JSAutoRequest rq(cx);
 
-    u32 i = 0;
+    // Maps the filename onto the replay data
+    std::map<CStr, JS::Heap<JS::Value>> cachedReplaysMap;
+
+    const OsPath cacheFileName = GetDirectoryName() / L"replayCache.json";
+    const OsPath tempCacheFileName = GetDirectoryName() / L"replayCache_temp.json";
+    JS::RootedObject cachedReplaysObject(cx);
+
+    bool cacheFound = FileExists(cacheFileName);
+    // Load cache and create fileList
+    if (cacheFound)
+    {
+        // Open cache file
+        std::istream* cacheStream = new std::ifstream(cacheFileName.string8().c_str());
+
+        // Read file into chacheStr
+        CStr cacheStr((std::istreambuf_iterator<char>(*cacheStream)), std::istreambuf_iterator<char>());
+        SAFE_DELETE(cacheStream);
+
+        // Create empty JS object and parse the context of the cache into it
+        JS::RootedValue cachedReplays(cx);
+        scriptInterface.ParseJSON(cacheStr, &cachedReplays);
+
+        cachedReplaysObject = &cachedReplays.toObject();
+
+        // Create list of files included in the cache
+        u32 cacheLength = 0;
+        JS_GetArrayLength(cx, cachedReplaysObject, &cacheLength);
+        for (u32 j = 0; j < cacheLength ; ++j)
+        {
+            JS::RootedValue replay(cx);
+            JS_GetElement(cx, cachedReplaysObject, j, &replay);
+
+            JS::RootedValue directoryJS(cx);
+            CStr directory;
+            scriptInterface.GetProperty(replay, "directory", &directoryJS);
+            scriptInterface.FromJSVal(cx, directoryJS, directory);
+            cachedReplaysMap.emplace(directory, JS::Heap<JS::Value>(replay.get()));
+        }
+    }
+
+    JS::RootedObject replays(cx, JS_NewArrayObject(cx, 0));
+    bool newReplays = false;
+    std::vector<JS::Value> copyFromOldCache;
     DirectoryNames directories;
-    JS::RootedObject replays(cx, JS_NewArrayObject(cx, 0));
 
-    if (GetDirectoryEntries(GetDirectoryName(), NULL, &directories) == INFO::OK)
-        for (OsPath& directory : directories)
+    // Specifies where the next replay data should go in replays
+    u32 i = 0;
+    if (GetDirectoryEntries(GetDirectoryName(), NULL, &directories) != INFO::OK)
+        return JS::ObjectValue(*replays);
+    
+    for (OsPath& directory : directories)
+    {
+        if (SDL_QuitRequested())
+            break;
+
+        std::map<CStr, JS::Heap<JS::Value>>::iterator it = cachedReplaysMap.find(directory.string8());
+        bool isNew = true;
+
+        // There is already a replay with this directory name, so check if the size of the file matches too
+        if (it != cachedReplaysMap.end())
         {
-            if (SDL_QuitRequested())
-                return JSVAL_NULL;
+            JS::RootedValue fileSizeJS(cx);
+            long fileSize;
+            JS::RootedValue replay(cx, it->second);
+            scriptInterface.GetProperty(replay, "fileSize", &fileSizeJS);
+            scriptInterface.FromJSVal(cx, fileSizeJS, fileSize);
 
+            CFileInfo fileInfo;
+            GetFileInfo(GetDirectoryName() / directory / L"commands.txt", &fileInfo);
+
+            if (fileInfo.Size() == fileSize)
+                isNew = false;
+        }
+
+        if (isNew)
+        {
             JS::RootedValue replayData(cx, LoadReplayData(scriptInterface, directory));
             if (!replayData.isNull())
+            {
                 JS_SetElement(cx, replays, i++, replayData);
+                newReplays = true;
+            }
         }
+        else
+            copyFromOldCache.push_back(it->second);
+    }
+
+    // No replay was changed, so just return the cache
+    if (!newReplays && cachedReplaysMap.size() == cachedReplaysMap.size())
+        return JS::ObjectValue(*cachedReplaysObject);
+
+    // Cache found, so copy the replays from the cache that are not deleted
+    if (!copyFromOldCache.empty())
+        for (JS::Value replay : copyFromOldCache)
+        {
+            JS::RootedValue replayRooted(cx, replay);
+            JS_SetElement(cx, replays, i++, replayRooted);
+        }
+
+    JS::RootedValue replaysRooted(cx, JS::ObjectValue(*replays));
+    std::ofstream stream(tempCacheFileName.string8().c_str(), std::ofstream::out | std::ofstream::trunc);
+    stream << scriptInterface.StringifyJSON(&replaysRooted);
+    stream.close();
+
+    wunlink(cacheFileName);
+    if (wrename(tempCacheFileName, cacheFileName))
+        LOGERROR("Could not store the replay cache");
+
     return JS::ObjectValue(*replays);
 }
 
@@ -173 +265 @@
     return -1;
 }
 
-JS::Value VisualReplay::LoadReplayData(ScriptInterface& scriptInterface, OsPath& directory)
+JS::Value VisualReplay::LoadReplayData(ScriptInterface& scriptInterface, const OsPath& directory)
 {
     // The directory argument must not be constant, otherwise concatenating will fail
     const OsPath replayFile = GetDirectoryName() / directory / L"commands.txt";
@@ -251 +343 @@
     scriptInterface.Eval("({})", &replayData);
     scriptInterface.SetProperty(replayData, "file", replayFile);
     scriptInterface.SetProperty(replayData, "directory", directory);
+    scriptInterface.SetProperty(replayData, "fileSize", (u32)fileSize);
     scriptInterface.SetProperty(replayData, "filemod_timestamp", std::to_string(fileTime));
     scriptInterface.SetProperty(replayData, "attribs", attribs);
     scriptInterface.SetProperty(replayData, "duration", duration);
@@ -266 +359 @@
     return DirectoryExists(directory) && DeleteDirectory(directory) == INFO::OK;
 }
 
-
 JS::Value VisualReplay::GetReplayAttributes(ScriptInterface::CxPrivate* pCxPrivate, const CStrW& directoryName)
 {
     // Create empty JS object
@@ -292 +384 @@
     return attribs;
 }
 
+void VisualReplay::AddReplayToCache(ScriptInterface& scriptInterface, const CStrW& directoryName)
+{
+    TIMER(L"AddReplayToCache");
+    JSContext* cx = scriptInterface.GetContext();
+    JSAutoRequest rq(cx);
+
+    JS::RootedValue replayData(cx, LoadReplayData(scriptInterface, OsPath(directoryName)));
+
+    if (replayData.isNull())
+        return;
+
+    const OsPath cacheFileName = GetDirectoryName() / L"replayCache.json";
+    JS::RootedObject cachedReplaysObject(cx, JS_NewArrayObject(cx, 0));
+
+    if (FileExists(cacheFileName))
+    {
+        // Open cache file
+        std::istream* cacheStream = new std::ifstream(cacheFileName.string8().c_str());
+
+        // Read file into chacheStr
+        CStr cacheStr((std::istreambuf_iterator<char>(*cacheStream)), std::istreambuf_iterator<char>());
+
+        // Create empty JS object and parse the context of the cache into it
+        JS::RootedValue cachedReplays(cx);
+        scriptInterface.ParseJSON(cacheStr, &cachedReplays);
+        SAFE_DELETE(cacheStream);
+
+        JS::RootedObject temp(cx, &cachedReplays.toObject());
+        cachedReplaysObject = temp;
+    }
+    
+    u32 cacheLength = 0;
+    JS_GetArrayLength(cx, cachedReplaysObject, &cacheLength);
+    JS_SetElement(cx, cachedReplaysObject, cacheLength, replayData);
+
+    JS::RootedValue replaysRooted(cx, JS::ObjectValue(*cachedReplaysObject));
+    std::ofstream cacheStream(cacheFileName.string8().c_str(), std::ofstream::out | std::ofstream::trunc);
+    cacheStream << scriptInterface.StringifyJSON(&replaysRooted);
+    cacheStream.close();
+}
+
+/*void VisualReplay::ReloadReplayCache(ScriptInterface& scriptInterface)
+{
+    JSContext* cx = scriptInterface.GetContext();
+    JSAutoRequest rq(cx);
+
+    JS::RootedObject replays(cx, JS_NewArrayObject(cx, 0));
+    DirectoryNames directories;
+    u32 i = 0;
+
+    if (GetDirectoryEntries(GetDirectoryName(), NULL, &directories) != INFO::OK)
+        return;
+
+    for (OsPath& directory : directories)
+    {
+        if (SDL_QuitRequested())
+            break;
+
+        JS::RootedValue replayData(cx, LoadReplayData(scriptInterface, directory));
+        if (!replayData.isNull())
+            JS_SetElement(cx, replays, i++, replayData);
+    }
+
+    const OsPath cacheFileName = GetDirectoryName() / L"replayCache.json";
+    JS::RootedValue replaysRooted(cx, JS::ObjectValue(*replays));
+    std::ofstream stream(cacheFileName.string8().c_str(), std::ofstream::out | std::ofstream::trunc);
+    stream << scriptInterface.StringifyJSON(&replaysRooted);
+    stream.close();
+}*/
+
 void VisualReplay::SaveReplayMetadata(ScriptInterface* scriptInterface)
 {
     JSContext* cx = scriptInterface->GetContext();

source/ps/VisualReplay.h

@@ -53 +53 @@
  * Parses a commands.txt file and extracts metadata.
  * Works similarly to CGame::LoadReplayData().
  */
-JS::Value LoadReplayData(ScriptInterface& scriptInterface, OsPath& directory);
+JS::Value LoadReplayData(ScriptInterface& scriptInterface, const OsPath& directory);
 
 /**
  * Permanently deletes the visual replay (including the parent directory)
@@ -83 +83 @@
  */
 void SaveReplayMetadata(ScriptInterface* scriptInterface);
 
+/**
+* Saves the metadata from the session to metadata.json
+*/
+void AddReplayToCache(ScriptInterface& scriptInterface, const CStrW& directoryName);
+
+/**
+ * Reloads the replay cache
+ *
+void ReloadReplayCache(ScriptInterface& scriptInterface);*/
+
 }
 
 #endif