feat(dat): async reads tickle the client to fetch a missing file (once each)

Add GwDatArchive::SetTrigger(fn): an optional hook the worker calls to ask
the client to load a file id that isn't resident. ProcessPendingReads invokes
it exactly once per pending request (a `triggered` flag guards against
re-asking on every poll), outside the list lock. The pure reader stays free
of any game-function lookup; if no trigger is wired it just waits passively.

GwDatTextureModule resolves the client's request-files function (the safe
FUN_0082da30 variant) by pattern and wires a trigger that issues the request
on the game thread. On a client update the pattern may need re-deriving; it
fails soft (logs, async reads still wait for natural streaming).

Together with ReadFileAsync this closes the loop: request -> client streams
the file into the .snapshot on disk -> MaybeRefresh picks it up -> callback
fires with the bytes, or empty after ~1 minute.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: 3vcloud

GWToolboxSetup/CMakeLists.txt

@@ -0,0 +1,18 @@
+
+FILE(GLOB SOURCES CONFIGURE_DEPENDS
+    "*.h"
+    "*.cpp"
+    "GWToolboxSetup.rc")
+
+add_executable(GWToolboxSetup)
+target_sources(GWToolboxSetup PRIVATE ${SOURCES})
+target_precompile_headers(GWToolboxSetup PRIVATE "stdafx.h")
+
+set_target_properties(GWToolboxSetup PROPERTIES
+    LINK_FLAGS_RELEASE "/SUBSYSTEM:WINDOWS"
+    LINK_FLAGS_RELWITHDEBINFO "/SUBSYSTEM:WINDOWS"
+    LINK_FLAGS_MINSIZEREL "/SUBSYSTEM:WINDOWS"
+)
+
+# Links Core only (Window, Path, Defender) - deliberately not the launcher's injection code, so this stays clean to AV.
+target_link_libraries(GWToolboxSetup PRIVATE Core)

GWToolboxSetup/GWToolboxSetup.rc

@@ -0,0 +1,3 @@
+#include "resource.h"
+
+IDI_ICON1 ICON "..\\resources\\gwtoolbox.ico"

GWToolboxSetup/main.cpp

@@ -0,0 +1,15 @@
+#include "stdafx.h"
+
+#include "AvReadinessWindow.h"
+
+// The antivirus readiness checklist runs as its own tiny, non-injecting executable so it carries a clean reputation -
+// unlike the launcher, which antivirus distrusts because it injects into Guild Wars. Read-only: never changes an AV setting.
+#ifdef _DEBUG
+int main()
+#else
+int WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)
+#endif
+{
+    AvReadinessWindow::Run();
+    return 0;
+}

GWToolboxSetup/resource.h

@@ -0,0 +1,3 @@
+#pragma once
+
+#define IDI_ICON1 101 // app icon; Core's Window loads resource id 101 by convention

GWToolboxSetup/stdafx.cpp

@@ -0,0 +1 @@
+#include "stdafx.h"

GWToolboxSetup/stdafx.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#ifndef UNICODE
+#define UNICODE
+#endif
+#ifndef _UNICODE
+#define _UNICODE
+#endif
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+
+#include <Windows.h>
+#include <Commctrl.h>
+#include <shellapi.h>
+#include <Shlobj.h>
+
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+
+#include <algorithm>
+#include <atomic>
+#include <filesystem>
+#include <format>
+#include <ranges>
+#include <sstream>
+#include <string>
+#include <thread>
+#include <vector>

GWToolboxdll/Modules/GwDatTextureModule.cpp

@@ -6,6 +6,9 @@
 #include <Logger.h>
 #include "GwDatTextureModule.h"
 
+#include <GWCA/Managers/GameThreadMgr.h>
+#include <GWCA/Utilities/Scanner.h>
+
 #include "Resources.h"
 #include <Utils/ArenaNetFileParser.h>
 #include <Utils/GwDat/GwDatArchive.h>
