Erste Version

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Loader/ProxyTest.cpp

@@ -0,0 +1,36 @@
+// Test ohne Spiel: laedt dist\dinput8.dll wie das Spiel, erstellt die Tastatur und fragt sie ein paar Mal ab.
+// Danach muss dist\BSO\BSO_Loader.txt den .NET-Start und den Bild-Takt zeigen.
+// Bauen (x64 Native Tools Prompt): cl /EHsc ProxyTest.cpp /link dinput8.lib dxguid.lib user32.lib
+// Starten: ProxyTest.exe <voller Pfad zu dist\dinput8.dll>
+// Erwartet im Protokoll: "Vision90.dll ist nicht geladen" - ohne Spiel gibt es keine Engine.
+#define DIRECTINPUT_VERSION 0x0800
+#include <windows.h>
+#include <dinput.h>
+#include <stdio.h>
+
+int wmain(int argc, wchar_t** argv)
+{
+    HMODULE proxy = LoadLibraryW(argc > 1 ? argv[1] : L"dinput8.dll");
+    if (!proxy) { printf("LoadLibrary fehlgeschlagen: %lu\n", GetLastError()); return 1; }
+    auto create = (decltype(&DirectInput8Create))GetProcAddress(proxy, "DirectInput8Create");
+
+    IDirectInput8W* di = nullptr;
+    HRESULT hr = create(GetModuleHandleW(nullptr), DIRECTINPUT_VERSION, IID_IDirectInput8W, (void**)&di, nullptr);
+    printf("DirectInput8Create: 0x%08lX\n", hr);
+    if (FAILED(hr)) return 1;
+
+    IDirectInputDevice8W* kb = nullptr;
+    hr = di->CreateDevice(GUID_SysKeyboard, &kb, nullptr);
+    printf("CreateDevice(Tastatur): 0x%08lX\n", hr);
+    if (FAILED(hr)) return 1;
+    kb->SetDataFormat(&c_dfDIKeyboard);
+    kb->SetCooperativeLevel(GetConsoleWindow(), DISCL_BACKGROUND | DISCL_NONEXCLUSIVE);
+    kb->Acquire();
+
+    BYTE keys[256];
+    for (int i = 0; i < 30; i++) { kb->GetDeviceState(sizeof(keys), keys); Sleep(16); }
+    printf("30 Bilder abgefragt\n");
+    kb->Release();
+    di->Release();
+    return 0;
+}

Loader/dinput8.cpp

