feat: add fun fact

src/dumper/main.cs

@@ -114,7 +114,7 @@ class DumpByDaylight
          */
         searchPaths = dataPak.Files.Keys.Where(x => x.Contains($"/ItemAddonDB.uasset", StringComparison.OrdinalIgnoreCase)).ToList();
         var camperAddons = new List<string>();
-        var slaherAddons = new List<string>();
+        var slasherAddons = new List<string>();
 
         foreach (var path in searchPaths)
         {
@@ -135,7 +135,7 @@ class DumpByDaylight
                     }
 
                     if (isSlasherAddon)
-                        slaherAddons.Add(row.Key.Text);
+                        slasherAddons.Add(row.Key.Text);
                     else
                         camperAddons.Add(row.Key.Text);
                 }
@@ -144,7 +144,7 @@ class DumpByDaylight
 
         var addonsSerialized = new
         {
-            Slashers = slaherAddons.OrderBy(x => x).ToList(),
+            Slashers = slasherAddons.OrderBy(x => x).ToList(),
             Campers = camperAddons.OrderBy(x => x).ToList()
         };
         File.WriteAllText("addons.json", JsonConvert.SerializeObject(addonsSerialized, Formatting.Indented));

src/unlocker/main.cpp

@@ -5,18 +5,6 @@
 
 #include <windows.h>
 #include <wininet.h>
-//#include <fstream>
-//#include <iostream>
-//#include <string>
-//#include <string_view>
-//#include <vector>
-//#include <format>
-//#include <mutex>
-//#include <ctime>
-//#include <regex>
-//#include <unordered_set>
-//#include <simdjson.h>
-
 
 bool setProxy(bool enable, const std::string& proxyAddr)
 {
@@ -83,7 +71,6 @@ BOOL WINAPI consoleHandler(DWORD dwType)
         running = false;
         cleanup();
         exit(0);
-        //return TRUE;
     }
     return FALSE;
 }

src/unlocker/proxy.cpp

@@ -336,8 +336,7 @@ void Proxy::handleClient(SOCKET hClientSocket)
                         std::string emptyBody = "";
                         OnClientRequest.run(url, emptyBody, headers);
 
-                        if (!pendingUrls.empty())
-                            pendingUrls.back() = url;
+                        if (!pendingUrls.empty()) pendingUrls.back() = url;
 
                         SSL_write(remoteSSL, headers.data(), (int)headers.size());
                         clientStream.buffer.erase(0, clientStream.headersEnd + 4);
