Merge branch '2.0.7' of https://github.com/SuperV1234/SSVOpenHexagon into 2.0.7

4 files changed, 92 insertions, 4 deletions

diff --git a/.gitignore b/.gitignore
index fa76b2f7..6638cbcf 100755
--- a/.gitignore
+++ b/.gitignore
diff --git a/include/SSVOpenHexagon/Global/Assets.hpp b/include/SSVOpenHexagon/Global/Assets.hpp
index 49689224..75815ab6 100644
--- a/include/SSVOpenHexagon/Global/Assets.hpp
+++ b/include/SSVOpenHexagon/Global/Assets.hpp
@@ -73,6 +73,7 @@ private:
 
     [[nodiscard]] bool loadAllPackDatas();
     [[nodiscard]] bool loadAllPackAssets();
+    [[nodiscard]] bool loadWorkshopPackDatasFromCache();
     [[nodiscard]] bool verifyAllPackDependencies();
     [[nodiscard]] bool loadAllLocalProfiles();
 
@@ -102,6 +103,10 @@ public:
 
     ~HGAssets();
 
+    // When the Steam API can not be retrieved, this set holds pack ids
+    // retrieved from the cache to try and load the workshop packs installed
+    std::unordered_set<std::string> cachedWorkshopPackIds;
+
     [[nodiscard]] LoadInfo& getLoadResults();
 
     [[nodiscard]] sf::Texture& getTexture(const std::string& mId);
diff --git a/src/SSVOpenHexagon/Core/Steam.cpp b/src/SSVOpenHexagon/Core/Steam.cpp
index ba490a5b..37ebe44e 100644
--- a/src/SSVOpenHexagon/Core/Steam.cpp
+++ b/src/SSVOpenHexagon/Core/Steam.cpp
@@ -193,6 +193,8 @@ void steam_manager::steam_manager_impl::load_workshop_data()
     constexpr std::size_t folderBufSize = 512;
     char folderBuf[folderBufSize];
 
+    ssvuj::Obj cacheArray;
+
     for(PublishedFileId_t id : subscribedItemsIds)
     {
         ssvu::lo("Steam") << "Workshop subscribed item id: " << id << '\n';
@@ -205,14 +207,29 @@ void steam_manager::steam_manager_impl::load_workshop_data()
 
         if(installed)
         {
+            std::string folderBufStr{folderBuf};
+
             ssvu::lo("Steam")
                 << "Workshop id " << id << " is installed, with size "
-                << itemDiskSize << " at folder " << std::string{folderBuf}
-                << '\n';
+                << itemDiskSize << " at folder " << folderBufStr << '\n';
 
-            _workshop_pack_folders.emplace(std::string{folderBuf});
+            // Write the path to an element in a JSON array.
+            ssvuj::arch(
+                cacheArray, _workshop_pack_folders.size(), folderBufStr);
+
+            _workshop_pack_folders.emplace(std::move(folderBufStr));
         }
     }
+
+    // Update the workshop cache with our loaded folders
+    if(_workshop_pack_folders.size() > 0)
+    {
+        ssvu::lo("Steam") << "Updating workshop cache\n";
+        ssvuj::Obj cacheObj;
+
+        ssvuj::arch(cacheObj, "cachedPacks", cacheArray);
+        ssvuj::writeToFile(cacheObj, "workshopCache.json");
+    }
 }
 
 steam_manager::steam_manager_impl::steam_manager_impl()
diff --git a/src/SSVOpenHexagon/Global/Assets.cpp b/src/SSVOpenHexagon/Global/Assets.cpp
index 18d164b9..771d03ad 100644
--- a/src/SSVOpenHexagon/Global/Assets.cpp
+++ b/src/SSVOpenHexagon/Global/Assets.cpp
@@ -457,6 +457,60 @@ HGAssets::getSelectablePackInfos() const noexcept
     return nullptr;
 }
 
+[[nodiscard]] bool HGAssets::loadWorkshopPackDatasFromCache()
+{
+    if(!ssvufs::Path{"workshopCache.json"}.exists<ssvufs::Type::File>())
+    {
+        ssvu::lo("::loadAssets") << "Workshop cache file does not exist. No "
+                                    "workshop packs to load\n";
+        return false;
+    }
+    auto [cacheObject, cacheError] =
+        ssvuj::getFromFileWithErrors("workshopCache.json");
+
+    ssvu::lo("::loadAssets") << "Loading workshop packs from cache\n";
+    if(ssvuj::hasObj(cacheObject, "cachedPacks"))
+    {
+        // Null check
+        auto& packValue = ssvuj::getObj(cacheObject, "cachedPacks");
+        if(packValue.type() == Json::ValueType::nullValue ||
+            packValue.type() != Json::ValueType::arrayValue)
+        {
+            ssvu::lo("::loadAssets")
+                << "Cache array is null. No workshop packs to load\n";
+            return false;
+        }
+
+        // Empty check
+        const auto packArray =
+            ssvuj::getExtr<std::vector<std::string>>(
+                cacheObject, "cachedPacks");
+
+        if(packArray.size() <= 0)
+        {
+            ssvu::lo("::loadAssets")
+                << "Cache array is empty. No workshop packs to load\n";
+            return false;
+        }
+
+        for(const auto& f : packArray)
+        {
+            // Simply emplace them. We will check them later.
+            cachedWorkshopPackIds.emplace(f);
+        }
+    }
+    else
+    {
+        ssvu::lo("::loadAssets")
+            << "[ERROR]: Cannot locate cache array in workshop cache file\n";
+
+        return false;
+    }
+
+    loadInfo.addFormattedError(cacheError);
+    return true;
+}
+
 [[nodiscard]] bool HGAssets::loadAllPackDatas()
 {
     if(!ssvufs::Path{"Packs/"}.exists<ssvufs::Type::Folder>())
@@ -494,7 +548,19 @@ HGAssets::getSelectablePackInfos() const noexcept
     // Load pack datas from Steam workshop.
     if(steamManager != nullptr)
     {
-        steamManager->for_workshop_pack_folders(tryLoadPackFromPath);
+        if(steamManager->is_initialized())
+        {
+            steamManager->for_workshop_pack_folders(tryLoadPackFromPath);
+        }
+        else if(loadWorkshopPackDatasFromCache())
+        {
+            // In the case the Steam API can't be retrieved, look for a cache
+            // that contains the paths we need to load
+            for(const auto& cachedPath : cachedWorkshopPackIds)
+            {
+                tryLoadPackFromPath(cachedPath);
+            }
+        }
     }
 
     return true;