From 5d86657c759217db25cf827a6ce4def26473572d Mon Sep 17 00:00:00 2001
From: Flechazo <2558755403@qq.com>
Date: Sat, 3 Oct 2026 23:04:32 +0800
Subject: [PATCH] feat: add game SDK and harden client login and game rules
- Add costume burst upgrades with durable replay and fix permanent SR equipment gacha.
- Add server game.json rules for optional collaboration UR weapons, with packaging and documentation.
- Add GameNames/GameSdk NuGet tooling, readable types, reobfuscation, complete source/PDB navigation and shared-runtime installation.
- Split plugin responsibilities, prefer typeof/nameof, centralize MSBuild settings and ignore local paths; remove the unused LoginUI test project.
- Fix login recovery and TLS through native platform HTTP and a private game relay; read device region directly from the OS time zone.
Validation: go test ./... -count=1, go vet ./..., plugin Release builds, SDK/runtime self-tests, Roslyn embedded-source navigation, gofmt check and git diff --check.
---
.gitignore | 3 +
Dockerfile.server | 2 +-
GAME_CONFIGURATION.md | 33 +
README.md | 8 +-
RELEASE.md | 2 +
build-release.ps1 | 14 +-
game.json | 6 +
go/cmd/bd2client/dev_sdk_integration_test.go | 28 +
go/cmd/bd2server/dev_command.go | 1 +
go/cmd/bd2server/main.go | 28 +
go/cmd/bd2server/preflight.go | 23 +-
go/internal/client/plugin/install.go | 33 +-
go/internal/client/plugin/install_test.go | 49 +
.../server/gacha/permanent_equipment_test.go | 79 +
go/internal/server/gameconfig/config.go | 95 +
go/internal/server/gameconfig/config_test.go | 76 +
go/internal/server/gamedata/costume_burst.go | 139 ++
.../server/gamedata/costume_burst_test.go | 119 ++
.../gamedata/equipment_collaboration.go | 160 ++
.../gamedata/equipment_collaboration_test.go | 149 ++
go/internal/server/gamedata/gacha.go | 29 +-
.../server/gamedata/gacha_active_test.go | 38 +-
go/internal/server/player/collection.go | 263 ++-
.../server/player/collection_entries.go | 17 +-
go/internal/server/player/costume_burst.go | 206 ++
.../player/costume_burst_collection_test.go | 185 ++
.../server/player/costume_burst_test.go | 256 +++
.../CaptureEnvironment.csproj | 16 +-
.../CaptureStorageIsolation.cs | 110 ++
plugins/CaptureEnvironment/CaptureWriter.cs | 283 +++
plugins/CaptureEnvironment/PacketCapture.cs | 155 ++
plugins/CaptureEnvironment/Plugin.cs | 540 +-----
plugins/CaptureEnvironment/README.md | 13 +
plugins/Directory.Build.local.props.example | 9 +
plugins/Directory.Build.props | 21 +
plugins/Directory.Build.targets | 9 +
plugins/GameNames/Game.cs | 243 +++
plugins/GameNames/GameMemberKind.cs | 14 +
plugins/GameNames/GameNames.csproj | 27 +
plugins/GameNames/Mappings/names.json.gz | Bin 0 -> 3443819 bytes
plugins/GameNames/NameTable.cs | 49 +
plugins/GameNames/README.md | 29 +
.../GameSdk.NavigationTests.csproj | 13 +
plugins/GameSdk.NavigationTests/Program.cs | 116 ++
plugins/GameSdk.targets | 21 +
plugins/GameSdk/GameSdk.csproj | 17 +
plugins/GameSdk/Pack.ps1 | 55 +
.../Package/BD2.GameSdk.Package.csproj | 25 +
plugins/GameSdk/Package/_._ | 0
.../GameSdk/Package/build/BD2.GameSdk.props | 7 +
.../GameSdk/Package/build/BD2.GameSdk.targets | 34 +
plugins/GameSdk/Program.cs | 573 ++++++
plugins/GameSdk/README.md | 257 +++
plugins/GameSdk/SelfTest.cs | 273 +++
plugins/GameSdk/SourceNavigation.cs | 464 +++++
plugins/GameSdk/THIRD-PARTY-NOTICES.txt | 75 +
plugins/GameSdk/UpdateNames.ps1 | 25 +
plugins/GameSdk/VerifyPackages.ps1 | 53 +
.../Directory.Build.props.example | 5 +
.../ExamplePlugin/ExamplePlugin.csproj | 11 +
.../samples/ExamplePlugin/NuGet.Config | 9 +
.../GameSdk/samples/ExamplePlugin/Plugin.cs | 38 +
plugins/LocalIdentity/ClientDiagnostics.cs | 141 ++
plugins/LocalIdentity/ClientPresentation.cs | 147 ++
plugins/LocalIdentity/ClientRouting.cs | 91 +-
plugins/LocalIdentity/LocalAccountPolicy.cs | 163 ++
plugins/LocalIdentity/LocalIdentity.csproj | 6 -
plugins/LocalIdentity/Plugin.cs | 530 +----
.../LocalIdentity/SystemTimeZoneCountries.cs | 707 +++++++
plugins/LocalIdentity/SystemTimeZoneRegion.cs | 106 +
plugins/LoginUI/ControlRequests.cs | 133 ++
plugins/LoginUI/LoginController.cs | 801 ++++++++
plugins/LoginUI/LoginPanel.cs | 301 +++
plugins/LoginUI/LoginRuntime.cs | 111 ++
plugins/LoginUI/LoginUI.csproj | 6 -
plugins/LoginUI/PlatformControlHttp.cs | 398 ++++
plugins/LoginUI/Plugin.cs | 1718 +----------------
plugins/LoginUI/SecureGameRelay.cs | 169 ++
plugins/LoginUI/SessionRecovery.cs | 595 ++++++
plugins/PackageMetadata.props | 18 +
plugins/README.md | 14 +-
plugins/VersionSource.targets | 4 -
tools/python/start-official-capture.ps1 | 9 +-
83 files changed, 8970 insertions(+), 2828 deletions(-)
create mode 100644 GAME_CONFIGURATION.md
create mode 100644 game.json
create mode 100644 go/cmd/bd2client/dev_sdk_integration_test.go
create mode 100644 go/internal/server/gacha/permanent_equipment_test.go
create mode 100644 go/internal/server/gameconfig/config.go
create mode 100644 go/internal/server/gameconfig/config_test.go
create mode 100644 go/internal/server/gamedata/costume_burst.go
create mode 100644 go/internal/server/gamedata/costume_burst_test.go
create mode 100644 go/internal/server/gamedata/equipment_collaboration.go
create mode 100644 go/internal/server/gamedata/equipment_collaboration_test.go
create mode 100644 go/internal/server/player/costume_burst.go
create mode 100644 go/internal/server/player/costume_burst_collection_test.go
create mode 100644 go/internal/server/player/costume_burst_test.go
create mode 100644 plugins/CaptureEnvironment/CaptureStorageIsolation.cs
create mode 100644 plugins/CaptureEnvironment/CaptureWriter.cs
create mode 100644 plugins/CaptureEnvironment/PacketCapture.cs
create mode 100644 plugins/Directory.Build.local.props.example
create mode 100644 plugins/Directory.Build.props
create mode 100644 plugins/Directory.Build.targets
create mode 100644 plugins/GameNames/Game.cs
create mode 100644 plugins/GameNames/GameMemberKind.cs
create mode 100644 plugins/GameNames/GameNames.csproj
create mode 100644 plugins/GameNames/Mappings/names.json.gz
create mode 100644 plugins/GameNames/NameTable.cs
create mode 100644 plugins/GameNames/README.md
create mode 100644 plugins/GameSdk.NavigationTests/GameSdk.NavigationTests.csproj
create mode 100644 plugins/GameSdk.NavigationTests/Program.cs
create mode 100644 plugins/GameSdk.targets
create mode 100644 plugins/GameSdk/GameSdk.csproj
create mode 100644 plugins/GameSdk/Pack.ps1
create mode 100644 plugins/GameSdk/Package/BD2.GameSdk.Package.csproj
create mode 100644 plugins/GameSdk/Package/_._
create mode 100644 plugins/GameSdk/Package/build/BD2.GameSdk.props
create mode 100644 plugins/GameSdk/Package/build/BD2.GameSdk.targets
create mode 100644 plugins/GameSdk/Program.cs
create mode 100644 plugins/GameSdk/README.md
create mode 100644 plugins/GameSdk/SelfTest.cs
create mode 100644 plugins/GameSdk/SourceNavigation.cs
create mode 100644 plugins/GameSdk/THIRD-PARTY-NOTICES.txt
create mode 100644 plugins/GameSdk/UpdateNames.ps1
create mode 100644 plugins/GameSdk/VerifyPackages.ps1
create mode 100644 plugins/GameSdk/samples/ExamplePlugin/Directory.Build.props.example
create mode 100644 plugins/GameSdk/samples/ExamplePlugin/ExamplePlugin.csproj
create mode 100644 plugins/GameSdk/samples/ExamplePlugin/NuGet.Config
create mode 100644 plugins/GameSdk/samples/ExamplePlugin/Plugin.cs
create mode 100644 plugins/LocalIdentity/ClientDiagnostics.cs
create mode 100644 plugins/LocalIdentity/ClientPresentation.cs
create mode 100644 plugins/LocalIdentity/LocalAccountPolicy.cs
create mode 100644 plugins/LocalIdentity/SystemTimeZoneCountries.cs
create mode 100644 plugins/LocalIdentity/SystemTimeZoneRegion.cs
create mode 100644 plugins/LoginUI/ControlRequests.cs
create mode 100644 plugins/LoginUI/LoginController.cs
create mode 100644 plugins/LoginUI/LoginPanel.cs
create mode 100644 plugins/LoginUI/LoginRuntime.cs
create mode 100644 plugins/LoginUI/PlatformControlHttp.cs
create mode 100644 plugins/LoginUI/SecureGameRelay.cs
create mode 100644 plugins/LoginUI/SessionRecovery.cs
create mode 100644 plugins/PackageMetadata.props
diff --git a/.gitignore b/.gitignore
index 4557ea7..31497dd 100644
--- a/.gitignore
+++ b/.gitignore
@@ -8,6 +8,9 @@
.env.*
!.env.example
go/config.json
+plugins/**/Directory.Build.props
+!plugins/Directory.Build.props
+plugins/Directory.Build.local.props
# Project notes and local/runtime data are intentionally outside source control
docs/
diff --git a/Dockerfile.server b/Dockerfile.server
index b6df7de..50acca8 100644
--- a/Dockerfile.server
+++ b/Dockerfile.server
@@ -17,7 +17,7 @@ RUN apt-get update \
WORKDIR /app
COPY --from=build /out/bd2server /app/bd2server
-COPY versions.json authentication.json resources.json /app/
+COPY versions.json authentication.json resources.json game.json /app/
COPY go/seed /app/go/seed
RUN mkdir -p /app/data && chown 10001:10001 /app/data
diff --git a/GAME_CONFIGURATION.md b/GAME_CONFIGURATION.md
new file mode 100644
index 0000000..9ee19dd
--- /dev/null
+++ b/GAME_CONFIGURATION.md
@@ -0,0 +1,33 @@
+# 服务端游戏规则配置
+
+`game.json` 是服务端统一的游戏规则配置入口。后续可配置的游戏规则在此按功能分组扩展；认证、资源源、版本清单仍分别使用现有配置文件。
+
+发布部署时，将文件放在 `bd2server.exe`（Linux/macOS 为 `bd2server`）旁。开发入口读取仓库根目录的同名文件。修改后重启服务端生效，客户端无需配置此文件。发布包只在服务端包中提供 `game.json` 和本指南。
+
+默认内容：
+
+```json
+{
+ "schema_version": 1,
+ "gacha": {
+ "include_collaboration_ur_weapons": false
+ }
+}
+```
+
+## 联动 UR 专武
+
+`gacha.include_collaboration_ur_weapons` 必须是 JSON 布尔值：
+
+| 值 | UR 必得装备券的结果 |
+|---|---|
+| `false`（默认） | 使用当前 GameData 的原始 UR 必得装备券池。 |
+| `true` | 在原池中加入 14 种联动角色 UR 专武（装备 ID `943200` 至 `943213`）。 |
+
+开关仅作用于 UR 必得装备券。新增装备沿用同星级原有装备的单件权重，原有星级权重规则保持不变；加入候选后，同星级内的概率按扩展后的权重总和计算。该设置只改变券池候选，不会直接发放装备。专武绑定角色，同一角色的多个服装共用专武。
+
+## 校验与升级
+
+`schema_version` 当前必须为 `1`。字段拼写错误、未知字段、错误类型（例如字符串 `"true"`）、`null`、格式错误或文件末尾多出的 JSON 都会使服务端拒绝启动，并在错误中给出文件路径。省略 `gacha` 或此布尔开关时使用 `false`。
+
+旧安装缺少整个文件时使用默认规则，服务端不会自动写入或覆盖文件。升级服务端时保留服主已经修改的 `game.json`；新发布包中的文件可用于比对新增字段。Docker 部署可将自定义文件只读挂载到 `/app/game.json`，重启容器后生效。
diff --git a/README.md b/README.md
index 149269d..ee5173e 100644
--- a/README.md
+++ b/README.md
@@ -28,7 +28,7 @@ $env:GOCACHE = (Join-Path $PWD '.cache\go-build')
go run .\cmd\bd2client --dev run
```
-服务端开发入口会自动使用仓库根目录的版本、认证、资源、数据和存档配置；客户端开发入口会直接使用仓库版本清单和插件产物，并从本机开发配置读取游戏目录，随后增量构建两个客户端插件。首次开发前创建该配置：
+服务端开发入口会自动使用仓库根目录的版本、认证、资源、数据和存档配置；客户端开发入口会直接使用仓库版本清单和插件产物，并从本机开发配置读取游戏目录，随后用 SDK 内嵌的当前版本名字表增量构建两个客户端插件，无需提供官方映射文件。首次开发前创建该配置：
```powershell
Copy-Item .\go\config.example.json .\go\config.json
@@ -44,7 +44,7 @@ Copy-Item .\go\config.example.json .\go\config.json
.\build-release.ps1
```
-脚本在 Windows 本机构建版本化归档，例如 `.build\bd2server-2.35.10+server.0.1.0-windows-x64.zip` 和 `.build\bd2client-2.35.10+client.0.1.0-windows-x64.zip`。纯服务端包只包含 `bd2server.exe`、seed、认证/资源策略和服务端数据目录；客户端包只包含 `bd2client.exe`、客户端插件和版本文件。
+脚本在 Windows 本机构建版本化归档，例如 `.build\bd2server-2.35.10+server.0.1.0-windows-x64.zip` 和 `.build\bd2client-2.35.10+client.0.1.0-windows-x64.zip`。纯服务端包只包含 `bd2server.exe`、seed、认证/资源策略、游戏规则配置和服务端数据目录；客户端包只包含 `bd2client.exe`、客户端插件和版本文件。
macOS 客户端使用系统 Cocoa / WKWebView，需要 macOS 原生构建环境。本地 Windows 发布脚本不会交叉编译或生成 macOS 发布包；找到 macOS 测试者或准备公开发布时，再通过 GitHub Actions 的 macOS runner 完成原生构建、测试及 `.app` 打包。签名和公证也应在该流程中配置。
@@ -61,7 +61,7 @@ BD2 Client Studio 是使用 Wails 的独立桌面客户端设置工具。Windows
- 选择并验证 Brown Dust II 安装目录。
- 填写服务器 origin 和端口，自动写入游戏目录下的 `BepInEx/config/bd2.client.json`。
- 应用带原文件备份的客户端入口补丁。
-- 检查 BepInEx 后安装或更新 `BD2LocalIdentity.dll` 与 `BD2LoginUI.dll`。
+- 检查 BepInEx 后安装或更新 `BD2LocalIdentity.dll`、`BD2LoginUI.dll` 及其共享运行时 `BD2.GameNames.dll`。
- 选择官方 CDN、服务器资源源或本地已下载资源。
服主同步官方资源、自建静态 CDN 或配置缓存反代的步骤见 [资源与 CDN 配置指南](RESOURCES.md)。
@@ -77,6 +77,8 @@ BD2 Client Studio 是使用 Wails 的独立桌面客户端设置工具。Windows
认证策略由 `bd2server.exe` 同目录的 `authentication.json` 权威决定。`mode=local`（默认）不依赖第三方登录，单人本地服保持不动，联机服可设为 `oauth` 来让玩家通过 Discord/Google 登录。
+游戏规则统一使用服务端同目录的 `game.json`，修改后重启生效；开发入口读取仓库根目录的文件。联动 UR 专武是否加入 UR 必得装备券池及升级保留配置的方法见 [服务端游戏规则配置](GAME_CONFIGURATION.md)。
+
### 启动客户端
先手动安装 [BepInEx](https://github.com/BepInEx/BepInEx/releases)。然后打开我们的客户端工具 `bd2client.exe`。
diff --git a/RELEASE.md b/RELEASE.md
index 92df680..8bb6cde 100644
--- a/RELEASE.md
+++ b/RELEASE.md
@@ -32,4 +32,6 @@
`authentication.json` 和 `resources.json` 必须与 `bd2server.exe` 保持在同一目录。默认 `local` 认证模式继续自动本地登录；公网或联机服可以启用 OAuth，并把资源策略设为官方 CDN 或统一的服务器资源源。服主自建与反代使用相同的 `server` 模式；玩家本地资源目录仅由 `bd2client.exe` 配置。逐步配置方法见发布包内的 [服主第三方登录配置指南](AUTHENTICATION.md) 和 [服主资源与 CDN 配置指南](RESOURCES.md)。
+游戏规则使用同目录的 `game.json`，修改后重启服务端生效。默认关闭联动 UR 专武扩展；需要将 14 种联动角色专武加入 UR 必得装备券池时，按 [服务端游戏规则配置](GAME_CONFIGURATION.md) 设置。升级时保留已修改的文件；旧安装缺少文件时使用默认规则。
+
OAuth access token 只在客户端内存中；Windows refresh credential 使用当前用户 DPAPI 加密后写入 PlayerPrefs 注册表，macOS 使用 Keychain Services。服务端 `auth.db` 只保存 token、device secret、OAuth state 及 provider subject 的 HMAC，临时可恢复材料使用 AES-256-GCM。
diff --git a/build-release.ps1 b/build-release.ps1
index 5ddd5fc..22931ec 100644
--- a/build-release.ps1
+++ b/build-release.ps1
@@ -17,6 +17,7 @@ $clientPluginDir = Join-Path $clientPackage 'plugins'
$versionConfig = Join-Path $root 'versions.json'
$authenticationConfig = Join-Path $root 'authentication.json'
$resourceConfig = Join-Path $root 'resources.json'
+$gameConfig = Join-Path $root 'game.json'
try {
$releaseVersions = Get-Content -LiteralPath $versionConfig -Raw | ConvertFrom-Json -ErrorAction Stop
@@ -91,20 +92,31 @@ $clientPlugins = @(
@{ Name = 'LoginUI'; Project = Join-Path $root 'plugins\LoginUI\LoginUI.csproj'; Output = Join-Path $root 'plugins\LoginUI\bin\Release\netstandard2.1\BD2LoginUI.dll'; FileName = 'BD2LoginUI.dll' }
)
foreach ($plugin in $clientPlugins) {
- dotnet build $plugin.Project -c Release "-p:GameDir=$GameDir" --nologo
+ $pluginBuildArgs = @('build', $plugin.Project, '-c', 'Release', "-p:GameDir=$GameDir", '--nologo')
+ dotnet @pluginBuildArgs
if ($LASTEXITCODE -ne 0) { throw "$($plugin.Name) build failed with exit code $LASTEXITCODE" }
if (-not (Test-Path -LiteralPath $plugin.Output -PathType Leaf)) { throw "$($plugin.Name) build output is missing" }
Copy-Item -LiteralPath $plugin.Output -Destination (Join-Path $clientPluginDir $plugin.FileName) -Force
+ $sharedRuntime = Join-Path (Split-Path -Parent $plugin.Output) 'BD2.GameNames.dll'
+ if (-not (Test-Path -LiteralPath $sharedRuntime -PathType Leaf)) { throw "Shared game names runtime is missing: $sharedRuntime" }
+ $packagedRuntime = Join-Path $clientPluginDir 'BD2.GameNames.dll'
+ if ((Test-Path -LiteralPath $packagedRuntime) -and
+ (Get-FileHash -LiteralPath $packagedRuntime).Hash -ne (Get-FileHash -LiteralPath $sharedRuntime).Hash) {
+ throw 'Client plugins were built with different BD2.GameNames libraries.'
+ }
+ Copy-Item -LiteralPath $sharedRuntime -Destination $packagedRuntime -Force
}
Copy-Item -LiteralPath (Join-Path $goRoot 'seed') -Destination $serverGoDir -Recurse -Force
Copy-Item -LiteralPath $versionConfig -Destination (Join-Path $serverPackage 'versions.json') -Force
Copy-Item -LiteralPath $authenticationConfig -Destination (Join-Path $serverPackage 'authentication.json') -Force
Copy-Item -LiteralPath $resourceConfig -Destination (Join-Path $serverPackage 'resources.json') -Force
+Copy-Item -LiteralPath $gameConfig -Destination (Join-Path $serverPackage 'game.json') -Force
Copy-Item -LiteralPath $versionConfig -Destination (Join-Path $clientPackage 'versions.json') -Force
Copy-Item -LiteralPath (Join-Path $root 'RELEASE.md') -Destination (Join-Path $serverPackage 'README.md') -Force
Copy-Item -LiteralPath (Join-Path $root 'AUTHENTICATION.md') -Destination (Join-Path $serverPackage 'AUTHENTICATION.md') -Force
Copy-Item -LiteralPath (Join-Path $root 'RESOURCES.md') -Destination (Join-Path $serverPackage 'RESOURCES.md') -Force
+Copy-Item -LiteralPath (Join-Path $root 'GAME_CONFIGURATION.md') -Destination (Join-Path $serverPackage 'GAME_CONFIGURATION.md') -Force
Copy-Item -LiteralPath (Join-Path $root 'docs\CLIENT.md') -Destination (Join-Path $clientPackage 'README.md') -Force
Copy-Item -LiteralPath (Join-Path $root 'LICENSE') -Destination (Join-Path $serverPackage 'LICENSE') -Force
Copy-Item -LiteralPath (Join-Path $root 'LICENSE') -Destination (Join-Path $clientPackage 'LICENSE') -Force
diff --git a/game.json b/game.json
new file mode 100644
index 0000000..971cd85
--- /dev/null
+++ b/game.json
@@ -0,0 +1,6 @@
+{
+ "schema_version": 1,
+ "gacha": {
+ "include_collaboration_ur_weapons": false
+ }
+}
diff --git a/go/cmd/bd2client/dev_sdk_integration_test.go b/go/cmd/bd2client/dev_sdk_integration_test.go
new file mode 100644
index 0000000..f98f9a3
--- /dev/null
+++ b/go/cmd/bd2client/dev_sdk_integration_test.go
@@ -0,0 +1,28 @@
+//go:build !release
+
+package main
+
+import (
+ "os"
+ "testing"
+)
+
+// Opt in on a developer machine with the game installed. Exercise the exact
+// --dev run preparation path without starting the interactive Wails window.
+func TestDevelopmentRunBuildsPluginsWithEmbeddedNames(t *testing.T) {
+ if os.Getenv("BD2_TEST_DEVELOPMENT_BUILD") != "1" {
+ t.Skip("set BD2_TEST_DEVELOPMENT_BUILD=1 to build against go/config.json")
+ }
+ args, options, err := developmentRunOptions([]string{"--dev", "run"})
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(args) != 0 {
+ t.Fatalf("unexpected runtime arguments: %v", args)
+ }
+ for _, path := range []string{options.localIdentityPlugin, options.loginUIPlugin} {
+ if !clientDevelopmentFile(path) {
+ t.Fatalf("development plugin output missing: %s", path)
+ }
+ }
+}
diff --git a/go/cmd/bd2server/dev_command.go b/go/cmd/bd2server/dev_command.go
index 3e3ec58..685f0e8 100644
--- a/go/cmd/bd2server/dev_command.go
+++ b/go/cmd/bd2server/dev_command.go
@@ -25,6 +25,7 @@ func runDevelopmentCommand(args []string) (bool, error) {
serveArgs = appendDefaultFlag(serveArgs, "--version-config", filepath.Join(root, "versions.json"))
serveArgs = appendDefaultFlag(serveArgs, "--authentication-config", filepath.Join(root, "authentication.json"))
serveArgs = appendDefaultFlag(serveArgs, "--resource-config", filepath.Join(root, "resources.json"))
+ serveArgs = appendDefaultFlag(serveArgs, "--game-config", filepath.Join(root, "game.json"))
serveArgs = appendDefaultFlag(serveArgs, "--data-dir", filepath.Join(root, "data"))
serveArgs = appendDefaultFlag(serveArgs, "--state", filepath.Join(root, "data", "state", "state.db"))
return true, serve(serveArgs)
diff --git a/go/cmd/bd2server/main.go b/go/cmd/bd2server/main.go
index 068a08c..df233b6 100644
--- a/go/cmd/bd2server/main.go
+++ b/go/cmd/bd2server/main.go
@@ -24,6 +24,7 @@ import (
"bd2server/internal/server/deck"
"bd2server/internal/server/feature"
"bd2server/internal/server/gacha"
+ "bd2server/internal/server/gameconfig"
"bd2server/internal/server/gamedata"
"bd2server/internal/server/lifecycle"
"bd2server/internal/server/mail"
@@ -80,6 +81,7 @@ func serve(args []string) (serveErr error) {
versionConfigPath := fs.String("version-config", "", "repository versions.json override")
authConfigPath := fs.String("authentication-config", "", "authentication.json override for development")
resourceConfigPath := fs.String("resource-config", "", "resources.json override for development")
+ gameConfigPath := fs.String("game-config", "", "game.json server gameplay configuration override")
listen := fs.String("listen", "127.0.0.1:8080", "local listen address")
dataDir := fs.String("data-dir", "", "server data directory (defaults beside the executable)")
gameDataVersion := fs.String("game-data-version", "", "validated GameData version (defaults to versions.json)")
@@ -118,6 +120,16 @@ func serve(args []string) (serveErr error) {
}
}
versionconfig.Use(versions)
+ if *gameConfigPath == "" {
+ *gameConfigPath, err = gameconfig.BesideExecutable()
+ if err != nil {
+ return err
+ }
+ }
+ gameRules, err := gameconfig.Load(*gameConfigPath)
+ if err != nil {
+ return err
+ }
if *authConfigPath == "" {
*authConfigPath, err = authconfig.BesideExecutable()
if err != nil {
@@ -220,6 +232,13 @@ func serve(args []string) (serveErr error) {
if err != nil {
return fmt.Errorf("load active gacha GameData: %w", err)
}
+ if gameRules.Gacha.IncludeCollaborationURWeapons {
+ if err := equipmentGacha.IncludeCollaborationURWeapons(gameData, *gameDataVersion); err != nil {
+ return fmt.Errorf("apply collaboration UR weapon game rule: %w", err)
+ }
+ }
+ slog.Info("server gameplay rules loaded", "config", *gameConfigPath,
+ "include_collaboration_ur_weapons", gameRules.Gacha.IncludeCollaborationURWeapons)
limitedCostumes, err := gamedata.LoadLimitedCostumes(gameData, *gameDataVersion)
if err != nil {
return fmt.Errorf("load limited costume GameData: %w", err)
@@ -519,6 +538,14 @@ func serve(args []string) (serveErr error) {
if err != nil {
return err
}
+ costumeBurstDesign, err := gamedata.LoadCostumeBurstDesign(gameData, *gameDataVersion)
+ if err != nil {
+ return fmt.Errorf("load costume burst GameData: %w", err)
+ }
+ costumeBurstService, err := player.NewCostumeBurstService(costumeBurstDesign, collection, ownedItems, wallet)
+ if err != nil {
+ return err
+ }
battleService := battle.NewService(gameData, *gameDataVersion, ownedItems, worldService.CurrentPackID)
battleService.AttachTutorialWin(func() error {
return missionService.CompleteMission(gamedata.MissionKey{GroupType: 0, GroupID: 1, ID: 113})
@@ -538,6 +565,7 @@ func serve(args []string) (serveErr error) {
inventorySlots,
charAwakeService,
costumePotentialService,
+ costumeBurstService,
starter,
mailService,
gachaService,
diff --git a/go/cmd/bd2server/preflight.go b/go/cmd/bd2server/preflight.go
index f2a161a..461a9b5 100644
--- a/go/cmd/bd2server/preflight.go
+++ b/go/cmd/bd2server/preflight.go
@@ -11,6 +11,7 @@ import (
"bd2server/internal/server/authconfig"
"bd2server/internal/server/deck"
"bd2server/internal/server/gacha"
+ "bd2server/internal/server/gameconfig"
"bd2server/internal/server/gamedata"
"bd2server/internal/server/mail"
"bd2server/internal/server/player"
@@ -28,6 +29,7 @@ func preflight(args []string) error {
versionPath := fs.String("version-config", "", "repository versions.json override")
authPath := fs.String("authentication-config", "", "authentication.json override")
resourcePath := fs.String("resource-config", "", "resources.json override")
+ gamePath := fs.String("game-config", "", "game.json server gameplay configuration override")
if err := fs.Parse(args); err != nil {
return err
}
@@ -39,6 +41,16 @@ func preflight(args []string) error {
return err
}
versionconfig.Use(versions)
+ if *gamePath == "" {
+ *gamePath, err = gameconfig.BesideExecutable()
+ if err != nil {
+ return err
+ }
+ }
+ gameRules, err := gameconfig.Load(*gamePath)
+ if err != nil {
+ return err
+ }
if *authPath == "" {
*authPath, err = authconfig.BesideExecutable()
if err != nil {
@@ -106,15 +118,24 @@ func preflight(args []string) error {
for _, window := range schedule.StepUps {
steps = append(steps, window.GroupID)
}
- if _, _, err := gamedata.LoadActiveGachaForSchedules(gameData, versions.GameDataVersion, groups, steps); err != nil {
+ _, equipment, err := gamedata.LoadActiveGachaForSchedules(gameData, versions.GameDataVersion, groups, steps)
+ if err != nil {
return err
}
+ if gameRules.Gacha.IncludeCollaborationURWeapons {
+ if err := equipment.IncludeCollaborationURWeapons(gameData, versions.GameDataVersion); err != nil {
+ return fmt.Errorf("preflight collaboration UR weapon game rule: %w", err)
+ }
+ }
if _, err := gamedata.LoadFirstGacha(gameData, versions.GameDataVersion); err != nil {
return err
}
if _, err := gamedata.LoadLimitedCostumes(gameData, versions.GameDataVersion); err != nil {
return err
}
+ if _, err := gamedata.LoadCostumeBurstDesign(gameData, versions.GameDataVersion); err != nil {
+ return err
+ }
return nil
}
diff --git a/go/internal/client/plugin/install.go b/go/internal/client/plugin/install.go
index 07656a8..6644205 100644
--- a/go/internal/client/plugin/install.go
+++ b/go/internal/client/plugin/install.go
@@ -23,6 +23,7 @@ type Spec struct {
var (
LocalIdentity = Spec{fileName: "BD2LocalIdentity.dll"}
LoginUI = Spec{fileName: "BD2LoginUI.dll"}
+ GameNames = Spec{fileName: "BD2.GameNames.dll"}
)
func (s Spec) FileName() string { return s.fileName }
@@ -54,8 +55,8 @@ func ResolvePackaged(spec Spec, explicit string) (string, error) {
}
// Install verifies that the user installed BepInEx, then atomically stages the
-// packaged plugin into its plugins directory. It never installs or downloads
-// BepInEx itself.
+// packaged plugin and its adjacent shared game-names runtime into its plugins
+// directory. It never installs or downloads BepInEx itself.
func Install(spec Spec, gameDir, source string) (Result, error) {
if err := spec.validate(); err != nil {
return Result{}, err
@@ -80,7 +81,33 @@ func Install(spec Spec, gameDir, source string) (Result, error) {
if len(sourceData) == 0 {
return Result{}, fmt.Errorf("clientplugin: packaged %s is empty", spec.fileName)
}
- pluginDir := installation.Plugins
+ // Read both artifacts before touching the installation. The runtime table
+ // library is shipped beside every plugin, including explicit development paths.
+ var runtimeData []byte
+ if spec == LocalIdentity || spec == LoginUI {
+ runtimeSource := filepath.Join(filepath.Dir(source), GameNames.fileName)
+ runtimeData, err = os.ReadFile(runtimeSource)
+ if err != nil {
+ return Result{}, fmt.Errorf("clientplugin: read shared runtime %s: %w", runtimeSource, err)
+ }
+ if len(runtimeData) == 0 {
+ return Result{}, fmt.Errorf("clientplugin: packaged %s is empty", GameNames.fileName)
+ }
+ }
+ changed := false
+ if runtimeData != nil {
+ runtimeResult, err := installData(GameNames, installation.Plugins, runtimeData)
+ if err != nil {
+ return Result{}, err
+ }
+ changed = runtimeResult.Changed
+ }
+ result, err := installData(spec, installation.Plugins, sourceData)
+ result.Changed = result.Changed || changed
+ return result, err
+}
+
+func installData(spec Spec, pluginDir string, sourceData []byte) (Result, error) {
destination := filepath.Join(pluginDir, spec.fileName)
if installed, err := os.ReadFile(destination); err == nil {
if bytes.Equal(hash(installed), hash(sourceData)) {
diff --git a/go/internal/client/plugin/install_test.go b/go/internal/client/plugin/install_test.go
index 280e365..4c4e695 100644
--- a/go/internal/client/plugin/install_test.go
+++ b/go/internal/client/plugin/install_test.go
@@ -23,6 +23,9 @@ func TestInstallRequiresBepInExWithoutCopyingPlugin(t *testing.T) {
}
}
source := filepath.Join(t.TempDir(), spec.FileName())
+ if err := os.WriteFile(filepath.Join(filepath.Dir(source), GameNames.FileName()), []byte("names-v1"), 0o600); err != nil {
+ t.Fatal(err)
+ }
if err := os.WriteFile(source, []byte("plugin"), 0o600); err != nil {
t.Fatal(err)
}
@@ -54,6 +57,9 @@ func TestInstallCopiesUpdatesAndSkipsIdenticalPlugin(t *testing.T) {
}
}
source := filepath.Join(t.TempDir(), spec.FileName())
+ if err := os.WriteFile(filepath.Join(filepath.Dir(source), GameNames.FileName()), []byte("names-v1"), 0o600); err != nil {
+ t.Fatal(err)
+ }
if err := os.WriteFile(source, []byte("v1"), 0o600); err != nil {
t.Fatal(err)
}
@@ -65,6 +71,18 @@ func TestInstallCopiesUpdatesAndSkipsIdenticalPlugin(t *testing.T) {
if err != nil || second.Changed {
t.Fatalf("idempotent install=%+v err=%v", second, err)
}
+ runtimeSource := filepath.Join(filepath.Dir(source), GameNames.FileName())
+ if err := os.WriteFile(runtimeSource, []byte("names-v2"), 0o600); err != nil {
+ t.Fatal(err)
+ }
+ runtimeUpdate, err := Install(spec, gameDir, source)
+ if err != nil || !runtimeUpdate.Changed {
+ t.Fatalf("runtime-only update=%+v err=%v", runtimeUpdate, err)
+ }
+ installedRuntime, err := os.ReadFile(filepath.Join(gameDir, "BepInEx", "plugins", GameNames.FileName()))
+ if err != nil || string(installedRuntime) != "names-v2" {
+ t.Fatalf("installed runtime=%q err=%v", installedRuntime, err)
+ }
if err := os.WriteFile(source, []byte("v2"), 0o600); err != nil {
t.Fatal(err)
}
@@ -80,6 +98,34 @@ func TestInstallCopiesUpdatesAndSkipsIdenticalPlugin(t *testing.T) {
}
}
+func TestInstallMissingSharedRuntimeDoesNotChangePlugin(t *testing.T) {
+ gameDir := t.TempDir()
+ for path, data := range map[string][]byte{
+ filepath.Join(gameDir, "BrownDust II.exe"): []byte("game"),
+ filepath.Join(gameDir, "BrownDust II_Data", "resources.assets"): []byte("assets"),
+ filepath.Join(gameDir, "BepInEx", "core", "BepInEx.dll"): []byte("bepinex"),
+ filepath.Join(gameDir, "BepInEx", "plugins", LocalIdentity.FileName()): []byte("old-plugin"),
+ } {
+ if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+ t.Fatal(err)
+ }
+ if err := os.WriteFile(path, data, 0o600); err != nil {
+ t.Fatal(err)
+ }
+ }
+ source := filepath.Join(t.TempDir(), LocalIdentity.FileName())
+ if err := os.WriteFile(source, []byte("new-plugin"), 0o600); err != nil {
+ t.Fatal(err)
+ }
+ if _, err := Install(LocalIdentity, gameDir, source); err == nil || !strings.Contains(err.Error(), GameNames.FileName()) {
+ t.Fatalf("missing runtime error=%v", err)
+ }
+ installed, err := os.ReadFile(filepath.Join(gameDir, "BepInEx", "plugins", LocalIdentity.FileName()))
+ if err != nil || string(installed) != "old-plugin" {
+ t.Fatalf("installed=%q err=%v", installed, err)
+ }
+}
+
func TestInstallKeepsPluginsSeparate(t *testing.T) {
gameDir := t.TempDir()
for path, data := range map[string][]byte{
@@ -96,6 +142,9 @@ func TestInstallKeepsPluginsSeparate(t *testing.T) {
}
for _, spec := range []Spec{LocalIdentity, LoginUI} {
source := filepath.Join(t.TempDir(), spec.FileName())
+ if err := os.WriteFile(filepath.Join(filepath.Dir(source), GameNames.FileName()), []byte("names-v1"), 0o600); err != nil {
+ t.Fatal(err)
+ }
if err := os.WriteFile(source, []byte(spec.FileName()), 0o600); err != nil {
t.Fatal(err)
}
diff --git a/go/internal/server/gacha/permanent_equipment_test.go b/go/internal/server/gacha/permanent_equipment_test.go
new file mode 100644
index 0000000..9db4d21
--- /dev/null
+++ b/go/internal/server/gacha/permanent_equipment_test.go
@@ -0,0 +1,79 @@
+package gacha
+
+import (
+ "bytes"
+ "fmt"
+ "os"
+ "testing"
+
+ "bd2server/internal/server/gamedata"
+ "bd2server/internal/server/player"
+ "bd2server/internal/server/stateio"
+ "bd2server/internal/server/wire"
+)
+
+func TestPermanentEquipmentBuyUsesActiveCatalogWithoutSchedule(t *testing.T) {
+ root := os.Getenv("BD2_TEST_GAMEDATA_ROOT")
+ if root == "" {
+ t.Skip("set BD2_TEST_GAMEDATA_ROOT for installed GameData integration test")
+ }
+ regular, catalog, err := gamedata.LoadActiveGachaForSchedules(root, "20260923193640", nil, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+ for _, ticketCount := range []uint64{5, 10} {
+ t.Run(fmt.Sprintf("tickets_%d", ticketCount), func(t *testing.T) {
+ storage := stateio.NewMemory()
+ service := newMultiBuyTestService(t, storage)
+ service.regular = regular
+ service.schedule.Schedules = nil
+ equipment, err := player.OpenEquipmentInventory(storage)
+ if err != nil {
+ t.Fatal(err)
+ }
+ service.AttachEquipmentGacha(catalog, equipment)
+ inventory, err := player.OpenInventory(storage, &player.Starter{Version: "2.35.10"})
+ if err != nil {
+ t.Fatal(err)
+ }
+ items, err := inventory.GrantOnce("tickets", []gamedata.BattleReward{{Type: 8, ID: 1000, Count: ticketCount + 1}})
+ if err != nil {
+ t.Fatal(err)
+ }
+ service.AttachInventory(inventory)
+ ticket := items[0]
+ ticket.Count = ticketCount
+ request := wire.AppendVarint(nil, 1, 90)
+ request = wire.AppendVarint(request, 2, 201)
+ request = wire.AppendVarint(request, 3, 1)
+ request = wire.AppendBytes(request, 4, player.ItemWire(ticket))
+ code, response, handled, err := service.Handle("/GachaBuy", request)
+ if err != nil || !handled || code != 146 {
+ t.Fatalf("code=%d handled=%v err=%v", code, handled, err)
+ }
+ bundle, _, _ := wire.Bytes(response, 1)
+ if countFields(bundle, 4) != 10 || len(equipment.All()) != 10 {
+ t.Fatal("ten equipment instances missing")
+ }
+ if got := service.wallet.Snapshot().FreeJewelry; got != 1000-(10-ticketCount)*200 {
+ t.Fatalf("free diamonds=%d", got)
+ }
+ user := service.collection.GachaUser(10002)
+ if user.Point != 10 || user.TotalBuyCount != 10 {
+ t.Fatalf("user=%+v", user)
+ }
+ if countFields(response, 3) != 4 {
+ t.Fatal("shared pity snapshot missing")
+ }
+ for _, item := range inventory.All() {
+ if item.InvenIndex == ticket.InvenIndex && item.Count != 1 {
+ t.Fatalf("remaining tickets=%d", item.Count)
+ }
+ }
+ _, replay, _, err := service.Handle("/GachaBuy", request)
+ if err != nil || !bytes.Equal(response, replay) || len(equipment.All()) != 10 {
+ t.Fatalf("retry changed draw: %v", err)
+ }
+ })
+ }
+}
diff --git a/go/internal/server/gameconfig/config.go b/go/internal/server/gameconfig/config.go
new file mode 100644
index 0000000..a416e7e
--- /dev/null
+++ b/go/internal/server/gameconfig/config.go
@@ -0,0 +1,95 @@
+// Package gameconfig loads server-authoritative gameplay rules.
+package gameconfig
+
+import (
+ "bytes"
+ "encoding/json"
+ "errors"
+ "fmt"
+ "io"
+ "os"
+ "path/filepath"
+)
+
+const FileName = "game.json"
+
+type Config struct {
+ SchemaVersion int `json:"schema_version"`
+ Gacha GachaConfig `json:"gacha"`
+}
+
+type GachaConfig struct {
+ IncludeCollaborationURWeapons bool `json:"include_collaboration_ur_weapons"`
+}
+
+func Default() Config { return Config{SchemaVersion: 1} }
+
+// Load reads one explicit path. Older installations without the file retain
+// the default rules; an existing invalid file must never silently fall back.
+func Load(path string) (Config, error) {
+ data, err := os.ReadFile(filepath.Clean(path))
+ if errors.Is(err, os.ErrNotExist) {
+ return Default(), nil
+ }
+ if err != nil {
+ return Config{}, fmt.Errorf("game configuration: read %s: %w", path, err)
+ }
+ var cfg Config
+ decoder := json.NewDecoder(bytes.NewReader(data))
+ decoder.DisallowUnknownFields()
+ if err := decoder.Decode(&cfg); err != nil {
+ return Config{}, fmt.Errorf("game configuration: decode %s: %w", path, err)
+ }
+ var trailing any
+ if err := decoder.Decode(&trailing); !errors.Is(err, io.EOF) {
+ return Config{}, fmt.Errorf("game configuration: trailing data in %s", path)
+ }
+ // encoding/json accepts null for scalar and struct fields. These rules have
+ // explicit defaults for omissions, while null is a configuration error.
+ var document any
+ if err := json.Unmarshal(data, &document); err != nil {
+ return Config{}, fmt.Errorf("game configuration: decode %s: %w", path, err)
+ }
+ if containsNull(document) {
+ return Config{}, fmt.Errorf("game configuration: null is not allowed in %s", path)
+ }
+ if err := cfg.Validate(); err != nil {
+ return Config{}, fmt.Errorf("game configuration: %s: %w", path, err)
+ }
+ return cfg, nil
+}
+
+func containsNull(value any) bool {
+ switch value := value.(type) {
+ case nil:
+ return true
+ case map[string]any:
+ for _, child := range value {
+ if containsNull(child) {
+ return true
+ }
+ }
+ case []any:
+ for _, child := range value {
+ if containsNull(child) {
+ return true
+ }
+ }
+ }
+ return false
+}
+
+func (c Config) Validate() error {
+ if c.SchemaVersion != 1 {
+ return fmt.Errorf("unsupported schema_version %d (expected 1)", c.SchemaVersion)
+ }
+ return nil
+}
+
+func BesideExecutable() (string, error) {
+ executable, err := os.Executable()
+ if err != nil {
+ return "", fmt.Errorf("game configuration: resolve server executable: %w", err)
+ }
+ return filepath.Join(filepath.Dir(executable), FileName), nil
+}
diff --git a/go/internal/server/gameconfig/config_test.go b/go/internal/server/gameconfig/config_test.go
new file mode 100644
index 0000000..afdd963
--- /dev/null
+++ b/go/internal/server/gameconfig/config_test.go
@@ -0,0 +1,76 @@
+package gameconfig
+
+import (
+ "os"
+ "path/filepath"
+ "testing"
+)
+
+func TestLoad(t *testing.T) {
+ for _, tc := range []struct {
+ name, text string
+ wantTrue, wantError bool
+ }{
+ {"enabled", `{"schema_version":1,"gacha":{"include_collaboration_ur_weapons":true}}`, true, false},
+ {"disabled", `{"schema_version":1,"gacha":{"include_collaboration_ur_weapons":false}}`, false, false},
+ {"omitted bool", `{"schema_version":1,"gacha":{}}`, false, false},
+ {"omitted gacha", `{"schema_version":1}`, false, false},
+ {"string bool", `{"schema_version":1,"gacha":{"include_collaboration_ur_weapons":"true"}}`, false, true},
+ {"unknown root", `{"schema_version":1,"unknown":true}`, false, true},
+ {"unknown rule", `{"schema_version":1,"gacha":{"typo":true}}`, false, true},
+ {"trailing object", `{"schema_version":1} {}`, false, true},
+ {"trailing garbage", `{"schema_version":1} invalid`, false, true},
+ {"null root", `null`, false, true},
+ {"null section", `{"schema_version":1,"gacha":null}`, false, true},
+ {"null bool", `{"schema_version":1,"gacha":{"include_collaboration_ur_weapons":null}}`, false, true},
+ {"null schema", `{"schema_version":null}`, false, true},
+ {"wrong version", `{"schema_version":2}`, false, true},
+ {"missing version", `{}`, false, true},
+ {"malformed", `{`, false, true},
+ } {
+ t.Run(tc.name, func(t *testing.T) {
+ path := filepath.Join(t.TempDir(), FileName)
+ if err := os.WriteFile(path, []byte(tc.text), 0600); err != nil {
+ t.Fatal(err)
+ }
+ cfg, err := Load(path)
+ if (err != nil) != tc.wantError {
+ t.Fatalf("Load error = %v, wantError %v", err, tc.wantError)
+ }
+ if err == nil && (cfg.SchemaVersion != 1 || cfg.Gacha.IncludeCollaborationURWeapons != tc.wantTrue) {
+ t.Fatalf("unexpected config: %+v", cfg)
+ }
+ })
+ }
+}
+
+func TestMissingFileDefaultsWithoutCreating(t *testing.T) {
+ path := filepath.Join(t.TempDir(), FileName)
+ cfg, err := Load(path)
+ if err != nil || cfg != Default() {
+ t.Fatalf("config = %+v, error = %v", cfg, err)
+ }
+ if _, err := os.Stat(path); !os.IsNotExist(err) {
+ t.Fatalf("Load created missing config: %v", err)
+ }
+}
+
+func TestReadError(t *testing.T) {
+ if _, err := Load(t.TempDir()); err == nil {
+ t.Fatal("directory must not use defaults")
+ }
+}
+
+func TestBesideExecutable(t *testing.T) {
+ path, err := BesideExecutable()
+ if err != nil {
+ t.Fatal(err)
+ }
+ executable, err := os.Executable()
+ if err != nil {
+ t.Fatal(err)
+ }
+ if path != filepath.Join(filepath.Dir(executable), FileName) {
+ t.Fatalf("unexpected path %s", path)
+ }
+}
diff --git a/go/internal/server/gamedata/costume_burst.go b/go/internal/server/gamedata/costume_burst.go
new file mode 100644
index 0000000..f4f4e1e
--- /dev/null
+++ b/go/internal/server/gamedata/costume_burst.go
@@ -0,0 +1,139 @@
+package gamedata
+
+import (
+ "database/sql"
+ "errors"
+ "fmt"
+)
+
+// CostumeBurstLevel is one row of CostumeBurstTable. Level is the database
+// row id (and is the level unlocked by upgrading from Level-1).
+type CostumeBurstLevel struct {
+ CostumeID uint64
+ Level uint64
+ Costs []PromotionCost
+}
+
+// CostumeBurstUpgradeRule is the exact cost for the next burst level.
+type CostumeBurstUpgradeRule struct {
+ CostumeID uint64
+ CurrentLevel uint64
+ NextLevel uint64
+ MaxLevel uint64
+ Costs []PromotionCost
+}
+
+// CostumeBurstDesign contains only costumes which have a complete, contiguous
+// CostumeBurstTable group. GroupId is the CostumeTable id for burst-enabled
+// costumes (the table also carries CostumeType for newer costume families).
+type CostumeBurstDesign struct {
+ Levels map[uint64]map[uint64]CostumeBurstLevel
+}
+
+func LoadCostumeBurstDesign(root, version string) (*CostumeBurstDesign, error) {
+ db, closeDB, err := openStatDatabase(root, version)
+ if err != nil {
+ return nil, err
+ }
+ defer closeDB()
+ return loadCostumeBurstDesign(db)
+}
+
+func loadCostumeBurstDesign(db *sql.DB) (*CostumeBurstDesign, error) {
+ if db == nil {
+ return nil, errors.New("gamedata: nil costume burst database")
+ }
+ design := &CostumeBurstDesign{Levels: make(map[uint64]map[uint64]CostumeBurstLevel)}
+ rows, err := db.Query("SELECT groupId,id,ProtoBuf FROM CostumeBurstTable ORDER BY groupId,id")
+ if err != nil {
+ return nil, err
+ }
+ for rows.Next() {
+ var groupID, level uint64
+ var raw []byte
+ if err := rows.Scan(&groupID, &level, &raw); err != nil {
+ rows.Close()
+ return nil, err
+ }
+ if groupID == 0 || level == 0 {
+ rows.Close()
+ return nil, fmt.Errorf("gamedata: invalid costume burst identity %d/%d", groupID, level)
+ }
+ groups, groupErr := packedInts(raw, 8)
+ ids, idErr := packedInts(raw, 9)
+ counts, countErr := packedInts(raw, 10)
+ itemIDs, itemIDErr := packedInts(raw, 11)
+ types, typeErr := packedInts(raw, 12)
+ if groupErr != nil || idErr != nil || countErr != nil || itemIDErr != nil || typeErr != nil {
+ rows.Close()
+ return nil, fmt.Errorf("gamedata: costume burst %d/%d has invalid fields", groupID, level)
+ }
+ if len(groups) != 1 || groups[0] != groupID || len(ids) != 1 || ids[0] != level {
+ rows.Close()
+ return nil, fmt.Errorf("gamedata: costume burst %d/%d has mismatched proto identity", groupID, level)
+ }
+ if len(counts) == 0 || len(counts) != len(itemIDs) || len(itemIDs) != len(types) {
+ rows.Close()
+ return nil, fmt.Errorf("gamedata: costume burst %d/%d has mismatched costs", groupID, level)
+ }
+ entry := CostumeBurstLevel{CostumeID: groupID, Level: level}
+ for i := range counts {
+ if counts[i] == 0 || (types[i] == 4 && itemIDs[i] != 0) ||
+ (types[i] == 8 && itemIDs[i] == 0) || (types[i] != 4 && types[i] != 8) {
+ rows.Close()
+ return nil, fmt.Errorf("gamedata: costume burst %d/%d has invalid cost", groupID, level)
+ }
+ entry.Costs = append(entry.Costs, PromotionCost{Type: types[i], ID: itemIDs[i], Count: counts[i]})
+ }
+ if _, exists := design.Levels[groupID][level]; exists {
+ rows.Close()
+ return nil, fmt.Errorf("gamedata: duplicate costume burst %d/%d", groupID, level)
+ }
+ if design.Levels[groupID] == nil {
+ design.Levels[groupID] = make(map[uint64]CostumeBurstLevel)
+ }
+ design.Levels[groupID][level] = entry
+ }
+ if err := rows.Err(); err != nil {
+ rows.Close()
+ return nil, err
+ }
+ if err := rows.Close(); err != nil {
+ return nil, err
+ }
+ if len(design.Levels) == 0 {
+ return nil, errors.New("gamedata: CostumeBurstTable is empty")
+ }
+ for costumeID, levels := range design.Levels {
+ for level := uint64(1); level <= uint64(len(levels)); level++ {
+ if _, ok := levels[level]; !ok {
+ return nil, fmt.Errorf("gamedata: costume burst %d missing level %d", costumeID, level)
+ }
+ }
+ }
+ return design, nil
+}
+
+// UpgradeRule returns the costs for currentLevel -> currentLevel+1.
+func (d *CostumeBurstDesign) UpgradeRule(costumeID, currentLevel uint64) (CostumeBurstUpgradeRule, error) {
+ if d == nil || costumeID == 0 {
+ return CostumeBurstUpgradeRule{}, errors.New("gamedata: invalid costume burst lookup")
+ }
+ levels, ok := d.Levels[costumeID]
+ if !ok {
+ return CostumeBurstUpgradeRule{}, fmt.Errorf("gamedata: costume %d has no burst design", costumeID)
+ }
+ maxLevel := uint64(len(levels))
+ if currentLevel >= maxLevel {
+ return CostumeBurstUpgradeRule{}, fmt.Errorf("gamedata: costume %d burst is already at maximum level %d", costumeID, maxLevel)
+ }
+ next := currentLevel + 1
+ entry, ok := levels[next]
+ if !ok {
+ return CostumeBurstUpgradeRule{}, fmt.Errorf("gamedata: costume %d missing burst level %d", costumeID, next)
+ }
+ return CostumeBurstUpgradeRule{
+ CostumeID: costumeID, CurrentLevel: currentLevel, NextLevel: next,
+ MaxLevel: maxLevel, Costs: append([]PromotionCost(nil), entry.Costs...),
+ }, nil
+}
diff --git a/go/internal/server/gamedata/costume_burst_test.go b/go/internal/server/gamedata/costume_burst_test.go
new file mode 100644
index 0000000..170e75f
--- /dev/null
+++ b/go/internal/server/gamedata/costume_burst_test.go
@@ -0,0 +1,119 @@
+package gamedata
+
+import (
+ "database/sql"
+ "os"
+ "strings"
+ "testing"
+)
+
+func TestCostumeBurstDesignAndUpgradeRule(t *testing.T) {
+ db, err := sql.Open("sqlite", ":memory:")
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer db.Close()
+ if _, err := db.Exec(`CREATE TABLE CostumeBurstTable (groupId INTEGER,id INTEGER,ProtoBuf BLOB,PRIMARY KEY(groupId,id))`); err != nil {
+ t.Fatal(err)
+ }
+ for level := 1; level <= 3; level++ {
+ raw := burstProto(8, 42, 9, uint64(level), 10, 60, 11, 710, 12, 8)
+ if _, err := db.Exec(`INSERT INTO CostumeBurstTable(groupId,id,ProtoBuf) VALUES(?,?,?)`, 42, level, raw); err != nil {
+ t.Fatal(err)
+ }
+ }
+ design, err := loadCostumeBurstDesign(db)
+ if err != nil {
+ t.Fatal(err)
+ }
+ rule, err := design.UpgradeRule(42, 1)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if rule.NextLevel != 2 || rule.MaxLevel != 3 || len(rule.Costs) != 1 || rule.Costs[0] != (PromotionCost{Type: 8, ID: 710, Count: 60}) {
+ t.Fatalf("unexpected rule: %+v", rule)
+ }
+ if _, err := design.UpgradeRule(42, 3); err == nil {
+ t.Fatal("expected max-level error")
+ }
+}
+
+func TestCostumeBurstRejectsInvalidIdentityCostAndGap(t *testing.T) {
+ cases := []struct {
+ name string
+ raw []byte
+ rows [][2]int
+ }{
+ {"identity", burstProto(8, 99, 9, 1, 10, 1, 11, 710, 12, 8), [][2]int{{42, 1}}},
+ {"zero-count", burstProto(8, 42, 9, 1, 10, 0, 11, 710, 12, 8), [][2]int{{42, 1}}},
+ {"gold-id", burstProto(8, 42, 9, 1, 10, 1, 11, 710, 12, 4), [][2]int{{42, 1}}},
+ {"gap", burstProto(8, 42, 9, 2, 10, 1, 11, 710, 12, 8), [][2]int{{42, 2}}},
+ }
+ for _, tc := range cases {
+ t.Run(tc.name, func(t *testing.T) {
+ db, err := sql.Open("sqlite", ":memory:")
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer db.Close()
+ if _, err := db.Exec(`CREATE TABLE CostumeBurstTable (groupId INTEGER,id INTEGER,ProtoBuf BLOB,PRIMARY KEY(groupId,id))`); err != nil {
+ t.Fatal(err)
+ }
+ for _, row := range tc.rows {
+ if _, err := db.Exec(`INSERT INTO CostumeBurstTable(groupId,id,ProtoBuf) VALUES(?,?,?)`, row[0], row[1], tc.raw); err != nil {
+ t.Fatal(err)
+ }
+ }
+ if _, err := loadCostumeBurstDesign(db); err == nil || !strings.Contains(err.Error(), "costume burst") {
+ t.Fatalf("expected costume burst validation error, got %v", err)
+ }
+ })
+ }
+}
+
+func TestCostumeBurstAgainstInstalledCurrentVersion(t *testing.T) {
+ root := os.Getenv("BD2_REAL_GAMEDATA")
+ if root == "" {
+ t.Skip("set BD2_REAL_GAMEDATA for installed GameData integration test")
+ }
+ design, err := LoadCostumeBurstDesign(root, "20260923193640")
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(design.Levels) != 56 {
+ t.Fatalf("installed burst groups=%d, want 56", len(design.Levels))
+ }
+ rows := 0
+ for _, levels := range design.Levels {
+ rows += len(levels)
+ }
+ if rows != 168 {
+ t.Fatalf("installed burst rows=%d, want 168", rows)
+ }
+ rule, err := design.UpgradeRule(4202, 0)
+ if err != nil {
+ t.Fatal(err)
+ }
+ want := []PromotionCost{{Type: 4, Count: 1_500_000}, {Type: 8, ID: 710, Count: 60}}
+ if rule.NextLevel != 1 || rule.MaxLevel != 3 || len(rule.Costs) != len(want) || rule.Costs[0] != want[0] || rule.Costs[1] != want[1] {
+ t.Fatalf("installed rule=%+v", rule)
+ }
+}
+
+// burstProto builds the small varint-only fields used by the loader tests.
+func burstProto(fields ...uint64) []byte {
+ if len(fields)%2 != 0 {
+ panic("burstProto requires field/value pairs")
+ }
+ var out []byte
+ for i := 0; i < len(fields); i += 2 {
+ field, value := fields[i], fields[i+1]
+ out = append(out, byte(field<<3))
+ for value >= 0x80 {
+ out = append(out, byte(value)|0x80)
+ value >>= 7
+ }
+ out = append(out, byte(value))
+ }
+ return out
+}
diff --git a/go/internal/server/gamedata/equipment_collaboration.go b/go/internal/server/gamedata/equipment_collaboration.go
new file mode 100644
index 0000000..770f2ca
--- /dev/null
+++ b/go/internal/server/gamedata/equipment_collaboration.go
@@ -0,0 +1,160 @@
+package gamedata
+
+import (
+ "database/sql"
+ "fmt"
+ "os"
+ "path/filepath"
+ "sort"
+)
+
+// IncludeCollaborationURWeapons extends only the UR equipment ticket pool.
+// Limited costumes identify eligible owners; equipment IDs remain version data.
+func (c *EquipmentGachaCatalog) IncludeCollaborationURWeapons(root, version string) error {
+ plain, err := ReadQuestDatabase(root, version)
+ if err != nil {
+ return err
+ }
+ dir, err := os.MkdirTemp("", "bd2-collaboration-equipment-")
+ if err != nil {
+ return err
+ }
+ defer os.RemoveAll(dir)
+ path := filepath.Join(dir, "common.db")
+ if err := os.WriteFile(path, plain, 0o600); err != nil {
+ return err
+ }
+ db, err := sql.Open("sqlite", "file:"+filepath.ToSlash(path)+"?mode=ro")
+ if err != nil {
+ return err
+ }
+ defer db.Close()
+ return c.includeCollaborationURWeapons(db)
+}
+
+func (c *EquipmentGachaCatalog) includeCollaborationURWeapons(db *sql.DB) error {
+ if c == nil || c.equipment == nil {
+ return fmt.Errorf("gamedata: missing equipment catalog")
+ }
+ g, ok := c.Gachas[71200001]
+ if !ok || !g.TicketOnly || len(g.TicketIDs) != 1 || g.TicketIDs[0] != 1104 || len(g.Pool) != 3 {
+ return fmt.Errorf("gamedata: missing or malformed UR equipment ticket pool")
+ }
+ readRows := func(query string) (map[uint64][]byte, error) {
+ rows, err := db.Query(query)
+ if err != nil {
+ return nil, err
+ }
+ defer rows.Close()
+ out := map[uint64][]byte{}
+ for rows.Next() {
+ var id uint64
+ var raw []byte
+ if err := rows.Scan(&id, &raw); err != nil {
+ return nil, err
+ }
+ out[id] = raw
+ }
+ return out, rows.Err()
+ }
+ scalar := func(raw []byte, field int) (uint64, error) {
+ v, err := packedInts(raw, field)
+ if err != nil || len(v) != 1 || v[0] == 0 {
+ return 0, fmt.Errorf("gamedata: invalid collaboration equipment field %d", field)
+ }
+ return v[0], nil
+ }
+ owners, err := readRows("SELECT DISTINCT c.useUniqueCharId,c.ProtoBuf FROM LimitedCostumeTable l JOIN CostumeTable c ON c.id=l.id ORDER BY c.useUniqueCharId")
+ if err != nil {
+ return err
+ }
+ chars, err := readRows("SELECT id,ProtoBuf FROM CharTable WHERE uniqueCharId IN (SELECT privateUniqueCharId FROM EquipmentTable WHERE privateUniqueCharId>0) ORDER BY id")
+ if err != nil {
+ return err
+ }
+ grades := map[uint64]uint64{}
+ for _, raw := range chars {
+ owner, err := scalar(raw, 20)
+ if err != nil {
+ return err
+ }
+ grade, err := scalar(raw, 9)
+ if err != nil {
+ return err
+ }
+ if previous, exists := grades[owner]; exists && previous != grade {
+ return fmt.Errorf("gamedata: conflicting character grade for %d", owner)
+ }
+ grades[owner] = grade
+ }
+ equipment, err := readRows("SELECT id,ProtoBuf FROM EquipmentTable ORDER BY id")
+ if err != nil {
+ return err
+ }
+ pool := make([]WeightedEquipment, len(g.Pool))
+ branchForGrade := map[uint64]int{}
+ seen := map[uint64]bool{}
+ for index, branch := range g.Pool {
+ if branch.ID != 0 || branch.Weight == 0 || len(branch.Children) == 0 {
+ return fmt.Errorf("gamedata: malformed UR ticket branch")
+ }
+ pool[index] = WeightedEquipment{Weight: branch.Weight, Children: append([]WeightedEquipment(nil), branch.Children...)}
+ var branchGrade uint64
+ for _, item := range branch.Children {
+ if item.ID == 0 || item.Weight != 1 || len(item.Children) != 0 || seen[item.ID] {
+ return fmt.Errorf("gamedata: malformed or duplicate UR ticket candidate %d", item.ID)
+ }
+ seen[item.ID] = true
+ owner, err := scalar(equipment[item.ID], 16)
+ if err != nil {
+ return err
+ }
+ grade := grades[owner]
+ if grade < 3 || grade > 5 || (branchGrade != 0 && branchGrade != grade) {
+ return fmt.Errorf("gamedata: unknown or mixed UR ticket character tier")
+ }
+ branchGrade = grade
+ }
+ if _, exists := branchForGrade[branchGrade]; exists {
+ return fmt.Errorf("gamedata: duplicate UR ticket tier")
+ }
+ branchForGrade[branchGrade] = index
+ }
+ // Collect designs before publishing the cloned pool, so a failed load leaves
+ // the catalog unchanged. Order by ID to keep repeated loads deterministic.
+ designs := map[uint64]EquipmentDesign{}
+ ids := make([]uint64, 0, len(equipment))
+ for id := range equipment {
+ ids = append(ids, id)
+ }
+ sort.Slice(ids, func(i, j int) bool { return ids[i] < ids[j] })
+ for _, id := range ids {
+ raw := equipment[id]
+ grade, _ := packedInts(raw, 3)
+ quality, _ := packedInts(raw, 18)
+ owner, _ := packedInts(raw, 16)
+ if len(grade) != 1 || grade[0] != 4 || len(quality) != 1 || quality[0] != 3 || len(owner) != 1 {
+ continue
+ }
+ if _, eligible := owners[owner[0]]; !eligible || seen[id] {
+ continue
+ }
+ index, exists := branchForGrade[grades[owner[0]]]
+ if !exists {
+ return fmt.Errorf("gamedata: unknown collaboration equipment tier for %d", id)
+ }
+ design, err := loadEquipmentDesign(db, id)
+ if err != nil {
+ return err
+ }
+ designs[id] = design
+ pool[index].Children = append(pool[index].Children, WeightedEquipment{ID: id, Weight: 1})
+ seen[id] = true
+ }
+ for id, design := range designs {
+ c.equipment[id] = design
+ }
+ g.Pool = pool
+ c.Gachas[g.ID] = g
+ return nil
+}
diff --git a/go/internal/server/gamedata/equipment_collaboration_test.go b/go/internal/server/gamedata/equipment_collaboration_test.go
new file mode 100644
index 0000000..18415ac
--- /dev/null
+++ b/go/internal/server/gamedata/equipment_collaboration_test.go
@@ -0,0 +1,149 @@
+package gamedata
+
+import (
+ "database/sql"
+ "encoding/binary"
+ "os"
+ "reflect"
+ "testing"
+)
+
+func TestIncludeCollaborationURWeaponsInstalled(t *testing.T) {
+ root := os.Getenv("BD2_TEST_GAMEDATA_ROOT")
+ if root == "" {
+ t.Skip("set BD2_TEST_GAMEDATA_ROOT for installed GameData integration test")
+ }
+ c, err := LoadEquipmentGacha(root, "20260923193640")
+ if err != nil {
+ t.Fatal(err)
+ }
+ before := map[uint64]EquipmentGacha{}
+ for id, g := range c.Gachas {
+ before[id] = g
+ }
+ if err := c.IncludeCollaborationURWeapons(root, "20260923193640"); err != nil {
+ t.Fatal(err)
+ }
+ g := c.Gachas[71200001]
+ oldIDs := map[uint64]bool{}
+ for _, branch := range before[g.ID].Pool {
+ for _, item := range branch.Children {
+ oldIDs[item.ID] = true
+ }
+ }
+ added := 0
+ for _, branch := range g.Pool {
+ for _, item := range branch.Children {
+ if !oldIDs[item.ID] {
+ added++
+ if item.ID < 943200 || item.ID > 943213 {
+ t.Fatalf("unexpected added collaboration weapon %d", item.ID)
+ }
+ }
+ }
+ }
+ if len(oldIDs) != 73 || added != 14 {
+ t.Fatalf("original=%d added=%d", len(oldIDs), added)
+ }
+ for index, want := range []int{64, 9, 14} {
+ if len(g.Pool[index].Children) != want || g.Pool[index].Weight != before[g.ID].Pool[index].Weight {
+ t.Fatalf("branch %d: %+v", index, g.Pool[index])
+ }
+ }
+ if len(before[g.ID].Pool[0].Children) != 50 {
+ t.Fatal("original pool mutated")
+ }
+ for id, old := range before {
+ if id != g.ID && !reflect.DeepEqual(old, c.Gachas[id]) {
+ t.Fatalf("other product %d changed", id)
+ }
+ }
+ for _, branch := range g.Pool {
+ for _, item := range branch.Children {
+ if _, _, _, err := c.RollOptions(item.ID); err != nil {
+ t.Fatalf("options %d: %v", item.ID, err)
+ }
+ }
+ }
+ if err := c.IncludeCollaborationURWeapons(root, "20260923193640"); err != nil {
+ t.Fatal(err)
+ }
+ if !reflect.DeepEqual(g, c.Gachas[g.ID]) {
+ t.Fatal("second inclusion changed pool")
+ }
+}
+
+func TestIncludeCollaborationURWeaponsSynthetic(t *testing.T) {
+ db, err := sql.Open("sqlite", ":memory:")
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer db.Close()
+ db.SetMaxOpenConns(1)
+ for _, schema := range []string{"CREATE TABLE LimitedCostumeTable(id INTEGER)", "CREATE TABLE CostumeTable(id INTEGER,useUniqueCharId INTEGER,ProtoBuf BLOB)", "CREATE TABLE CharTable(id INTEGER,uniqueCharId INTEGER,ProtoBuf BLOB)", "CREATE TABLE EquipmentTable(id INTEGER,privateUniqueCharId INTEGER,ProtoBuf BLOB)", "CREATE TABLE EquipmentOptionTable(id INTEGER,GroupId INTEGER,ProtoBuf BLOB)"} {
+ if _, err := db.Exec(schema); err != nil {
+ t.Fatal(err)
+ }
+ }
+ proto := func(values ...uint64) []byte {
+ var b []byte
+ for i := 0; i < len(values); i += 2 {
+ b = binary.AppendUvarint(b, values[i]<<3)
+ b = binary.AppendUvarint(b, values[i+1])
+ }
+ return b
+ }
+ for i := uint64(1); i <= 4; i++ {
+ grade := uint64(6 - i)
+ if i == 4 {
+ grade = 5
+ }
+ if _, err := db.Exec("INSERT INTO CharTable VALUES(?,?,?)", i, i, proto(20, i, 9, grade)); err != nil {
+ t.Fatal(err)
+ }
+ if _, err := db.Exec("INSERT INTO EquipmentTable VALUES(?,?,?)", 100+i, i, proto(6, 100+i, 16, i, 3, 4, 18, 3)); err != nil {
+ t.Fatal(err)
+ }
+ }
+ if _, err := db.Exec("INSERT INTO LimitedCostumeTable VALUES(40),(41)"); err != nil {
+ t.Fatal(err)
+ }
+ if _, err := db.Exec("INSERT INTO CostumeTable VALUES(40,4,?),(41,4,?)", proto(27, 4), proto(27, 4)); err != nil {
+ t.Fatal(err)
+ }
+ pool := []WeightedEquipment{{Weight: 150, Children: []WeightedEquipment{{ID: 101, Weight: 1}}}, {Weight: 350, Children: []WeightedEquipment{{ID: 102, Weight: 1}}}, {Weight: 500, Children: []WeightedEquipment{{ID: 103, Weight: 1}}}}
+ c := &EquipmentGachaCatalog{Gachas: map[uint64]EquipmentGacha{71200001: {ID: 71200001, TicketOnly: true, TicketIDs: []uint64{1104}, Pool: pool}, 77: {ID: 77, Pool: pool}}, equipment: map[uint64]EquipmentDesign{}}
+ if err := c.includeCollaborationURWeapons(db); err != nil {
+ t.Fatal(err)
+ }
+ if len(c.Gachas[71200001].Pool[0].Children) != 2 || len(c.Gachas[77].Pool[0].Children) != 1 {
+ t.Fatal("extension or isolation failed")
+ }
+ if _, ok := c.equipment[104]; !ok {
+ t.Fatal("new equipment design not loaded")
+ }
+ if err := c.includeCollaborationURWeapons(db); err != nil {
+ t.Fatal(err)
+ }
+ if len(c.Gachas[71200001].Pool[0].Children) != 2 {
+ t.Fatal("duplicate owner or repeated inclusion duplicated equipment")
+ }
+ if _, err := db.Exec("UPDATE CharTable SET ProtoBuf=? WHERE id=4", proto(20, 4, 9, 2)); err != nil {
+ t.Fatal(err)
+ }
+ delete(c.Gachas, 71200001)
+ c.Gachas[71200001] = EquipmentGacha{ID: 71200001, TicketOnly: true, TicketIDs: []uint64{1104}, Pool: pool}
+ if err := c.includeCollaborationURWeapons(db); err == nil {
+ t.Fatal("unknown tier accepted")
+ }
+ if len(c.Gachas[71200001].Pool[0].Children) != 1 {
+ t.Fatal("failed inclusion published partial pool")
+ }
+ invalid := c.Gachas[71200001]
+ invalid.Pool = append([]WeightedEquipment(nil), pool...)
+ invalid.Pool[0].Children = []WeightedEquipment{{ID: 101, Weight: 1}, {ID: 101, Weight: 1}}
+ c.Gachas[71200001] = invalid
+ if err := c.includeCollaborationURWeapons(db); err == nil {
+ t.Fatal("duplicate existing candidate accepted")
+ }
+}
diff --git a/go/internal/server/gamedata/gacha.go b/go/internal/server/gamedata/gacha.go
index 6e6ffb1..6249b46 100644
--- a/go/internal/server/gamedata/gacha.go
+++ b/go/internal/server/gamedata/gacha.go
@@ -917,17 +917,17 @@ func LoadActiveGachaForSchedules(root, version string, scheduleGroupIDs, stepUpG
return LoadActiveGacha(root, version, costume, equipment, stepUpGroupIDs)
}
-// permanentGachaGroupIDs returns static selection groups. ScheduleType=0
+// permanentGachaGroupIDs returns static selection and ordinary equipment groups. ScheduleType=0
// groups are deliberately absent from the dynamic schedule response; the
-// selection metadata is what distinguishes permanent 12PICK-style banners
-// from standalone content-ticket banners handled by other flows.
+// selection or shared pity/point metadata distinguishes these banners from
+// content-ticket banners handled by other flows.
func permanentGachaGroupIDs(root, version string) ([]uint64, error) {
db, closeDB, err := openStatDatabase(root, version)
if err != nil {
return nil, err
}
defer closeDB()
- rows, err := db.Query("SELECT id,ProtoBuf FROM GachaGroupTable WHERE scheduleType=0 AND gachaType=1 ORDER BY id")
+ rows, err := db.Query("SELECT id,ProtoBuf FROM GachaGroupTable WHERE scheduleType=0 AND gachaType IN (1,2) ORDER BY id")
if err != nil {
return nil, fmt.Errorf("gamedata: list permanent gacha groups: %w", err)
}
@@ -941,7 +941,10 @@ func permanentGachaGroupIDs(root, version string) ([]uint64, error) {
}
subTypes, _ := packedInts(raw, 16)
selectCounts, _ := packedInts(raw, 29)
- if len(subTypes) == 1 && subTypes[0] == 1 && len(selectCounts) == 1 && selectCounts[0] != 0 {
+ types, _ := packedInts(raw, 17)
+ if len(types) == 1 && types[0] == 1 && len(subTypes) == 1 && subTypes[0] == 1 && len(selectCounts) == 1 && selectCounts[0] != 0 {
+ result = append(result, id)
+ } else if isPermanentEquipmentGachaGroup(raw) {
result = append(result, id)
}
}
@@ -951,6 +954,22 @@ func permanentGachaGroupIDs(root, version string) ([]uint64, error) {
return result, nil
}
+func isPermanentEquipmentGachaGroup(raw []byte) bool {
+ types, _ := packedInts(raw, 17)
+ subTypes, _ := packedInts(raw, 16)
+ selectCounts, _ := packedInts(raw, 29)
+ fixed, _ := packedInts(raw, 10)
+ points, _ := packedInts(raw, 27)
+ one, _ := packedInts(raw, 24)
+ ten, _ := packedInts(raw, 33)
+ // Static content-ticket groups also have one/ten IDs, but have neither
+ // shared pity nor draw points. They must not enter the ordinary catalog.
+ // LoadEquipmentGachaGroups validates the referenced products and pools.
+ return len(types) == 1 && types[0] == 2 && (len(subTypes) == 0 || len(subTypes) == 1 && subTypes[0] == 0) && len(selectCounts) == 0 &&
+ len(fixed) == 1 && fixed[0] != 0 && len(points) == 1 && points[0] != 0 &&
+ len(one) == 1 && one[0] != 0 && len(ten) == 1 && ten[0] != 0
+}
+
// ClassifyActiveGachaGroups reads static type metadata for groups already
// selected by a captured schedule. Resemara is owned by LoadInfiniteGacha and
// is intentionally omitted from both ordinary catalogs.
diff --git a/go/internal/server/gamedata/gacha_active_test.go b/go/internal/server/gamedata/gacha_active_test.go
index db0cf66..148ef34 100644
--- a/go/internal/server/gamedata/gacha_active_test.go
+++ b/go/internal/server/gamedata/gacha_active_test.go
@@ -3,8 +3,29 @@ package gamedata
import (
"os"
"testing"
+
+ "bd2server/internal/server/wire"
)
+func TestPermanentEquipmentGroupRequiresPityAndPoints(t *testing.T) {
+ // Content-ticket groups have both products too; those alone do not make
+ // a group an ordinary permanent equipment draw.
+ content := wire.AppendVarint(nil, 17, 2)
+ content = wire.AppendVarint(content, 24, 70100001)
+ content = wire.AppendVarint(content, 33, 71000001)
+ if isPermanentEquipmentGachaGroup(content) {
+ t.Fatal("content-ticket group classified as ordinary equipment")
+ }
+ ordinary := wire.AppendVarint(content, 10, 1)
+ ordinary = wire.AppendVarint(ordinary, 27, 1)
+ if !isPermanentEquipmentGachaGroup(ordinary) {
+ t.Fatal("permanent equipment group with shared pity and points omitted")
+ }
+ if isPermanentEquipmentGachaGroup(wire.AppendVarint(ordinary, 16, 1)) {
+ t.Fatal("equipment selection group classified as ordinary equipment")
+ }
+}
+
func TestSingleSidedCostumeFixedThresholdsDoNotTriggerZeroSide(t *testing.T) {
pool := []WeightedCostume{
{Weight: 150, ID: 5001}, {Weight: 150, ID: 5002},
@@ -162,11 +183,26 @@ func TestActiveGachaAgainstInstalledVersion23510(t *testing.T) {
t.Errorf("step-up %d=%+v ok=%v", groupID, stepUp, ok)
}
}
- for _, id := range []uint64{20100082, 21000082, 20100034, 21000034, 20100070, 21000070, 20100083, 21000083} {
+ for _, id := range []uint64{200, 201, 20100082, 21000082, 20100034, 21000034, 20100070, 21000070, 20100083, 21000083} {
if _, ok := equipment.Gacha(id); !ok {
t.Errorf("equipment gacha %d missing", id)
}
}
+ permanentEquipment, ok := equipment.Group(10002)
+ if !ok || permanentEquipment.OneTimeGachaID != 200 || permanentEquipment.TenTimeGachaID != 201 || permanentEquipment.FixedID != 1 || permanentEquipment.PointCount != 1 {
+ t.Fatalf("permanent equipment group=%+v ok=%v", permanentEquipment, ok)
+ }
+ for _, id := range []uint64{200, 201} {
+ product, _ := equipment.Gacha(id)
+ if product.TicketOnly || product.PriceType != 3 || product.Price != uint64(product.Count)*200 || len(product.TicketIDs) != 1 || product.TicketIDs[0] != 1000 || len(product.Pool) != 8 {
+ t.Fatalf("permanent equipment product %d=%+v", id, product)
+ }
+ }
+ for _, groupID := range []uint64{1003, 1004, 1005, 1006} {
+ if _, ok := equipment.Group(groupID); ok {
+ t.Errorf("content-ticket equipment group %d became ordinary permanent draw", groupID)
+ }
+ }
}
func TestLegacyRegularGachaLoaderAgainstInstalledVersion23510(t *testing.T) {
diff --git a/go/internal/server/player/collection.go b/go/internal/server/player/collection.go
index b56e727..3ab3a52 100644
--- a/go/internal/server/player/collection.go
+++ b/go/internal/server/player/collection.go
@@ -1,17 +1,21 @@
package player
import (
+ "encoding/hex"
"encoding/json"
"errors"
"fmt"
+ "math"
"sort"
"strconv"
+ "strings"
"sync"
"time"
"bd2server/internal/server/gamedata"
"bd2server/internal/server/stateio"
"bd2server/internal/server/versionconfig"
+ "bd2server/internal/server/wire"
)
type CostumeUpgrade struct {
@@ -106,32 +110,46 @@ type CharAwakeProgress struct {
IsAwake bool `json:"is_awake"`
}
+// CostumeBurstUpgradeRecord is the durable result of one costume burst level
+// transition. Digest identifies the exact protobuf request whose successful
+// response is stored in Body, allowing a committed request to be replayed
+// after a process restart without charging its materials again.
+type CostumeBurstUpgradeRecord struct {
+ CostumeID uint64 `json:"costume_id"`
+ Level uint64 `json:"level"`
+ Digest string `json:"digest"`
+ Code int `json:"code"`
+ Body []byte `json:"body"`
+}
+
// FirstGachaCompletedIdentity is the persisted account flag represented in
// the existing collection grant ledger. It is written atomically with the
// official GachaSubType=3 first-pick transaction.
const FirstGachaCompletedIdentity = "account:first-gacha-completed"
type collectionSnapshot struct {
- Version string `json:"version"`
- NextCharacterIndex uint64 `json:"next_character_index"`
- NextCostumeIndex uint64 `json:"next_costume_index"`
- LatestPreview []uint64 `json:"latest_preview"`
- PreviewEventIndex uint64 `json:"preview_event_index"`
- PreviewLocked bool `json:"preview_locked"`
- Characters []Character `json:"characters,omitempty"`
- Costumes []Costume `json:"costumes,omitempty"`
- BaseCostumeLevels map[string]uint64 `json:"base_costume_levels"`
- CostumePotential map[string][]uint64 `json:"costume_potential,omitempty"`
- CharAwake map[string]CharAwakeProgress `json:"char_awake,omitempty"`
- GachaSelections map[string][]GachaSelection `json:"gacha_selections,omitempty"`
- GachaSelectionChanges map[string]uint64 `json:"gacha_selection_changes,omitempty"`
- StepUpProgress map[string]uint64 `json:"step_up_progress,omitempty"`
- GachaUsers map[string]GachaUserState `json:"gacha_users,omitempty"`
- GachaFixed map[string]GachaFixedState `json:"gacha_fixed,omitempty"`
- GachaApplied map[string]bool `json:"gacha_applied,omitempty"`
- GachaPointExchange map[string]GachaPointExchange `json:"gacha_point_exchanges,omitempty"`
- GachaCountCorrected bool `json:"gacha_count_corrected"`
- Grants map[string]CollectionGrant `json:"grants,omitempty"`
+ Version string `json:"version"`
+ NextCharacterIndex uint64 `json:"next_character_index"`
+ NextCostumeIndex uint64 `json:"next_costume_index"`
+ LatestPreview []uint64 `json:"latest_preview"`
+ PreviewEventIndex uint64 `json:"preview_event_index"`
+ PreviewLocked bool `json:"preview_locked"`
+ Characters []Character `json:"characters,omitempty"`
+ Costumes []Costume `json:"costumes,omitempty"`
+ BaseCostumeLevels map[string]uint64 `json:"base_costume_levels"`
+ CostumePotential map[string][]uint64 `json:"costume_potential,omitempty"`
+ CostumeBurstLevels map[string]uint64 `json:"-"`
+ CostumeBurstUpgrades map[string]CostumeBurstUpgradeRecord `json:"-"`
+ CharAwake map[string]CharAwakeProgress `json:"char_awake,omitempty"`
+ GachaSelections map[string][]GachaSelection `json:"gacha_selections,omitempty"`
+ GachaSelectionChanges map[string]uint64 `json:"gacha_selection_changes,omitempty"`
+ StepUpProgress map[string]uint64 `json:"step_up_progress,omitempty"`
+ GachaUsers map[string]GachaUserState `json:"gacha_users,omitempty"`
+ GachaFixed map[string]GachaFixedState `json:"gacha_fixed,omitempty"`
+ GachaApplied map[string]bool `json:"gacha_applied,omitempty"`
+ GachaPointExchange map[string]GachaPointExchange `json:"gacha_point_exchanges,omitempty"`
+ GachaCountCorrected bool `json:"gacha_count_corrected"`
+ Grants map[string]CollectionGrant `json:"grants,omitempty"`
}
// CollectionStore owns non-stackable character/costume rewards as one atomic
@@ -157,9 +175,10 @@ func OpenCollectionStore(store stateio.Store, base []Costume) (*CollectionStore,
s := &CollectionStore{store: entries, base: append([]Costume(nil), base...), data: collectionSnapshot{
Version: versionconfig.State(), NextCharacterIndex: 920000001, NextCostumeIndex: 930000001,
BaseCostumeLevels: map[string]uint64{}, GachaSelections: map[string][]GachaSelection{}, GachaSelectionChanges: map[string]uint64{},
- CostumePotential: map[string][]uint64{},
- CharAwake: map[string]CharAwakeProgress{},
- StepUpProgress: map[string]uint64{}, GachaUsers: map[string]GachaUserState{}, GachaFixed: map[string]GachaFixedState{},
+ CostumePotential: map[string][]uint64{},
+ CostumeBurstLevels: map[string]uint64{}, CostumeBurstUpgrades: map[string]CostumeBurstUpgradeRecord{},
+ CharAwake: map[string]CharAwakeProgress{},
+ StepUpProgress: map[string]uint64{}, GachaUsers: map[string]GachaUserState{}, GachaFixed: map[string]GachaFixedState{},
GachaApplied: map[string]bool{}, GachaPointExchange: map[string]GachaPointExchange{}, Grants: map[string]CollectionGrant{},
}}
b, err := store.Load("collection")
@@ -193,6 +212,9 @@ func OpenCollectionStore(store stateio.Store, base []Costume) (*CollectionStore,
if s.data.CharAwake == nil {
return nil, errors.New("player: collection save requires char_awake; migrate the development save")
}
+ if err := s.validateCostumeBurstStorage(); err != nil {
+ return nil, err
+ }
for key, progress := range s.data.CharAwake {
uniqueID, parseErr := strconv.ParseUint(key, 10, 64)
if parseErr != nil || uniqueID == 0 || (progress.ImprintLevels == [3]uint64{} && !progress.IsAwake) {
@@ -811,20 +833,191 @@ func (s *CollectionStore) UpdateCharacter(oldID uint64, character Character) err
func (s *CollectionStore) Costumes() []Costume {
s.mu.Lock()
defer s.mu.Unlock()
+ return s.costumesLocked()
+}
+
+func (s *CollectionStore) costumesLocked() []Costume {
result := append([]Costume(nil), s.base...)
for i := range result {
- if level := s.data.BaseCostumeLevels[strconv.FormatUint(result[i].InvenIndex, 10)]; level > result[i].Level {
+ key := strconv.FormatUint(result[i].InvenIndex, 10)
+ if level := s.data.BaseCostumeLevels[key]; level > result[i].Level {
result[i].Level = level
}
- result[i].PotentialIDs = append([]uint64(nil), s.data.CostumePotential[strconv.FormatUint(result[i].InvenIndex, 10)]...)
+ if level, found := s.data.CostumeBurstLevels[key]; found {
+ result[i].BurstLevel = level
+ }
+ result[i].PotentialIDs = append([]uint64(nil), s.data.CostumePotential[key]...)
}
collection := append([]Costume(nil), s.data.Costumes...)
for i := range collection {
- collection[i].PotentialIDs = append([]uint64(nil), s.data.CostumePotential[strconv.FormatUint(collection[i].InvenIndex, 10)]...)
+ key := strconv.FormatUint(collection[i].InvenIndex, 10)
+ if level, found := s.data.CostumeBurstLevels[key]; found {
+ collection[i].BurstLevel = level
+ }
+ collection[i].PotentialIDs = append([]uint64(nil), s.data.CostumePotential[key]...)
}
return append(result, collection...)
}
+// CostumeByID finds the single owned costume with the logical CostumeTable ID.
+// A duplicate logical ID is invalid ownership state and is deliberately not
+// resolved by choosing an arbitrary inventory instance.
+func (s *CollectionStore) CostumeByID(id uint64) (Costume, bool) {
+ if id == 0 {
+ return Costume{}, false
+ }
+ s.mu.Lock()
+ defer s.mu.Unlock()
+ var result Costume
+ found := false
+ for _, costume := range s.costumesLocked() {
+ if costume.ID != id {
+ continue
+ }
+ if found {
+ return Costume{}, false
+ }
+ result, found = costume, true
+ }
+ return result, found
+}
+
+// CostumeBurstReplay returns an owned copy of the durable response recorded
+// for one inventory instance and target burst level.
+func (s *CollectionStore) CostumeBurstReplay(invenIndex, target uint64) (CostumeBurstUpgradeRecord, bool) {
+ if invenIndex == 0 || target == 0 {
+ return CostumeBurstUpgradeRecord{}, false
+ }
+ s.mu.Lock()
+ defer s.mu.Unlock()
+ record, found := s.data.CostumeBurstUpgrades[costumeBurstUpgradeKey(invenIndex, target)]
+ record.Body = append([]byte(nil), record.Body...)
+ return record, found
+}
+
+// ApplyCostumeBurst atomically advances one owned costume and stores the exact
+// successful reply. expectedCurrent is a compare-and-swap guard against a
+// stale request overwriting a newer level.
+func (s *CollectionStore) ApplyCostumeBurst(invenIndex, expectedCurrent, target uint64, record CostumeBurstUpgradeRecord) error {
+ if invenIndex == 0 || expectedCurrent == math.MaxUint64 || target != expectedCurrent+1 {
+ return errors.New("player: invalid costume burst transition")
+ }
+ if record.Level != target || record.CostumeID == 0 {
+ return errors.New("player: inconsistent costume burst record")
+ }
+ if err := validateCostumeBurstRecord(record); err != nil {
+ return err
+ }
+ s.mu.Lock()
+ defer s.mu.Unlock()
+ costume, found := s.costumeByIndexLocked(invenIndex)
+ if !found {
+ return fmt.Errorf("player: costume %d not found", invenIndex)
+ }
+ if costume.ID != record.CostumeID {
+ return errors.New("player: costume burst record design mismatch")
+ }
+ if costume.BurstLevel != expectedCurrent {
+ return errors.New("player: stale costume burst level")
+ }
+ ledgerKey := costumeBurstUpgradeKey(invenIndex, target)
+ if _, exists := s.data.CostumeBurstUpgrades[ledgerKey]; exists {
+ return errors.New("player: costume burst transition already recorded")
+ }
+ next := cloneCollection(s.data)
+ next.CostumeBurstLevels[strconv.FormatUint(invenIndex, 10)] = target
+ record.Body = append([]byte(nil), record.Body...)
+ next.CostumeBurstUpgrades[ledgerKey] = record
+ return s.commit(next)
+}
+
+func (s *CollectionStore) costumeByIndexLocked(index uint64) (Costume, bool) {
+ for _, costume := range s.costumesLocked() {
+ if costume.InvenIndex == index {
+ return costume, true
+ }
+ }
+ return Costume{}, false
+}
+
+func costumeBurstUpgradeKey(invenIndex, target uint64) string {
+ return strconv.FormatUint(invenIndex, 10) + ":" + strconv.FormatUint(target, 10)
+}
+
+func parseCostumeBurstUpgradeKey(key string) (uint64, uint64, bool) {
+ left, right, found := strings.Cut(key, ":")
+ if !found || strings.Contains(right, ":") {
+ return 0, 0, false
+ }
+ index, indexErr := strconv.ParseUint(left, 10, 64)
+ level, levelErr := strconv.ParseUint(right, 10, 64)
+ return index, level, indexErr == nil && levelErr == nil && index != 0 && level != 0 && key == costumeBurstUpgradeKey(index, level)
+}
+
+func validateCostumeBurstRecord(record CostumeBurstUpgradeRecord) error {
+ if record.CostumeID == 0 || record.Level == 0 || record.Code != 578 || len(record.Digest) != costumeBurstDigestHexSize {
+ return errors.New("player: invalid costume burst upgrade record")
+ }
+ if _, err := hex.DecodeString(record.Digest); err != nil {
+ return errors.New("player: invalid costume burst upgrade digest")
+ }
+ level, found, err := wire.Varint(record.Body, 1)
+ if err != nil || !found || level != record.Level {
+ return errors.New("player: invalid costume burst upgrade response")
+ }
+ fieldCount := 0
+ if err := wire.Walk(record.Body, func(field wire.Field) error {
+ if field.Number != 1 || field.Type != 0 {
+ return errors.New("unexpected costume burst response field")
+ }
+ fieldCount++
+ return nil
+ }); err != nil || fieldCount != 1 {
+ return errors.New("player: invalid costume burst upgrade response")
+ }
+ return nil
+}
+
+const costumeBurstDigestHexSize = 64
+
+func (s *CollectionStore) validateCostumeBurstStorage() error {
+ if s.data.CostumeBurstLevels == nil || s.data.CostumeBurstUpgrades == nil {
+ return errors.New("player: collection save requires costume burst ledgers")
+ }
+ owned := make(map[uint64]Costume, len(s.base)+len(s.data.Costumes))
+ for _, costume := range append(append([]Costume(nil), s.base...), s.data.Costumes...) {
+ if costume.InvenIndex == 0 || costume.ID == 0 {
+ return errors.New("player: invalid costume burst ownership")
+ }
+ if _, exists := owned[costume.InvenIndex]; exists {
+ return errors.New("player: duplicate costume burst inventory index")
+ }
+ owned[costume.InvenIndex] = costume
+ }
+ for key, level := range s.data.CostumeBurstLevels {
+ index, err := strconv.ParseUint(key, 10, 64)
+ costume, found := owned[index]
+ if err != nil || index == 0 || key != strconv.FormatUint(index, 10) || level == 0 || !found || level < costume.BurstLevel {
+ return fmt.Errorf("player: invalid costume burst level entry %q", key)
+ }
+ }
+ for key, record := range s.data.CostumeBurstUpgrades {
+ index, level, valid := parseCostumeBurstUpgradeKey(key)
+ costume, found := owned[index]
+ current := costume.BurstLevel
+ if overlay, exists := s.data.CostumeBurstLevels[strconv.FormatUint(index, 10)]; exists {
+ current = overlay
+ }
+ if !valid || !found || record.CostumeID != costume.ID || record.Level != level || level > current {
+ return fmt.Errorf("player: invalid costume burst upgrade entry %q", key)
+ }
+ if err := validateCostumeBurstRecord(record); err != nil {
+ return fmt.Errorf("player: invalid costume burst upgrade entry %q: %w", key, err)
+ }
+ }
+ return nil
+}
+
func (s *CollectionStore) ValidateCostumePotentialActivation(costumeIndex uint64, nodes []uint64) error {
s.mu.Lock()
defer s.mu.Unlock()
@@ -948,12 +1141,9 @@ func (s *CollectionStore) CharacterByIndex(index uint64) (Character, bool) {
}
func (s *CollectionStore) CostumeByIndex(index uint64) (Costume, bool) {
- for _, costume := range s.Costumes() {
- if costume.InvenIndex == index {
- return costume, true
- }
- }
- return Costume{}, false
+ s.mu.Lock()
+ defer s.mu.Unlock()
+ return s.costumeByIndexLocked(index)
}
func findCostume(costumes []Costume, id uint64) (int, bool) {
@@ -1005,6 +1195,15 @@ func cloneCollection(in collectionSnapshot) collectionSnapshot {
for k, v := range in.CostumePotential {
out.CostumePotential[k] = append([]uint64(nil), v...)
}
+ out.CostumeBurstLevels = make(map[string]uint64, len(in.CostumeBurstLevels))
+ for k, v := range in.CostumeBurstLevels {
+ out.CostumeBurstLevels[k] = v
+ }
+ out.CostumeBurstUpgrades = make(map[string]CostumeBurstUpgradeRecord, len(in.CostumeBurstUpgrades))
+ for k, v := range in.CostumeBurstUpgrades {
+ v.Body = append([]byte(nil), v.Body...)
+ out.CostumeBurstUpgrades[k] = v
+ }
out.CharAwake = make(map[string]CharAwakeProgress, len(in.CharAwake))
for k, v := range in.CharAwake {
out.CharAwake[k] = v
diff --git a/go/internal/server/player/collection_entries.go b/go/internal/server/player/collection_entries.go
index feca994..9ff57a5 100644
--- a/go/internal/server/player/collection_entries.go
+++ b/go/internal/server/player/collection_entries.go
@@ -15,7 +15,8 @@ const collectionDomain = "collection"
var collectionEntryBuckets = [...]string{
"characters", "costumes", "grants", "gacha_applied", "gacha_users",
"gacha_fixed", "step_up_progress", "gacha_point_exchanges",
- "gacha_selections", "gacha_selection_changes", "costume_potential", "char_awake",
+ "gacha_selections", "gacha_selection_changes", "costume_potential",
+ "costume_burst_levels", "costume_burst_upgrades", "char_awake",
}
func rejectInlineCollectionEntries(raw []byte) error {
@@ -88,6 +89,12 @@ func loadCollectionEntries(store stateio.EntryStore, data *collectionSnapshot) e
if data.CostumePotential, err = loadEntryMap[[]uint64](store, "costume_potential"); err != nil {
return err
}
+ if data.CostumeBurstLevels, err = loadEntryMap[uint64](store, "costume_burst_levels"); err != nil {
+ return err
+ }
+ if data.CostumeBurstUpgrades, err = loadEntryMap[CostumeBurstUpgradeRecord](store, "costume_burst_upgrades"); err != nil {
+ return err
+ }
if data.CharAwake, err = loadEntryMap[CharAwakeProgress](store, "char_awake"); err != nil {
return err
}
@@ -127,6 +134,8 @@ func collectionCore(in collectionSnapshot) collectionSnapshot {
in.GachaSelections = nil
in.GachaSelectionChanges = nil
in.CostumePotential = nil
+ in.CostumeBurstLevels = nil
+ in.CostumeBurstUpgrades = nil
in.CharAwake = nil
return in
}
@@ -226,6 +235,12 @@ func diffCollectionEntries(before, after collectionSnapshot) ([]stateio.EntryMut
if err := diffEntryMap("costume_potential", before.CostumePotential, after.CostumePotential, &changes); err != nil {
return nil, err
}
+ if err := diffEntryMap("costume_burst_levels", before.CostumeBurstLevels, after.CostumeBurstLevels, &changes); err != nil {
+ return nil, err
+ }
+ if err := diffEntryMap("costume_burst_upgrades", before.CostumeBurstUpgrades, after.CostumeBurstUpgrades, &changes); err != nil {
+ return nil, err
+ }
if err := diffEntryMap("char_awake", before.CharAwake, after.CharAwake, &changes); err != nil {
return nil, err
}
diff --git a/go/internal/server/player/costume_burst.go b/go/internal/server/player/costume_burst.go
new file mode 100644
index 0000000..d3b38c3
--- /dev/null
+++ b/go/internal/server/player/costume_burst.go
@@ -0,0 +1,206 @@
+package player
+
+import (
+ "crypto/sha256"
+ "encoding/hex"
+ "errors"
+ "fmt"
+ "math"
+ "strconv"
+ "sync"
+
+ "bd2server/internal/server/gamedata"
+ "bd2server/internal/server/wire"
+)
+
+const costumeBurstPacketCode = 578
+
+type costumeBurstReply struct {
+ Digest string
+ Code int
+ Body []byte
+}
+
+// CostumeBurstService applies one adjacent costume-burst level from the
+// authoritative GameData row. The account request transaction makes the
+// wallet, inventory, and collection writes one atomic SQLite operation.
+type CostumeBurstService struct {
+ mu sync.Mutex
+ design *gamedata.CostumeBurstDesign
+ collection *CollectionStore
+ inventory *Inventory
+ wallet *Wallet
+ sessionID string
+ replies map[string]map[uint64]costumeBurstReply
+}
+
+func NewCostumeBurstService(design *gamedata.CostumeBurstDesign, collection *CollectionStore, inventory *Inventory, wallet *Wallet) (*CostumeBurstService, error) {
+ if design == nil || collection == nil || inventory == nil || wallet == nil {
+ return nil, errors.New("player: incomplete costume burst service")
+ }
+ return &CostumeBurstService{
+ design: design, collection: collection, inventory: inventory, wallet: wallet,
+ replies: make(map[string]map[uint64]costumeBurstReply),
+ }, nil
+}
+
+// BeginSession scopes protobuf sequence replay without forgetting older live
+// sessions. Session dispatch calls it before each authenticated request.
+func (s *CostumeBurstService) BeginSession(id string) {
+ s.mu.Lock()
+ defer s.mu.Unlock()
+ if id == "" || id == s.sessionID {
+ return
+ }
+ s.sessionID = id
+ if s.replies[id] != nil {
+ return
+ }
+ if len(s.replies) >= 1024 {
+ for oldID := range s.replies {
+ if oldID != id {
+ delete(s.replies, oldID)
+ break
+ }
+ }
+ }
+ s.replies[id] = make(map[uint64]costumeBurstReply)
+}
+
+func (s *CostumeBurstService) Handle(path string, request []byte) (int, []byte, bool, error) {
+ if path != "/CostumeBurst" {
+ return 0, nil, false, nil
+ }
+ seq, found, err := wire.Varint(request, 1)
+ if err != nil || !found || seq == 0 || seq > math.MaxInt32 {
+ return 0, nil, true, errors.New("player: CostumeBurst missing sequence")
+ }
+ costumeID, found, err := wire.Varint(request, 2)
+ if err != nil || !found || costumeID == 0 || costumeID > math.MaxInt32 {
+ return 0, nil, true, errors.New("player: CostumeBurst missing costume")
+ }
+ materials, err := equipmentRequestItems(request, 3, "CostumeBurst")
+ if err != nil {
+ return 0, nil, true, err
+ }
+ for _, material := range materials {
+ if material.InvenIndex > math.MaxInt64 || material.ID > math.MaxInt32 || material.Type > math.MaxInt32 || material.Count > math.MaxInt32 ||
+ material.KeepFlag > math.MaxInt32 || material.TimeValue > math.MaxInt64 || material.ExpiryTime > math.MaxInt64 ||
+ material.SortID > math.MaxInt32 || material.UseCount > math.MaxInt32 {
+ return 0, nil, true, errors.New("player: CostumeBurst material exceeds protocol range")
+ }
+ }
+
+ digestBytes := sha256.Sum256(request)
+ digest := hex.EncodeToString(digestBytes[:])
+ s.mu.Lock()
+ defer s.mu.Unlock()
+ sessionID := s.sessionID
+ if sessionID == "" {
+ sessionID = "__direct__"
+ }
+ if s.replies[sessionID] == nil {
+ s.replies[sessionID] = make(map[uint64]costumeBurstReply)
+ }
+ if reply, ok := s.replies[sessionID][seq]; ok {
+ if reply.Digest != digest {
+ return 0, nil, true, errors.New("player: CostumeBurst sequence reused with different request")
+ }
+ return reply.Code, append([]byte(nil), reply.Body...), true, nil
+ }
+
+ costume, found := s.collection.CostumeByID(costumeID)
+ if !found {
+ return 0, nil, true, fmt.Errorf("player: CostumeBurst costume %d is not owned", costumeID)
+ }
+ if costume.BurstLevel != 0 {
+ if applied, ok := s.collection.CostumeBurstReplay(costume.InvenIndex, costume.BurstLevel); ok && applied.Digest == digest {
+ reply := costumeBurstReply{Digest: digest, Code: applied.Code, Body: append([]byte(nil), applied.Body...)}
+ s.replies[sessionID][seq] = reply
+ return reply.Code, append([]byte(nil), reply.Body...), true, nil
+ }
+ }
+ rule, err := s.design.UpgradeRule(costume.ID, costume.BurstLevel)
+ if err != nil {
+ return 0, nil, true, fmt.Errorf("player: resolve CostumeBurst rule: %w", err)
+ }
+ items, gold, err := validateCostumeBurstMaterials(rule.Costs, materials)
+ if err != nil {
+ return 0, nil, true, err
+ }
+ if gold != 0 && !s.wallet.CanSpendGold(gold) {
+ return 0, nil, true, errors.New("player: insufficient gold for CostumeBurst")
+ }
+ if len(items) != 0 {
+ if err := s.inventory.CanConsume(items); err != nil {
+ return 0, nil, true, fmt.Errorf("player: validate CostumeBurst items: %w", err)
+ }
+ }
+
+ identity := "costume-burst:" + strconv.FormatUint(costume.InvenIndex, 10) + ":" + strconv.FormatUint(rule.NextLevel, 10)
+ if gold != 0 {
+ if _, err := s.wallet.SpendGoldOnce(identity, gold); err != nil {
+ return 0, nil, true, fmt.Errorf("player: consume CostumeBurst gold: %w", err)
+ }
+ }
+ if len(items) != 0 {
+ if err := s.inventory.Consume(items); err != nil {
+ return 0, nil, true, fmt.Errorf("player: consume CostumeBurst items: %w", err)
+ }
+ }
+ body := wire.AppendVarint(nil, 1, rule.NextLevel)
+ record := CostumeBurstUpgradeRecord{CostumeID: costume.ID, Level: rule.NextLevel, Digest: digest, Code: costumeBurstPacketCode, Body: append([]byte(nil), body...)}
+ if err := s.collection.ApplyCostumeBurst(costume.InvenIndex, costume.BurstLevel, rule.NextLevel, record); err != nil {
+ return 0, nil, true, fmt.Errorf("player: persist CostumeBurst: %w", err)
+ }
+ reply := costumeBurstReply{Digest: digest, Code: costumeBurstPacketCode, Body: append([]byte(nil), body...)}
+ s.replies[sessionID][seq] = reply
+ return reply.Code, append([]byte(nil), reply.Body...), true, nil
+}
+
+func validateCostumeBurstMaterials(costs []gamedata.PromotionCost, materials []Item) ([]Item, uint64, error) {
+ if len(costs) == 0 || len(materials) == 0 {
+ return nil, 0, errors.New("player: CostumeBurst has no material")
+ }
+ want := make(map[[2]uint64]uint64, len(costs))
+ for _, cost := range costs {
+ if cost.Count == 0 || (cost.Type == 4 && cost.ID != 0) || (cost.Type == 8 && cost.ID == 0) || (cost.Type != 4 && cost.Type != 8) {
+ return nil, 0, errors.New("player: invalid CostumeBurst GameData cost")
+ }
+ key := [2]uint64{cost.Type, cost.ID}
+ if want[key] > math.MaxUint64-cost.Count {
+ return nil, 0, errors.New("player: CostumeBurst GameData cost overflow")
+ }
+ want[key] += cost.Count
+ }
+ got := make(map[[2]uint64]uint64, len(materials))
+ items := make([]Item, 0, len(materials))
+ var gold uint64
+ for _, material := range materials {
+ if material.Type != 4 && material.Type != 8 {
+ return nil, 0, fmt.Errorf("player: unsupported CostumeBurst material type %d", material.Type)
+ }
+ key := [2]uint64{material.Type, material.ID}
+ if got[key] > math.MaxUint64-material.Count {
+ return nil, 0, errors.New("player: CostumeBurst submitted material overflow")
+ }
+ got[key] += material.Count
+ if material.Type == 4 {
+ if material.InvenIndex != 0 || material.ID != 0 || gold != 0 {
+ return nil, 0, errors.New("player: invalid CostumeBurst currency")
+ }
+ gold = material.Count
+ } else {
+ items = append(items, material)
+ }
+ }
+ if len(got) != len(want) {
+ return nil, 0, errors.New("player: CostumeBurst material kinds mismatch")
+ }
+ for key, count := range want {
+ if got[key] != count {
+ return nil, 0, fmt.Errorf("player: CostumeBurst material %d/%d=%d want %d", key[0], key[1], got[key], count)
+ }
+ }
+ return items, gold, nil
+}
diff --git a/go/internal/server/player/costume_burst_collection_test.go b/go/internal/server/player/costume_burst_collection_test.go
new file mode 100644
index 0000000..d498889
--- /dev/null
+++ b/go/internal/server/player/costume_burst_collection_test.go
@@ -0,0 +1,185 @@
+package player
+
+import (
+ "encoding/json"
+ "strings"
+ "testing"
+
+ "bd2server/internal/server/stateio"
+ "bd2server/internal/server/wire"
+)
+
+func testCostumeBurstRecord(costumeID, level uint64) CostumeBurstUpgradeRecord {
+ return CostumeBurstUpgradeRecord{
+ CostumeID: costumeID,
+ Level: level,
+ Digest: strings.Repeat("ab", 32),
+ Code: 578,
+ Body: wire.AppendVarint(nil, 1, level),
+ }
+}
+
+func TestCollectionCostumeBurstPersistsOverlayAndReplayForEveryCostumeSource(t *testing.T) {
+ storage := &collectionWriteSpy{Memory: stateio.NewMemory()}
+ base := []Costume{{InvenIndex: 11, ID: 101, BurstLevel: 0}}
+ collection, err := OpenCollectionStore(storage, base)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if err := collection.EnsurePersisted(); err != nil {
+ t.Fatal(err)
+ }
+ next := cloneCollection(collection.data)
+ next.Costumes = []Costume{{InvenIndex: 22, ID: 202}}
+ if err := collection.commit(next); err != nil {
+ t.Fatal(err)
+ }
+
+ baseRecord := testCostumeBurstRecord(101, 1)
+ before := len(storage.mutations)
+ if err := collection.ApplyCostumeBurst(11, 0, 1, baseRecord); err != nil {
+ t.Fatal(err)
+ }
+ if len(storage.mutations) != before+1 || len(storage.mutations[before]) != 2 {
+ t.Fatalf("burst level and replay were not one collection write: %+v", storage.mutations[before:])
+ }
+ if storage.mutations[before][0].Bucket != "costume_burst_levels" || storage.mutations[before][1].Bucket != "costume_burst_upgrades" {
+ t.Fatalf("unexpected burst mutations: %+v", storage.mutations[before])
+ }
+ if err := collection.ApplyCostumeBurst(22, 0, 1, testCostumeBurstRecord(202, 1)); err != nil {
+ t.Fatal(err)
+ }
+ if err := collection.ApplyCostumeBurst(22, 1, 2, testCostumeBurstRecord(202, 2)); err != nil {
+ t.Fatal(err)
+ }
+
+ if got, found := collection.CostumeByID(101); !found || got.InvenIndex != 11 || got.BurstLevel != 1 {
+ t.Fatalf("base costume overlay=%+v found=%v", got, found)
+ }
+ if got, found := collection.CostumeByIndex(22); !found || got.ID != 202 || got.BurstLevel != 2 {
+ t.Fatalf("collection costume overlay=%+v found=%v", got, found)
+ }
+ replay, found := collection.CostumeBurstReplay(22, 2)
+ if !found || replay.CostumeID != 202 || replay.Level != 2 || replay.Code != 578 {
+ t.Fatalf("replay=%+v found=%v", replay, found)
+ }
+ replay.Body[0] = 0
+ if again, _ := collection.CostumeBurstReplay(22, 2); len(again.Body) == 0 || again.Body[0] == 0 {
+ t.Fatal("CostumeBurstReplay returned an aliased response body")
+ }
+
+ core, err := storage.Load("collection")
+ if err != nil {
+ t.Fatal(err)
+ }
+ if strings.Contains(string(core), "costume_burst") {
+ t.Fatalf("burst entries leaked into collection core: %s", core)
+ }
+ restarted, err := OpenCollectionStore(storage, base)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if got, _ := restarted.CostumeByIndex(11); got.BurstLevel != 1 {
+ t.Fatalf("restarted base burst level=%d", got.BurstLevel)
+ }
+ if got, _ := restarted.CostumeByID(202); got.BurstLevel != 2 {
+ t.Fatalf("restarted collection burst level=%d", got.BurstLevel)
+ }
+ if got, ok := restarted.CostumeBurstReplay(22, 1); !ok || got.Level != 1 {
+ t.Fatalf("restarted first replay=%+v found=%v", got, ok)
+ }
+}
+
+func TestCollectionCostumeBurstCASAndRecordValidation(t *testing.T) {
+ collection, err := OpenCollectionStore(stateio.NewMemory(), []Costume{{InvenIndex: 11, ID: 101}})
+ if err != nil {
+ t.Fatal(err)
+ }
+ record := testCostumeBurstRecord(101, 1)
+ if err := collection.ApplyCostumeBurst(11, 0, 1, record); err != nil {
+ t.Fatal(err)
+ }
+ for name, call := range map[string]func() error{
+ "stale current": func() error { return collection.ApplyCostumeBurst(11, 0, 1, record) },
+ "skipped level": func() error { return collection.ApplyCostumeBurst(11, 1, 3, testCostumeBurstRecord(101, 3)) },
+ "wrong costume": func() error { return collection.ApplyCostumeBurst(11, 1, 2, testCostumeBurstRecord(102, 2)) },
+ "unknown instance": func() error { return collection.ApplyCostumeBurst(99, 0, 1, record) },
+ } {
+ t.Run(name, func(t *testing.T) {
+ if err := call(); err == nil {
+ t.Fatal("invalid costume burst transition was accepted")
+ }
+ })
+ }
+ if got, _ := collection.CostumeByIndex(11); got.BurstLevel != 1 {
+ t.Fatalf("rejected transitions mutated level to %d", got.BurstLevel)
+ }
+ if _, found := collection.CostumeBurstReplay(11, 2); found {
+ t.Fatal("rejected transition wrote a replay")
+ }
+}
+
+func TestCollectionCostumeByIDRejectsAmbiguousOwnership(t *testing.T) {
+ collection, err := OpenCollectionStore(stateio.NewMemory(), []Costume{{InvenIndex: 11, ID: 101}, {InvenIndex: 12, ID: 101}})
+ if err != nil {
+ t.Fatal(err)
+ }
+ if costume, found := collection.CostumeByID(101); found || costume.InvenIndex != 0 || costume.ID != 0 {
+ t.Fatalf("ambiguous logical ID resolved to %+v", costume)
+ }
+}
+
+func TestCollectionRejectsMalformedCostumeBurstEntries(t *testing.T) {
+ validRecord, err := json.Marshal(testCostumeBurstRecord(101, 1))
+ if err != nil {
+ t.Fatal(err)
+ }
+ tests := []struct {
+ name string
+ bucket string
+ key string
+ payload []byte
+ seed Costume
+ prepare func(*stateio.Memory)
+ }{
+ {name: "noncanonical level key", bucket: "costume_burst_levels", key: "011", payload: []byte("1"), seed: Costume{InvenIndex: 11, ID: 101}},
+ {name: "orphan level", bucket: "costume_burst_levels", key: "99", payload: []byte("1"), seed: Costume{InvenIndex: 11, ID: 101}},
+ {name: "zero level", bucket: "costume_burst_levels", key: "11", payload: []byte("0"), seed: Costume{InvenIndex: 11, ID: 101}},
+ {name: "level decreases seed", bucket: "costume_burst_levels", key: "11", payload: []byte("1"), seed: Costume{InvenIndex: 11, ID: 101, BurstLevel: 2}},
+ {name: "noncanonical replay key", bucket: "costume_burst_upgrades", key: "011:1", payload: validRecord, seed: Costume{InvenIndex: 11, ID: 101}, prepare: func(s *stateio.Memory) { _ = s.PutEntry("collection", "costume_burst_levels", "11", []byte("1")) }},
+ {name: "replay above current", bucket: "costume_burst_upgrades", key: "11:1", payload: validRecord, seed: Costume{InvenIndex: 11, ID: 101}},
+ {name: "invalid replay digest", bucket: "costume_burst_upgrades", key: "11:1", payload: func() []byte {
+ r := testCostumeBurstRecord(101, 1)
+ r.Digest = strings.Repeat("zz", 32)
+ b, _ := json.Marshal(r)
+ return b
+ }(), seed: Costume{InvenIndex: 11, ID: 101}, prepare: func(s *stateio.Memory) { _ = s.PutEntry("collection", "costume_burst_levels", "11", []byte("1")) }},
+ {name: "mismatched response", bucket: "costume_burst_upgrades", key: "11:1", payload: func() []byte {
+ r := testCostumeBurstRecord(101, 1)
+ r.Body = wire.AppendVarint(nil, 1, 2)
+ b, _ := json.Marshal(r)
+ return b
+ }(), seed: Costume{InvenIndex: 11, ID: 101}, prepare: func(s *stateio.Memory) { _ = s.PutEntry("collection", "costume_burst_levels", "11", []byte("1")) }},
+ }
+ for _, test := range tests {
+ t.Run(test.name, func(t *testing.T) {
+ storage := stateio.NewMemory()
+ collection, err := OpenCollectionStore(storage, []Costume{test.seed})
+ if err != nil {
+ t.Fatal(err)
+ }
+ if err := collection.EnsurePersisted(); err != nil {
+ t.Fatal(err)
+ }
+ if test.prepare != nil {
+ test.prepare(storage)
+ }
+ if err := storage.PutEntry("collection", test.bucket, test.key, test.payload); err != nil {
+ t.Fatal(err)
+ }
+ if _, err := OpenCollectionStore(storage, []Costume{test.seed}); err == nil {
+ t.Fatal("malformed costume burst storage was accepted")
+ }
+ })
+ }
+}
diff --git a/go/internal/server/player/costume_burst_test.go b/go/internal/server/player/costume_burst_test.go
new file mode 100644
index 0000000..2ec233c
--- /dev/null
+++ b/go/internal/server/player/costume_burst_test.go
@@ -0,0 +1,256 @@
+package player
+
+import (
+ "math"
+ "path/filepath"
+ "testing"
+
+ "bd2server/internal/server/accountstate"
+ "bd2server/internal/server/gamedata"
+ "bd2server/internal/server/wire"
+)
+
+func testCostumeBurstDesign() *gamedata.CostumeBurstDesign {
+ return &gamedata.CostumeBurstDesign{Levels: map[uint64]map[uint64]gamedata.CostumeBurstLevel{
+ 4202: {
+ 1: {CostumeID: 4202, Level: 1, Costs: []gamedata.PromotionCost{{Type: 4, Count: 100}, {Type: 8, ID: 710, Count: 2}}},
+ 2: {CostumeID: 4202, Level: 2, Costs: []gamedata.PromotionCost{{Type: 4, Count: 200}, {Type: 8, ID: 710, Count: 2}}},
+ },
+ }}
+}
+
+func costumeBurstRequest(seq, costumeID uint64, materials ...Item) []byte {
+ request := wire.AppendVarint(wire.AppendVarint(nil, 1, seq), 2, costumeID)
+ for _, material := range materials {
+ request = wire.AppendBytes(request, 3, ItemWire(material))
+ }
+ return request
+}
+
+func newCostumeBurstFixture(t *testing.T, storePath string, stacks []gamedata.BattleReward) (*CostumeBurstService, *CollectionStore, *Inventory, *Wallet, []Item) {
+ t.Helper()
+ store := testStore(storePath)
+ starter := &Starter{Version: "2.35.10"}
+ inventory, err := OpenInventory(store, starter)
+ if err != nil {
+ t.Fatal(err)
+ }
+ items, err := inventory.GrantOnce("costume-burst-materials", stacks)
+ if err != nil {
+ t.Fatal(err)
+ }
+ wallet, err := OpenWallet(store, Currency{Gold: 1000})
+ if err != nil {
+ t.Fatal(err)
+ }
+ collection, err := OpenCollectionStore(store, []Costume{{InvenIndex: 88, ID: 4202, DesignID: 9911}})
+ if err != nil {
+ t.Fatal(err)
+ }
+ service, err := NewCostumeBurstService(testCostumeBurstDesign(), collection, inventory, wallet)
+ if err != nil {
+ t.Fatal(err)
+ }
+ return service, collection, inventory, wallet, items
+}
+
+func TestCostumeBurstConsumesExactSplitCostsPersistsAndReplays(t *testing.T) {
+ path := filepath.Join(t.TempDir(), "state.json")
+ service, collection, inventory, wallet, stacks := newCostumeBurstFixture(t, path, []gamedata.BattleReward{
+ {Type: 8, ID: 710, Count: 1},
+ {Type: 8, ID: 710, Count: 1},
+ })
+ service.BeginSession("login-a")
+ request := costumeBurstRequest(7, 4202, stacks[1], Item{Type: 4, Count: 100}, stacks[0])
+ code, body, handled, err := service.Handle("/CostumeBurst", request)
+ if err != nil || !handled || code != costumeBurstPacketCode {
+ t.Fatalf("CostumeBurst code=%d handled=%v body=%x err=%v", code, handled, body, err)
+ }
+ level, found, err := wire.Varint(body, 1)
+ if err != nil || !found || level != 1 {
+ t.Fatalf("response level=%d found=%v err=%v body=%x", level, found, err, body)
+ }
+ got, found := collection.CostumeByID(4202)
+ if !found || got.InvenIndex != 88 || got.DesignID != 9911 || got.BurstLevel != 1 {
+ t.Fatalf("upgraded costume=%+v found=%v", got, found)
+ }
+ if wallet.Snapshot().Gold != 900 {
+ t.Fatalf("gold=%d", wallet.Snapshot().Gold)
+ }
+ for _, stack := range stacks {
+ if err := inventory.CanConsume([]Item{stack}); err == nil {
+ t.Fatalf("material stack %d survived", stack.InvenIndex)
+ }
+ }
+
+ code2, body2, handled, err := service.Handle("/CostumeBurst", request)
+ if err != nil || !handled || code2 != code || string(body2) != string(body) {
+ t.Fatalf("same-session replay code=%d handled=%v body=%x err=%v", code2, handled, body2, err)
+ }
+ if wallet.Snapshot().Gold != 900 || collection.Costumes()[0].BurstLevel != 1 {
+ t.Fatal("same-session replay mutated state")
+ }
+
+ store := testStore(path)
+ reloadedInventory, err := OpenInventory(store, &Starter{Version: "2.35.10"})
+ if err != nil {
+ t.Fatal(err)
+ }
+ reloadedWallet, err := OpenWallet(store, Currency{})
+ if err != nil {
+ t.Fatal(err)
+ }
+ reloadedCollection, err := OpenCollectionStore(store, []Costume{{InvenIndex: 88, ID: 4202, DesignID: 9911}})
+ if err != nil {
+ t.Fatal(err)
+ }
+ restarted, err := NewCostumeBurstService(testCostumeBurstDesign(), reloadedCollection, reloadedInventory, reloadedWallet)
+ if err != nil {
+ t.Fatal(err)
+ }
+ restarted.BeginSession("after-restart")
+ code2, body2, handled, err = restarted.Handle("/CostumeBurst", request)
+ if err != nil || !handled || code2 != code || string(body2) != string(body) {
+ t.Fatalf("durable replay code=%d handled=%v body=%x err=%v", code2, handled, body2, err)
+ }
+ if reloadedWallet.Snapshot().Gold != 900 || reloadedCollection.Costumes()[0].BurstLevel != 1 {
+ t.Fatal("durable replay charged or advanced again")
+ }
+}
+
+func TestCostumeBurstRequiresLogicalCostumeIDAndProtectsSessionSequence(t *testing.T) {
+ service, collection, inventory, wallet, stacks := newCostumeBurstFixture(t, filepath.Join(t.TempDir(), "state.json"), []gamedata.BattleReward{{Type: 8, ID: 710, Count: 4}})
+ material := stacks[0]
+ material.Count = 2
+ for _, wrong := range []uint64{88, 9911} {
+ request := costumeBurstRequest(wrong, wrong, material, Item{Type: 4, Count: 100})
+ if _, _, handled, err := service.Handle("/CostumeBurst", request); err == nil || !handled {
+ t.Fatalf("non-logical costume ID %d accepted: handled=%v err=%v", wrong, handled, err)
+ }
+ }
+ service.BeginSession("login-a")
+ request := costumeBurstRequest(9, 4202, material, Item{Type: 4, Count: 100})
+ if _, _, _, err := service.Handle("/CostumeBurst", request); err != nil {
+ t.Fatal(err)
+ }
+ different := costumeBurstRequest(9, 4202, material, Item{Type: 4, Count: 200})
+ if _, _, handled, err := service.Handle("/CostumeBurst", different); err == nil || !handled {
+ t.Fatalf("sequence reuse accepted: handled=%v err=%v", handled, err)
+ }
+ if collection.Costumes()[0].BurstLevel != 1 || wallet.Snapshot().Gold != 900 {
+ t.Fatal("rejected sequence reuse mutated state")
+ }
+ remaining := material
+ remaining.Count = 2
+ if err := inventory.CanConsume([]Item{remaining}); err != nil {
+ t.Fatalf("rejected request consumed remaining items: %v", err)
+ }
+}
+
+func TestCostumeBurstRejectsInvalidMaterialsAndProtocolRanges(t *testing.T) {
+ tests := []struct {
+ name string
+ materials func(Item) []Item
+ }{
+ {"short", func(stack Item) []Item { stack.Count = 1; return []Item{stack, {Type: 4, Count: 100}} }},
+ {"extra", func(stack Item) []Item {
+ stack.Count = 2
+ return []Item{stack, {Type: 4, Count: 100}, {InvenIndex: 900, Type: 8, ID: 711, Count: 1}}
+ }},
+ {"wrong-gold", func(stack Item) []Item { stack.Count = 2; return []Item{stack, {Type: 4, Count: 99}} }},
+ {"duplicate-overdraw", func(stack Item) []Item { stack.Count = 1; return []Item{stack, stack, {Type: 4, Count: 100}} }},
+ {"range", func(stack Item) []Item {
+ stack.Count = 2
+ stack.ExpiryTime = math.MaxInt64 + 1
+ return []Item{stack, {Type: 4, Count: 100}}
+ }},
+ }
+ for _, test := range tests {
+ t.Run(test.name, func(t *testing.T) {
+ stackCount := uint64(2)
+ if test.name == "duplicate-overdraw" {
+ stackCount = 1
+ }
+ service, collection, inventory, wallet, stacks := newCostumeBurstFixture(t, filepath.Join(t.TempDir(), "state.json"), []gamedata.BattleReward{{Type: 8, ID: 710, Count: stackCount}})
+ request := costumeBurstRequest(1, 4202, test.materials(stacks[0])...)
+ if _, _, handled, err := service.Handle("/CostumeBurst", request); err == nil || !handled {
+ t.Fatalf("invalid request accepted: handled=%v err=%v", handled, err)
+ }
+ if collection.Costumes()[0].BurstLevel != 0 || wallet.Snapshot().Gold != 1000 {
+ t.Fatal("invalid request mutated level or wallet")
+ }
+ if err := inventory.CanConsume([]Item{stacks[0]}); err != nil {
+ t.Fatalf("invalid request consumed material: %v", err)
+ }
+ })
+ }
+}
+
+func TestCostumeBurstSQLiteRollbackIsAtomic(t *testing.T) {
+ path := filepath.Join(t.TempDir(), "state.db")
+ repository, err := accountstate.Open(path)
+ if err != nil {
+ t.Fatal(err)
+ }
+ starter := &Starter{Version: "2.35.10"}
+ inventory, err := OpenInventory(repository, starter)
+ if err != nil {
+ t.Fatal(err)
+ }
+ stacks, err := inventory.GrantOnce("rollback-material", []gamedata.BattleReward{{Type: 8, ID: 710, Count: 2}})
+ if err != nil {
+ t.Fatal(err)
+ }
+ wallet, err := OpenWallet(repository, Currency{Gold: 1000})
+ if err != nil {
+ t.Fatal(err)
+ }
+ collection, err := OpenCollectionStore(repository, []Costume{{InvenIndex: 88, ID: 4202}})
+ if err != nil {
+ t.Fatal(err)
+ }
+ for _, ensure := range []func() error{inventory.EnsurePersisted, wallet.EnsurePersisted, collection.EnsurePersisted} {
+ if err := ensure(); err != nil {
+ t.Fatal(err)
+ }
+ }
+ service, _ := NewCostumeBurstService(testCostumeBurstDesign(), collection, inventory, wallet)
+ request := costumeBurstRequest(1, 4202, stacks[0], Item{Type: 4, Count: 100})
+ operation, err := repository.BeginOperation()
+ if err != nil {
+ t.Fatal(err)
+ }
+ if code, _, handled, err := service.Handle("/CostumeBurst", request); err != nil || !handled || code != costumeBurstPacketCode {
+ t.Fatalf("transactional request code=%d handled=%v err=%v", code, handled, err)
+ }
+ if err := operation.Rollback(); err == nil {
+ t.Fatal("dirty request rollback did not fence published in-memory state")
+ }
+ if err := repository.Close(); err != nil {
+ t.Fatal(err)
+ }
+
+ reopened, err := accountstate.Open(path)
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer reopened.Close()
+ reloadedInventory, err := OpenInventory(reopened, starter)
+ if err != nil {
+ t.Fatal(err)
+ }
+ reloadedWallet, err := OpenWallet(reopened, Currency{})
+ if err != nil {
+ t.Fatal(err)
+ }
+ reloadedCollection, err := OpenCollectionStore(reopened, []Costume{{InvenIndex: 88, ID: 4202}})
+ if err != nil {
+ t.Fatal(err)
+ }
+ if reloadedWallet.Snapshot().Gold != 1000 || reloadedCollection.Costumes()[0].BurstLevel != 0 {
+ t.Fatalf("rolled back state gold=%d costume=%+v", reloadedWallet.Snapshot().Gold, reloadedCollection.Costumes()[0])
+ }
+ if err := reloadedInventory.CanConsume([]Item{stacks[0]}); err != nil {
+ t.Fatalf("rolled back inventory did not restore materials: %v", err)
+ }
+}
diff --git a/plugins/CaptureEnvironment/CaptureEnvironment.csproj b/plugins/CaptureEnvironment/CaptureEnvironment.csproj
index 6b1388b..e2fcd7a 100644
--- a/plugins/CaptureEnvironment/CaptureEnvironment.csproj
+++ b/plugins/CaptureEnvironment/CaptureEnvironment.csproj
@@ -7,34 +7,30 @@
Bd2CaptureEnvironment
capture_environment
-
-
-
- $(GameDir)\BepInEx\core\BepInEx.dll
+ $(BD2BepInExDir)/core/BepInEx.dll
false
- $(GameDir)\BepInEx\core\0Harmony.dll
+ $(BD2BepInExDir)/core/0Harmony.dll
false
- $(GameDir)\BrownDust II_Data\Managed\UnityEngine.CoreModule.dll
+ $(BD2ManagedDir)/UnityEngine.CoreModule.dll
false
- $(GameDir)\BrownDust II_Data\Managed\UnityEngine.dll
+ $(BD2ManagedDir)/UnityEngine.dll
false
- $(GameDir)\BrownDust II_Data\Managed\UnityEngine.UnityWebRequestModule.dll
+ $(BD2ManagedDir)/UnityEngine.UnityWebRequestModule.dll
false
- $(GameDir)\BrownDust II_Data\Managed\Google.Protobuf.dll
+ $(BD2ManagedDir)/Google.Protobuf.dll
false
-
diff --git a/plugins/CaptureEnvironment/CaptureStorageIsolation.cs b/plugins/CaptureEnvironment/CaptureStorageIsolation.cs
new file mode 100644
index 0000000..6e5d08f
--- /dev/null
+++ b/plugins/CaptureEnvironment/CaptureStorageIsolation.cs
@@ -0,0 +1,110 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Reflection;
+using BD2.GameNames;
+using BepInEx.Logging;
+using HarmonyLib;
+using UnityEngine;
+using static BD2.GameNames.Game;
+
+namespace Bd2CaptureEnvironment;
+
+internal static class CaptureStorageIsolation
+{
+ private const string PlayerPrefsPrefix = "BD2OfficialCapture:" + Bd2Build.Versions.Game + ":";
+ private static ManualLogSource Log;
+ internal static string DataDirectory { get; private set; }
+ internal static string GameDataDirectory { get; private set; }
+ internal static void Initialize(string root, ManualLogSource log)
+ {
+ Log = log;
+ DataDirectory = Path.GetFullPath(Path.Combine(root, "IsolatedUserData"));
+ GameDataDirectory = Path.Combine(DataDirectory, "Data", "t");
+ EnsurePrivateGameDataDirectory();
+ }
+ private static void EnsurePrivateGameDataDirectory()
+ {
+ foreach (string path in new[]
+ {
+ DataDirectory,
+ Path.Combine(DataDirectory, "Data"),
+ GameDataDirectory
+ })
+ {
+ if (Directory.Exists(path) &&
+ (new DirectoryInfo(path).Attributes & FileAttributes.ReparsePoint) != 0)
+ throw new InvalidOperationException("Isolated GameData path is linked: " + path);
+ Directory.CreateDirectory(path);
+ }
+ }
+
+ internal static void Install(Harmony harmony)
+ {
+ PropertyInfo persistent = typeof(Application).GetGameProperty(
+ "persistentDataPath", BindingFlags.Static | BindingFlags.Public);
+ MethodInfo getter = persistent?.GetGetMethod();
+ if (getter == null)
+ throw new MissingMethodException("Application.persistentDataPath getter not found");
+ harmony.Patch(getter, prefix: new HarmonyMethod(
+ typeof(CaptureStorageIsolation), nameof(PersistentDataPathPrefix)));
+
+ var names = new HashSet(StringComparer.Ordinal)
+ {
+ "GetString", "SetString", "GetInt", "SetInt", "GetFloat", "SetFloat",
+ "HasKey", "DeleteKey"
+ };
+ foreach (MethodInfo method in typeof(PlayerPrefs).GetMethods(
+ BindingFlags.Static | BindingFlags.Public))
+ {
+ ParameterInfo[] parameters = method.GetParameters();
+ if (!names.Contains(method.Name) || parameters.Length == 0 ||
+ parameters[0].ParameterType != typeof(string))
+ continue;
+ harmony.Patch(method, prefix: new HarmonyMethod(
+ typeof(CaptureStorageIsolation), nameof(PlayerPrefsKeyPrefix)));
+ }
+
+ MethodInfo deleteAll = typeof(PlayerPrefs).GetGameMethod(
+ "DeleteAll", BindingFlags.Static | BindingFlags.Public,
+ null, Type.EmptyTypes, null);
+ if (deleteAll != null)
+ harmony.Patch(deleteAll, prefix: new HarmonyMethod(
+ typeof(CaptureStorageIsolation), nameof(BlockPlayerPrefsDeleteAll)));
+ }
+
+ private static bool PersistentDataPathPrefix(ref string __result)
+ {
+ __result = DataDirectory;
+ return false;
+ }
+
+ private static void PlayerPrefsKeyPrefix(ref string key)
+ {
+ if (key != null && !key.StartsWith(PlayerPrefsPrefix, StringComparison.Ordinal))
+ key = PlayerPrefsPrefix + key;
+ }
+
+ private static bool BlockPlayerPrefsDeleteAll()
+ {
+ Log?.LogWarning("Blocked PlayerPrefs.DeleteAll to protect the primary client profile");
+ return false;
+ }
+
+ internal static void InstallGameDataPath(Harmony harmony)
+ {
+ MethodInfo gameDataPath = Game.Method(network => network.GetPachedGameDataPath());
+ if (gameDataPath == null || gameDataPath.ReturnType != typeof(string))
+ throw new MissingMethodException("NetworkManager.GetPachedGameDataPath not found");
+ harmony.Patch(gameDataPath, prefix: new HarmonyMethod(
+ typeof(CaptureStorageIsolation), nameof(GameDataPathPrefix)));
+ Log?.LogInfo("Private installed GameData path hook installed");
+ }
+
+ private static bool GameDataPathPrefix(ref string __result)
+ {
+ __result = GameDataDirectory;
+ return false;
+ }
+
+}
diff --git a/plugins/CaptureEnvironment/CaptureWriter.cs b/plugins/CaptureEnvironment/CaptureWriter.cs
new file mode 100644
index 0000000..401046a
--- /dev/null
+++ b/plugins/CaptureEnvironment/CaptureWriter.cs
@@ -0,0 +1,283 @@
+using System;
+using System.Collections.Concurrent;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using BepInEx.Logging;
+
+namespace Bd2CaptureEnvironment;
+
+internal static class CaptureWriter
+{
+ private const int MaxBodyBytes = 16 * 1024 * 1024;
+ private const int MaxQueuedRecords = 256;
+ private const int WriterShutdownSeconds = 30;
+ private static readonly object FailureFileLock = new object();
+ private static readonly BlockingCollection WriteQueue =
+ new BlockingCollection(new ConcurrentQueue(), MaxQueuedRecords);
+ private static ManualLogSource Log;
+ internal static string DirectoryPath { get; private set; }
+ private static string JsonlPath;
+ private static string ReadableLogPath;
+ private static Thread WriterThread;
+ private static int WriterFailed;
+ private static int RejectionLogged;
+ private static int StopRequested;
+ internal static void Initialize(string root, ManualLogSource log)
+ {
+ Log = log;
+ DirectoryPath = Path.GetFullPath(Path.Combine(root, "Capture", DateTime.Now.ToString("yyyyMMdd-HHmmss")));
+ JsonlPath = Path.Combine(DirectoryPath, "capture.jsonl");
+ ReadableLogPath = Path.Combine(DirectoryPath, "capture.log");
+ Directory.CreateDirectory(Path.Combine(DirectoryPath, "bodies"));
+ StartWriter();
+ }
+ private sealed class CaptureRecord
+ {
+ public DateTime Timestamp;
+ public long Id;
+ public string Direction;
+ public string Path;
+ public string Type;
+ public byte[] Body;
+ public int Length;
+ public string Note;
+ }
+
+ internal static void QueueCapture(long id, string direction, string path,
+ string type, byte[] body)
+ {
+ if (Volatile.Read(ref WriterFailed) != 0)
+ {
+ LogRejectedPacket(id, direction, path,
+ "capture writer is unavailable");
+ return;
+ }
+ if (WriteQueue.IsAddingCompleted)
+ {
+ string closedReason = "capture queue was already closed when packet " +
+ id + " " + direction + " " + path + " arrived";
+ MarkIncomplete(closedReason, null);
+ LogRejectedPacket(id, direction, path, closedReason);
+ return;
+ }
+ int length = body?.Length ?? 0;
+ string note = body == null ? "protobuf body is null" : null;
+ byte[] owned = null;
+ if (length <= MaxBodyBytes)
+ {
+ if (length != 0)
+ {
+ owned = new byte[length];
+ Buffer.BlockCopy(body, 0, owned, 0, length);
+ }
+ }
+ else
+ {
+ note = "body exceeds " + MaxBodyBytes + " byte capture limit";
+ }
+ var record = new CaptureRecord
+ {
+ Timestamp = DateTime.Now,
+ Id = id,
+ Direction = direction,
+ Path = path,
+ Type = type,
+ Body = owned,
+ Length = length,
+ Note = note
+ };
+ try
+ {
+ if (WriteQueue.TryAdd(record)) return;
+ }
+ catch (InvalidOperationException)
+ {
+ // CompleteAdding can race a producer during application shutdown.
+ }
+ string reason = WriteQueue.IsAddingCompleted
+ ? "capture queue closed before packet " + id + " " + direction +
+ " " + path + " could be queued"
+ : "capture queue capacity " + MaxQueuedRecords +
+ " was exceeded; packet " + id + " " + direction + " " + path +
+ " was not captured";
+ MarkIncomplete(reason, null);
+ LogRejectedPacket(id, direction, path, reason);
+ }
+
+ private static void StartWriter()
+ {
+ WriterThread = new Thread(WriterLoop)
+ {
+ IsBackground = true,
+ Name = "BD2 capture writer"
+ };
+ WriterThread.Start();
+ }
+
+ internal static void Stop()
+ {
+ if (Interlocked.Exchange(ref StopRequested, 1) != 0) return;
+ CompleteWriterQueue();
+ if (WriterThread == null || !WriterThread.IsAlive) return;
+ if (WriterThread.Join(TimeSpan.FromSeconds(WriterShutdownSeconds))) return;
+ MarkIncomplete(
+ "capture writer did not drain " + WriteQueue.Count +
+ " queued records within " + WriterShutdownSeconds +
+ " seconds during shutdown", null);
+ }
+
+ private static void WriterLoop()
+ {
+ try
+ {
+ using var json = new StreamWriter(JsonlPath, false, new UTF8Encoding(false));
+ using var readable = new StreamWriter(
+ ReadableLogPath, false, new UTF8Encoding(false));
+ readable.WriteLine("timestamp id dir path protobuf type bytes body");
+ readable.WriteLine(new string('-', 160));
+ foreach (CaptureRecord record in WriteQueue.GetConsumingEnumerable())
+ {
+ try
+ {
+ string bodyFile = WriteBody(record);
+ json.WriteLine(RecordJson(record, bodyFile));
+ readable.WriteLine(ReadableLine(record, bodyFile));
+ json.Flush();
+ readable.Flush();
+ }
+ catch (Exception ex)
+ {
+ MarkIncomplete(
+ "capture writer failed while writing packet " + record.Id +
+ " " + record.Direction + " " + record.Path, ex);
+ return;
+ }
+ }
+ }
+ catch (Exception ex)
+ {
+ MarkIncomplete("capture writer failed to initialize or finalize", ex);
+ }
+ }
+
+ private static void CompleteWriterQueue()
+ {
+ if (WriteQueue.IsAddingCompleted) return;
+ try { WriteQueue.CompleteAdding(); }
+ catch (InvalidOperationException) { }
+ }
+
+ internal static void MarkIncomplete(string reason, Exception error)
+ {
+ if (Interlocked.CompareExchange(ref WriterFailed, 1, 0) != 0) return;
+ CompleteWriterQueue();
+ string detail = DateTime.Now.ToString("O") + Environment.NewLine + reason;
+ if (error != null) detail += Environment.NewLine + error;
+ detail += Environment.NewLine;
+ try
+ {
+ if (!string.IsNullOrEmpty(DirectoryPath))
+ {
+ Directory.CreateDirectory(DirectoryPath);
+ lock (FailureFileLock)
+ {
+ File.WriteAllText(
+ Path.Combine(DirectoryPath, "INCOMPLETE.txt"),
+ detail, new UTF8Encoding(false));
+ }
+ }
+ }
+ catch (Exception markerError)
+ {
+ Log?.LogError("could not write capture INCOMPLETE marker: " + markerError);
+ }
+ Log?.LogError("CAPTURE IS INCOMPLETE: " + reason +
+ (error == null ? "" : Environment.NewLine + error));
+ }
+
+ private static void LogRejectedPacket(long id, string direction, string path,
+ string reason)
+ {
+ if (Interlocked.Exchange(ref RejectionLogged, 1) != 0) return;
+ Log?.LogError("CAPTURE PACKETS ARE BEING REJECTED: packet " + id + " " +
+ direction + " " + path + "; " + reason);
+ }
+
+ private static string WriteBody(CaptureRecord record)
+ {
+ if (record.Body == null || record.Body.Length == 0) return null;
+ string type = record.Type ?? record.Path ?? "protobuf";
+ int dot = type.LastIndexOf('.');
+ if (dot >= 0) type = type.Substring(dot + 1);
+ string safe = new string(type.Select(ch => char.IsLetterOrDigit(ch) ? ch : '_')
+ .ToArray()).Trim('_');
+ if (safe.Length == 0) safe = "protobuf";
+ string name = record.Id.ToString("D6") + "_" + record.Direction +
+ "_" + safe + ".pb";
+ File.WriteAllBytes(Path.Combine(DirectoryPath, "bodies", name), record.Body);
+ return "bodies/" + name;
+ }
+
+ private static string RecordJson(CaptureRecord record, string bodyFile)
+ {
+ return "{" +
+ "\"timestamp\":\"" + Escape(record.Timestamp.ToString("O")) + "\"," +
+ "\"id\":" + record.Id + "," +
+ "\"direction\":\"" + Escape(record.Direction) + "\"," +
+ "\"path\":\"" + Escape(record.Path) + "\"," +
+ "\"protobuf_type\":\"" + Escape(record.Type) + "\"," +
+ "\"length\":" + record.Length + "," +
+ "\"body\":" + JsonString(bodyFile) + "," +
+ "\"note\":" + JsonString(record.Note) + "}";
+ }
+
+ private static string ReadableLine(CaptureRecord record, string bodyFile)
+ {
+ string direction = record.Direction == "request" ? "REQ" : "RESP";
+ return string.Format("{0,-33} {1,6:D6} {2,-4} {3,-40} {4,-50} {5,8} {6}",
+ record.Timestamp.ToString("O"), record.Id, direction,
+ Truncate(record.Path, 40), Truncate(record.Type, 50), record.Length,
+ bodyFile ?? record.Note ?? "-");
+ }
+
+ private static string Truncate(string value, int width)
+ {
+ value ??= "";
+ return value.Length <= width ? value : value.Substring(0, width - 1) + "…";
+ }
+
+ private static string JsonString(string value)
+ {
+ return value == null ? "null" : "\"" + Escape(value) + "\"";
+ }
+
+ private static string Escape(string value)
+ {
+ if (value == null) return "";
+ var escaped = new StringBuilder(value.Length + 16);
+ foreach (char character in value)
+ {
+ switch (character)
+ {
+ case '\"': escaped.Append("\\\""); break;
+ case '\\': escaped.Append("\\\\"); break;
+ case '\b': escaped.Append("\\b"); break;
+ case '\f': escaped.Append("\\f"); break;
+ case '\n': escaped.Append("\\n"); break;
+ case '\r': escaped.Append("\\r"); break;
+ case '\t': escaped.Append("\\t"); break;
+ default:
+ if (character <= '\u001f')
+ escaped.Append("\\u").Append(((int)character).ToString("x4"));
+ else
+ escaped.Append(character);
+ break;
+ }
+ }
+ return escaped.ToString();
+ }
+
+
+}
diff --git a/plugins/CaptureEnvironment/PacketCapture.cs b/plugins/CaptureEnvironment/PacketCapture.cs
new file mode 100644
index 0000000..26db24c
--- /dev/null
+++ b/plugins/CaptureEnvironment/PacketCapture.cs
@@ -0,0 +1,155 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Threading;
+using BD2.GameNames;
+using BepInEx.Logging;
+using Google.Protobuf;
+using HarmonyLib;
+using static BD2.GameNames.Game;
+
+namespace Bd2CaptureEnvironment;
+
+internal static class PacketCapture
+{
+ private static readonly object CorrelationLock = new object();
+ private static readonly Dictionary> PendingRequests =
+ new Dictionary>(StringComparer.Ordinal);
+ private static ManualLogSource Log;
+ private static long Sequence;
+ private sealed class PendingRequest
+ {
+ public long Id;
+ public string Type;
+ }
+
+ internal static void Install(Harmony harmony, ManualLogSource log)
+ {
+ Log = log;
+ Type manager = typeof(BDNetwork.NetworkManager);
+ MethodInfo send = manager?.GetMethods(BindingFlags.Instance | BindingFlags.Public)
+ .SingleOrDefault(method => method.IsGameMethod("Send") &&
+ method.ReturnType == typeof(void) &&
+ method.GetParameters().Length == 6 &&
+ typeof(IMessage).IsAssignableFrom(method.GetParameters()[0].ParameterType));
+ if (send != null)
+ {
+ harmony.Patch(send, prefix: new HarmonyMethod(
+ typeof(PacketCapture), nameof(GameSendPrefix)));
+ Log?.LogInfo("Plaintext request capture installed");
+ }
+ else
+ {
+ Log?.LogWarning("NetworkManager.Send plaintext hook not found");
+ }
+
+ Type responseData = typeof(BDNetwork.ResponseData);
+ MethodInfo responseCheck = manager?.GetMethods(
+ BindingFlags.Instance | BindingFlags.NonPublic)
+ .SingleOrDefault(method =>
+ {
+ ParameterInfo[] parameters = method.GetParameters();
+ return method.IsGameMethod("ResponseCheck") && method.ReturnType == typeof(bool) && parameters.Length == 4 &&
+ parameters[0].ParameterType == typeof(string) &&
+ parameters[2].ParameterType == responseData &&
+ parameters[3].ParameterType == typeof(byte[]);
+ });
+ if (responseCheck != null)
+ {
+ harmony.Patch(responseCheck, prefix: new HarmonyMethod(
+ typeof(PacketCapture), nameof(ResponseCheckPrefix)));
+ Log?.LogInfo("Path-correlated plaintext response capture installed");
+ }
+ else
+ {
+ Log?.LogWarning("NetworkManager.ResponseCheck plaintext hook not found");
+ }
+ }
+
+ private static void GameSendPrefix(IMessage __0)
+ {
+ try
+ {
+ if (__0 == null) return;
+ byte[] body = __0.ToByteArray();
+ string type = __0.GetType().FullName ?? __0.GetType().Name;
+ string path = RequestPath(__0.GetType().Name);
+ long id = Interlocked.Increment(ref Sequence);
+ EnqueueRequest(path, new PendingRequest { Id = id, Type = type });
+ CaptureWriter.QueueCapture(id, "request", path, type, body);
+ }
+ catch (Exception ex)
+ {
+ Log?.LogWarning("plaintext request capture failed: " + ex.Message);
+ }
+ }
+
+ private static void ResponseCheckPrefix(string __0, byte[] __3)
+ {
+ try
+ {
+ string path = NormalizePath(__0);
+ PendingRequest request = DequeueRequest(path);
+ long id = request?.Id ?? Interlocked.Increment(ref Sequence);
+ string type = ResponseType(request?.Type, path);
+ CaptureWriter.QueueCapture(id, "response", path, type, __3);
+ }
+ catch (Exception ex)
+ {
+ Log?.LogWarning("plaintext response capture failed: " + ex.Message);
+ }
+ }
+
+ private static string RequestPath(string typeName)
+ {
+ const string suffix = "Request";
+ if (typeName != null && typeName.EndsWith(suffix, StringComparison.Ordinal))
+ typeName = typeName.Substring(0, typeName.Length - suffix.Length);
+ return NormalizePath(typeName);
+ }
+
+ private static string NormalizePath(string path)
+ {
+ if (string.IsNullOrWhiteSpace(path)) return "/unknown";
+ return path[0] == '/' ? path : "/" + path;
+ }
+
+ private static string ResponseType(string requestType, string path)
+ {
+ const string suffix = "Request";
+ if (!string.IsNullOrEmpty(requestType) &&
+ requestType.EndsWith(suffix, StringComparison.Ordinal))
+ return requestType.Substring(0, requestType.Length - suffix.Length) + "Response";
+ return "Proto.Net." + path.TrimStart('/') + "Response";
+ }
+
+ private static void EnqueueRequest(string path, PendingRequest request)
+ {
+ lock (CorrelationLock)
+ {
+ if (!PendingRequests.TryGetValue(path, out Queue requests))
+ {
+ requests = new Queue();
+ PendingRequests.Add(path, requests);
+ }
+ requests.Enqueue(request);
+ }
+ }
+
+ private static PendingRequest DequeueRequest(string path)
+ {
+ lock (CorrelationLock)
+ {
+ if (PendingRequests.TryGetValue(path, out Queue requests) &&
+ requests.Count != 0)
+ {
+ PendingRequest request = requests.Dequeue();
+ if (requests.Count == 0) PendingRequests.Remove(path);
+ return request;
+ }
+ }
+ return null;
+ }
+
+}
diff --git a/plugins/CaptureEnvironment/Plugin.cs b/plugins/CaptureEnvironment/Plugin.cs
index 2bc7874..878ecd2 100644
--- a/plugins/CaptureEnvironment/Plugin.cs
+++ b/plugins/CaptureEnvironment/Plugin.cs
@@ -1,14 +1,8 @@
using System;
-using System.Collections.Concurrent;
-using System.Collections.Generic;
using System.IO;
-using System.Linq;
-using System.Reflection;
using System.Text;
-using System.Threading;
+using BD2.GameNames;
using BepInEx;
-using BepInEx.Logging;
-using Google.Protobuf;
using HarmonyLib;
using UnityEngine;
@@ -21,548 +15,46 @@ public sealed class Plugin : BaseUnityPlugin
public const string Name = "BD2 Capture Environment";
public const string Version = Bd2Build.Versions.Plugin;
- private const int MaxBodyBytes = 16 * 1024 * 1024;
- private const int MaxQueuedRecords = 256;
- private const int WriterShutdownSeconds = 30;
- private const string PlayerPrefsPrefix = "BD2OfficialCapture:" + Bd2Build.Versions.Game + ":";
- private static readonly object CorrelationLock = new object();
- private static readonly object FailureFileLock = new object();
- private static readonly Dictionary> PendingRequests =
- new Dictionary>(StringComparer.Ordinal);
- private static readonly BlockingCollection WriteQueue =
- new BlockingCollection(
- new ConcurrentQueue(), MaxQueuedRecords);
- private static ManualLogSource Log;
- private static string CaptureDirectory;
- private static string JsonlPath;
- private static string ReadableLogPath;
- private static string IsolatedDataDirectory;
- private static string IsolatedGameDataDirectory;
- private static long Sequence;
- private static Thread WriterThread;
- private static int WriterFailed;
- private static int RejectionLogged;
- private static int StopRequested;
-
private void Awake()
{
try
{
- Log = Logger;
- string root = Paths.GameRootPath;
- IsolatedDataDirectory = Path.GetFullPath(Path.Combine(root, "IsolatedUserData"));
- IsolatedGameDataDirectory = Path.Combine(IsolatedDataDirectory, "Data", "t");
- CaptureDirectory = Path.GetFullPath(Path.Combine(
- root, "Capture", DateTime.Now.ToString("yyyyMMdd-HHmmss")));
- JsonlPath = Path.Combine(CaptureDirectory, "capture.jsonl");
- ReadableLogPath = Path.Combine(CaptureDirectory, "capture.log");
- EnsurePrivateGameDataDirectory();
- Directory.CreateDirectory(Path.Combine(CaptureDirectory, "bodies"));
- StartWriter();
+ Game.Validate(typeof(Plugin).Assembly, Bd2Build.Versions.Game, message => Logger.LogInfo(message));
+ CaptureStorageIsolation.Initialize(Paths.GameRootPath, Logger);
+ CaptureWriter.Initialize(Paths.GameRootPath, Logger);
var harmony = new Harmony(Guid);
- InstallStorageIsolation(harmony);
+ CaptureStorageIsolation.Install(harmony);
string effectiveDataPath = Application.persistentDataPath;
if (!string.Equals(
Path.GetFullPath(effectiveDataPath).TrimEnd(Path.DirectorySeparatorChar),
- IsolatedDataDirectory.TrimEnd(Path.DirectorySeparatorChar),
+ CaptureStorageIsolation.DataDirectory.TrimEnd(Path.DirectorySeparatorChar),
StringComparison.OrdinalIgnoreCase))
throw new InvalidOperationException(
"persistentDataPath isolation verification failed: " + effectiveDataPath);
- InstallPlaintextCapture(harmony);
+ CaptureStorageIsolation.InstallGameDataPath(harmony);
+ PacketCapture.Install(harmony, Logger);
WriteMetadata();
Logger.LogInfo("Official capture environment active");
- Logger.LogInfo("persistentDataPath => " + IsolatedDataDirectory);
- Logger.LogInfo("isolated GameData => " + IsolatedGameDataDirectory);
- Logger.LogInfo("capture => " + CaptureDirectory);
+ Logger.LogInfo("persistentDataPath => " + CaptureStorageIsolation.DataDirectory);
+ Logger.LogInfo("isolated GameData => " + CaptureStorageIsolation.GameDataDirectory);
+ Logger.LogInfo("capture => " + CaptureWriter.DirectoryPath);
}
catch (Exception ex)
{
Logger.LogError("Capture environment setup failed: " + ex);
- MarkCaptureIncomplete("capture environment setup failed", ex);
+ CaptureWriter.MarkIncomplete("capture environment setup failed", ex);
}
}
private void OnApplicationQuit()
{
- StopWriter();
- }
-
- private sealed class PendingRequest
- {
- public long Id;
- public string Type;
- }
-
- private sealed class CaptureRecord
- {
- public DateTime Timestamp;
- public long Id;
- public string Direction;
- public string Path;
- public string Type;
- public byte[] Body;
- public int Length;
- public string Note;
- }
-
- private static void EnsurePrivateGameDataDirectory()
- {
- foreach (string path in new[]
- {
- IsolatedDataDirectory,
- Path.Combine(IsolatedDataDirectory, "Data"),
- IsolatedGameDataDirectory
- })
- {
- if (Directory.Exists(path) &&
- (new DirectoryInfo(path).Attributes & FileAttributes.ReparsePoint) != 0)
- throw new InvalidOperationException("Isolated GameData path is linked: " + path);
- Directory.CreateDirectory(path);
- }
- }
-
- private static void InstallStorageIsolation(Harmony harmony)
- {
- PropertyInfo persistent = typeof(Application).GetProperty(
- "persistentDataPath", BindingFlags.Static | BindingFlags.Public);
- MethodInfo getter = persistent?.GetGetMethod();
- if (getter == null)
- throw new MissingMethodException("Application.persistentDataPath getter not found");
- harmony.Patch(getter, prefix: new HarmonyMethod(
- typeof(Plugin), nameof(PersistentDataPathPrefix)));
-
- var names = new HashSet(StringComparer.Ordinal)
- {
- "GetString", "SetString", "GetInt", "SetInt", "GetFloat", "SetFloat",
- "HasKey", "DeleteKey"
- };
- foreach (MethodInfo method in typeof(PlayerPrefs).GetMethods(
- BindingFlags.Static | BindingFlags.Public))
- {
- ParameterInfo[] parameters = method.GetParameters();
- if (!names.Contains(method.Name) || parameters.Length == 0 ||
- parameters[0].ParameterType != typeof(string))
- continue;
- harmony.Patch(method, prefix: new HarmonyMethod(
- typeof(Plugin), nameof(PlayerPrefsKeyPrefix)));
- }
-
- MethodInfo deleteAll = typeof(PlayerPrefs).GetMethod(
- "DeleteAll", BindingFlags.Static | BindingFlags.Public,
- null, Type.EmptyTypes, null);
- if (deleteAll != null)
- harmony.Patch(deleteAll, prefix: new HarmonyMethod(
- typeof(Plugin), nameof(BlockPlayerPrefsDeleteAll)));
- }
-
- private static bool PersistentDataPathPrefix(ref string __result)
- {
- __result = IsolatedDataDirectory;
- return false;
- }
-
- private static void PlayerPrefsKeyPrefix(ref string key)
- {
- if (key != null && !key.StartsWith(PlayerPrefsPrefix, StringComparison.Ordinal))
- key = PlayerPrefsPrefix + key;
- }
-
- private static bool BlockPlayerPrefsDeleteAll()
- {
- Log?.LogWarning("Blocked PlayerPrefs.DeleteAll to protect the primary client profile");
- return false;
- }
-
- private static void InstallPlaintextCapture(Harmony harmony)
- {
- Type manager = FindType("BDNetwork.NetworkManager");
- MethodInfo gameDataPath = manager?.GetMethod("GetPachedGameDataPath",
- BindingFlags.Instance | BindingFlags.Public, null, Type.EmptyTypes, null);
- if (gameDataPath == null || gameDataPath.ReturnType != typeof(string))
- throw new MissingMethodException("NetworkManager.GetPachedGameDataPath not found");
- harmony.Patch(gameDataPath, prefix: new HarmonyMethod(
- typeof(Plugin), nameof(GameDataPathPrefix)));
- Log?.LogInfo("Private installed GameData path hook installed");
-
- MethodInfo send = manager?.GetMethods(BindingFlags.Instance | BindingFlags.Public)
- .FirstOrDefault(method => method.Name == "Send" &&
- method.ReturnType == typeof(void) &&
- method.GetParameters().Length == 6 &&
- typeof(IMessage).IsAssignableFrom(method.GetParameters()[0].ParameterType));
- if (send != null)
- {
- harmony.Patch(send, prefix: new HarmonyMethod(
- typeof(Plugin), nameof(GameSendPrefix)));
- Log?.LogInfo("Plaintext request capture installed");
- }
- else
- {
- Log?.LogWarning("NetworkManager.Send plaintext hook not found");
- }
-
- Type responseData = FindType("BDNetwork.ResponseData");
- MethodInfo responseCheck = manager?.GetMethods(
- BindingFlags.Instance | BindingFlags.NonPublic)
- .SingleOrDefault(method =>
- {
- ParameterInfo[] parameters = method.GetParameters();
- return method.ReturnType == typeof(bool) && parameters.Length == 4 &&
- parameters[0].ParameterType == typeof(string) &&
- parameters[2].ParameterType == responseData &&
- parameters[3].ParameterType == typeof(byte[]);
- });
- if (responseCheck != null)
- {
- harmony.Patch(responseCheck, prefix: new HarmonyMethod(
- typeof(Plugin), nameof(ResponseCheckPrefix)));
- Log?.LogInfo("Path-correlated plaintext response capture installed");
- }
- else
- {
- Log?.LogWarning("NetworkManager.ResponseCheck plaintext hook not found");
- }
- }
-
- private static bool GameDataPathPrefix(ref string __result)
- {
- __result = IsolatedGameDataDirectory;
- return false;
- }
-
- private static void GameSendPrefix(IMessage __0)
- {
- try
- {
- if (__0 == null) return;
- byte[] body = __0.ToByteArray();
- string type = __0.GetType().FullName ?? __0.GetType().Name;
- string path = RequestPath(__0.GetType().Name);
- long id = Interlocked.Increment(ref Sequence);
- EnqueueRequest(path, new PendingRequest { Id = id, Type = type });
- QueueCapture(id, "request", path, type, body);
- }
- catch (Exception ex)
- {
- Log?.LogWarning("plaintext request capture failed: " + ex.Message);
- }
- }
-
- private static void ResponseCheckPrefix(string __0, byte[] __3)
- {
- try
- {
- string path = NormalizePath(__0);
- PendingRequest request = DequeueRequest(path);
- long id = request?.Id ?? Interlocked.Increment(ref Sequence);
- string type = ResponseType(request?.Type, path);
- QueueCapture(id, "response", path, type, __3);
- }
- catch (Exception ex)
- {
- Log?.LogWarning("plaintext response capture failed: " + ex.Message);
- }
- }
-
- private static string RequestPath(string typeName)
- {
- const string suffix = "Request";
- if (typeName != null && typeName.EndsWith(suffix, StringComparison.Ordinal))
- typeName = typeName.Substring(0, typeName.Length - suffix.Length);
- return NormalizePath(typeName);
- }
-
- private static string NormalizePath(string path)
- {
- if (string.IsNullOrWhiteSpace(path)) return "/unknown";
- return path[0] == '/' ? path : "/" + path;
- }
-
- private static string ResponseType(string requestType, string path)
- {
- const string suffix = "Request";
- if (!string.IsNullOrEmpty(requestType) &&
- requestType.EndsWith(suffix, StringComparison.Ordinal))
- return requestType.Substring(0, requestType.Length - suffix.Length) + "Response";
- return "Proto.Net." + path.TrimStart('/') + "Response";
- }
-
- private static void EnqueueRequest(string path, PendingRequest request)
- {
- lock (CorrelationLock)
- {
- if (!PendingRequests.TryGetValue(path, out Queue requests))
- {
- requests = new Queue();
- PendingRequests.Add(path, requests);
- }
- requests.Enqueue(request);
- }
- }
-
- private static PendingRequest DequeueRequest(string path)
- {
- lock (CorrelationLock)
- {
- if (PendingRequests.TryGetValue(path, out Queue requests) &&
- requests.Count != 0)
- {
- PendingRequest request = requests.Dequeue();
- if (requests.Count == 0) PendingRequests.Remove(path);
- return request;
- }
- }
- return null;
- }
-
- private static void QueueCapture(long id, string direction, string path,
- string type, byte[] body)
- {
- if (Volatile.Read(ref WriterFailed) != 0)
- {
- LogRejectedPacket(id, direction, path,
- "capture writer is unavailable");
- return;
- }
- if (WriteQueue.IsAddingCompleted)
- {
- string closedReason = "capture queue was already closed when packet " +
- id + " " + direction + " " + path + " arrived";
- MarkCaptureIncomplete(closedReason, null);
- LogRejectedPacket(id, direction, path, closedReason);
- return;
- }
- int length = body?.Length ?? 0;
- string note = body == null ? "protobuf body is null" : null;
- byte[] owned = null;
- if (length <= MaxBodyBytes)
- {
- if (length != 0)
- {
- owned = new byte[length];
- Buffer.BlockCopy(body, 0, owned, 0, length);
- }
- }
- else
- {
- note = "body exceeds " + MaxBodyBytes + " byte capture limit";
- }
- var record = new CaptureRecord
- {
- Timestamp = DateTime.Now,
- Id = id,
- Direction = direction,
- Path = path,
- Type = type,
- Body = owned,
- Length = length,
- Note = note
- };
- try
- {
- if (WriteQueue.TryAdd(record)) return;
- }
- catch (InvalidOperationException)
- {
- // CompleteAdding can race a producer during application shutdown.
- }
- string reason = WriteQueue.IsAddingCompleted
- ? "capture queue closed before packet " + id + " " + direction +
- " " + path + " could be queued"
- : "capture queue capacity " + MaxQueuedRecords +
- " was exceeded; packet " + id + " " + direction + " " + path +
- " was not captured";
- MarkCaptureIncomplete(reason, null);
- LogRejectedPacket(id, direction, path, reason);
- }
-
- private static void StartWriter()
- {
- WriterThread = new Thread(WriterLoop)
- {
- IsBackground = true,
- Name = "BD2 capture writer"
- };
- WriterThread.Start();
- }
-
- private static void StopWriter()
- {
- if (Interlocked.Exchange(ref StopRequested, 1) != 0) return;
- CompleteWriterQueue();
- if (WriterThread == null || !WriterThread.IsAlive) return;
- if (WriterThread.Join(TimeSpan.FromSeconds(WriterShutdownSeconds))) return;
- MarkCaptureIncomplete(
- "capture writer did not drain " + WriteQueue.Count +
- " queued records within " + WriterShutdownSeconds +
- " seconds during shutdown", null);
- }
-
- private static void WriterLoop()
- {
- try
- {
- using var json = new StreamWriter(JsonlPath, false, new UTF8Encoding(false));
- using var readable = new StreamWriter(
- ReadableLogPath, false, new UTF8Encoding(false));
- readable.WriteLine("timestamp id dir path protobuf type bytes body");
- readable.WriteLine(new string('-', 160));
- foreach (CaptureRecord record in WriteQueue.GetConsumingEnumerable())
- {
- try
- {
- string bodyFile = WriteBody(record);
- json.WriteLine(RecordJson(record, bodyFile));
- readable.WriteLine(ReadableLine(record, bodyFile));
- json.Flush();
- readable.Flush();
- }
- catch (Exception ex)
- {
- MarkCaptureIncomplete(
- "capture writer failed while writing packet " + record.Id +
- " " + record.Direction + " " + record.Path, ex);
- return;
- }
- }
- }
- catch (Exception ex)
- {
- MarkCaptureIncomplete("capture writer failed to initialize or finalize", ex);
- }
- }
-
- private static void CompleteWriterQueue()
- {
- if (WriteQueue.IsAddingCompleted) return;
- try { WriteQueue.CompleteAdding(); }
- catch (InvalidOperationException) { }
- }
-
- private static void MarkCaptureIncomplete(string reason, Exception error)
- {
- if (Interlocked.CompareExchange(ref WriterFailed, 1, 0) != 0) return;
- CompleteWriterQueue();
- string detail = DateTime.Now.ToString("O") + Environment.NewLine + reason;
- if (error != null) detail += Environment.NewLine + error;
- detail += Environment.NewLine;
- try
- {
- if (!string.IsNullOrEmpty(CaptureDirectory))
- {
- Directory.CreateDirectory(CaptureDirectory);
- lock (FailureFileLock)
- {
- File.WriteAllText(
- Path.Combine(CaptureDirectory, "INCOMPLETE.txt"),
- detail, new UTF8Encoding(false));
- }
- }
- }
- catch (Exception markerError)
- {
- Log?.LogError("could not write capture INCOMPLETE marker: " + markerError);
- }
- Log?.LogError("CAPTURE IS INCOMPLETE: " + reason +
- (error == null ? "" : Environment.NewLine + error));
- }
-
- private static void LogRejectedPacket(long id, string direction, string path,
- string reason)
- {
- if (Interlocked.Exchange(ref RejectionLogged, 1) != 0) return;
- Log?.LogError("CAPTURE PACKETS ARE BEING REJECTED: packet " + id + " " +
- direction + " " + path + "; " + reason);
- }
-
- private static string WriteBody(CaptureRecord record)
- {
- if (record.Body == null || record.Body.Length == 0) return null;
- string type = record.Type ?? record.Path ?? "protobuf";
- int dot = type.LastIndexOf('.');
- if (dot >= 0) type = type.Substring(dot + 1);
- string safe = new string(type.Select(ch => char.IsLetterOrDigit(ch) ? ch : '_')
- .ToArray()).Trim('_');
- if (safe.Length == 0) safe = "protobuf";
- string name = record.Id.ToString("D6") + "_" + record.Direction +
- "_" + safe + ".pb";
- File.WriteAllBytes(Path.Combine(CaptureDirectory, "bodies", name), record.Body);
- return "bodies/" + name;
- }
-
- private static string RecordJson(CaptureRecord record, string bodyFile)
- {
- return "{" +
- "\"timestamp\":\"" + Escape(record.Timestamp.ToString("O")) + "\"," +
- "\"id\":" + record.Id + "," +
- "\"direction\":\"" + Escape(record.Direction) + "\"," +
- "\"path\":\"" + Escape(record.Path) + "\"," +
- "\"protobuf_type\":\"" + Escape(record.Type) + "\"," +
- "\"length\":" + record.Length + "," +
- "\"body\":" + JsonString(bodyFile) + "," +
- "\"note\":" + JsonString(record.Note) + "}";
- }
-
- private static string ReadableLine(CaptureRecord record, string bodyFile)
- {
- string direction = record.Direction == "request" ? "REQ" : "RESP";
- return string.Format("{0,-33} {1,6:D6} {2,-4} {3,-40} {4,-50} {5,8} {6}",
- record.Timestamp.ToString("O"), record.Id, direction,
- Truncate(record.Path, 40), Truncate(record.Type, 50), record.Length,
- bodyFile ?? record.Note ?? "-");
- }
-
- private static string Truncate(string value, int width)
- {
- value ??= "";
- return value.Length <= width ? value : value.Substring(0, width - 1) + "…";
- }
-
- private static string JsonString(string value)
- {
- return value == null ? "null" : "\"" + Escape(value) + "\"";
- }
-
- private static string Escape(string value)
- {
- if (value == null) return "";
- var escaped = new StringBuilder(value.Length + 16);
- foreach (char character in value)
- {
- switch (character)
- {
- case '\"': escaped.Append("\\\""); break;
- case '\\': escaped.Append("\\\\"); break;
- case '\b': escaped.Append("\\b"); break;
- case '\f': escaped.Append("\\f"); break;
- case '\n': escaped.Append("\\n"); break;
- case '\r': escaped.Append("\\r"); break;
- case '\t': escaped.Append("\\t"); break;
- default:
- if (character <= '\u001f')
- escaped.Append("\\u").Append(((int)character).ToString("x4"));
- else
- escaped.Append(character);
- break;
- }
- }
- return escaped.ToString();
- }
-
- private static Type FindType(string fullName)
- {
- foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies())
- {
- Type type = assembly.GetType(fullName, false);
- if (type != null) return type;
- }
- try { return Assembly.Load("Assembly-CSharp")?.GetType(fullName, false); }
- catch { return null; }
+ CaptureWriter.Stop();
}
private static void WriteMetadata()
{
- File.WriteAllText(Path.Combine(CaptureDirectory, "README.txt"),
+ File.WriteAllText(Path.Combine(CaptureWriter.DirectoryPath, "README.txt"),
"BD2 " + Bd2Build.Versions.Game + " official API capture.\r\n" +
"All NetworkManager plaintext protobuf requests and responses are recorded.\r\n" +
"capture.jsonl is machine-readable; capture.log is the aligned human-readable index.\r\n" +
@@ -570,8 +62,8 @@ public sealed class Plugin : BaseUnityPlugin
"No Cookie/Authorization headers or URL query strings are recorded.\r\n" +
"Raw protobuf/account bodies can still contain private account data. Do not share this directory.\r\n" +
"clientVersion=" + Application.version + "\r\n" +
- "persistentDataPath=" + IsolatedDataDirectory + "\r\n" +
- "gameDataPath=" + IsolatedGameDataDirectory + "\r\n",
+ "persistentDataPath=" + CaptureStorageIsolation.DataDirectory + "\r\n" +
+ "gameDataPath=" + CaptureStorageIsolation.GameDataDirectory + "\r\n",
new UTF8Encoding(false));
}
}
diff --git a/plugins/CaptureEnvironment/README.md b/plugins/CaptureEnvironment/README.md
index 732302b..98c8a58 100644
--- a/plugins/CaptureEnvironment/README.md
+++ b/plugins/CaptureEnvironment/README.md
@@ -2,6 +2,19 @@
This BepInEx plugin is only for the separately extracted official client selected by the repository-root `versions.json`.
+The SDK embeds the version-locked names table. Build with the game directory; the build generates the readable reference assembly and reobfuscates the plugin automatically:
+
+```powershell
+dotnet build plugins/CaptureEnvironment/CaptureEnvironment.csproj -c Release `
+ '-p:GameDir='
+```
+
+Deploy the runtime `BD2CaptureEnvironment.dll` together with the adjacent
+`BD2.GameNames.dll`. The launcher copies both from the staged build and requires
+both to exist. The shared library validates the plugin/table version and game
+binary before game patches are installed. See [the GameSdk guide](../GameSdk/README.md)
+for the compiler/runtime name contract; the readable shell stays in `obj`.
+
- redirects `Application.persistentDataPath` to `/IsolatedUserData`;
- prefixes game `PlayerPrefs` keys with a namespace derived from the configured client version;
- keeps account/profile/Neo/Intro and the installed GameData working set in
diff --git a/plugins/Directory.Build.local.props.example b/plugins/Directory.Build.local.props.example
new file mode 100644
index 0000000..1272ffe
--- /dev/null
+++ b/plugins/Directory.Build.local.props.example
@@ -0,0 +1,9 @@
+
+
+ E:\Games\BrownDustII
+
+ E:\Games\BrownDustII-Capture
+
+
+
+
diff --git a/plugins/Directory.Build.props b/plugins/Directory.Build.props
new file mode 100644
index 0000000..f787693
--- /dev/null
+++ b/plugins/Directory.Build.props
@@ -0,0 +1,21 @@
+
+
+
+ $(MSBuildThisFileDirectory)
+ $([System.IO.Path]::GetFullPath('$(BD2PluginsDir)..'))/
+
+
+
+ $(BD2CaptureGameDir)
+ $(BD2LocalGameDir)
+ $(GameDir)/BrownDust II_Data/Managed
+ $(GameDir)/BepInEx
+ $(BD2RepositoryDir)versions.json
+ $(BD2PluginsDir)GameSdk/GameSdk.csproj
+ $(BD2PluginsDir)GameNames/GameNames.csproj
+ Release
+ $(BD2PluginsDir)GameSdk/bin/$(BD2SdkConfiguration)/net8.0/GameSdk.dll
+ game-sdk
+ $(BD2_GAME_SDK_CACHE)
+
+
diff --git a/plugins/Directory.Build.targets b/plugins/Directory.Build.targets
new file mode 100644
index 0000000..7d112bf
--- /dev/null
+++ b/plugins/Directory.Build.targets
@@ -0,0 +1,9 @@
+
+
+
+ $([System.IO.Path]::GetFullPath('$(MSBuildProjectDirectory)/$(IntermediateOutputPath)$(BD2SdkIntermediateFolder)'))
+ $([System.IO.Path]::GetFullPath('$(MSBuildProjectDirectory)/$(IntermediateOutputPath)Bd2Versions.g.cs'))
+
+
+
+
diff --git a/plugins/GameNames/Game.cs b/plugins/GameNames/Game.cs
new file mode 100644
index 0000000..d83ab4e
--- /dev/null
+++ b/plugins/GameNames/Game.cs
@@ -0,0 +1,243 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.IO;
+using System.IO.Compression;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Reflection;
+using System.Runtime.Serialization.Json;
+using System.Security.Cryptography;
+using BD2.GameNames.Internal;
+
+namespace BD2.GameNames;
+
+/// Readable names for string-based reflection. Unknown names retain their literal spelling.
+public static class Game
+{
+ private sealed class Index
+ {
+ internal readonly NameTable Table;
+ internal readonly Dictionary Types;
+ internal readonly Dictionary Tokens;
+ internal Index()
+ {
+ using (var stream = typeof(Game).Assembly.GetManifestResourceStream("BD2.GameNames.names.json.gz"))
+ using (var gzip = new GZipStream(stream ?? throw new InvalidDataException("BD2.GameNames: embedded table missing"), CompressionMode.Decompress))
+ Table = (NameTable)new DataContractJsonSerializer(typeof(NameTable)).ReadObject(gzip);
+ if (Table.schema_version != 1) throw new InvalidDataException("BD2.GameNames: unsupported table schema");
+ Types = Table.types.ToDictionary(t => t.readable, StringComparer.Ordinal);
+ Tokens = Table.members.ToDictionary(m => m.token);
+ }
+ }
+ private static readonly Lazy Names = new Lazy(() => new Index());
+ private static readonly ConcurrentDictionary TypeCache = new ConcurrentDictionary();
+ private static readonly ConcurrentDictionary MemberCache = new ConcurrentDictionary();
+ private static readonly object ValidationLock = new object();
+ private static string ValidatedStamp;
+ /// Gets the game version embedded in this package.
+ public static string GameVersion => Names.Value.Table.game_version;
+
+ /// Translates a full readable type name. Unknown names retain their literal spelling.
+ public static string TypeName(string readableFullName)
+ {
+ if (readableFullName == null) throw new ArgumentNullException(nameof(readableFullName));
+ return Names.Value.Types.TryGetValue(readableFullName.Replace('/', '+'), out var entry) ? entry.original : readableFullName;
+ }
+
+ /// Finds a readable type in Assembly-CSharp or loaded assemblies; returns null when absent.
+ public static Type FindType(string readableFullName)
+ {
+ if (readableFullName == null) throw new ArgumentNullException(nameof(readableFullName));
+ if (TypeCache.TryGetValue(readableFullName, out var cached)) return cached;
+ string original = TypeName(readableFullName);
+ Type found = GameAssembly().GetType(original, false);
+ if (found == null)
+ foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
+ {
+ found = assembly.GetType(original, false);
+ if (found != null) break;
+ }
+ if (found != null) TypeCache.TryAdd(readableFullName, found);
+ return found;
+ }
+
+ private static Assembly GameAssembly() => Assembly.Load("Assembly-CSharp");
+ private static bool Matches(MemberInfo member, string kind, string readable)
+ {
+ if (member == null) throw new ArgumentNullException(nameof(member));
+ if (readable == null) throw new ArgumentNullException(nameof(readable));
+ // Metadata tokens retain declaration identity through inheritance and closed generics.
+ // A hidden literal member must not be mistaken for a renamed member of a base class.
+ if (member.DeclaringType.Assembly.GetName().Name == Names.Value.Table.assembly_name && Names.Value.Tokens.TryGetValue(member.MetadataToken, out var entry))
+ return entry.kind == kind && entry.readable == readable;
+ return member.Name == readable;
+ }
+
+ /// Translate coroutine/member strings. Overloads with different runtime names require Method/MethodName(MethodInfo).
+ public static string MemberName(Type type, string readable, GameMemberKind kind = GameMemberKind.Method)
+ {
+ if (type == null) throw new ArgumentNullException(nameof(type));
+ if (readable == null) throw new ArgumentNullException(nameof(readable));
+ string key = kind switch
+ {
+ GameMemberKind.Method => "method",
+ GameMemberKind.Field => "field",
+ GameMemberKind.Property => "property",
+ GameMemberKind.Event => "event",
+ _ => throw new ArgumentOutOfRangeException(nameof(kind))
+ };
+ const BindingFlags all = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
+ var reflected = kind switch
+ {
+ GameMemberKind.Method => type.GetMethods(all).Cast(),
+ GameMemberKind.Field => type.GetFields(all).Cast(),
+ GameMemberKind.Property => type.GetProperties(all).Cast(),
+ GameMemberKind.Event => type.GetEvents(all).Cast(),
+ _ => throw new ArgumentOutOfRangeException(nameof(kind))
+ };
+ var names = reflected.Where(m => Matches(m, key, readable)).Select(m => m.Name).Distinct().ToArray();
+ if (names.Length == 0) return readable;
+ if (names.Length != 1) throw new AmbiguousMatchException(type.FullName + "." + readable + ": supply the member signature");
+ return names[0];
+ }
+ /// Returns the actual CLR method name for APIs that accept strings.
+ public static string MethodName(MethodInfo method) => method?.Name ?? throw new ArgumentNullException(nameof(method));
+ /// Tests a reflected method against its readable name, preserving overload identity.
+ public static bool IsGameMethod(this MethodInfo method, string readable) => Matches(method, "method", readable);
+ /// Translates a readable parameter name using the method declaration; unknown names remain unchanged.
+ public static string ParameterName(MethodBase method, string readable)
+ {
+ if (method == null) throw new ArgumentNullException(nameof(method));
+ if (readable == null) throw new ArgumentNullException(nameof(readable));
+ if (method.DeclaringType.Assembly.GetName().Name == Names.Value.Table.assembly_name && Names.Value.Tokens.TryGetValue(method.MetadataToken, out var entry))
+ {
+ var p = entry.parameters.SingleOrDefault(n => n.readable == readable);
+ if (p != null) return p.original;
+ }
+ return readable;
+ }
+
+ /// Extracts a MethodInfo from a call expression without executing the expression.
+ public static MethodInfo Method(Expression> expression) => Call(expression);
+ /// Extracts a MethodInfo from a call expression without executing the expression.
+ public static MethodInfo Method(Expression expression) => Call(expression);
+ /// Extracts a property getter from an expression without evaluating the property.
+ public static MethodInfo Getter(Expression> expression) => PropertyGetter(expression);
+ /// Extracts a property getter from an expression without evaluating the property.
+ public static MethodInfo Getter(Expression> expression) => PropertyGetter(expression);
+
+ private static MethodInfo Call(LambdaExpression expression)
+ {
+ if (expression == null) throw new ArgumentNullException(nameof(expression));
+ return expression.Body is MethodCallExpression call ? call.Method : throw new ArgumentException("Expected a method call", nameof(expression));
+ }
+ private static MethodInfo PropertyGetter(LambdaExpression expression)
+ {
+ if (expression == null) throw new ArgumentNullException(nameof(expression));
+ return expression.Body is MemberExpression member && member.Member is PropertyInfo property
+ ? property.GetGetMethod(true) : throw new ArgumentException("Expected a property access", nameof(expression));
+ }
+
+ private static T Cached(Type type, string kind, string readable, BindingFlags flags, Type[] parameters, Func resolve) where T : MemberInfo
+ {
+ if (readable == null) throw new ArgumentNullException(nameof(readable));
+ if (type == null) return null;
+ string key = type.AssemblyQualifiedName + "|" + kind + "|" + readable + "|" + (int)flags + "|" + (parameters == null ? "*" : string.Join(";", parameters.Select(p => p.AssemblyQualifiedName)));
+ if (MemberCache.TryGetValue(key, out var cached)) return (T)cached;
+ T found = resolve();
+ if (found != null) MemberCache.TryAdd(key, found);
+ return found;
+ }
+ /// Finds a method by readable name and binding flags. Returns null when absent; ambiguous matches throw.
+ public static MethodInfo GetGameMethod(this Type type, string readable, BindingFlags flags) => Cached(type, "method", readable, flags, null,
+ () => Single(type.GetMethods(flags).Where(m => Matches(m, "method", readable)), type, readable));
+ /// Finds a method by readable name and binding flags. Returns null when absent; ambiguous matches throw.
+ public static MethodInfo GetGameMethod(this Type type, string readable, BindingFlags flags, Binder binder, Type[] parameters, ParameterModifier[] modifiers)
+ {
+ if (readable == null) throw new ArgumentNullException(nameof(readable));
+ if (parameters == null) throw new ArgumentNullException(nameof(parameters));
+ if (parameters.Any(p => p == null)) throw new ArgumentException("Parameter types cannot contain null", nameof(parameters));
+ if (type == null) return null;
+ MethodInfo Resolve()
+ {
+ var candidates = type.GetMethods(flags).Where(m => Matches(m, "method", readable)).ToArray();
+ if (candidates.Length == 0) return null;
+ return (MethodInfo)(binder ?? Type.DefaultBinder).SelectMethod(flags, candidates, parameters, modifiers);
+ }
+ // Custom binders/modifiers can affect resolution; do not cache those calls.
+ if (binder != null || modifiers != null) return Resolve();
+ return Cached(type, "method", readable, flags, parameters, Resolve);
+ }
+ private static T Single(IEnumerable members, Type type, string readable) where T : MemberInfo
+ {
+ var candidates = members.Take(2).ToArray();
+ if (candidates.Length > 1) throw new AmbiguousMatchException(type.FullName + "." + readable + ": supply the member signature");
+ return candidates.FirstOrDefault();
+ }
+ /// Finds a field by readable name and binding flags. Returns null when absent.
+ public static FieldInfo GetGameField(this Type type, string readable, BindingFlags flags) => Cached(type, "field", readable, flags, null,
+ () => Single(type.GetFields(flags).Where(m => Matches(m, "field", readable)), type, readable));
+ /// Finds a property by readable name and binding flags. Returns null when absent; ambiguous matches throw.
+ public static PropertyInfo GetGameProperty(this Type type, string readable, BindingFlags flags) => Cached(type, "property", readable, flags, null,
+ () => Single(type.GetProperties(flags).Where(m => Matches(m, "property", readable)), type, readable));
+ /// Finds an event by readable name and binding flags. Returns null when absent.
+ public static EventInfo GetGameEvent(this Type type, string readable, BindingFlags flags) => Cached(type, "event", readable, flags, null,
+ () => Single(type.GetEvents(flags).Where(m => Matches(m, "event", readable)), type, readable));
+
+ /// Validate plugin/table version, binary fingerprint and known metadata entries before installing patches.
+ public static void Validate(Assembly plugin, Action log = null) => Validate(plugin, GameVersion, log);
+
+ /// Validates only the game binary against the embedded table for plugins that do not use the compiler SDK.
+ public static void ValidateGame(Action log = null) => ValidateCore(null, GameVersion, log);
+
+ /// Validates a compiler SDK plugin, its expected game version, the table and the game binary. Throws on mismatch.
+ public static void Validate(Assembly plugin, string expectedVersion, Action log)
+ {
+ if (plugin == null) throw new ArgumentNullException(nameof(plugin));
+ if (expectedVersion == null) throw new ArgumentNullException(nameof(expectedVersion));
+ ValidateCore(plugin, expectedVersion, log);
+ }
+
+ private static void ValidateCore(Assembly plugin, string expectedVersion, Action log)
+ {
+ try
+ {
+ var table = Names.Value.Table;
+ string stamp = table.game_version + "|" + table.assembly_sha256 + "|" + table.mapping_sha256;
+ var metadata = plugin?.GetCustomAttributes().SingleOrDefault(a => a.Key == "BD2.GameNames");
+ if (expectedVersion != table.game_version || plugin != null && metadata?.Value != stamp)
+ throw new InvalidDataException("plugin/table mismatch; rebuild the plugin and BD2.GameNames together");
+ lock (ValidationLock)
+ {
+ if (ValidatedStamp != stamp)
+ {
+ var assembly = GameAssembly();
+ if (assembly.ManifestModule.ModuleVersionId.ToString() != table.assembly_mvid)
+ throw new InvalidDataException("Assembly-CSharp MVID mismatch");
+ using (var sha = SHA256.Create())
+ using (var stream = File.OpenRead(assembly.Location))
+ {
+ string actual = BitConverter.ToString(sha.ComputeHash(stream)).Replace("-", "").ToLowerInvariant();
+ if (actual != table.assembly_sha256) throw new InvalidDataException("Assembly-CSharp SHA-256 mismatch");
+ }
+ const BindingFlags all = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
+ var app = FindType("AppManager") ?? throw new TypeLoadException("AppManager");
+ var intro = FindType("IntroUI") ?? throw new TypeLoadException("IntroUI");
+ var network = FindType("BDNetwork.NetworkManager") ?? throw new TypeLoadException("BDNetwork.NetworkManager");
+ if (app.GetGameProperty("IsPlatformLogin", all)?.PropertyType != typeof(bool) ||
+ intro.GetGameMethod("SendMaintenanceInfo", all, null, new[] { typeof(bool) }, null) == null ||
+ network.GetGameMethod("GetPachedGameDataPath", all, null, Type.EmptyTypes, null)?.ReturnType != typeof(string))
+ throw new MissingMemberException("known game-name probes failed");
+ ValidatedStamp = stamp;
+ }
+ }
+ log?.Invoke("BD2.GameNames self-check passed: game=" + table.game_version + ", MVID=" + table.assembly_mvid);
+ }
+ catch (Exception ex)
+ {
+ log?.Invoke("BD2.GameNames SELF-CHECK FAILED: expected game=" + expectedVersion + "; " + ex.Message + "; game patches will not be installed");
+ throw;
+ }
+ }
+}
diff --git a/plugins/GameNames/GameMemberKind.cs b/plugins/GameNames/GameMemberKind.cs
new file mode 100644
index 0000000..9830587
--- /dev/null
+++ b/plugins/GameNames/GameMemberKind.cs
@@ -0,0 +1,14 @@
+namespace BD2.GameNames;
+
+/// Specifies the kind of game member whose readable name should be resolved.
+public enum GameMemberKind
+{
+ /// A method, including a coroutine entry point.
+ Method,
+ /// A field.
+ Field,
+ /// A property.
+ Property,
+ /// An event.
+ Event
+}
diff --git a/plugins/GameNames/GameNames.csproj b/plugins/GameNames/GameNames.csproj
new file mode 100644
index 0000000..1a2a9a7
--- /dev/null
+++ b/plugins/GameNames/GameNames.csproj
@@ -0,0 +1,27 @@
+
+
+
+ netstandard2.0
+ latest
+ BD2.GameNames
+ disable
+ false
+ true
+ none
+ $(BaseIntermediateOutputPath)=/_/BD2.GameNames/obj,$(MSBuildProjectDirectory)=/_/BD2.GameNames
+ BD2.GameNames
+ Readable game-name resolution, reflection helpers and compatibility validation for Brown Dust II plugins. Includes a version-locked names table.
+ BD2;BrownDust;Unity;BepInEx;Harmony;modding
+ true
+ 1.0.0.0
+ $(MSBuildThisFileDirectory)Mappings/names.json
+
+
+
+
+
+
+
+
+
+
diff --git a/plugins/GameNames/Mappings/names.json.gz b/plugins/GameNames/Mappings/names.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..b41384a499991b101012baaa04b2eccb64c8da7a
GIT binary patch
literal 3443819
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