@@ -15,6 +18,34 @@
 
 namespace {
 
+    // Game file-request trigger: asks the client to load a file id from its dat/network (the safe
+    // FUN_0082da30 variant, which no-ops on bad state). Byte-pattern scanned against build 388118, so
+    // it may need re-deriving after a client update; if it doesn't resolve, async reads just wait
+    // passively for the client to stream the file on its own.
+    using RequestFiles_pt = void(__cdecl*)(uint32_t count, const uint32_t* file_ids, uint32_t flags);
+    constexpr uint32_t kTriggerFlags = 0x2; // enqueue + kick the download pump
+    RequestFiles_pt RequestFiles_Func = nullptr;
+
+    void WireGameFileTrigger()
+    {
+        RequestFiles_Func = reinterpret_cast<RequestFiles_pt>(GW::Scanner::Find(
+            "\x55\x8b\xec\x53\x8b\x5d\x08\x56\x57\x85\xdb\x0f\x84\x9c\x02\x00\x00"
+            "\x83\x3d\x78\x52\x07\x01\x00\x0f\x85\x8f\x02\x00\x00\x8b\x35\xf4\x76\xbe\x00\x85\xf6",
+            "xxxxxxxxxxxxx????xx????xxx????xx????xx", 0));
+        if (!RequestFiles_Func) {
+            Log::Log("[GwDat] game file-request trigger not found; async reads will wait passively.");
+            return;
+        }
+        Log::Log("[GwDat] game file-request trigger resolved at %p", reinterpret_cast<void*>(RequestFiles_Func));
+        GwDatArchive::Instance().SetTrigger([](uint32_t file_id) {
+            // FUN_0082da30 touches client state, so issue the request on the game thread.
+            GW::GameThread::Enqueue([file_id] {
+                if (RequestFiles_Func)
+                    RequestFiles_Func(1, &file_id, kTriggerFlags);
+            });
+        });
+    }
+
     struct Vec2i {
         int x = 0;
         int y = 0;
@@ -320,6 +351,8 @@ void GwDatTextureModule::Initialize()
     ToolboxModule::Initialize();
     // The dat is indexed lazily on the first read; start its dedicated read/decode worker.
     GwDatArchive::Instance().StartWorker();
+    // Let async reads prompt the client to fetch a streamed-only file (best-effort; see the helper).
+    WireGameFileTrigger();
 }
 
 IDirect3DTexture9** GwDatTextureModule::LoadTextureFromFileId(uint32_t file_id, uint32_t stream_id)

GWToolboxdll/Utils/GwDat/GwDatArchive.cpp

@@ -424,18 +424,27 @@ void GwDatArchive::ReadFileAsync(uint32_t file_id, ReadCallback callback, uint32
     StartWorker(); // the poll loop must be running to deliver
     const uint32_t deadline = GetTickCount() + kAsyncReadTimeoutMs;
     std::scoped_lock<std::mutex> lock(m_pending_mutex);
-    m_pending_reads.push_back({file_id, stream_id, deadline, std::move(callback)});
+    m_pending_reads.push_back({file_id, stream_id, deadline, std::move(callback), false});
+}
+
+void GwDatArchive::SetTrigger(TriggerFn trigger)
+{
+    std::scoped_lock<std::mutex> lock(m_pending_mutex);
+    m_trigger = std::move(trigger);
 }
 
 // Worker-thread pass over the pending async reads: deliver any that now resolve, expire any past
 // their deadline. Callbacks fire outside the lock so they can't stall other ReadFileAsync callers.
 void GwDatArchive::ProcessPendingReads()
 {
     std::vector<std::pair<ReadCallback, std::vector<uint8_t>>> ready;
+    std::vector<uint32_t> to_trigger; // file ids to ask the client to load, fired outside the lock
+    TriggerFn trigger;
     {
         std::scoped_lock<std::mutex> lock(m_pending_mutex);
         if (m_pending_reads.empty())
             return;
+        trigger = m_trigger; // copy so we can call it after releasing the lock
         const uint32_t now = GetTickCount();
         for (auto it = m_pending_reads.begin(); it != m_pending_reads.end();) {
             std::vector<uint8_t> data;
@@ -448,10 +457,17 @@ void GwDatArchive::ProcessPendingReads()
                 it = m_pending_reads.erase(it);
             }
             else {
+                // Not resident yet: ask the client to fetch it, but only once per request.
+                if (trigger && !it->triggered) {
+                    to_trigger.push_back(it->file_id);
+                    it->triggered = true;
+                }
                 ++it;
             }
         }
     }
+    for (uint32_t file_id : to_trigger)
+        trigger(file_id);
     for (auto& [callback, data] : ready)
         callback(data);
 }

GWToolboxdll/Utils/GwDat/GwDatArchive.h

@@ -45,6 +45,13 @@ class GwDatArchive {
     using ReadCallback = std::function<void(std::vector<uint8_t>&)>;
     void ReadFileAsync(uint32_t file_id, ReadCallback callback, uint32_t stream_id = 0);
 
+    // Optional hook that asks the running client to load a file id (from the dat or the network). When
+    // set, ReadFileAsync calls it once per pending file that isn't resident yet, so streamed-only files
+    // (e.g. a Steam .snapshot) get fetched instead of only waited for. Wired by the GWCA layer, which
+    // owns the game-function lookup; the pure reader here works with or without it.
+    using TriggerFn = std::function<void(uint32_t file_id)>;
+    void SetTrigger(TriggerFn trigger);
+
     // Dedicated worker so reads/decodes run off the caller's thread; EnqueueTask runs inline if not started.
     void StartWorker();
     void StopWorker();
@@ -109,11 +116,13 @@ class GwDatArchive {
     struct PendingRead {
         uint32_t file_id;
         uint32_t stream_id;
-        uint32_t deadline_ms; // GetTickCount() value at which this request gives up
+        uint32_t deadline_ms;   // GetTickCount() value at which this request gives up
         ReadCallback callback;
+        bool triggered = false; // whether we've already asked the client to load this file
     };
-    std::mutex m_pending_mutex; // guards m_pending_reads
+    std::mutex m_pending_mutex; // guards m_pending_reads + m_trigger
     std::vector<PendingRead> m_pending_reads;
+    TriggerFn m_trigger;
     std::shared_mutex m_index_mutex;               // guards m_mapping/m_slots/m_fileid_to_slot against MaybeRefresh
     uint32_t m_last_refresh_ms = 0;                // GetTickCount of the last re-parse, to throttle refreshes
     void* m_mapping = nullptr;      // file-mapping HANDLE for the dat, replaced by MaybeRefresh when the dat grows