@@ -387,8 +386,7 @@ void Proxy::handleClient(SOCKET hClientSocket)
                     if (complete)
                     {
                         OnClientRequest.run(url, body, headers);
-                        if (!pendingUrls.empty() && pendingUrls.back() != url)
-                            pendingUrls.back() = url;
+                        if (!pendingUrls.empty() && pendingUrls.back() != url) pendingUrls.back() = url;
 
                         SSL_write(remoteSSL, headers.data(), (int)headers.size());
                         SSL_write(remoteSSL, clientStream.buffer.data() + bodyStart,

src/unlocker/spoofing.cpp

@@ -1,8 +1,10 @@
-#include "spoofing.h"
+#include "spoofing.h"
 
 #include <fstream>
 #include <algorithm>
 #include <unordered_set>
+#include <random>
+#include <chrono>
 
 #include <minwindef.h>
 
@@ -199,6 +201,10 @@ void Spoofer::parseAndDumpCatalog(std::string& data)
     parseCatalog(data);
 }
 
+std::unordered_set<std::string> killerNames = {
+    "Chuckles",  "Bob", "HillBilly", "Nurse",  "Shape",  "Witch",     "Killer07",   "Cannibal", "Bear",
+    "Nightmare", "Pig", "Clown",     "Spirit", "Plague", "Ghostface", "Demogorgon", "Oni",      "Gunslinger"};
+
 void Spoofer::modifyCharacterData(json& js)
 {
     std::unordered_set<std::string> existingItemIds;
@@ -207,19 +213,77 @@ void Spoofer::modifyCharacterData(json& js)
     if (js.contains("characterName") && js["characterName"].is_string())
     {
         std::string name = js["characterName"];
-        if (name == "Bear" || name == "Bob" || name == "Chuckles" || (name.length() >= 2 && name[0] == 'K'))
-            isSlasher = true;
+        if (killerNames.contains(name) || (name.length() == 3 && name[0] == 'K')) isSlasher = true;
     }
 
-    std::unordered_set<std::string> stackableIds;
-    stackableIds.insert(_camperItemIds.begin(), _camperItemIds.end());
-    stackableIds.insert(_camperOfferingIds.begin(), _camperOfferingIds.end());
-    stackableIds.insert(_camperAddonIds.begin(), _camperAddonIds.end());
-    stackableIds.insert(_slasherAddonIds.begin(), _slasherAddonIds.end());
-    stackableIds.insert(_slasherOfferingIds.begin(), _slasherOfferingIds.end());
+    if (js.contains("prestigeLevel") && js["prestigeLevel"].get<int>() <= 1)
+        if (js.contains("bloodWebLevel") && js["bloodWebLevel"].get<int>() <= 15) js["bloodWebLevel"] = 16;
+
+    if (js.contains("bloodWebData"))
+    {
+        static std::random_device rd;
+        static std::mt19937 rng(rd());
+
+        std::unordered_set<std::string> stackableIds;
+        stackableIds.insert(_camperItemIds.begin(), _camperItemIds.end());
+        stackableIds.insert(_camperOfferingIds.begin(), _camperOfferingIds.end());
+        stackableIds.insert(_camperAddonIds.begin(), _camperAddonIds.end());
+        stackableIds.insert(_slasherAddonIds.begin(), _slasherAddonIds.end());
+        stackableIds.insert(_slasherOfferingIds.begin(), _slasherOfferingIds.end());
+
+        std::string selectedContentId = "Spring2024Offering";
+        auto it = stackableIds.begin();
+        std::advance(it, std::uniform_int_distribution<>(0, static_cast<int>(_camperOfferingIds.size()) - 1)(rng));
+        selectedContentId = *it;
+
+        std::vector<std::string> paths;
+        json ringDataArray = json::array();
+
+        ringDataArray.push_back({{"nodeData", json::array({{{"nodeId", "0"}, {"state", "Collected"}}})}});
+
+        int nodesPerRing[] = {6, 12, 12};
+        std::vector<std::string> prevRingNodes = {"0"};
+
+        for (int ring = 1; ring <= 3; ++ring)
+        {
+            json nodeDataArray = json::array();
+            std::vector<std::string> currentRingNodes;
+            int numNodes = nodesPerRing[ring - 1];
+
+            for (int i = 1; i <= numNodes; ++i)
+            {
+                std::string childId = std::to_string((ring * 100) + i);
+                currentRingNodes.push_back(childId);
+
+                int parentIndex = (i - 1) / (numNodes / static_cast<int>(prevRingNodes.size()));
+
+                if (parentIndex >= static_cast<int>(prevRingNodes.size()))
+                    parentIndex = static_cast<int>(prevRingNodes.size()) - 1;
+
+                std::string parentId = prevRingNodes[parentIndex];
+                paths.push_back(parentId + "_" + childId);
+
+                nodeDataArray.push_back(
+                    {{"nodeId", childId}, {"state", "Collected"}, {"contentId", selectedContentId}});
+            }
+
+            ringDataArray.push_back({{"nodeData", nodeDataArray}});
+            prevRingNodes = std::move(currentRingNodes);
+        }
+
+        js["bloodWebData"]["paths"] = paths;
+        js["bloodWebData"]["ringData"] = ringDataArray;
+    }
 
     if (js.contains("characterItems") && js["characterItems"].is_array())
     {
+        std::unordered_set<std::string> stackableIds;
+        stackableIds.insert(_camperItemIds.begin(), _camperItemIds.end());
+        stackableIds.insert(_camperOfferingIds.begin(), _camperOfferingIds.end());
+        stackableIds.insert(_camperAddonIds.begin(), _camperAddonIds.end());
+        stackableIds.insert(_slasherAddonIds.begin(), _slasherAddonIds.end());
+        stackableIds.insert(_slasherOfferingIds.begin(), _slasherOfferingIds.end());
+
         for (auto& item : js["characterItems"])
         {
             if (item.contains("itemId") && item["itemId"].is_string())
@@ -272,6 +336,69 @@ void Spoofer::serverResponseHandler(const std::string& url, std::string& body, s
 
     if (url.find("api/v1/extensions/store/getCatalogItems") != std::string::npos) return parseAndDumpCatalog(body);
 
+    if (url.find("/api/v1/messages/listV2") != std::string::npos)
+    {
+        try
+        {
+            auto now = std::chrono::system_clock::now();
+            auto now_seconds = std::chrono::duration_cast<std::chrono::seconds>(now.time_since_epoch()).count();
+            auto now_milliseconds =
+                std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()).count();
+
+            json doc = json::parse(body);
+            if (!doc.contains("messages")) return;
+
+            json msg;
+            /*
+                msg base
+            */
+            msg["allowedPlatforms"] = json::array({"egs", "grdk", "ps4", "ps5", "steam", "xbox", "xsx"});
+            msg["flag"] = "READ";
+            msg["gameSpecificData"] = {};
+            msg["read"] = false;
+            msg["tag"] = json::array({"inbox"});
+            msg["expireAt"] = now_seconds + (1337 * 24 * 60 * 60);
+            msg["received"] = now_milliseconds;
+            msg["recipientId"] = "system";
+
+            /*
+                msg content
+            */
+            json bodyContent;
+            bodyContent["sections"] = json::array();
+            bodyContent["sections"].push_back(
+                {{"type", "text"},
+                 {"text", "Japan is turning footsteps into electricity!<br><br>Using piezoelectric tiles, every step "
+                          "you take generates a small amount of energy. Millions of steps together can power LED "
+                          "lights and displays in busy places like Shibuya Station.<br><br>A brilliant way to create a "
+                          "sustainable and smart city — turning movement into clean, renewable energy."}});
+
+            bodyContent["image"] = {
+                {"packagedPath", "/Game/UI/UMGAssets/Icons/ItemAddons/iconAddon_powerBulb.iconAddon_powerBulb"},
+                {"contentVersion", "ccc3f02b0a671fe19a0017d6a69293876a465fd9"},
+                {"uri", ""}};
+
+            bodyContent["sections"].push_back(
+                {{"type", "itemshowcase"},
+                 {"rewards", json::array({
+                                 {{"type", "inventory"}, {"id", "ADDON_flashlight_oddbulb"}, {"amount", 1}}
+                             })}});
+
+            msg["message"] = {};
+            msg["message"]["title"] = "Japan is turning footsteps into electricity";
+            msg["message"]["body"] = bodyContent.dump();
+
+            doc["messages"].push_back(msg);
+
+            body = doc.dump();
+
+            return;
+        }
+        catch (const json::parse_error& /*e*/)
+        {
+        }
+    }
+
     if (url.find("api/v1/dbd-inventories/all") != std::string::npos)
     {
         try
@@ -386,7 +513,7 @@ void Spoofer::serverResponseHandler(const std::string& url, std::string& body, s
             {
                 if (charInfo.contains("bloodWebLevel") && charInfo.at("bloodWebLevel").get<int>() <= 15)
                     if (!charInfo.contains("prestigeLevel") || charInfo.at("prestigeLevel").get<int>() <= 0)
-                        charInfo["bloodWebLevel"] = 15;
+                        charInfo["bloodWebLevel"] = 16;
 
                 if (charInfo.contains("bloodWebData") && charInfo.at("bloodWebData").contains("level"))
                     charInfo["bloodWebData"]["level"] = 1;
@@ -427,7 +554,7 @@ void Spoofer::serverResponseHandler(const std::string& url, std::string& body, s
                 json mock;
                 mock["bloodWebLevelChanged"] = false;
                 mock["updatedWallets"] = json::array();
-                mock["bloodWebLevel"] = 15;
+                mock["bloodWebLevel"] = 16;
                 mock["prestigeLevel"] = 0;
                 mock["bloodWebData"] = {{"ringData", json::array()}, {"paths", json::array()}};
                 mock["characterItems"] = json::array();
@@ -436,10 +563,7 @@ void Spoofer::serverResponseHandler(const std::string& url, std::string& body, s
                 modifyCharacterData(mock);
 
                 size_t firstSpace = respHeaders.find(' ');
-                if (firstSpace != std::string::npos)
-                {
-                    respHeaders.replace(firstSpace + 1, 3, "200");
-                }
+                if (firstSpace != std::string::npos) respHeaders.replace(firstSpace + 1, 3, "200");
 
                 body = mock.dump();
                 return;