@@ -0,0 +1,305 @@
+// BSO Loader - dinput8.dll-Proxy (wie Unity Doorstop bei MSCO, nur fuer die Vision Engine).
+//
+// Game.vPlugin importiert DINPUT8.dll, Windows sucht sie zuerst im Spielordner. Diese DLL reicht alles an die echte
+// dinput8.dll aus System32 weiter und
+//  1. startet beim ersten DirectInput8Create .NET (hostfxr) und ruft BSO.Bootstrap.Start in BSO\BSO.dll auf,
+//  2. haengt sich in GetDeviceState/GetDeviceData der Tastatur: das Spiel fragt die Tastatur einmal pro Bild im
+//     Hauptthread ab - dort wird BSO.Bootstrap.OnFrame aufgerufen. Kein Spielcode wird gepatcht.
+// Protokoll: <Spielordner>\BSO\BSO_Loader.txt (schreibt auch die Mod ueber HostApi.Log).
+
+#define WIN32_LEAN_AND_MEAN
+#define NETHOST_USE_AS_STATIC
+#include <windows.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <string>
+#include <nethost.h>
+#include <hostfxr.h>
+#include <coreclr_delegates.h>
+
+static HMODULE self, real;
+static FILE* logFile;
+static CRITICAL_SECTION logLock;
+static std::wstring bsoDir;
+
+static void LogLine(const char* text)
+{
+    EnterCriticalSection(&logLock);
+    if (!logFile)
+    {
+        CreateDirectoryW(bsoDir.c_str(), nullptr);
+        logFile = _wfsopen((bsoDir + L"\\BSO_Loader.txt").c_str(), L"w", _SH_DENYWR);
+    }
+    if (logFile)
+    {
+        SYSTEMTIME t;
+        GetLocalTime(&t);
+        fprintf(logFile, "%02d:%02d:%02d  %s\n", t.wHour, t.wMinute, t.wSecond, text);
+        fflush(logFile);
+    }
+    LeaveCriticalSection(&logLock);
+}
+
+static void Log(const char* fmt, ...)
+{
+    char buf[1024];
+    va_list args;
+    va_start(args, fmt);
+    vsnprintf(buf, sizeof(buf), fmt, args);
+    va_end(args);
+    LogLine(buf);
+}
+
+// ---------------------------------------------------------------------------------------------------------------
+// .NET starten
+
+/// <summary>Was die Mod vom Loader bekommt (Gegenstueck: BSO.HostApi).</summary>
+struct HostApi
+{
+    void (*log)(const char* utf8);
+    const wchar_t* gameDir;
+    const wchar_t* bsoDir;
+};
+
+typedef void (CORECLR_DELEGATE_CALLTYPE* StartFn)(HostApi*);
+typedef void (CORECLR_DELEGATE_CALLTYPE* FrameFn)();
+
+static HostApi hostApi;
+static std::wstring gameDir;
+static FrameFn onFrame;
+static bool managedTried;
+
+static void StartManaged()
+{
+    if (managedTried) return;
+    managedTried = true;
+
+    std::wstring assembly = bsoDir + L"\\BSO.dll";
+    std::wstring config = bsoDir + L"\\BSO.runtimeconfig.json";
+    if (GetFileAttributesW(assembly.c_str()) == INVALID_FILE_ATTRIBUTES)
+    {
+        Log("BSO\\BSO.dll fehlt - nur Proxy, keine Mod");
+        return;
+    }
+
+    char_t fxrPath[MAX_PATH];
+    size_t fxrSize = MAX_PATH;
+    int rc = get_hostfxr_path(fxrPath, &fxrSize, nullptr);
+    if (rc != 0) { Log(".NET nicht gefunden (get_hostfxr_path 0x%08X) - .NET 10 Runtime installieren", rc); return; }
+
+    HMODULE fxr = LoadLibraryW(fxrPath);
+    auto init = (hostfxr_initialize_for_runtime_config_fn)GetProcAddress(fxr, "hostfxr_initialize_for_runtime_config");
+    auto getDelegate = (hostfxr_get_runtime_delegate_fn)GetProcAddress(fxr, "hostfxr_get_runtime_delegate");
+    auto close = (hostfxr_close_fn)GetProcAddress(fxr, "hostfxr_close");
+    if (!init || !getDelegate || !close) { Log("hostfxr unvollstaendig"); return; }
+
+    hostfxr_handle ctx = nullptr;
+    rc = init(config.c_str(), nullptr, &ctx);
+    if (rc < 0 || !ctx) { Log("hostfxr_initialize_for_runtime_config 0x%08X", rc); if (ctx) close(ctx); return; }
+
+    load_assembly_and_get_function_pointer_fn load = nullptr;
+    rc = getDelegate(ctx, hdt_load_assembly_and_get_function_pointer, (void**)&load);
+    close(ctx);
+    if (rc != 0 || !load) { Log("hostfxr_get_runtime_delegate 0x%08X", rc); return; }
+
+    StartFn start = nullptr;
+    rc = load(assembly.c_str(), L"BSO.Bootstrap, BSO", L"Start", UNMANAGEDCALLERSONLY_METHOD, nullptr, (void**)&start);
+    if (rc != 0 || !start) { Log("BSO.Bootstrap.Start nicht gefunden (0x%08X)", rc); return; }
+    rc = load(assembly.c_str(), L"BSO.Bootstrap, BSO", L"OnFrame", UNMANAGEDCALLERSONLY_METHOD, nullptr, (void**)&onFrame);
+    if (rc != 0) { Log("BSO.Bootstrap.OnFrame nicht gefunden (0x%08X)", rc); onFrame = nullptr; }
+
+    hostApi.log = LogLine;
+    hostApi.gameDir = gameDir.c_str();
+    hostApi.bsoDir = bsoDir.c_str();
+    start(&hostApi);
+}
+
+// ---------------------------------------------------------------------------------------------------------------
+// Bild-Takt ueber die Tastatur-Abfrage
+
+static const GUID GUID_SysKeyboard_ = { 0x6F1D2B61, 0xD5A0, 0x11CF, { 0xBF, 0xC7, 0x44, 0x45, 0x53, 0x54, 0x00, 0x00 } };
+
+// Feste Plaetze in den COM-vtables (IDirectInput8 / IDirectInputDevice8, A und W gleich)
+enum { SlotCreateDevice = 3, SlotGetDeviceState = 9, SlotGetDeviceData = 10 };
+
+typedef HRESULT (WINAPI* CreateDeviceFn)(void* self, REFGUID guid, void** device, void* outer);
+typedef HRESULT (WINAPI* GetDeviceStateFn)(void* self, DWORD size, void* data);
+typedef HRESULT (WINAPI* GetDeviceDataFn)(void* self, DWORD size, void* data, DWORD* count, DWORD flags);
+
+/// <summary>Originalfunktionen je vtable (A- und W-Schnittstellen haben eigene vtables).</summary>
+struct Patched { void** vtable; void* original[3]; };
+static Patched patched[16];
+static int patchedCount;
+
+static Patched* Find(void* object)
+{
+    void** vtable = *(void***)object;
+    for (int i = 0; i < patchedCount; i++) if (patched[i].vtable == vtable) return &patched[i];
+    return nullptr;
+}
+
+/// <summary>Ersetzt Eintraege einer vtable (liegt schreibgeschuetzt in dinput8.dll) und merkt sich die Originale.</summary>
+static Patched* Patch(void* object, const int* slots, void* const* hooks, int n)
+{
+    if (Patched* p = Find(object)) return p;
+    if (patchedCount == 16) return nullptr;
+    Patched* p = &patched[patchedCount++];
+    p->vtable = *(void***)object;
+    for (int i = 0; i < n; i++)
+    {
+        void** entry = &p->vtable[slots[i]];
+        p->original[i] = *entry;
+        DWORD old;
+        VirtualProtect(entry, sizeof(void*), PAGE_READWRITE, &old);
+        *entry = hooks[i];
+        VirtualProtect(entry, sizeof(void*), old, &old);
+    }
+    return p;
+}
+
+static void* keyboard;
+static DWORD mainThread;         // Thread, der Game.vPlugin (und damit uns) geladen hat
+static int frameSlot;            // 0 = noch offen, sonst SlotGetDeviceState/SlotGetDeviceData - nur einer zaehlt
+static DWORD statStart, statMain, statOther;
+static bool statDone;
+
+// Das Spiel fragt die Tastatur mehrmals pro Bild ab (1. Lauf: ~7400/s). Die Mod erkennt ein neues Bild selbst an der
+// Engine-Uhr - hier wird nur sichergestellt, dass sie ausschliesslich im Hauptthread laeuft.
+static void Frame(void* device, int slot)
+{
+    if (device != keyboard) return;
+    if (!frameSlot)
+    {
+        frameSlot = slot;
+        Log("Takt ueber Tastatur-%s", slot == SlotGetDeviceState ? "GetDeviceState" : "GetDeviceData");
+        statStart = GetTickCount();
+    }
+    if (slot != frameSlot) return;
+
+    bool main = GetCurrentThreadId() == mainThread;
+    if (!statDone)
+    {
+        if (main) statMain++; else statOther++;
+        if (GetTickCount() - statStart >= 5000)
+        {
+            statDone = true;
+            Log("Takt: in 5 s %lu Aufrufe im Hauptthread, %lu in anderen Threads", statMain, statOther);
+        }
+    }
+    if (main && onFrame) onFrame();
+}
+
+static HRESULT WINAPI HookGetDeviceState(void* self, DWORD size, void* data)
+{
+    HRESULT hr = ((GetDeviceStateFn)Find(self)->original[0])(self, size, data);
+    Frame(self, SlotGetDeviceState);
+    return hr;
+}
+
+static HRESULT WINAPI HookGetDeviceData(void* self, DWORD size, void* data, DWORD* count, DWORD flags)
+{
+    HRESULT hr = ((GetDeviceDataFn)Find(self)->original[1])(self, size, data, count, flags);
+    Frame(self, SlotGetDeviceData);
+    return hr;
+}
+
+static HRESULT WINAPI HookCreateDevice(void* self, REFGUID guid, void** device, void* outer)
+{
+    HRESULT hr = ((CreateDeviceFn)Find(self)->original[0])(self, guid, device, outer);
+    if (SUCCEEDED(hr) && device && *device && IsEqualGUID(guid, GUID_SysKeyboard_))
+    {
+        keyboard = *device;
+        static const int slots[] = { SlotGetDeviceState, SlotGetDeviceData };
+        static void* const hooks[] = { (void*)HookGetDeviceState, (void*)HookGetDeviceData };
+        Patch(*device, slots, hooks, 2);
+        Log("Tastatur-Geraet erstellt");
+    }
+    return hr;
+}
+
+// ---------------------------------------------------------------------------------------------------------------
+// Exporte der echten dinput8.dll
+
+static FARPROC Real(const char* name)
+{
+    if (!real)
+    {
+        wchar_t path[MAX_PATH];
+        GetSystemDirectoryW(path, MAX_PATH);
+        wcscat_s(path, L"\\dinput8.dll");
+        real = LoadLibraryW(path);
+        if (!real) Log("Echte dinput8.dll nicht ladbar (%lu)", GetLastError());
+    }
+    return real ? GetProcAddress(real, name) : nullptr;
+}
+
+extern "C" HRESULT WINAPI Proxy_DirectInput8Create(HINSTANCE inst, DWORD version, REFIID iid, void** out, void* outer)
+{
+    typedef HRESULT (WINAPI* Fn)(HINSTANCE, DWORD, REFIID, void**, void*);
+    Fn fn = (Fn)Real("DirectInput8Create");
+    if (!fn) return E_FAIL;
+    HRESULT hr = fn(inst, version, iid, out, outer);
+
+    StartManaged();
+    if (SUCCEEDED(hr) && out && *out)
+    {
+        static const int slots[] = { SlotCreateDevice };
+        static void* const hooks[] = { (void*)HookCreateDevice };
+        Patch(*out, slots, hooks, 1);
+    }
+    return hr;
+}
+
+extern "C" HRESULT WINAPI Proxy_DllCanUnloadNow()
+{
+    typedef HRESULT (WINAPI* Fn)();
+    Fn fn = (Fn)Real("DllCanUnloadNow");
+    return fn ? fn() : S_FALSE;
+}
+
+extern "C" HRESULT WINAPI Proxy_DllGetClassObject(REFCLSID clsid, REFIID iid, void** out)
+{
+    typedef HRESULT (WINAPI* Fn)(REFCLSID, REFIID, void**);
+    Fn fn = (Fn)Real("DllGetClassObject");
+    return fn ? fn(clsid, iid, out) : CLASS_E_CLASSNOTAVAILABLE;
+}
+
+extern "C" HRESULT WINAPI Proxy_DllRegisterServer()
+{
+    typedef HRESULT (WINAPI* Fn)();
+    Fn fn = (Fn)Real("DllRegisterServer");
+    return fn ? fn() : E_FAIL;
+}
+
+extern "C" HRESULT WINAPI Proxy_DllUnregisterServer()
+{
+    typedef HRESULT (WINAPI* Fn)();
+    Fn fn = (Fn)Real("DllUnregisterServer");
+    return fn ? fn() : E_FAIL;
+}
+
+extern "C" const void* WINAPI Proxy_GetdfDIJoystick()
+{
+    typedef const void* (WINAPI* Fn)();
+    Fn fn = (Fn)Real("GetdfDIJoystick");
+    return fn ? fn() : nullptr;
+}
+
+BOOL WINAPI DllMain(HINSTANCE module, DWORD reason, void*)
+{
+    if (reason == DLL_PROCESS_ATTACH)
+    {
+        // Unter dem Loader-Lock nur Pfade merken - .NET startet erst im ersten DirectInput8Create
+        self = module;
+        mainThread = GetCurrentThreadId();
+        DisableThreadLibraryCalls(module);
+        InitializeCriticalSection(&logLock);
+        wchar_t path[MAX_PATH];
+        GetModuleFileNameW(module, path, MAX_PATH);
+        gameDir = path;
+        gameDir = gameDir.substr(0, gameDir.find_last_of(L'\\'));
+        bsoDir = gameDir + L"\\BSO";
+        Log("BSO Loader geladen aus %ls", path);
+    }
+    return TRUE;
+}

Loader/dinput8.def

@@ -0,0 +1,8 @@
+LIBRARY dinput8
+EXPORTS
+    DirectInput8Create=Proxy_DirectInput8Create @1
+    DllCanUnloadNow=Proxy_DllCanUnloadNow PRIVATE
+    DllGetClassObject=Proxy_DllGetClassObject PRIVATE
+    DllRegisterServer=Proxy_DllRegisterServer PRIVATE
+    DllUnregisterServer=Proxy_DllUnregisterServer PRIVATE
+    GetdfDIJoystick=Proxy_GetdfDIJoystick