Ticket #3433: 3433_replay_cache_v1.5.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

@@ -537 +537 @@
 
     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

@@ -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
@@ -51 +51 @@
     return VisualReplay::GetReplayMetadata(pCxPrivate, directoryName);
 }
 
-void JSI_VisualReplay::SaveReplayMetadata(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), const CStrW& data)
+void JSI_VisualReplay::SaveReplayMetadata(ScriptInterface::CxPrivate* pCxPrivate, const CStrW& data)
 {
     VisualReplay::SaveReplayMetadata(data);
 }
 
+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");
@@ -65 +75 @@
     scriptInterface.RegisterFunction<JS::Value, CStrW, &GetReplayMetadata>("GetReplayMetadata");
     scriptInterface.RegisterFunction<bool, CStrW, &HasReplayMetadata>("HasReplayMetadata");
     scriptInterface.RegisterFunction<void, CStrW, &SaveReplayMetadata>("SaveReplayMetadata");
+    scriptInterface.RegisterFunction<void, CStrW, &AddReplayToCache>("AddReplayToCache");
+    scriptInterface.RegisterFunction<void, &ReloadReplayCache>("ReloadReplayCache");
 }

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
@@ -30 +30 @@
     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);
+    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)
 {
@@ -72 +70 @@
     TIMER(L"GetReplays");
     JSContext* cx = scriptInterface.GetContext();
     JSAutoRequest rq(cx);
+    
+    std::map<CStr, u32> fileList;
 
+    const OsPath cacheFileName = GetDirectoryName() / L"replayCache.json";
+    JS::RootedObject cachedReplaysObject(cx);
+
+    bool cacheFound = FileExists(cacheFileName);
+    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>());
+
+        // 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;
+
+        // 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::RootedObject replayObject(cx, &replay.toObject());
+            JS::RootedValue file(cx);
+            JS_GetProperty(cx, replayObject, "directory", &file);
+
+            CStr fileName;
+            scriptInterface.FromJSVal(cx, file, fileName);
+            fileList.emplace(fileName, j);
+        }
+    }
+
+    JS::RootedObject replays(cx, JS_NewArrayObject(cx, 0));
+    bool newReplays = false;
+    DirectoryNames directories;
     u32 i = 0;
-    DirectoryNames directories;
-    JS::RootedObject replays(cx, JS_NewArrayObject(cx, 0));
-
     if (GetDirectoryEntries(GetDirectoryName(), NULL, &directories) == INFO::OK)
+    {
         for (OsPath& directory : directories)
         {
             if (SDL_QuitRequested())
-                return JSVAL_NULL;
+                break;
 
-            JS::RootedValue replayData(cx, LoadReplayData(scriptInterface, directory));
-            if (!replayData.isNull())
-                JS_SetElement(cx, replays, i++, replayData);
+            std::map<CStr, u32>::iterator it = fileList.find(directory.string8());
+            
+            // directory is not element of fileList
+            if (it == fileList.end())
+            {
+                JS::RootedValue replayData(cx, LoadReplayData(scriptInterface, directory));
+                if (!replayData.isNull())
+                {
+                    JS_SetElement(cx, replays, i++, replayData);
+                    newReplays = true;
+                }
+            }
+            else
+                fileList.erase(it);
         }
+
+        // No replay was changed, so just return the cache
+        if (!newReplays && fileList.empty())
+            return JS::ObjectValue(*cachedReplaysObject);
+
+        // Cache found, so copy the replays from the cache that are not deleted
+        if (cacheFound)
+        {
+            std::vector<u32> deleteIndices;
+            for (const std::pair<CStr, u32>& file : fileList)
+                deleteIndices.push_back(file.second);
+
+            u32 cacheLength = 0;
+            JS_GetArrayLength(cx, cachedReplaysObject, &cacheLength);
+
+            for (u32 j = 0; j < cacheLength; ++j)
+                // a not in deleteIndices, so copy it into replays
+                if (std::find(deleteIndices.begin(), deleteIndices.end(), j) == deleteIndices.end())
+                {
+                    JS::RootedValue replay(cx);
+                    JS_GetElement(cx, cachedReplaysObject, j, &replay);
+                    JS_SetElement(cx, replays, i++, replay);
+                }
+        }
+
+        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();
+    }
+
     return JS::ObjectValue(*replays);
 }
 
@@ -292 +373 @@
     return attribs;
 }
 
+
+void VisualReplay::AddReplayToCache(ScriptInterface& scriptInterface, const CStrW& directoryName)
+{
+    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();
+}
+
 // TODO: enhancement: how to save the data if the process is killed? (case SDL_QUIT in main.cpp)
 void VisualReplay::SaveReplayMetadata(const CStrW& data)
 {

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
@@ -83 +83 @@
  */
 void SaveReplayMetadata(const CStrW& data);
 
+/**
+* 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