Sync docs sources\n\nlancommander@v2.0.2

interposer@v1.0.1
bf1942@v1.61
callofduty@v1.5b
counterstrikesource@v1.0.0
darkmessiah@unversioned
eliteforce@v1.30
jediacademy@v1.0.0
jedioutcast@v1.4.1
portalknights@unversioned
quake3arena@v1.0.0
rtcw@unversioned
ut2004@v3339

Author: github-actions[bot]

.external/interposer

@@ -1 +1 @@
-Subproject commit cee070268da7e7757f6411c53f03f0564aa1ff69
+Subproject commit 7d5567a76bf3783d3f2c0abe2b040c7f91d73685

Interposer/Overview.md

@@ -35,4 +35,5 @@ Configuration and use of the Interposer is broken down on this site under the fo
 - [File Redirection](FileRedirection)
 - [Registry Emulation](RegistryEmulation)
 - [FastDL](FastDL)
-- [Borderless Fullscreen](BorderlessFullscreen)
+- [Borderless Fullscreen](BorderlessFullscreen)
+- [Plugins](Plugins)

Interposer/Plugins/CDKey.md

@@ -0,0 +1,97 @@
+---
+sidebar_label: CD Key
+sidebar_position: 3
+---
+
+# CD Key Plugin
+
+The CD Key plugin generates a deterministic CD key from the player's username and injects it into a registry value so the game reads it as if the game were installed with that key. The same username always produces the same key for a given mask, so every player on a LAN has a unique key that is consistent across sessions without any manual entry.
+
+## How It Works
+
+On load the plugin:
+
+1. Reads the key mask, registry key path suffix, and value name from `Config.yml`.
+2. Resolves the player username via the Interposer identity system (the `Player.Username` config value or `--username` injector flag, falling back to the real Windows account name).
+3. Generates a key by hashing the username with FNV-1a and stepping an LCG to fill each `*` position in the mask with a character from `[A-Z0-9]`.
+4. Injects the generated key into the virtual registry store using suffix matching, so any registered key whose path ends with the configured `KeyPath` receives the value.
+
+The injection is transient — it is not written back to `.interposer\Registry.reg`.
+
+## Setup
+
+### 1. Add the key to Registry.reg
+
+The target registry key must appear in `.interposer\Registry.reg` for registry emulation to intercept reads. If the game stores the CD key as the default (unnamed) value, an empty key header is sufficient:
+
+```
+Windows Registry Editor Version 5.00
+
+[HKEY_LOCAL_MACHINE\SOFTWARE\WOW6432Node\Electronic Arts\EA Games\Battlefield 1942\ergc]
+```
+
+If the key already has other values you want to preserve, export it from `regedit.exe` and include the full entry.
+
+### 2. Configure the plugin
+
+Add a `Plugins.CDKey` section to `.interposer\Config.yml`:
+
+```yaml
+Plugins:
+  CDKey:
+    Mask:      "****-**********-*******-****"
+    KeyPath:   "Battlefield 1942\\ergc"
+    ValueName: "@"
+```
+
+| Option | Required | Description |
+|---|---|---|
+| `Mask` | Yes | Key template — `*` is replaced with a generated character, all other characters are copied verbatim |
+| `KeyPath` | Yes | Suffix of the registry key path to target. Matched case-insensitively on a backslash boundary against all keys in the virtual store |
+| `ValueName` | No | Name of the registry value to write. Use `@` or omit entirely to target the default (unnamed) value. Defaults to `@` |
+
+### 3. Place the plugin
+
+Copy `LANCommander.Interposer.Plugin.CDKey.dll` into `.interposer\Plugins\` next to the main DLL:
+
+```
+C:\Games\Battlefield 1942\
+  BF1942.exe
+  LANCommander.Interposer.dll
+  .interposer\
+    Config.yml
+    Registry.reg
+    Plugins\
+      LANCommander.Interposer.Plugin.CDKey.dll
+```
+
+## Mask Syntax
+
+The mask defines the shape of the generated key. Any `*` character is replaced with a letter or digit (`[A-Z0-9]`). All other characters — including hyphens, spaces, and brackets — are preserved exactly as written.
+
+| Mask | Example output |
+|---|---|
+| `****-****-****-****` | `K7MN-2BPQ-X4RT-9LWA` |
+| `****-**********-*******-****` | `K7MN-2BPQ3X4RT9L-WA5FM2Z-8QBR` |
+| `{****-****}` | `{K7MN-2BPQ}` |
+
+## Log Output
+
+With the plugin loaded, the session log shows the injected value:
+
+```
+2025-03-14 12:00:01  [PLUGIN LOAD]   ...\.interposer\Plugins\LANCommander.Interposer.Plugin.CDKey.dll
+2025-03-14 12:00:01  [CDKEY]         Battlefield 1942\ergc\@  ->  K7MN-2BPQ3X4RT9L-WA5FM2Z-8QBR
+```
+
+If the configured `KeyPath` suffix matches no keys in the virtual store, a warning is logged instead:
+
+```
+2025-03-14 12:00:01  [CDKEY]         No virtual store keys matched suffix "Battlefield 1942\ergc" — add the key to Registry.reg
+```
+
+## Notes
+
+- Key generation is deterministic: the same username and mask always produce the same key.
+- The generated key is uppercase alphanumeric only. If a game requires a specific character set or checksum validation, a custom plugin with a tailored generation algorithm will be needed instead.
+- If `KeyPath` matches more than one key in the virtual store (e.g. two subkeys both ending with the same suffix), the value is injected into all of them and the log line notes how many keys were updated.

Interposer/Plugins/CreatingPlugins.md

@@ -0,0 +1,206 @@
+---
+sidebar_label: Creating a Plugin
+sidebar_position: 2
+---
+
+# Creating a Plugin
+
+A plugin is a standard Windows DLL (`.dll`) or ASI file (`.asi`) placed in `.interposer\Plugins\`. It has no link-time dependency on the Interposer — all API functions are resolved at runtime via `GetProcAddress`.
+
+## Project Setup
+
+Create a new DLL project targeting the same architecture as the game (x86 for 32-bit games, x64 for 64-bit games). No additional libraries or headers are required beyond the Windows SDK.
+
+The only entry point needed is `DllMain`:
+
+```cpp
+BOOL APIENTRY DllMain(HMODULE /*hModule*/, DWORD fdwReason, LPVOID /*lpReserved*/)
+{
+    if (fdwReason == DLL_PROCESS_ATTACH)
+        Initialize();
+    return TRUE;
+}
+```
+
+## Resolving the API
+
+Declare function pointer types for the Interposer exports you need and resolve them with `GetProcAddress`. The Interposer may be loaded under different filenames depending on the deployment variant, so check the known names in order:
+
+```cpp
+using FnInterposerLog             = void (WINAPI*)(const wchar_t* verb, const wchar_t* message);
+using FnInterposerGetConfigString = BOOL (WINAPI*)(const wchar_t* dotPath, wchar_t* buf, DWORD bufSize);
+
+static FnInterposerLog             pfnLog       = nullptr;
+static FnInterposerGetConfigString pfnGetConfig = nullptr;
+
+static bool ResolveAPI()
+{
+    static const wchar_t* kCandidates[] = {
+        L"LANCommander.Interposer.dll",
+        L"version.dll",   // proxy variant
+    };
+
+    HMODULE hInterposer = nullptr;
+    for (const wchar_t* name : kCandidates)
+    {
+        hInterposer = GetModuleHandleW(name);
+        if (hInterposer) break;
+    }
+
+    if (!hInterposer) return false;
+
+    pfnLog       = (FnInterposerLog)            GetProcAddress(hInterposer, "InterposerLog");
+    pfnGetConfig = (FnInterposerGetConfigString)GetProcAddress(hInterposer, "InterposerGetConfigString");
+
+    return pfnLog && pfnGetConfig;
+}
+```
+
+## API Reference
+
+All exported functions use the `WINAPI` (`__stdcall`) calling convention and undecorated `extern "C"` names.
+
+### `InterposerLog`
+
+```cpp
+void InterposerLog(const wchar_t* verb, const wchar_t* message);
+```
+
+Writes a line to the session log regardless of the `Logging` flags in `Config.yml`. The log line format matches the rest of the session log:
+
+```
+YYYY-MM-DD HH:MM:SS  [VERB]             <message>
+```
+
+`verb` is normalised automatically: any existing `[`/`]` brackets and surrounding whitespace are stripped, the content is truncated to 16 characters, and it is re-wrapped as `[verb]` right-padded to 18 characters. Pass a plain string such as `L"MYPLUGIN"` — no manual padding required.
+
+---
+
+### `InterposerGetConfigString`
+
+```cpp
+BOOL InterposerGetConfigString(const wchar_t* dotPath, wchar_t* buffer, DWORD bufferSize);
+```
+
+Reads a scalar value from `Config.yml` by dot-separated YAML path. Returns `TRUE` on success, `FALSE` if the key does not exist, is not a scalar, or the buffer is too small.
+
+`bufferSize` is in `wchar_t` units and must include room for the null terminator.
+
+```cpp
+wchar_t setting[256];
+if (pfnGetConfig(L"Plugins.MyPlugin.Setting", setting, ARRAYSIZE(setting)))
+{
+    // use setting
+}
+```
+
+Plugin configuration should live under a `Plugins.<PluginName>` namespace in `Config.yml` to avoid collisions:
+
+```yaml
+Plugins:
+  MyPlugin:
+    Setting: hello
+    Count: 42
+```
+
+---
+
+### `InterposerGetUsername`
+
+```cpp
+BOOL InterposerGetUsername(wchar_t* buffer, DWORD bufferSize);
+```
+
+Returns the effective player username: the value configured in `Config.yml` under `Player.Username` or passed via the `--username` injector flag. Falls back to the real Windows account name (`GetUserNameW`) if no override is configured.
+
+`bufferSize` is in `wchar_t` units including the null terminator. Returns `TRUE` on success.
+
+---
+
+### `InterposerSetRegistryValue`
+
+```cpp
+void InterposerSetRegistryValue(const wchar_t* keyPath, const wchar_t* valueName, const wchar_t* value);
+```
+
+Injects a `REG_SZ` string value into the in-memory virtual registry store. Subsequent `RegQueryValueEx` calls for `keyPath\valueName` return `value` without touching the real registry. The injection is transient — it is not persisted to `.interposer\Registry.reg`.
+
+`keyPath` must be a full path beginning with a hive name:
+
+```
+HKEY_LOCAL_MACHINE\SOFTWARE\MyGame\1.0
+```
+
+Set `valueName` to `L"@"`, `L""`, or `nullptr` to target the default (unnamed) registry value — the entry shown as `(Default)` in Registry Editor.
+
+:::note
+The target key must already exist in `.interposer\Registry.reg` for reads to be intercepted. Add an empty key header if no values need to be pre-populated:
+
+```
+[HKEY_LOCAL_MACHINE\SOFTWARE\MyGame\1.0]
+```
+:::
+
+---
+
+### `InterposerSetRegistryValueBySuffix`
+
+```cpp
+DWORD InterposerSetRegistryValueBySuffix(const wchar_t* keySuffix, const wchar_t* valueName, const wchar_t* value);
+```
+
+Like `InterposerSetRegistryValue`, but matches by suffix rather than exact path. Any key in the virtual store whose path ends with `\keySuffix` (matched case-insensitively on a backslash component boundary) receives the injected value.
+
+Returns the number of keys updated. A return value of `0` means the suffix matched nothing in the virtual store — check that the target key is present in `.interposer\Registry.reg`.
+
+This is useful when the full registry path varies between game versions or installations:
+
+```cpp
+// Matches HKEY_LOCAL_MACHINE\...\Electronic Arts\EA Games\Battlefield 1942\ergc
+// regardless of any intermediate path components.
+pfnSetBySuffix(L"Battlefield 1942\\ergc", L"@", generatedKey);
+```
+
+## Minimal Example
+
+```cpp
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#include <string>
+
+using FnInterposerLog             = void (WINAPI*)(const wchar_t*, const wchar_t*);
+using FnInterposerGetConfigString = BOOL (WINAPI*)(const wchar_t*, wchar_t*, DWORD);
+
+static FnInterposerLog             pfnLog       = nullptr;
+static FnInterposerGetConfigString pfnGetConfig = nullptr;
+
+static void Initialize()
+{
+    HMODULE h = GetModuleHandleW(L"LANCommander.Interposer.dll");
+    if (!h) h = GetModuleHandleW(L"version.dll");
+    if (!h) return;
+
+    pfnLog       = (FnInterposerLog)            GetProcAddress(h, "InterposerLog");
+    pfnGetConfig = (FnInterposerGetConfigString)GetProcAddress(h, "InterposerGetConfigString");
+    if (!pfnLog || !pfnGetConfig) return;
+
+    wchar_t greeting[256] = L"hello";
+    pfnGetConfig(L"Plugins.MyPlugin.Greeting", greeting, ARRAYSIZE(greeting));
+
+    pfnLog(L"MYPLUGIN", greeting);
+}
+
+BOOL APIENTRY DllMain(HMODULE, DWORD reason, LPVOID)
+{
+    if (reason == DLL_PROCESS_ATTACH)
+        Initialize();
+    return TRUE;
+}
+```
+
+```yaml
+# .interposer\Config.yml
+Plugins:
+  MyPlugin:
+    Greeting: "Plugin loaded successfully"
+```

Interposer/Plugins/Overview.md

@@ -0,0 +1,34 @@
+---
+sidebar_label: Overview
+sidebar_position: 1
+---
+
+# Plugins
+
+The Interposer supports plugins — DLL or ASI files placed in `.interposer\Plugins\` next to the main DLL. Plugins are loaded automatically after all built-in hooks are active, so they can rely on the full Interposer API from the moment they initialise.
+
+## How Plugins Are Loaded
+
+On startup, after installing and enabling all built-in hooks, the Interposer scans `.interposer\Plugins\` for files matching `*.dll` and `*.asi` and loads each one with `LoadLibrary`. Plugins are unloaded in reverse order when the process exits.
+
+Each successful load is recorded in the session log:
+
+```
+2025-03-14 12:00:01  [PLUGIN LOAD]   C:\Games\MyGame\.interposer\Plugins\CDKey.dll
+```
+
+If a plugin fails to load, the error is logged with the Win32 error code and the remaining plugins continue loading:
+
+```
+2025-03-14 12:00:01  [PLUGIN ERROR]  C:\Games\MyGame\.interposer\Plugins\broken.dll  (error 126)
+```
+
+## Available Plugins
+
+| Plugin | Description |
+|---|---|
+| [CD Key](CDKey) | Generates a deterministic CD key from the player username and injects it into a registry value |
+
+## Writing Your Own Plugin
+
+See [Creating a Plugin](CreatingPlugins) for the full API reference and a worked example.

Interposer/Plugins/_category_.json

@@ -0,0 +1,4 @@
+{
+  "label": "Plugins",
+  "position": 8
+}