freeguy2006 Claude Opus 4.8 (1M context) commited on
Commit
0c167c4
·
1 Parent(s): b11b2b5

feat(sanctus): 新增 Sanctus 5 關路線(能量×技能×意圖)+ 地圖敵人詳情 + 資源分類

Browse files

- battle-core: foes.ts(Sanctus 5 關曲線/技能/AI/意圖預告)、審判反傷(無視 DEF・無上限)、Aegis 護盾、能量系統;createGame 加 campaign 路線分流(史萊姆 11 / Sanctus 5),既有系統不受影響
- web: 地圖兩路線 + 敵人詳情面板、戰鬥敵人能量格子/意圖/盾、破關畫面依路線顯示、戰士圖卡移除疊字、UI 去 emoji
- resources: public/resources 分類成 cards/、monsters/(slime,sanctus)、barbarian/CardBack(走 LFS)
- 一併提交先前未提交的 server/卡牌/guide/nameFilter 等工作
- 342 測試全綠、typecheck/build 通過

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

This view is limited to 50 files because it contains too many changes.   See raw diff
Files changed (50) hide show
  1. CLAUDE.md +108 -0
  2. guide/01-game-design-spec.md +6 -2
  3. guide/04-data-schemas-and-api.md +5 -1
  4. guide/13-barbarian-design.md +1 -1
  5. guide/barbarian-original-spec.md +162 -0
  6. packages/battle-core/data/cards.json +57 -13
  7. packages/battle-core/package.json +1 -0
  8. packages/battle-core/scripts/class-output-sim.ts +175 -0
  9. packages/battle-core/scripts/gen-seed-ghost.ts +214 -0
  10. packages/battle-core/scripts/sanctus-trace.ts +42 -0
  11. packages/battle-core/src/data/cards.ts +51 -10
  12. packages/battle-core/src/deck.ts +1 -1
  13. packages/battle-core/src/effects.ts +2 -7
  14. packages/battle-core/src/engine.ts +22 -8
  15. packages/battle-core/src/foes.ts +206 -0
  16. packages/battle-core/src/index.ts +14 -0
  17. packages/battle-core/src/nameFilter.ts +141 -0
  18. packages/battle-core/src/opponent.ts +28 -7
  19. packages/battle-core/src/player.ts +48 -9
  20. packages/battle-core/src/types.ts +22 -5
  21. packages/battle-core/src/version.ts +1 -1
  22. packages/battle-core/test/barbarian.test.ts +26 -32
  23. packages/battle-core/test/battle-core.test.ts +9 -0
  24. packages/battle-core/test/ghost.test.ts +14 -3
  25. packages/battle-core/test/nameFilter.test.ts +98 -0
  26. packages/battle-core/test/preview-cost.test.ts +62 -0
  27. packages/battle-core/test/sanctus.test.ts +134 -0
  28. packages/server/src/ghostService.ts +6 -0
  29. packages/server/src/pvpMatch.ts +5 -0
  30. packages/server/src/repository.ts +15 -2
  31. packages/server/src/server.ts +6 -1
  32. packages/web/public/resources/barbarian/CardBack.png +3 -0
  33. packages/web/public/resources/{0.png → cards/0.png} +0 -0
  34. packages/web/public/resources/{1.png → cards/1.png} +0 -0
  35. packages/web/public/resources/{10.png → cards/10.png} +0 -0
  36. packages/web/public/resources/{11.png → cards/11.png} +0 -0
  37. packages/web/public/resources/{12.png → cards/12.png} +0 -0
  38. packages/web/public/resources/{13.png → cards/13.png} +0 -0
  39. packages/web/public/resources/{14.png → cards/14.png} +0 -0
  40. packages/web/public/resources/{15.png → cards/15.png} +0 -0
  41. packages/web/public/resources/{16.png → cards/16.png} +0 -0
  42. packages/web/public/resources/{17.png → cards/17.png} +0 -0
  43. packages/web/public/resources/{18.png → cards/18.png} +0 -0
  44. packages/web/public/resources/{19.png → cards/19.png} +0 -0
  45. packages/web/public/resources/{2.png → cards/2.png} +0 -0
  46. packages/web/public/resources/{20.png → cards/20.png} +0 -0
  47. packages/web/public/resources/{21.png → cards/21.png} +0 -0
  48. packages/web/public/resources/{22.png → cards/22.png} +0 -0
  49. packages/web/public/resources/{23.png → cards/23.png} +0 -0
  50. packages/web/public/resources/{24.png → cards/24.png} +0 -0
CLAUDE.md ADDED
@@ -0,0 +1,108 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # CLAUDE.md
2
+
3
+ This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
4
+
5
+ > 溝通與註解一律用**繁體中文**(整個 codebase 皆如此)。
6
+
7
+ ## 這是什麼
8
+
9
+ 卡牌 Rogue-like 的 TypeScript / React / Node 重製版(原版為 C++)。單人闖 11 關打逐關變強的怪物、每關三選一加卡;第 12 關打別人存檔產生的「鬼影」;另有即時 PvP。
10
+
11
+ - **規則的唯一事實來源是 [`guide/`](guide/)**(中文規格,逐項抽取自原版程式)。原版 C++ 在 `../Lengend-of-Strategy-Card-Game-/`,**凍結不動、不讀不改**。
12
+ - 推薦先讀 `guide/HANDOFF.md` → `guide/01-game-design-spec.md`(規則)→ `guide/03-architecture.md`(架構)→ `guide/04-data-schemas-and-api.md`(型別/API)。
13
+ - ⚠️ `guide/00-roadmap.md`、`HANDOFF.md` 等是**早期規格**,部分敘述(如「尚未開工」)已過時。**程式碼是實作現況的事實來源**:battle-core 規則引擎、鬼影、PvP、野蠻人職業皆已落地(見 `src/version.ts` 的 `RULE_VERSION`,目前 `1.2.0`)。
14
+
15
+ ## 指令(一律在 `worst-card-game/` 根目錄執行;Node ≥ 20)
16
+
17
+ ```bash
18
+ npm install # 安裝 workspaces
19
+ npm test # 跑所有套件測試(主要是 battle-core 的 vitest,含 golden 測試)
20
+ npm run typecheck # 全套件型別檢查(最快抓錯的一步)
21
+ npm run build # 編譯全套件(battle-core 先,web/server 吃其 dist)
22
+ npm run dev # 啟前端 vite dev(:5173,proxy /api 與 /ws 到 :3001)
23
+ npm run dev:server # 啟後端 fastify(tsx watch,:3001)
24
+ ```
25
+
26
+ PvP / 鬼影要兩個都開:一個終端 `npm run dev:server`,另一個 `npm run dev`。
27
+
28
+ battle-core 專屬(在根目錄用 `-w` 指定):
29
+
30
+ ```bash
31
+ npm run test:watch -w @wcg/battle-core # 規則層 watch 模式(改規則時常駐)
32
+ npm run build -w @wcg/battle-core # 只重建 battle-core 的 dist
33
+ npm run gen:cards -w @wcg/battle-core # 由 src/data/cards.ts 產生 data/cards.json(改卡後必跑)
34
+ npm run gen:ghost -w @wcg/battle-core # 產生種子鬼影
35
+ # 跑單一測試檔 / 單一案例(vitest):
36
+ npx vitest run packages/battle-core/test/golden.test.ts
37
+ npx vitest run -t "G4" # 用測試名稱過濾
38
+ ```
39
+
40
+ CI(`.github/workflows/ci.yml`)只跑三步:`npm run build -w @wcg/battle-core` → `npm run typecheck` → `npm test`。送 PR 前本機跑這三步即綠。
41
+
42
+ ## 架構:三層分離(最高原則)
43
+
44
+ ```
45
+ battle-core(純規則引擎,零相依、決定性、可注入種子,不碰畫面/網路)
46
+ ▲ import ▲ import
47
+ web(React 前端) ◀─HTTP/WS─▶ server(Fastify:鬼影 REST + PvP WebSocket,權威解算)
48
+ ```
49
+
50
+ **單機 / 鬼影 / PvP 三模式共用同一份 battle-core**。模式差異只能透過:
51
+ 1. `cards.json` 的 `modeOverride.PVP`(卡的 PvP 數值覆寫),或
52
+ 2. 薄協調層(server 的 `pvpHub` / `pvpMatch`)。
53
+
54
+ **嚴禁在 core 內寫 `if (isPvp)` 之類分叉規則。** 職業差異也不在 core 內散落 `if (classType)`,而是集中在 `classes.ts` 的 `CLASS_INIT` 行為旗標(`hasDef` / `handAlwaysFull` / `hasCoinGate`)。
55
+
56
+ ### battle-core(`packages/battle-core/`)— 純規則引擎
57
+
58
+ - 對外只透過 `src/index.ts`。核心是 `createGame(opts)` 與 `step(state, action)`:**純函式,同輸入→同輸出**。`step()` 先 `structuredClone` 再在副本上改,確保零副作用、可重播。`replay(seed, actions)` 供後端反作弊重算。
59
+ - **一切亂數走可種子化 PRNG**(`rng.ts` 的 `makeRng`/`shuffle`),`RngState = { seed, cursor }`。**core 內絕不可用 `Math.random()`**——否則破壞決定性,鬼影/PvP 重算會對不上。亂數消費順序固定。
60
+ - `GameState`(見 `types.ts`)是純可序列化資料。`Action`:`PLAY_CARD` / `END_TURN` / `PICK_REWARD` / `CHOOSE_CARDS`。`BattlePhase`:`PLAYER_TURN` / `PENDING_CHOICE`(互動選牌暫停態)/ `REWARD_SELECT` / `GAME_OVER` / `VICTORY`。
61
+ - 檔案分工:`engine.ts`(流程/回合結算/獎勵/關卡推進)、`player.ts`(出牌 PlayCardLogic、回合結算、互動選牌)、`effects.ts`(EffectOp 指令集解譯)、`opponent.ts`(怪物 + 鬼影 GhostOpponent)、`deck.ts`(抽牌/洗牌)、`pileView.ts`(三堆檢視)、`pvp*.ts`(PvP 結算/抽牌/數值)、`progress.ts`(升級鏈)。
62
+ - **卡牌是純資料**:每張卡 = `onPlay[]` + `onCombo[]`(外加 `onDraw`/`onChosen`/`playableIf` 等互動鉤子),由有限的 `EffectOp` 指令集表達(`ADD_ATK` / `SET_FLAG` / `IF` / `BRANCH_NEXT_TAG` …)。`ValueExpr` 可寫動態值(`Combo*2`、`floor(effMaxHp*3/10)`…)。新增行為儘量組合既有 op,必要時才擴 op。
63
+ - **卡表單一事實來源 = `src/data/cards.ts`**(型別化 TS)。`data/cards.json` 是**衍生物**��由 `npm run gen:cards` 產生,勿手改。
64
+
65
+ ### 兩段式效果(整個遊戲最關鍵、最易出錯的機制)
66
+
67
+ 每張卡有兩段效果,觸發時機不同:
68
+ - **即時效果 `onPlay`**:打出當下立刻結算(每次成功出牌都跑)。
69
+ - **連擊效果 `onCombo`**:屬於「**上一張卡**」,要等下一張**成功接上**才結算——即**延遲一張**。連擊中斷或回合結束 → 最後一張的 `onCombo` **不結算**。
70
+
71
+ 實作上由 `pendingComboCardId` 記住上一張待結算的卡。改動出牌/連擊邏輯時,務必先讀 `guide/01-game-design-spec.md §3-§4` 與對應 golden 測試(`test/golden.test.ts` 的 G1/G2)。
72
+
73
+ ### 職業(`classType`)
74
+
75
+ - `WARRIOR`(0-40 號卡,對應 `web/public/resources/cards/<id>.png`):硬幣啟動連擊、依標籤(A 攻 / B 守 / Any / None)串連、每 5 連抽 1。
76
+ - `BARBARIAN`(100-191 號卡,白底文字卡無圖):**無 DEF、無硬幣/連擊/標籤閘門、手牌恆滿**;核心是「每出 1 張先 `n+1` 再扣 `n` 點 HP」的自傷曲線,加上臨時血量上限(`tempMaxHp`)、token 衍生卡、真實傷害、跨戰計數、互動選牌、條件變形鏈、特殊勝利(蓄力 ×15)、復活等機制。設計見 `guide/13-barbarian-design.md`。
77
+ - 各職業**卡池完全獨立、不可混用**。
78
+
79
+ ### server(`packages/server/`)— 鬼影 REST + PvP
80
+
81
+ - 入口 `index.ts` → `server.ts` 的 `buildServer()`(Fastify)。監聽 `PORT ?? 3001`。
82
+ - 鬼影 REST:`POST /api/ghosts`(破關上傳,含 per-IP 速率限制 + 形狀驗證 + 可選重播驗證)、`GET /api/ghosts/random`(第 12 關抽鬼影,無存檔回 204)。
83
+ - **PvP 走 `/ws/pvp` WebSocket,server 為唯一權威**:四相狀態機 `PLAN → LOCK → RESOLVE → ADVANCE`(同時暗回合,消先手優勢),協調層在 `pvpHub.ts`(房間/配對/draft/rematch)與 `pvpMatch.ts`,**解算仍呼叫 core 的 `pvpResolve`**。**seed 絕不下發 client**(會洩漏牌序/擲骰)。
84
+ - 鬼影儲存(`repository.ts`):預設 `/tmp/ghosts.json`(短暫,重啟清空);設了 `UPSTASH_REDIS_REST_URL` + `_TOKEN` 則改用 Upstash Redis 永久保存。
85
+ - 部署時設 `WEB_ROOT` → 同進程用 `@fastify/static` 服務前端靜態檔(單容器、同源免 CORS)。
86
+
87
+ ### web(`packages/web/`)— React + Vite
88
+
89
+ - `App.tsx` 是單檔狀態機(`start` / `select` / `map` / `playing` / `pvp` 畫面),**直接在 client 跑 battle-core**(單機/鬼影本機即時跑,體驗流暢);PvP 則透過 `pvpClient.ts` 連 WebSocket,由 server 權威解算。
90
+ - battle-core 以**原始碼**形式被 import(workspace),Vite 直接吃 TS。dev proxy 把 `/api`、`/ws` 導到 `:3001`。
91
+ - **三堆檢視(deck/discard/burn)只能給合併計數、絕不洩漏順序**(順序=預告下一張抽牌)。PvP 尤其:永不把有序 deck 或 seed 給 client。用 `pileView()`。
92
+
93
+ ## 開發鐵則(最容易踩雷之處)
94
+
95
+ - **改了 core 沒效果?** web/server 在 dev 下吃原始碼,但 build/部署吃 `dist`——改完 core 要 `npm run build -w @wcg/battle-core`(CI 與 Docker 都先 build battle-core)。
96
+ - **改卡牌?** 只改 `src/data/cards.ts`,然後 `npm run gen:cards` 重產 `data/cards.json`,並視語意變更在 `src/version.ts` bump `RULE_VERSION`(鬼影/PvP 存檔靠它與 `CARDS_HASH` 判斷是否降級不校驗)。
97
+ - **出牌順序**:永遠「先把牌移出手牌,再結算效果」。
98
+ - **測試釘的是「應然」(規格),不是「現況」**:規格與原版行為衝突時,以 `guide/` 的修訂為準(例:重擊強制結束改採 §4.6、鬼影 DEF 不外推)。新增卡/規則要同步補 golden 測試與 `guide/02`、`guide/08`、`guide/09`。
99
+ - **`maxLevel` 是除錯旋鈕**(`createGame` 選項,預設 11):除錯可設小(如 3)秒到最後一關驗證破關/結算/鬼影串接,**正式版務必維持 11,勿把除錯值帶上線**。所有「最後一關」判斷讀 `state.maxLevel`,不寫死數字。
100
+
101
+ ## 部署
102
+
103
+ 單容器(`Dockerfile`,HuggingFace Spaces Docker SDK):build 三套件 → `node packages/server/dist/index.js` 監聽 `7860`,同進程服務前端 + `/api` + `/ws`。細節與環境變數見 `DEPLOY.md`。本機驗證 production 行為:
104
+
105
+ ```bash
106
+ npm run build -w @wcg/battle-core && npm run build -w @wcg/web && npm run build -w @wcg/server
107
+ WEB_ROOT="$PWD/packages/web/dist" PORT=7860 node packages/server/dist/index.js
108
+ ```
guide/01-game-design-spec.md CHANGED
@@ -194,12 +194,16 @@
194
  | 情況 | 攻擊 | 防禦 |
195
  |---|---|---|
196
  | `n ≤ k`(紀錄內) | `atk[n]` | `def[n]` |
197
- | `n > k`(紀錄用完) | `平均atk + n` | `平均def + n` |
198
  | 完全沒有任何存檔 | 退化成預設怪物 | 同左 |
199
 
200
  - 「平均」是**固定值**:永遠用存檔那 `k` 筆算出來,不隨外推變動。
201
  - 鬼影血量 = 存檔那位玩家的 maxHP。
202
- - 設計目的:紀錄用完後越打越痛,逼戰鬥盡快結束,避免無限拖。
 
 
 
 
203
  - 詳細範例見原版 [`../Lengend-of-Strategy-Card-Game-/PLAN.md`](../Lengend-of-Strategy-Card-Game-/PLAN.md) 第三節。
204
 
205
  ---
 
194
  | 情況 | 攻擊 | 防禦 |
195
  |---|---|---|
196
  | `n ≤ k`(紀錄內) | `atk[n]` | `def[n]` |
197
+ | `n > k`(紀錄用完) | `平均atk + n` | `平均def`(**固定,不加 n**) |
198
  | 完全沒有任何存檔 | 退化成預設怪物 | 同左 |
199
 
200
  - 「平均」是**固定值**:永遠用存檔那 `k` 筆算出來,不隨外推變動。
201
  - 鬼影血量 = 存檔那位玩家的 maxHP。
202
+ - 設計目的:紀錄用完後**攻擊**越打越痛,逼戰鬥盡快結束,避免無限拖。
203
+ - ⚠ **防禦不外推(2026 修正)**:原版/舊 spec 對 DEF 也用 `平均def + n`,但這會讓鬼影防禦每回合 +1 直到
204
+ 超過玩家攻擊力 → 變成「永遠打不死」的無敵怪,且出現紀錄裡從未有過的合成防禦值(玩家會看到「顯然
205
+ 不可能是過 11 關的人打出來的數值」)。逼速戰的壓力交給 ATK 即可,故 DEF 外推固定在 `平均def`,
206
+ 確保鬼影永遠可被擊殺。(實作:`opponent.ts` `ghostTurnValues`。)
207
  - 詳細範例見原版 [`../Lengend-of-Strategy-Card-Game-/PLAN.md`](../Lengend-of-Strategy-Card-Game-/PLAN.md) 第三節。
208
 
209
  ---
guide/04-data-schemas-and-api.md CHANGED
@@ -161,9 +161,13 @@ interface GhostRecord {
161
  **鬼影出招計算**(GhostOpponent;`k = turns.length`,平均為固定值):
162
  - 第 n 回合(n 從 1):
163
  - `n <= k` → `atk = turns[n-1].atk`,`def = turns[n-1].def`
164
- - `n > k` → `atk = avgAtk + n`,`def = avgDef + n`(avg 用 k 筆固定算出)
165
  - 沒有任何鬼影 → 用預設怪物。
166
 
 
 
 
 
167
  ---
168
 
169
  ## 5. API(模式 A,REST,極簡)
 
161
  **鬼影出招計算**(GhostOpponent;`k = turns.length`,平均為固定值):
162
  - 第 n 回合(n 從 1):
163
  - `n <= k` → `atk = turns[n-1].atk`,`def = turns[n-1].def`
164
+ - `n > k` → `atk = avgAtk + n`,`def = avgDef`(**DEF 固定,不加 n**;avg 用 k 筆固定算出)
165
  - 沒有任何鬼影 → 用預設怪物。
166
 
167
+ > ⚠ DEF 外推固定在 `avgDef`(2026 修正):若比照 ATK 用 `avgDef + n`,鬼影防禦會無限上升 →
168
+ > 超過玩家攻擊力後變「永遠打不死」的無敵怪,且是紀錄裡從未出現過的合成數值。逼速戰交給 ATK,
169
+ > DEF 不外推,確保鬼影恆可被擊殺。詳見 `01` §9 與 `opponent.ts` `ghostTurnValues`。
170
+
171
  ---
172
 
173
  ## 5. API(模式 A,REST,極簡)
guide/13-barbarian-design.md CHANGED
@@ -1,7 +1,7 @@
1
  # 野蠻人實作藍圖(Barbarian Implementation Blueprint)
2
 
3
  ## ★ 已拍板決策(2026-06-21,覆寫下方建議)
4
- 1. **專注 token**:`isToken + exhaust`(使用後進消耗堆)。**抽到即自動釋放**(on-draw 觸發,**不計入出牌數 n、不扣血**),效果=**臨時血量上限 +1**(依機制2 同時回 1 HP)。→ 需在 `drawCards` 加 on-draw hook(轉世之門/萬象寂滅同此管道)。
5
  2. **野蠻人出牌限制**:**全部取消**——無起手硬幣、無連擊、無 A/B 標籤鎖。手牌恆滿、隨意出牌,唯一代價是 n 扣血。
6
  3. **傷害模型**:多數「造成 X 傷害」**併入回合總攻擊**(`ADD_ATK`,過 DEF/倍率一次結算);僅真實傷害/抽到即傷用即時管道。多段攻擊折算成總和。
7
  4. **變數 n 扣血**:**野蠻人沒有 DEF**(不吃 DEF 機制、受傷不減免);每成功出 1 張先 +1 再**直接扣 n 點 HP**;「因出牌失去的血」只計 n 自傷。回合/戰鬥結束 n 歸 0。
 
1
  # 野蠻人實作藍圖(Barbarian Implementation Blueprint)
2
 
3
  ## ★ 已拍板決策(2026-06-21,覆寫下方建議)
4
+ 1. **專注 token**:`isToken + exhaust`(使用後進消耗堆)。**抽到即自動釋放**(on-draw 觸發,**不計入出牌數 n、不扣血**),效果=**臨時血量上限 +2**(依機制2 同時回 2 HP)。→ 需在 `drawCards` 加 on-draw hook(轉世之門/萬象寂滅同此管道)。
5
  2. **野蠻人出牌限制**:**全部取消**——無起手硬幣、無連擊、無 A/B 標籤鎖。手牌恆滿、隨意出牌,唯一代價是 n 扣血。
6
  3. **傷害模型**:多數「造成 X 傷害」**併入回合總攻擊**(`ADD_ATK`,過 DEF/倍率一次結算);僅真實傷害/抽到即傷用即時管道。多段攻擊折算成總和。
7
  4. **變數 n 扣血**:**野蠻人沒有 DEF**(不吃 DEF 機制、受傷不減免);每成功出 1 張先 +1 再**直接扣 n 點 HP**;「因出牌失去的血」只計 n 自傷。回合/戰鬥結束 n 歸 0。
guide/barbarian-original-spec.md ADDED
@@ -0,0 +1,162 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ 新職業:野蠻人特性如下
2
+ 單人初始血量:130
3
+ pvp初始血量:260
4
+
5
+ 機制說明:
6
+ 1.手牌永遠保持上限(打出牌後會自動抽牌)
7
+ 2.有「臨時血量上限機制」,增加臨時血量上限時同時回復等量hp(相當於 餘裕 的運作模式)
8
+ 3.單人模式的臨時血量上限會在戰鬥勝利後消失,其中20%會轉為永久的血量上限
9
+ 4.具有塞入Token卡的機制:Token卡中「專注」跟「蓄力」跟「轉世之門」會在每場戰鬥結束時消失(不論其在抽牌棄牌或消耗牌堆中都消失)
10
+ 5.有變數n存放當回合所打牌數,每打一張牌+1,並扣除玩家n點hp,回合結束及戰鬥結束時歸零。
11
+ 6.衍生卡不會是玩家可選擇的卡(不在卡池中),只有在滿足特定條件後才會出現。
12
+
13
+ 卡牌製作說明:
14
+ 由於製作卡片耗費時間長。此角色卡片先以web裡面的public中的barbarian裡的CardBack為主,將每張卡都以此基底表示。希望可以寫個程式讓它在抽取及獲取及使用卡片時,能將其對應的文字敘述放到底下卡片填字的方格中,其中「傷害:」後面的數值請填到CardBack的圓形中央格子當中。而效果說明則填到底下方格中。希望透過卡牌本身固定位置以及放大後固定的位置來讓此卡的文字說明能在正確的位置上。讓玩家雖然沒有看到卡圖,仍可以透過相關文字來使用卡片。
15
+
16
+ 以下是卡牌稀有度及相關效果文字敘述描述:
17
+
18
+ 普通:
19
+
20
+
21
+ ​凝神|傷害:4|效果:將 1 張「專注」洗入棄牌堆。若本回合出牌計數 (n) 大於等於 3,額外再洗入 1 張。
22
+
23
+ ​戰術重整|傷害:0|效果:臨時血量上限 +2,並將 1 張「專注」洗入棄牌堆。
24
+
25
+ ​雜念捨棄|傷害:2|效果:選擇並棄掉 1 張手牌,將 2 張「專注」洗入棄牌堆。
26
+
27
+ ​厚皮打擊|傷害:5|效果:將 1 張「專注」洗入棄牌堆。
28
+
29
+ ​尋思|傷害:0|效果:自身受到 3 點傷害,將 3 張「專注」洗入棄牌堆。
30
+
31
+ 重擊|傷害:7|效果:無。
32
+
33
+ 雙持狂斬|傷害:3*2|效果:無。
34
+
35
+ 嗜血|傷害:6|效果:回復 6 點 HP。
36
+
37
+ 魯莽衝撞|傷害:12|效果:自身受到 3 點額外傷害。
38
+
39
+ 狂怒|傷害:15|效果:只有在當前 HP 低於 總數(含臨時上限)30% 時才能打出。
40
+
41
+ 打擊|傷害:?|效果:傷害等於「你本回合因出牌失去的總血量」。
42
+
43
+ 咆哮|傷害:0|效果:本回合下一張攻擊卡的傷害翻倍。
44
+
45
+ 肌肉膨脹|傷害:3|效果:臨時血量上限 +3。
46
+
47
+ 突破極限|傷害:0|效果:臨時血量上限 +10,但自身受到 5 點傷害。
48
+
49
+ 沸騰之血|傷害:0|效果:造成等同於「目前總血量上限5%」的傷害。
50
+
51
+ 強運一擊‖傷害:0‖效果:從棄牌堆中隨機抽取一張牌,若其為「專注」,重複施放此卡效果(抽到不是專注為止)
52
+
53
+ 腎上腺素|傷害:0|效果:出牌計數 (n) 重置為 1,但臨時血量上限 -5。
54
+
55
+ 借力打力|傷害:?|效果:造成等同於「出牌計數 x 2」的傷害。
56
+
57
+ 以痛換力|傷害:0|效果:將出牌計數 (n) 直接提升至 5,臨時血量上限 +10。
58
+
59
+ 盲目亂揮|傷害:6|效果:隨機棄掉 1 張手牌。
60
+
61
+ 無腦傾瀉|傷害:0|效果:棄掉所有手牌(換 5 張全新的牌),自身受到 3 點傷害。
62
+
63
+ 重整|傷害:0|效果:選擇並棄掉 1 張手牌,臨時血量上限 +1。
64
+
65
+ 血腥狂歡|傷害:0|效果:打出此卡後,到本回合結束前每棄掉 1 張手牌,回復 2 點 HP。
66
+
67
+
68
+ 蠻性試煉‖傷害:0‖效果:獲取這張卡時開始計入因自身被動所受到的傷害。若總數>100,打出這張卡時將它轉成「成神試煉」。(計數不隨戰鬥結束而重置)
69
+
70
+ 衍生卡:成神試煉(焚燒)‖傷害:8‖效果:打出後當洗牌時「神性」+1。(神性不會隨結束戰鬥而重置)「神性」到20時,此卡變為「致命一擊」。
71
+
72
+ 衍生卡:致命一擊(焚燒)‖傷害 10‖效果:打出後將15張「蓄力」洗入棄牌堆。
73
+
74
+ 衍生卡:蓄力(焚燒)‖傷害:3‖效果:若打出15張蓄力,獲得特殊勝利。
75
+
76
+ 史詩:
77
+
78
+ ​
79
+ ​死境反擊|傷害:?|效果:造成等同於「你已損失的生命值 x 0.6」的傷害。
80
+
81
+ ​血祭巨刃|傷害:15|效果:若當前血量低於 40%,此卡傷害翻倍。
82
+
83
+ ​狂人亂舞|傷害:5|效果:隨機對敵人造成傷害 4 次。你每失去 20 點生命值,額外多砍一次。
84
+
85
+ ​飲血巨斧|傷害:12|效果:回復等同於「此卡造成傷害 50%」的生命值。
86
+
87
+ ​痛苦共鳴|傷害:0|效果:本回合你每次因出牌扣血時,敵人受到等量的真實傷害。
88
+ ​
89
+ ​泰坦之血|傷害:0|效果:臨時血量上限+20。
90
+
91
+ ​血肉燃燒|傷害:0|效果:失去所有「臨時血量上限」,每失去 1 點對敵人造成 2 點傷害。
92
+
93
+ ​巨��咆哮|傷害:10|效果:你的當前「最大生命值(含臨時上限)」每有 50 點,額外造成 5 點傷害。
94
+
95
+ ​沸騰轉換|傷害:0|效果:將當前出牌計數 (n) 的數值乘上 3,轉化為臨時血量上限。
96
+
97
+
98
+ 無畏的莽撞衝鋒‖傷害:5‖效果:此卡攻擊次數等同本局(會因戰鬥結束重置)打出的次數。
99
+
100
+ ​生命汲取|傷害:8|效果:將此卡造成的傷害 100% 轉化為臨時血量上限。
101
+ ​
102
+ ​痛覺逆轉|傷害:0|效果:將目前的出牌計數 (n) 轉化為生命回復(回復 n )
103
+
104
+ ​血氣連爆|傷害:10|效果:目前的出牌計數 (n) 每有 3點,這張牌就自動額外打出 1 次。
105
+
106
+ ​死神擦肩|傷害:0|效果:將出牌計數 (n) 強制鎖定在 1,持續接下來的 3 次出牌。
107
+
108
+ ​千刀萬剮|傷害:?|效果:傷害等於 n x 3。打出後出牌計數 n 額外 +2。
109
+
110
+ ​血腥連結|傷害:0|效果:本回合接下來你每次因出牌扣血時,敵人將受到等量的真實傷害,但你依然會受到原本的扣血效果。
111
+ ​
112
+ ​狂風掃落葉|傷害:0|效果:選擇並棄掉 3 張手牌,每棄一張對敵人造成 8 點傷害。
113
+
114
+ ​戰術捨棄|傷害:0|效果:選擇並棄掉 1 張手牌,本回合出牌計數 (n) 減少 2(最低為 1)。
115
+
116
+ ​血腥收割|傷害:10|效果:若這是本回合因「棄牌補滿」機制而抽上來的第一張牌,傷害 +15。
117
+
118
+ ​無盡怒火|傷害:0|效果:棄掉所有手牌(立刻換 5 張新牌),本回合下一張攻擊牌將會被打出兩次。
119
+
120
+ ​本能閃避|傷害:0|效果:隨機棄掉 2 張手牌,回復 15 點生命值。
121
+
122
+ ​野蠻直覺|傷害:0|效果:檢視牌堆頂的 5 張牌,將其中 1 張加入手牌(並棄掉原本一張),其餘燒毀。
123
+
124
+ ​血誓契約|傷害:0|效果:選擇手牌中的一張牌,使其本場戰鬥傷害永久 +8,但你立刻失去 8 點血。
125
+
126
+ ​野性先手|傷害:12|效果:若此卡是本回合打出的第一張牌(即 n=1 時),將 n 變為 -2(n 為負數時視為回血)。否則 n 額外 +1。
127
+
128
+ ​蠻荒震擊|傷害:18|效果:有 50% 機率讓敵人下回合造成的傷害直接減半。
129
+
130
+
131
+ ​專注湧現|傷害:0|效果:將 4 張「專注」直接洗入抽牌堆(而非棄牌堆)。本回合下一張打出的攻擊卡傷害 +4。
132
+
133
+ ​冥想重擊|傷害:0|效果:此卡造成的傷害,等同「本局戰鬥中已被消耗(進入消耗牌堆)的『專注』總張數 x 2」。
134
+ ​
135
+ ​心流狂暴|傷害:0|效果:打出此卡後,本回合每當你抽到並釋放「專注」時,除了原本的加血上限效果,額外對敵人造成 3 點真實傷害。
136
+
137
+ ​殘響喚醒|傷害:0|效果:從消耗牌堆(Burn Pile)中,將最多 3 張「專注」洗入棄牌堆。臨時血量上限 + 5。
138
+
139
+ ​雜念絕殺|傷害:0|效果:打出此卡後,強制棄掉你手牌中的其他所有卡牌。將 5張「專注」放入棄牌堆。
140
+
141
+ 傳說:
142
+
143
+ 地獄之門的殘響(焚燒)‖傷害:0‖效果:打出後本場戰鬥的專注將不再消耗。但每張專注會扣除自己1點生命值。
144
+
145
+ 輪迴轉世(焚燒)‖傷害:0‖效果:將一張「轉世之門」放入棄牌堆中,此牌在洗入抽牌堆時固定於牌堆底部出現。
146
+
147
+ 衍生:「轉世之門」‖傷害:0‖效果:抽到時自動施放,對敵人造成n點傷害,將n歸0。
148
+
149
+ 放手一搏(焚燒)‖傷害:0‖效果:本回合n的計算由增加改為減少。當n小於或等於0時,結束這回合。
150
+
151
+ Inverse(焚燒)‖傷害:0‖效果:血量和已損血量交換。
152
+
153
+ 專注斬擊‖傷害:5‖效果:將消耗牌堆中的所有「專注」全部移除。每移除一張,此卡額外攻擊一次。
154
+
155
+ 死亡前的凝視(焚燒)‖傷害:0‖效果:若在本回合死亡。則將臨時生命以1:1全數轉為玩家永久生命,並以100%總生命值復活。若觸發成功,則此卡永久移除(也不進消耗牌堆)
156
+
157
+ 反刃血鎧|傷害:0|效果:本回合中,每當你的「臨時血量上限」替你抵擋了出牌扣血 (n) 時,將該次扣血量的 2 倍轉化為對敵人的傷害。
158
+
159
+
160
+ 狂神開眼(焚燒)|傷害:0|效果:本局戰鬥剩餘時間內,每當你釋放「專注」時,除原本的加血效果外,使你本回合的出牌計數 (n) 減少 1(最低為 1,一回合最多觸發5次)。
161
+
162
+ 萬象寂滅(焚燒)|傷害:0|效果:將你棄牌堆中的隨機 5 張卡牌直接移入「消耗牌堆」。將 10 張「專注」洗入棄牌堆。
packages/battle-core/data/cards.json CHANGED
@@ -7,6 +7,7 @@
7
  "atk": 0,
8
  "def": 2,
9
  "rarity": "normal",
 
10
  "onCombo": [
11
  {
12
  "op": "DRAW",
@@ -25,6 +26,7 @@
25
  "atk": 0,
26
  "def": 0,
27
  "rarity": "normal",
 
28
  "onCombo": [
29
  {
30
  "op": "ADD_ATK",
@@ -45,6 +47,7 @@
45
  "atk": 0,
46
  "def": 4,
47
  "rarity": "normal",
 
48
  "onCombo": [
49
  {
50
  "op": "ADD_BASE_DEF",
@@ -60,6 +63,7 @@
60
  "atk": 2,
61
  "def": 0,
62
  "rarity": "normal",
 
63
  "onPlay": [
64
  {
65
  "op": "IF",
@@ -83,6 +87,7 @@
83
  "atk": 6,
84
  "def": 0,
85
  "rarity": "normal",
 
86
  "onPlay": [
87
  {
88
  "op": "SET_FLAG",
@@ -98,6 +103,7 @@
98
  "atk": 0,
99
  "def": 8,
100
  "rarity": "normal",
 
101
  "onPlay": [
102
  {
103
  "op": "LOCK_TAG",
@@ -113,6 +119,7 @@
113
  "atk": 7,
114
  "def": 0,
115
  "rarity": "normal",
 
116
  "onPlay": [
117
  {
118
  "op": "ADD_HP",
@@ -138,6 +145,7 @@
138
  "atk": 0,
139
  "def": 0,
140
  "rarity": "normal",
 
141
  "onPlay": [
142
  {
143
  "op": "RANDOM_DEF_0_8"
@@ -158,6 +166,7 @@
158
  "atk": 0,
159
  "def": 2,
160
  "rarity": "normal",
 
161
  "onCombo": [
162
  {
163
  "op": "IF",
@@ -182,6 +191,7 @@
182
  "atk": 3,
183
  "def": 0,
184
  "rarity": "normal",
 
185
  "onPlay": [
186
  {
187
  "op": "SET_FLAG",
@@ -207,6 +217,7 @@
207
  "atk": 1,
208
  "def": 0,
209
  "rarity": "normal",
 
210
  "onPlay": [
211
  {
212
  "op": "IF",
@@ -236,6 +247,7 @@
236
  "atk": 0,
237
  "def": 5,
238
  "rarity": "normal",
 
239
  "onPlay": [
240
  {
241
  "op": "SET_FLAG",
@@ -251,6 +263,7 @@
251
  "atk": 0,
252
  "def": 4,
253
  "rarity": "normal",
 
254
  "onPlay": [
255
  {
256
  "op": "IF",
@@ -275,6 +288,7 @@
275
  "atk": 5,
276
  "def": 0,
277
  "rarity": "normal",
 
278
  "onPlay": [
279
  {
280
  "op": "IF",
@@ -310,6 +324,7 @@
310
  "atk": 11,
311
  "def": 0,
312
  "rarity": "normal",
 
313
  "onPlay": [
314
  {
315
  "op": "ADD_ATK",
@@ -359,6 +374,7 @@
359
  "atk": 1,
360
  "def": 0,
361
  "rarity": "normal",
 
362
  "onPlay": [
363
  {
364
  "op": "ADD_ATK",
@@ -388,6 +404,7 @@
388
  "atk": 0,
389
  "def": 0,
390
  "rarity": "normal",
 
391
  "onCombo": [
392
  {
393
  "op": "ADD_COUNTER",
@@ -411,6 +428,7 @@
411
  "atk": 1,
412
  "def": 0,
413
  "rarity": "normal",
 
414
  "onPlay": [
415
  {
416
  "op": "ADD_MAX_HAND",
@@ -436,6 +454,7 @@
436
  "atk": 7,
437
  "def": 0,
438
  "rarity": "epic",
 
439
  "onCombo": [
440
  {
441
  "op": "ADD_ATK",
@@ -451,6 +470,7 @@
451
  "atk": 5,
452
  "def": 0,
453
  "rarity": "epic",
 
454
  "onPlay": [
455
  {
456
  "op": "IF",
@@ -475,6 +495,7 @@
475
  "atk": 4,
476
  "def": 0,
477
  "rarity": "epic",
 
478
  "onPlay": [
479
  {
480
  "op": "SET_FLAG",
@@ -490,6 +511,7 @@
490
  "atk": 1,
491
  "def": 0,
492
  "rarity": "epic",
 
493
  "onCombo": [
494
  {
495
  "op": "DRAW",
@@ -505,6 +527,7 @@
505
  "atk": 6,
506
  "def": 0,
507
  "rarity": "epic",
 
508
  "onPlay": [
509
  {
510
  "op": "SET_FLAG",
@@ -525,6 +548,7 @@
525
  "atk": 0,
526
  "def": 3,
527
  "rarity": "epic",
 
528
  "onCombo": [
529
  {
530
  "op": "ADD_DEF",
@@ -542,6 +566,7 @@
542
  "atk": 1,
543
  "def": 0,
544
  "rarity": "epic",
 
545
  "onPlay": [
546
  {
547
  "op": "ADD_ATK",
@@ -564,6 +589,7 @@
564
  "atk": 0,
565
  "def": 0,
566
  "rarity": "epic",
 
567
  "onPlay": [
568
  {
569
  "op": "ADD_ATK",
@@ -587,6 +613,7 @@
587
  "atk": 5,
588
  "def": 0,
589
  "rarity": "epic",
 
590
  "onCombo": [
591
  {
592
  "op": "ADD_BASE_ATK",
@@ -602,6 +629,7 @@
602
  "atk": 4,
603
  "def": 4,
604
  "rarity": "epic",
 
605
  "onCombo": [
606
  {
607
  "op": "ADD_DEF",
@@ -621,6 +649,7 @@
621
  "atk": 2,
622
  "def": 0,
623
  "rarity": "epic",
 
624
  "onCombo": [
625
  {
626
  "op": "SET_FLAG",
@@ -636,6 +665,7 @@
636
  "atk": 3,
637
  "def": 0,
638
  "rarity": "epic",
 
639
  "onCombo": [
640
  {
641
  "op": "ADD_ATK",
@@ -668,6 +698,7 @@
668
  "atk": 0,
669
  "def": 1,
670
  "rarity": "epic",
 
671
  "onPlay": [
672
  {
673
  "op": "ADD_DEF",
@@ -697,6 +728,7 @@
697
  "atk": 0,
698
  "def": 0,
699
  "rarity": "normal",
 
700
  "onPlay": [
701
  {
702
  "op": "RANDOM_SET",
@@ -773,6 +805,7 @@
773
  "atk": 0,
774
  "def": 1,
775
  "rarity": "epic",
 
776
  "onPlay": [
777
  {
778
  "op": "ADD_COIN",
@@ -798,6 +831,7 @@
798
  "atk": 0,
799
  "def": 15,
800
  "rarity": "legend",
 
801
  "onPlay": [
802
  {
803
  "op": "SET_FLAG",
@@ -820,7 +854,7 @@
820
  "atk": 5,
821
  "def": 0,
822
  "rarity": "legend",
823
- "exhaust": true,
824
  "onCombo": [
825
  {
826
  "op": "BRANCH_NEXT_TAG",
@@ -857,6 +891,7 @@
857
  "atk": 3,
858
  "def": 0,
859
  "rarity": "legend",
 
860
  "onPlay": [
861
  {
862
  "op": "SET_FLAG",
@@ -877,6 +912,7 @@
877
  "atk": 5,
878
  "def": 5,
879
  "rarity": "legend",
 
880
  "onPlay": [
881
  {
882
  "op": "SWAP_ATK_HP"
@@ -899,6 +935,7 @@
899
  "atk": 5,
900
  "def": 5,
901
  "rarity": "legend",
 
902
  "onPlay": [
903
  {
904
  "op": "SET_FLAG",
@@ -919,6 +956,7 @@
919
  "atk": 0,
920
  "def": 0,
921
  "rarity": "legend",
 
922
  "onPlay": [
923
  {
924
  "op": "ADD_ATK",
@@ -941,6 +979,7 @@
941
  "atk": 8,
942
  "def": 0,
943
  "rarity": "upgrade",
 
944
  "onCombo": [
945
  {
946
  "op": "ADD_COUNTER",
@@ -957,6 +996,7 @@
957
  "atk": 20,
958
  "def": 0,
959
  "rarity": "upgrade",
 
960
  "onPlay": [
961
  {
962
  "op": "ULT_WIN_CHECK"
@@ -2015,11 +2055,11 @@
2015
  "name": "野性先手",
2016
  "tag": "None",
2017
  "nextReq": "None",
2018
- "atk": 15,
2019
  "def": 0,
2020
  "rarity": "epic",
2021
- "dmgText": "15",
2022
- "desc": "造成 15 點傷害;若為本回合第一張牌,本次不扣血,否則出牌計數 n 額外 +1。",
2023
  "onPlay": [
2024
  {
2025
  "op": "IF",
@@ -2029,7 +2069,8 @@
2029
  },
2030
  "then": [
2031
  {
2032
- "op": "SUPPRESS_SELFDMG"
 
2033
  }
2034
  ],
2035
  "else": [
@@ -2239,11 +2280,11 @@
2239
  "def": 0,
2240
  "rarity": "legend",
2241
  "exhaust": true,
2242
- "desc": "本回合若你將死亡,改為復活並回復至總生命上限的 50%。若觸發,本卡將被永久移除(連消耗堆都不留)。",
2243
  "onPlay": [
2244
  {
2245
  "op": "ARM_REVIVE",
2246
- "fraction": 0.5
2247
  }
2248
  ]
2249
  },
@@ -2309,14 +2350,17 @@
2309
  "def": 0,
2310
  "rarity": "legend",
2311
  "exhaust": true,
2312
- "desc": "將棄牌堆中隨機 5 張卡牌直接移入消耗堆;將 10 張「專注」放在抽牌堆頂部。",
2313
  "onPlay": [
2314
  {
2315
  "op": "ANNIHILATE",
 
 
 
 
2316
  "token": 110,
2317
- "moveCount": 5,
2318
- "tokenCount": 10,
2319
- "position": "top"
2320
  }
2321
  ]
2322
  },
@@ -2367,11 +2411,11 @@
2367
  "isToken": true,
2368
  "derived": true,
2369
  "exhaust": true,
2370
- "desc": "(Token)抽到即釋放:臨時血量上限 +1(並回 1 HP,不計入出牌數)。用完進消耗堆。",
2371
  "onDraw": [
2372
  {
2373
  "op": "ADD_TEMP_MAXHP",
2374
- "value": 1
2375
  }
2376
  ]
2377
  },
 
7
  "atk": 0,
8
  "def": 2,
9
  "rarity": "normal",
10
+ "desc": "連擊:抽 1 張,然後結束本次連擊。",
11
  "onCombo": [
12
  {
13
  "op": "DRAW",
 
26
  "atk": 0,
27
  "def": 0,
28
  "rarity": "normal",
29
+ "desc": "連擊:ATK += 連擊數,然後結束本次連擊。",
30
  "onCombo": [
31
  {
32
  "op": "ADD_ATK",
 
47
  "atk": 0,
48
  "def": 4,
49
  "rarity": "normal",
50
+ "desc": "連擊:基礎 DEF +1(本場戰鬥持續,過關重置)。",
51
  "onCombo": [
52
  {
53
  "op": "ADD_BASE_DEF",
 
63
  "atk": 2,
64
  "def": 0,
65
  "rarity": "normal",
66
+ "desc": "即時:若為起手(出牌前連擊數為 0)→ 抽 1 張。",
67
  "onPlay": [
68
  {
69
  "op": "IF",
 
87
  "atk": 6,
88
  "def": 0,
89
  "rarity": "normal",
90
+ "desc": "即時:設下強制結束旗標(再打一張接不上即強制結束回合)。",
91
  "onPlay": [
92
  {
93
  "op": "SET_FLAG",
 
103
  "atk": 0,
104
  "def": 8,
105
  "rarity": "normal",
106
+ "desc": "即時:鎖 A,本回合無法再打出 A 標籤的牌。",
107
  "onPlay": [
108
  {
109
  "op": "LOCK_TAG",
 
119
  "atk": 7,
120
  "def": 0,
121
  "rarity": "normal",
122
+ "desc": "即時:HP -2,並鎖 B,本回合無法再打出 B 標籤的牌。連擊:ATK +3。",
123
  "onPlay": [
124
  {
125
  "op": "ADD_HP",
 
145
  "atk": 0,
146
  "def": 0,
147
  "rarity": "normal",
148
+ "desc": "即時:DEF += 隨機 0~8(每次不同,可能毫無作用)。連擊:DEF -3。",
149
  "onPlay": [
150
  {
151
  "op": "RANDOM_DEF_0_8"
 
166
  "atk": 0,
167
  "def": 2,
168
  "rarity": "normal",
169
+ "desc": "連擊:若手牌中已無任何 A 標籤卡 → 抽 1。",
170
  "onCombo": [
171
  {
172
  "op": "IF",
 
191
  "atk": 3,
192
  "def": 0,
193
  "rarity": "normal",
194
+ "desc": "即時:抽 1,並讓本回合怪物反擊 ATK +1。連擊:再抽 1。",
195
  "onPlay": [
196
  {
197
  "op": "SET_FLAG",
 
217
  "atk": 1,
218
  "def": 0,
219
  "rarity": "normal",
220
+ "desc": "即時:若連擊數為偶數 → DEF +3,否則 ATK +3。",
221
  "onPlay": [
222
  {
223
  "op": "IF",
 
247
  "atk": 0,
248
  "def": 5,
249
  "rarity": "normal",
250
+ "desc": "即時:回合末若硬幣 >0 → HP +5、maxHP +5。",
251
  "onPlay": [
252
  {
253
  "op": "SET_FLAG",
 
263
  "atk": 0,
264
  "def": 4,
265
  "rarity": "normal",
266
+ "desc": "即時:若連擊數恰為 1(起手首張)→ 硬幣 +1。",
267
  "onPlay": [
268
  {
269
  "op": "IF",
 
288
  "atk": 5,
289
  "def": 0,
290
  "rarity": "normal",
291
+ "desc": "即時:若硬幣為 0 且手牌已空 → ATK +15 並結束連擊。",
292
  "onPlay": [
293
  {
294
  "op": "IF",
 
324
  "atk": 11,
325
  "def": 0,
326
  "rarity": "normal",
327
+ "desc": "即時:ATK -= 當前手牌張數。連擊(依下一張 tag):A→ATK -2;B→DEF -4;Any→ATK -2 且 DEF -3。",
328
  "onPlay": [
329
  {
330
  "op": "ADD_ATK",
 
374
  "atk": 1,
375
  "def": 0,
376
  "rarity": "normal",
377
+ "desc": "即時:ATK += 新月計數 × 2。連擊:新月計數 +1(本場累積)。",
378
  "onPlay": [
379
  {
380
  "op": "ADD_ATK",
 
404
  "atk": 0,
405
  "def": 0,
406
  "rarity": "normal",
407
+ "desc": "連擊:斷劍計數 +(當前硬幣 + 1)(累積達 20 升級為血劍)。",
408
  "onCombo": [
409
  {
410
  "op": "ADD_COUNTER",
 
428
  "atk": 1,
429
  "def": 0,
430
  "rarity": "normal",
431
+ "desc": "即時:手牌上限 -1、抽 2 張。連擊:DEF +2。",
432
  "onPlay": [
433
  {
434
  "op": "ADD_MAX_HAND",
 
454
  "atk": 7,
455
  "def": 0,
456
  "rarity": "epic",
457
+ "desc": "連擊:ATK +5。",
458
  "onCombo": [
459
  {
460
  "op": "ADD_ATK",
 
470
  "atk": 5,
471
  "def": 0,
472
  "rarity": "epic",
473
+ "desc": "即時:若打出當下連擊數 ≥ 6 → 下回合硬幣回滿時額外 +1。",
474
  "onPlay": [
475
  {
476
  "op": "IF",
 
495
  "atk": 4,
496
  "def": 0,
497
  "rarity": "epic",
498
+ "desc": "即時:本次出傷時回血 min(本波傷害÷2, 10)(夾當前生命上限)。",
499
  "onPlay": [
500
  {
501
  "op": "SET_FLAG",
 
511
  "atk": 1,
512
  "def": 0,
513
  "rarity": "epic",
514
+ "desc": "連擊:抽 5 張。",
515
  "onCombo": [
516
  {
517
  "op": "DRAW",
 
527
  "atk": 6,
528
  "def": 0,
529
  "rarity": "epic",
530
+ "desc": "即時:本次出傷額外 + 怪物當前 HP 的 30%(向下取整)。",
531
  "onPlay": [
532
  {
533
  "op": "SET_FLAG",
 
548
  "atk": 0,
549
  "def": 3,
550
  "rarity": "epic",
551
+ "desc": "連擊:當前 DEF 翻倍(DEF += 當前 DEF)。",
552
  "onCombo": [
553
  {
554
  "op": "ADD_DEF",
 
566
  "atk": 1,
567
  "def": 0,
568
  "rarity": "epic",
569
+ "desc": "即��:ATK += 連擊數 × 2。",
570
  "onPlay": [
571
  {
572
  "op": "ADD_ATK",
 
589
  "atk": 0,
590
  "def": 0,
591
  "rarity": "epic",
592
+ "desc": "即時:ATK += 當前 DEF。連擊:ATK +1。",
593
  "onPlay": [
594
  {
595
  "op": "ADD_ATK",
 
613
  "atk": 5,
614
  "def": 0,
615
  "rarity": "epic",
616
+ "desc": "連擊:基礎 ATK 永久 +1(整場累積、過關也不重置)。",
617
  "onCombo": [
618
  {
619
  "op": "ADD_BASE_ATK",
 
629
  "atk": 4,
630
  "def": 4,
631
  "rarity": "epic",
632
+ "desc": "連擊:DEF +4、ATK +4。",
633
  "onCombo": [
634
  {
635
  "op": "ADD_DEF",
 
649
  "atk": 2,
650
  "def": 0,
651
  "rarity": "epic",
652
+ "desc": "連擊:下一次出傷 +25%(無條件捨去)後消耗。",
653
  "onCombo": [
654
  {
655
  "op": "SET_FLAG",
 
665
  "atk": 3,
666
  "def": 0,
667
  "rarity": "epic",
668
+ "desc": "連擊:ATK += 硬幣 × 硬幣 × 3,接著硬幣歸 0 並結束連擊。",
669
  "onCombo": [
670
  {
671
  "op": "ADD_ATK",
 
698
  "atk": 0,
699
  "def": 1,
700
  "rarity": "epic",
701
+ "desc": "即時:DEF += 2 × 訓練計數(本場累積)。連擊:訓練計數 +1。",
702
  "onPlay": [
703
  {
704
  "op": "ADD_DEF",
 
728
  "atk": 0,
729
  "def": 0,
730
  "rarity": "normal",
731
+ "desc": "即時:擲幸運硬幣(0/1)——0 則硬幣 +3,否則 DEF += 3 × 當前硬幣。連擊:結算相反那半,結束後幸運值歸 0。",
732
  "onPlay": [
733
  {
734
  "op": "RANDOM_SET",
 
805
  "atk": 0,
806
  "def": 1,
807
  "rarity": "epic",
808
+ "desc": "即時:硬幣 -1、抽 1 張。連擊:抽 2 張。",
809
  "onPlay": [
810
  {
811
  "op": "ADD_COIN",
 
831
  "atk": 0,
832
  "def": 15,
833
  "rarity": "legend",
834
+ "desc": "即時:本回合 DEF 延後一回合才重置(多撐一回合)。連擊:ATK +1。(焚燒:用完進消耗堆)",
835
  "onPlay": [
836
  {
837
  "op": "SET_FLAG",
 
854
  "atk": 5,
855
  "def": 0,
856
  "rarity": "legend",
857
+ "desc": "連擊(依下一張 tag):A→本回合 ATK 半數保留到下回合(連擊中斷也保留);B→抽 2;Any→抽 1 並 ATK +5。",
858
  "onCombo": [
859
  {
860
  "op": "BRANCH_NEXT_TAG",
 
891
  "atk": 3,
892
  "def": 0,
893
  "rarity": "legend",
894
+ "desc": "即時:清空當前 DEF 並本場鎖 DEF=0;之後加 DEF 改以一半(四捨五入)轉 ATK,連擊改每 2 連抽 1。本場持續、下一關重置。(焚燒:用完進消耗堆)",
895
  "onPlay": [
896
  {
897
  "op": "SET_FLAG",
 
912
  "atk": 5,
913
  "def": 5,
914
  "rarity": "legend",
915
+ "desc": "即時:互換當前 ATK 與 HP 數值,並結束連擊。",
916
  "onPlay": [
917
  {
918
  "op": "SWAP_ATK_HP"
 
935
  "atk": 5,
936
  "def": 5,
937
  "rarity": "legend",
938
+ "desc": "即時:本場任何卡都能接續連擊(無視標籤閘門),硬幣上限設為 1。(焚燒:用完進消耗堆)",
939
  "onPlay": [
940
  {
941
  "op": "SET_FLAG",
 
956
  "atk": 0,
957
  "def": 0,
958
  "rarity": "legend",
959
+ "desc": "即時:ATK += 本場此卡前已出牌數 × 3。",
960
  "onPlay": [
961
  {
962
  "op": "ADD_ATK",
 
979
  "atk": 8,
980
  "def": 0,
981
  "rarity": "upgrade",
982
+ "desc": "連擊:血劍計數 +1(本場累積,達 8 升級為終極一擊)。",
983
  "onCombo": [
984
  {
985
  "op": "ADD_COUNTER",
 
996
  "atk": 20,
997
  "def": 0,
998
  "rarity": "upgrade",
999
+ "desc": "即時:依連擊數推進處決——連擊 1 時 winValue÷2、2÷3、3÷5、4÷7(由 210 起);整除到 1 時本回合出傷額外 +怪物當前 HP(斬殺)。連擊:硬幣 +1。",
1000
  "onPlay": [
1001
  {
1002
  "op": "ULT_WIN_CHECK"
 
2055
  "name": "野性先手",
2056
  "tag": "None",
2057
  "nextReq": "None",
2058
+ "atk": 12,
2059
  "def": 0,
2060
  "rarity": "epic",
2061
+ "dmgText": "12",
2062
+ "desc": "造成 12 點傷害;若為本回合第一張牌(n=1),出牌計數 n 變為 -2(n 為負時視為回血),否則 n 額外 +1。",
2063
  "onPlay": [
2064
  {
2065
  "op": "IF",
 
2069
  },
2070
  "then": [
2071
  {
2072
+ "op": "SET_N",
2073
+ "value": -2
2074
  }
2075
  ],
2076
  "else": [
 
2280
  "def": 0,
2281
  "rarity": "legend",
2282
  "exhaust": true,
2283
+ "desc": "本回合若你將死亡,改為:臨時生命上限 1:1 全數轉為永久生命,並以 100% 總生命復活。若觸發,本卡將被永久移除(連消耗��都不留)。",
2284
  "onPlay": [
2285
  {
2286
  "op": "ARM_REVIVE",
2287
+ "fraction": 1
2288
  }
2289
  ]
2290
  },
 
2350
  "def": 0,
2351
  "rarity": "legend",
2352
  "exhaust": true,
2353
+ "desc": "將棄牌堆中隨機 5 張卡牌直接移入消耗堆;將 10 張「專注」洗入棄牌堆。",
2354
  "onPlay": [
2355
  {
2356
  "op": "ANNIHILATE",
2357
+ "moveCount": 5
2358
+ },
2359
+ {
2360
+ "op": "SHUFFLE_TOKEN",
2361
  "token": 110,
2362
+ "pile": "discard",
2363
+ "count": 10
 
2364
  }
2365
  ]
2366
  },
 
2411
  "isToken": true,
2412
  "derived": true,
2413
  "exhaust": true,
2414
+ "desc": "(Token)抽到即釋放:臨時血量上限 +2(並回 2 HP,不計入出牌數)。用完進消耗堆。",
2415
  "onDraw": [
2416
  {
2417
  "op": "ADD_TEMP_MAXHP",
2418
+ "value": 2
2419
  }
2420
  ]
2421
  },
packages/battle-core/package.json CHANGED
@@ -20,6 +20,7 @@
20
  "build": "tsc -p tsconfig.json",
21
  "typecheck": "tsc -p tsconfig.json --noEmit",
22
  "gen:cards": "tsx scripts/gen-cards-json.ts",
 
23
  "test": "vitest run",
24
  "test:watch": "vitest"
25
  },
 
20
  "build": "tsc -p tsconfig.json",
21
  "typecheck": "tsc -p tsconfig.json --noEmit",
22
  "gen:cards": "tsx scripts/gen-cards-json.ts",
23
+ "gen:ghost": "tsx scripts/gen-seed-ghost.ts",
24
  "test": "vitest run",
25
  "test:watch": "vitest"
26
  },
packages/battle-core/scripts/class-output-sim.ts ADDED
@@ -0,0 +1,175 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ /**
2
+ * 單人「每回合輸出」平衡量測(決定性):跑大量單人對局,統計每職業每回合的 ATK / DEF 平均。
3
+ * 用來替 Sanctus 的 HP / DEF / 護盾 / 審判線 定數值。非玩法 AI,只為平衡訊號。
4
+ *
5
+ * 策略:
6
+ * - 戰士:會「串連擊」的貪婪——combo 中優先打能接上 nextReq 的牌、否則才開新連擊;沒硬幣就收手。
7
+ * (單純「打最高 ATK」不串連擊會嚴重低估戰士,故特別處理。)
8
+ * - 野蠻人:打最高 ATK,但守安全線(再出一張的自傷會使 HP < effMax×15% 就收手)。
9
+ * - 互動選牌:scry 留最高 atk;keep 強化最高;棄牌棄最低。獎勵三選一挑最高 atk(進攻取向)。
10
+ *
11
+ * 量測來源:GameState.turnLog(引擎權威的每回合 {atk, def}),逐回合標記當時關卡。
12
+ * 執行:npx tsx scripts/class-output-sim.ts [gamesPerClass]
13
+ */
14
+ import { createGame, step } from "../src/engine.js";
15
+ import { getCard } from "../src/cards.js";
16
+ import type { Action, ClassType, GameState, PlayerState, Tag } from "../src/types.js";
17
+
18
+ const cardAtk = (p: PlayerState, id: number): number => getCard(id).atk + (p.cardBuffs?.[id] ?? 0);
19
+ const tagLocked = (p: PlayerState, tag: Tag): boolean => (tag === "A" && !p.useA) || (tag === "B" && !p.useB);
20
+
21
+ /** 戰士:會串連擊的貪婪。回傳要出的手牌 index,或 null = 收手(結束回合)。 */
22
+ function warriorPick(p: PlayerState): number | null {
23
+ const hand = p.hand.map((id, i) => ({ i, id, card: getCard(id) })).filter((c) => !tagLocked(p, c.card.tag));
24
+ if (hand.length === 0) return null;
25
+ if (p.combo === 0) {
26
+ if (p.coin <= 0) return null; // 無硬幣無法起手
27
+ hand.sort((a, b) => b.card.atk - a.card.atk);
28
+ return hand[0]!.i; // 起手挑最高 atk
29
+ }
30
+ // combo > 0:優先能接上的牌(tag==nextReq / nextReq==Any / tag==Any)
31
+ const chains = hand.filter((c) => c.card.tag === p.nextReq || p.nextReq === "Any" || c.card.tag === "Any");
32
+ if (chains.length > 0) {
33
+ chains.sort((a, b) => b.card.atk - a.card.atk);
34
+ return chains[0]!.i;
35
+ }
36
+ // 接不上:有硬幣就打最高(中斷後可再開新連擊),沒硬幣就收手
37
+ if (p.coin <= 0) return null;
38
+ hand.sort((a, b) => b.card.atk - a.card.atk);
39
+ return hand[0]!.i;
40
+ }
41
+
42
+ /** 野蠻人:打最高 atk,守 15% 安全線。 */
43
+ function barbarianPick(p: PlayerState): number | null {
44
+ if (p.hand.length === 0) return null;
45
+ const nextN = p.nMode === "dec" ? Math.max(0, p.n - 1) : p.n + 1;
46
+ const effMax = p.maxHp + p.tempMaxHp;
47
+ if (p.hp - Math.max(0, nextN) < effMax * 0.15) return null; // 安全線:別把自己玩死
48
+ let bi = 0, bv = -Infinity;
49
+ for (let i = 0; i < p.hand.length; i++) {
50
+ const v = cardAtk(p, p.hand[i]!);
51
+ if (v > bv) { bv = v; bi = i; }
52
+ }
53
+ return bi;
54
+ }
55
+
56
+ /** 互動選牌:scry 留最高 atk;keep 強化最高;棄牌棄最低。 */
57
+ function pickChoice(p: PlayerState, pend: { count: number; keep?: boolean; scry?: number[] }): number[] {
58
+ if (pend.scry) {
59
+ const order = pend.scry.map((id, i) => ({ i, v: getCard(id).atk })).sort((a, b) => b.v - a.v);
60
+ return order.slice(0, Math.min(pend.count, pend.scry.length)).map((o) => o.i);
61
+ }
62
+ const order = p.hand.map((id, i) => ({ i, v: cardAtk(p, id) })).sort((a, b) => (pend.keep ? b.v - a.v : a.v - b.v));
63
+ return order.slice(0, Math.min(pend.count, p.hand.length)).map((o) => o.i);
64
+ }
65
+
66
+ interface Row { level: number; atk: number; def: number; dmg: number; }
67
+
68
+ function playGame(classType: ClassType, seed: number, maxLevel?: number): Row[] {
69
+ let s: GameState = createGame({ classType, seed, maxLevel });
70
+ const rows: Row[] = [];
71
+ const apply = (a: Action) => { s = step(s, a).state; };
72
+ let guard = 0;
73
+ while (s.phase !== "GAME_OVER" && s.phase !== "VICTORY" && guard++ < 5000) {
74
+ if (s.phase === "REWARD_SELECT") {
75
+ const ch = s.rewardChoices ?? [];
76
+ let bi = 0, bv = -1;
77
+ ch.forEach((id, i) => { const v = getCard(id).atk; if (v > bv) { bv = v; bi = i; } });
78
+ apply({ type: "PICK_REWARD", choiceIndex: bi });
79
+ continue;
80
+ }
81
+ if (s.phase === "PENDING_CHOICE") {
82
+ apply({ type: "CHOOSE_CARDS", indices: pickChoice(s.player, s.pendingChoice!) });
83
+ continue;
84
+ }
85
+ if (s.phase === "PLAYER_TURN") {
86
+ let g = 0;
87
+ while (s.phase === "PLAYER_TURN" && g++ < 60) {
88
+ const pick = classType === "BARBARIAN" ? barbarianPick(s.player) : warriorPick(s.player);
89
+ if (pick === null) break;
90
+ const before = s.turnLog.length + "|" + s.player.hand.length + "|" + s.player.coin + "|" + s.player.combo;
91
+ apply({ type: "PLAY_CARD", handIndex: pick });
92
+ if (s.phase !== "PLAYER_TURN") break; // forcedEnd / pending / reward
93
+ if (before === s.turnLog.length + "|" + s.player.hand.length + "|" + s.player.coin + "|" + s.player.combo) break; // 出牌無效化 → 收手
94
+ }
95
+ if (s.phase === "PLAYER_TURN") {
96
+ const lvl = s.level;
97
+ const n0 = s.turnLog.length;
98
+ const hpB = s.opponent.hp; // 怪物掉血 = 本回合對怪實際輸出(含野蠻人真實傷害;slime DEF=0 故≈原始輸出)
99
+ apply({ type: "END_TURN" });
100
+ const last = s.turnLog[s.turnLog.length - 1];
101
+ const hpA = s.opponent.isAlive ? s.opponent.hp : 0;
102
+ if (s.turnLog.length > n0 && last) rows.push({ level: lvl, atk: last.atk, def: last.def, dmg: Math.max(0, hpB - hpA) });
103
+ }
104
+ continue;
105
+ }
106
+ break;
107
+ }
108
+ return rows;
109
+ }
110
+
111
+ interface Stat { turns: number; avgDmg: number; avgAtkBatched: number; avgDef: number; maxDmg: number; maxDef: number; }
112
+ function summarize(rows: Row[]): Stat {
113
+ if (rows.length === 0) return { turns: 0, avgDmg: 0, avgAtkBatched: 0, avgDef: 0, maxDmg: 0, maxDef: 0 };
114
+ const avg = (f: (r: Row) => number) => +(rows.reduce((s, r) => s + f(r), 0) / rows.length).toFixed(2);
115
+ return {
116
+ turns: rows.length,
117
+ avgDmg: avg((r) => r.dmg), // 對怪實際輸出/回合(含真實傷害)= 真「攻擊力」
118
+ avgAtkBatched: avg((r) => r.atk), // 批次 ATK(turnLog;野蠻人會少算真傷)
119
+ avgDef: avg((r) => r.def),
120
+ maxDmg: Math.max(...rows.map((r) => r.dmg)),
121
+ maxDef: Math.max(...rows.map((r) => r.def)),
122
+ };
123
+ }
124
+
125
+ /** 不死訓練假人:血量灌爆(不會過殺截斷)、低攻(讓角色撐久),量「基礎牌組」每回合真實總輸出(含真傷)。 */
126
+ function dummyOutput(classType: ClassType, seed: number, turnsToMeasure = 8): number[] {
127
+ let s: GameState = createGame({ classType, seed });
128
+ const dmgs: number[] = [];
129
+ let guard = 0;
130
+ while (dmgs.length < turnsToMeasure && guard++ < 400) {
131
+ if (s.phase === "PENDING_CHOICE") { s = step(s, { type: "CHOOSE_CARDS", indices: pickChoice(s.player, s.pendingChoice!) }).state; continue; }
132
+ if (s.phase !== "PLAYER_TURN") break;
133
+ s.opponent.hp = 1e9; s.opponent.maxHp = 1e9; s.opponent.def = 0; s.opponent.atk = 3; s.opponent.isAlive = true; // 不死假人
134
+ let g = 0;
135
+ while (s.phase === "PLAYER_TURN" && g++ < 60) {
136
+ const pick = classType === "BARBARIAN" ? barbarianPick(s.player) : warriorPick(s.player);
137
+ if (pick === null) break;
138
+ const sig = s.player.hand.length + "|" + s.player.coin + "|" + s.player.combo;
139
+ s = step(s, { type: "PLAY_CARD", handIndex: pick }).state;
140
+ if (s.phase === "PENDING_CHOICE") { s = step(s, { type: "CHOOSE_CARDS", indices: pickChoice(s.player, s.pendingChoice!) }).state; continue; }
141
+ if (s.phase !== "PLAYER_TURN") break;
142
+ if (sig === s.player.hand.length + "|" + s.player.coin + "|" + s.player.combo) break;
143
+ }
144
+ if (s.phase !== "PLAYER_TURN") break;
145
+ s = step(s, { type: "END_TURN" }).state;
146
+ dmgs.push(1e9 - s.opponent.hp); // 本回合對假人總輸出(真傷+批次,未被過殺截斷)
147
+ if (s.phase === "GAME_OVER") break;
148
+ }
149
+ return dmgs;
150
+ }
151
+
152
+ const N = Number(process.argv[2]) || 300;
153
+ const out: Record<string, unknown> = { gamesPerClass: N, policy: "warrior=chain-aware-greedy; barbarian=highest-atk+15%-safety; reward=highest-atk" };
154
+
155
+ // 不死假人量基礎牌組真實輸出(特別是野蠻人真傷)
156
+ for (const cls of ["WARRIOR", "BARBARIAN"] as ClassType[]) {
157
+ const all: number[] = [];
158
+ for (let i = 0; i < Math.min(N, 120); i++) all.push(...dummyOutput(cls, 9000 + i * 11));
159
+ const avg = all.length ? +(all.reduce((a, b) => a + b, 0) / all.length).toFixed(2) : 0;
160
+ out[`${cls}_不死假人_基礎牌組每回合輸出`] = { 取樣回合: all.length, 平均: avg, 最高: all.length ? Math.max(...all) : 0 };
161
+ }
162
+
163
+ for (const cls of ["WARRIOR", "BARBARIAN"] as ClassType[]) {
164
+ const all: Row[] = [];
165
+ for (let i = 0; i < N; i++) all.push(...playGame(cls, 7000 + i * 7));
166
+ const early = all.filter((r) => r.level <= 2);
167
+ const lvl1 = all.filter((r) => r.level === 1);
168
+ out[cls] = {
169
+ 全程: summarize(all),
170
+ 早期_關1到2: summarize(early),
171
+ 只關1: summarize(lvl1),
172
+ };
173
+ }
174
+
175
+ console.log(JSON.stringify(out, null, 2));
packages/battle-core/scripts/gen-seed-ghost.ts ADDED
@@ -0,0 +1,214 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ /**
2
+ * 產生一筆「真實可驗證」的鬼影存檔,寫進 packages/server/data/ghosts.json,取代假樣本。
3
+ *
4
+ * 為什麼需要這支腳本:這遊戲故意很難,單純「每回合出 0 號牌」的貪婪 AI 在 11 關打不贏,
5
+ * 無法產生合法存檔。這裡用 beam search(束搜索)自動探索「出牌順序+獎勵選擇」,
6
+ * 找出一場真的打到 VICTORY(第 11 關)的通關,再用「伺服器同款 verifyGhost」自驗後落檔。
7
+ *
8
+ * 用法:cd packages/battle-core && npx tsx scripts/gen-seed-ghost.ts
9
+ *
10
+ * 設計依據:ultracode 工作流彙整的引擎事實——
11
+ * - 怪物 DEF 恆 0,玩家原始 atk≈實際傷害;唯一壓力是怪物每回合 atk += trunc(growAtk) 的反擊爬升。
12
+ * - 第 11 關 BOSS:195 HP、atk 17、growAtk 5。
13
+ * - turnLog 在「傷害結算前」快照 {player.atk, player.def},每回合一筆。
14
+ * - replay() 寫死 classType=WARRIOR、maxLevel=11 → 搜尋與落檔都必須用同樣設定。
15
+ */
16
+ import { writeFileSync } from "node:fs";
17
+ import { fileURLToPath } from "node:url";
18
+ import { dirname, join } from "node:path";
19
+ import { createGame, step, replay } from "../src/engine.js";
20
+ import { buildGhostRecord } from "../src/opponent.js";
21
+ import { RULE_VERSION, CARDS_HASH } from "../src/version.js";
22
+ import type { Action, GameState } from "../src/types.js";
23
+
24
+ // ---- 參數(可調;先用設計建議的保守值)----
25
+ const SEEDS_TO_TRY = 200; // 掃描種子上限
26
+ const BEAM_WIDTH = 64; // 束寬 K
27
+ const MAX_PLIES = 2000; // 每顆種子的最大展開層數(動作數,非回合數)
28
+ const PLAY_CHILD_CAP = 10; // 單一節點最多保留幾個 PLAY_CARD 後代(其餘靠去重收斂)
29
+
30
+ // ---- 啟發式評分:對「套用一個動作後的 state」打一個分數(越高越好)----
31
+ function score(s: GameState): number {
32
+ const p = s.player;
33
+ const opp = s.opponent;
34
+ if (p.hp <= 0 || s.phase === "GAME_OVER") return -1e9; // 死亡=最差,永不展開
35
+ if (s.phase === "VICTORY") return 1e9; // 勝利=終局最佳
36
+ const levelTerm = s.level * 100000; // 關卡權重壓過所有關內項 → 永遠優先往更深的關推進
37
+ const dmgProgress = (opp.maxHp - opp.hp) * 50; // 本關已造成的傷害
38
+ const hpTerm = p.hp * 30; // 存活
39
+ const offenseTerm = p.atk * 12 + p.def * 4; // 本回合累積的攻防(堆爆發)
40
+ const resourceTerm = p.hand.length * 6 + p.coin * 8 + p.combo * 3; // 保留的選擇權
41
+ return levelTerm + dmgProgress + hpTerm + offenseTerm + resourceTerm;
42
+ }
43
+
44
+ // ---- 去重 key:只取「玩法相關」狀態,刻意排除 rng(否則束會爆炸、且交換出牌順序無法合併)----
45
+ function key(s: GameState): string {
46
+ const p = s.player;
47
+ const opp = s.opponent;
48
+ const sortNum = (a: number[]) => [...a].sort((x, y) => x - y);
49
+ return JSON.stringify([
50
+ s.phase,
51
+ s.level,
52
+ opp.hp,
53
+ opp.atk,
54
+ opp.def,
55
+ p.hp,
56
+ p.atk,
57
+ p.def,
58
+ p.coin,
59
+ p.combo,
60
+ p.nextReq,
61
+ sortNum(p.hand), // 排序後的手牌多重集合 → 合併「同一手牌不同出牌順序」抵達的相同狀態(最大的剪枝)
62
+ sortNum(p.deck),
63
+ sortNum(p.discard),
64
+ sortNum(p.burn),
65
+ s.rewardChoices ?? null,
66
+ s.turnLog.length,
67
+ ]);
68
+ }
69
+
70
+ // ---- 依相位枚舉「候選動作」----
71
+ function enumerateActions(s: GameState): Action[] {
72
+ const p = s.player;
73
+ if (s.phase === "PLAYER_TURN") {
74
+ const acts: Action[] = [];
75
+ const n = Math.min(p.hand.length, 64);
76
+ for (let i = 0; i < n; i++) acts.push({ type: "PLAY_CARD", handIndex: i });
77
+ acts.push({ type: "END_TURN" }); // END_TURN 永遠保留 → 保證有前進
78
+ return acts;
79
+ }
80
+ if (s.phase === "REWARD_SELECT") {
81
+ // 三個都展開(一場僅約 11 次,成本極低;不同選擇 → 不同牌組 → 去重不會誤併)
82
+ const m = (s.rewardChoices ?? []).length;
83
+ const acts: Action[] = [];
84
+ for (let c = 0; c < m && c < 3; c++) acts.push({ type: "PICK_REWARD", choiceIndex: c });
85
+ return acts;
86
+ }
87
+ if (s.phase === "PENDING_CHOICE") {
88
+ // 純戰士跑不到這(選牌卡都是野蠻人);空 indices 永遠合法,僅作保險。
89
+ return [{ type: "CHOOSE_CARDS", indices: [] }];
90
+ }
91
+ return [];
92
+ }
93
+
94
+ interface Node {
95
+ state: GameState;
96
+ actions: Action[];
97
+ }
98
+
99
+ /** 束搜索:找出一條打到 VICTORY 的動作序列;找不到回 null。 */
100
+ function beamSearch(root: GameState): Action[] | null {
101
+ let beam: Node[] = [{ state: root, actions: [] }];
102
+ for (let ply = 0; ply < MAX_PLIES; ply++) {
103
+ const children: { node: Node; sc: number; k: string }[] = [];
104
+ for (const node of beam) {
105
+ const parentKey = key(node.state);
106
+ const plays: { node: Node; sc: number; k: string }[] = [];
107
+ const others: { node: Node; sc: number; k: string }[] = [];
108
+ for (const a of enumerateActions(node.state)) {
109
+ const childState = step(node.state, a).state;
110
+ const childActions = [...node.actions, a];
111
+ if (childState.phase === "VICTORY") return childActions; // 立刻收手
112
+ if (childState.phase === "GAME_OVER") continue; // 丟棄死亡節點
113
+ const k = key(childState);
114
+ const entry = { node: { state: childState, actions: childActions }, sc: score(childState), k };
115
+ if (a.type === "PLAY_CARD") {
116
+ if (k === parentKey) continue; // 出牌無效化(無硬幣/標籤鎖/壞索引)→ no-op,丟棄避免死循環
117
+ plays.push(entry);
118
+ } else {
119
+ others.push(entry); // END_TURN / PICK_REWARD / CHOOSE_CARDS 一律保留
120
+ }
121
+ }
122
+ // 單節點 PLAY_CARD 後代上限(取分數最高的前 N 個)+全部 others
123
+ plays.sort((x, y) => y.sc - x.sc);
124
+ for (const e of plays.slice(0, PLAY_CHILD_CAP)) children.push(e);
125
+ for (const e of others) children.push(e);
126
+ }
127
+ if (children.length === 0) break; // 全滅(每條路都死)
128
+
129
+ // 排序:分數↓ → 路徑短↑(偏好較短勝利)→ key(穩定);再依 key 去重保留第一筆(最佳)
130
+ children.sort((a, b) => b.sc - a.sc || a.node.actions.length - b.node.actions.length || (a.k < b.k ? -1 : a.k > b.k ? 1 : 0));
131
+ const seen = new Set<string>();
132
+ const next: Node[] = [];
133
+ for (const c of children) {
134
+ if (seen.has(c.k)) continue;
135
+ seen.add(c.k);
136
+ next.push(c.node);
137
+ if (next.length >= BEAM_WIDTH) break;
138
+ }
139
+ beam = next;
140
+ }
141
+ return null;
142
+ }
143
+
144
+ // ---- 自驗:完全照伺服器 verifyGhost(ghostService.ts)+ validateGhostShape 的邏輯(battle-core 不能 import @wcg/server,故就地複製)----
145
+ function selfVerify(record: ReturnType<typeof buildGhostRecord>): void {
146
+ const ok = (cond: boolean, msg: string) => {
147
+ if (!cond) throw new Error(`自驗失敗:${msg}`);
148
+ };
149
+ const intIn = (v: unknown, lo: number, hi: number) => typeof v === "number" && Number.isInteger(v) && v >= lo && v <= hi;
150
+ // verifyGhost 等價檢查
151
+ ok(record.ruleVersion === RULE_VERSION && record.cardsHash === CARDS_HASH, "版本/卡表指紋不符");
152
+ ok(Array.isArray(record.actions) && record.actions.length > 0, "缺 actions(無法重播)");
153
+ const f = replay(record.seed, record.actions!);
154
+ ok(f.phase === "VICTORY", `重播未達破關(phase=${f.phase})`);
155
+ ok(f.player.maxHp === record.playerMaxHp, "playerMaxHp 不符");
156
+ ok(f.turnLog.length === record.turns.length, `turns 長度不符(replay=${f.turnLog.length} record=${record.turns.length})`);
157
+ for (let i = 0; i < record.turns.length; i++) {
158
+ ok(f.turnLog[i]!.atk === record.turns[i]!.atk && f.turnLog[i]!.def === record.turns[i]!.def, `第 ${i + 1} 回合 atk/def 不符`);
159
+ }
160
+ // validateGhostShape 邊界
161
+ ok(intIn(record.playerMaxHp, 1, 100000), "playerMaxHp 超界");
162
+ ok(record.turns.length <= 2000, "turns 過長");
163
+ for (const t of record.turns) ok(intIn(t.atk, -100000, 100000) && intIn(t.def, -100000, 100000), "turn atk/def 超界");
164
+ ok(intIn(record.seed, -0x80000000, 0xffffffff), "seed 超界");
165
+ ok(record.actions!.length <= 20000, "actions 過長");
166
+ for (const a of record.actions!) {
167
+ if (a.type === "PLAY_CARD") ok(intIn(a.handIndex, 0, 63), "PLAY_CARD handIndex 超界");
168
+ if (a.type === "PICK_REWARD") ok(intIn(a.choiceIndex, 0, 9), "PICK_REWARD choiceIndex 超界");
169
+ if (a.type === "CHOOSE_CARDS") ok(Array.isArray(a.indices) && a.indices.length <= 16 && a.indices.every((x) => intIn(x, 0, 63)), "CHOOSE_CARDS indices 超界");
170
+ }
171
+ }
172
+
173
+ // ================= 主流程 =================
174
+ function main(): void {
175
+ let winning: { seed: number; actions: Action[] } | null = null;
176
+ const t0 = Date.now();
177
+ for (let seed = 1; seed <= SEEDS_TO_TRY; seed++) {
178
+ const root = createGame({ classType: "WARRIOR", seed }); // 不帶 maxLevel → 與 replay 一致用 11
179
+ const actions = beamSearch(root);
180
+ if (actions) {
181
+ winning = { seed, actions };
182
+ console.log(`✅ seed=${seed} 找到通關線(${actions.length} 個動作,耗時 ${Date.now() - t0}ms)`);
183
+ break;
184
+ }
185
+ if (seed % 10 === 0) console.log(`…已掃到 seed=${seed}(${Date.now() - t0}ms)尚未找到,繼續`);
186
+ }
187
+ if (!winning) {
188
+ console.error(`❌ 在 seed 1..${SEEDS_TO_TRY}、K=${BEAM_WIDTH} 內沒找到通關線。請調高 BEAM_WIDTH(128/256)或 SEEDS_TO_TRY 再試。`);
189
+ process.exit(1);
190
+ }
191
+
192
+ // 用「乾淨重播」重建破關狀態(不沿用 beam 節點),確保 turnLog/maxHp 與全新一場完全一致
193
+ let s = createGame({ classType: "WARRIOR", seed: winning.seed });
194
+ for (const a of winning.actions) s = step(s, a).state;
195
+ if (s.phase !== "VICTORY") throw new Error("重建破關狀態失敗(非 VICTORY)");
196
+
197
+ const record = buildGhostRecord(s, { seed: winning.seed, actions: winning.actions, createdAt: new Date().toISOString(), heroName: "範例勇者" });
198
+ selfVerify(record);
199
+ console.log(`✅ 自驗通過:playerMaxHp=${record.playerMaxHp}、回合數 k=${record.turns.length}、動作數=${record.actions!.length}`);
200
+
201
+ // 落檔:一元素 JSON 陣列��補上伺服器端欄位 id / verified(與 StoredGhost 形狀一致)
202
+ const here = dirname(fileURLToPath(import.meta.url));
203
+ const outFile = join(here, "..", "..", "server", "data", "ghosts.json");
204
+ const out = [{ id: "00000000-0000-4000-8000-000000000001", verified: true, ...record }];
205
+ writeFileSync(outFile, JSON.stringify(out, null, 2), "utf8");
206
+ console.log(`✅ 已寫入 ${outFile}(1 筆 verified:true 真實鬼影,取代假樣本)`);
207
+
208
+ // 印出 turns 摘要,便於肉眼確認「數值像不像過 11 關的人」
209
+ const k = record.turns.length;
210
+ console.log(` 前 5 回合:${JSON.stringify(record.turns.slice(0, 5))}`);
211
+ console.log(` 末 5 回合:${JSON.stringify(record.turns.slice(-5))}`);
212
+ }
213
+
214
+ main();
packages/battle-core/scripts/sanctus-trace.ts ADDED
@@ -0,0 +1,42 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ /** Sanctus 多回合追蹤:戰士(會串連擊的貪婪)打 Sanctus,逐回合印能量/意圖/護盾/技能,肉眼驗證能量×技能×意圖迴圈。 */
2
+ import { createGame, step } from "../src/engine.js";
3
+ import { getCard } from "../src/cards.js";
4
+ import { SANCTUS_SKILLS } from "../src/foes.js";
5
+ import type { GameState, PlayerState, Tag } from "../src/types.js";
6
+
7
+ const tagLocked = (p: PlayerState, t: Tag) => (t === "A" && !p.useA) || (t === "B" && !p.useB);
8
+ function pick(p: PlayerState): number | null {
9
+ const h = p.hand.map((id, i) => ({ i, c: getCard(id) })).filter((x) => !tagLocked(p, x.c.tag));
10
+ if (h.length === 0) return null;
11
+ if (p.combo === 0) { if (p.coin <= 0) return null; h.sort((a, b) => b.c.atk - a.c.atk); return h[0]!.i; }
12
+ const ch = h.filter((x) => x.c.tag === p.nextReq || p.nextReq === "Any" || x.c.tag === "Any");
13
+ if (ch.length) { ch.sort((a, b) => b.c.atk - a.c.atk); return ch[0]!.i; }
14
+ if (p.coin <= 0) return null;
15
+ h.sort((a, b) => b.c.atk - a.c.atk); return h[0]!.i;
16
+ }
17
+ const names = (ids: string[] = []) => ids.map((id) => SANCTUS_SKILLS[id]?.name ?? id).join("、") || "(蓄力中)";
18
+
19
+ let s: GameState = createGame({ classType: "WARRIOR", seed: 42, campaign: "sanctus" });
20
+ for (let t = 1; t <= 12 && s.phase !== "GAME_OVER" && s.phase !== "VICTORY"; t++) {
21
+ let g = 0;
22
+ while (s.phase === "PLAYER_TURN" && g++ < 40) {
23
+ const i = pick(s.player); if (i === null) break;
24
+ const sig = s.player.hand.length + "|" + s.player.coin + "|" + s.player.combo;
25
+ s = step(s, { type: "PLAY_CARD", handIndex: i }).state;
26
+ if (s.phase === "PENDING_CHOICE") { s = step(s, { type: "CHOOSE_CARDS", indices: [] }).state; continue; }
27
+ if (s.phase !== "PLAYER_TURN") break;
28
+ if (sig === s.player.hand.length + "|" + s.player.coin + "|" + s.player.combo) break;
29
+ }
30
+ const o = s.opponent;
31
+ console.log(`關${s.level} T${t} 出牌後|玩家ATK ${s.player.atk}(審判線${o.judgeLine})|敵 HP ${o.hp}/${o.maxHp} 能量 ${o.energy}/${o.maxEnergy} 盾 ${o.aegis}|下一步: ${names(o.intent)}`);
32
+ if (s.phase === "PLAYER_TURN") {
33
+ const r = step(s, { type: "END_TURN" }); s = r.state;
34
+ const log = r.events.map((e) =>
35
+ e.type === "SKILL_USED" ? `技【${e.name}】` :
36
+ e.type === "MONSTER_REFLECT" ? `聖裁反噬${e.damage}` :
37
+ e.type === "MONSTER_ATTACK" ? `普攻${e.damage}` :
38
+ e.type === "MONSTER_DEAD" ? "★擊敗" : "").filter(Boolean).join(" ");
39
+ console.log(` 結算: ${log}|玩家HP ${s.player.hp}`);
40
+ }
41
+ if (s.phase === "REWARD_SELECT") s = step(s, { type: "PICK_REWARD", choiceIndex: 0 }).state;
42
+ }
packages/battle-core/src/data/cards.ts CHANGED
@@ -19,67 +19,81 @@ export const CARDS: readonly CardData[] = [
19
  // ===== A. 普通卡(獎勵池:0–12, 30, 31, 32, 33, 36)=====
20
  {
21
  id: 0, name: "閃躲", tag: "B", nextReq: "Any", atk: 0, def: 2, rarity: "normal",
 
22
  onCombo: [{ op: "DRAW", value: 1 }, { op: "END_COMBO" }],
23
  },
24
  {
25
  id: 1, name: "瘋狂連打", tag: "A", nextReq: "None", atk: 0, def: 0, rarity: "normal",
 
26
  onCombo: [{ op: "ADD_ATK", value: { var: "combo" } }, { op: "END_COMBO" }],
27
  },
28
  {
29
  id: 2, name: "加固", tag: "B", nextReq: "B", atk: 0, def: 4, rarity: "normal",
 
30
  // BaseDEF +1:本局持續(過關時 initStates 把 baseDef 歸零而重置)。卡面即「此場戰鬥內 DEF+1」。
31
  onCombo: [{ op: "ADD_BASE_DEF", value: 1 }],
32
  },
33
  {
34
  id: 3, name: "好的開始", tag: "Any", nextReq: "Any", atk: 2, def: 0, rarity: "normal",
 
35
  // 抽牌只發生在「起手」這條路徑(01 §4.2)
36
  onPlay: [{ op: "IF", cond: { kind: "isStarter" }, then: [{ op: "DRAW", value: 1 }] }],
37
  },
38
  {
39
  id: 4, name: "重擊", tag: "A", nextReq: "A", atk: 6, def: 0, rarity: "normal",
 
40
  // 只設旗標;「再打一張即強制結束」由引擎處理(Q2 拍板)
41
  onPlay: [{ op: "SET_FLAG", flag: "重擊" }],
42
  },
43
  {
44
  id: 5, name: "龜縮", tag: "B", nextReq: "B", atk: 0, def: 8, rarity: "normal",
 
45
  onPlay: [{ op: "LOCK_TAG", tag: "A" }],
46
  },
47
  {
48
  id: 6, name: "捨身一擊", tag: "A", nextReq: "A", atk: 7, def: 0, rarity: "normal",
 
49
  onPlay: [{ op: "ADD_HP", value: -2 }, { op: "LOCK_TAG", tag: "B" }],
50
  onCombo: [{ op: "ADD_ATK", value: 3 }],
51
  },
52
  {
53
  id: 7, name: "不穩定的格擋", tag: "Any", nextReq: "B", atk: 0, def: 0, rarity: "normal",
 
54
  onPlay: [{ op: "RANDOM_DEF_0_8" }],
55
  onCombo: [{ op: "ADD_DEF", value: -3 }],
56
  },
57
  {
58
  id: 8, name: "深呼吸", tag: "B", nextReq: "Any", atk: 0, def: 2, rarity: "normal",
 
59
  onCombo: [{ op: "IF", cond: { kind: "noTagInHand", tag: "A" }, then: [{ op: "DRAW", value: 1 }] }],
60
  },
61
  {
62
  id: 9, name: "挑釁", tag: "Any", nextReq: "Any", atk: 3, def: 0, rarity: "normal",
 
63
  onPlay: [{ op: "SET_FLAG", flag: "挑釁" }, { op: "DRAW", value: 1 }],
64
  onCombo: [{ op: "DRAW", value: 1 }],
65
  },
66
  {
67
  id: 10, name: "節奏感", tag: "A", nextReq: "Any", atk: 1, def: 0, rarity: "normal",
 
68
  onPlay: [
69
  { op: "IF", cond: { kind: "comboEven" }, then: [{ op: "ADD_DEF", value: 3 }], else: [{ op: "ADD_ATK", value: 3 }] },
70
  ],
71
  },
72
  {
73
  id: 11, name: "餘裕", tag: "B", nextReq: "Any", atk: 0, def: 5, rarity: "normal",
 
74
  onPlay: [{ op: "SET_FLAG", flag: "餘裕" }],
75
  },
76
  {
77
  id: 12, name: "沉穩應對", tag: "B", nextReq: "Any", atk: 0, def: 4, rarity: "normal",
 
78
  // 名為 COMBO_0 但檢查 Combo==1(起手後 Combo 立即為 1,06 已知問題 #7,行為照舊)
79
  onPlay: [{ op: "IF", cond: { kind: "comboEq", value: 1 }, then: [{ op: "ADD_COIN", value: 1 }] }],
80
  },
81
  {
82
  id: 30, name: "終章決戰", tag: "None", nextReq: "None", atk: 5, def: 0, rarity: "normal",
 
83
  onPlay: [
84
  {
85
  op: "IF",
@@ -90,6 +104,7 @@ export const CARDS: readonly CardData[] = [
90
  },
91
  {
92
  id: 31, name: "懸崖前的注視", tag: "A", nextReq: "Any", atk: 11, def: 0, rarity: "normal",
 
93
  onPlay: [{ op: "ADD_ATK", value: { mul: [-1, { var: "handCount" }] } }],
94
  onCombo: [
95
  {
@@ -102,16 +117,19 @@ export const CARDS: readonly CardData[] = [
102
  },
103
  {
104
  id: 32, name: "新月訓練", tag: "A", nextReq: "B", atk: 1, def: 0, rarity: "normal",
 
105
  onPlay: [{ op: "ADD_ATK", value: { mul: [2, { var: "newmoon" }] } }],
106
  onCombo: [{ op: "ADD_COUNTER", counter: "newmoon", value: 1 }],
107
  },
108
  {
109
  id: 33, name: "斷��", tag: "A", nextReq: "A", atk: 0, def: 0, rarity: "normal",
 
110
  // 連擊:鍛造(broken 計數)+(當前剩餘硬幣 + 1)
111
  onCombo: [{ op: "ADD_COUNTER", counter: "broken", value: { add: [{ var: "coin" }, 1] } }],
112
  },
113
  {
114
  id: 36, name: "應急", tag: "A", nextReq: "B", atk: 1, def: 0, rarity: "normal",
 
115
  onPlay: [{ op: "ADD_MAX_HAND", value: -1 }, { op: "DRAW", value: 2 }],
116
  onCombo: [{ op: "ADD_DEF", value: 2 }],
117
  },
@@ -119,53 +137,65 @@ export const CARDS: readonly CardData[] = [
119
  // ===== B. 史詩卡(獎勵池:13–23, 37, 38, 39, 40)=====
120
  {
121
  id: 13, name: "連環爆發", tag: "Any", nextReq: "Any", atk: 7, def: 0, rarity: "epic",
 
122
  onCombo: [{ op: "ADD_ATK", value: 5 }],
123
  },
124
  {
125
  id: 14, name: "黃金律動", tag: "A", nextReq: "A", atk: 5, def: 0, rarity: "epic",
 
126
  onPlay: [{ op: "IF", cond: { kind: "comboGte", value: 6 }, then: [{ op: "SET_FLAG", flag: "黃金律動" }] }],
127
  },
128
  {
129
  id: 15, name: "生命汲取", tag: "A", nextReq: "B", atk: 4, def: 0, rarity: "epic",
 
130
  onPlay: [{ op: "SET_FLAG", flag: "生命汲取" }],
131
  },
132
  {
133
  id: 16, name: "快速裝填", tag: "Any", nextReq: "Any", atk: 1, def: 0, rarity: "epic",
 
134
  onCombo: [{ op: "DRAW", value: 5 }],
135
  },
136
  {
137
  id: 17, name: "烈空斬", tag: "A", nextReq: "Any", atk: 6, def: 0, rarity: "epic",
 
138
  onPlay: [{ op: "SET_FLAG", flag: "烈空斬" }],
139
  modeOverride: { PVP: { notes: "烈空斬上限綁對手 maxHP=floor(maxHP×3/10)(maxHP=200→60),見 pvpResolve outgoing()" } },
140
  },
141
  {
142
  id: 18, name: "盾牆", tag: "B", nextReq: "B", atk: 0, def: 3, rarity: "epic",
 
143
  onCombo: [{ op: "ADD_DEF", value: { var: "def" } }], // 當前 DEF 翻倍
144
  },
145
  {
146
  id: 19, name: "連擊狂熱", tag: "A", nextReq: "A", atk: 1, def: 0, rarity: "epic",
 
147
  onPlay: [{ op: "ADD_ATK", value: { mul: [{ var: "combo" }, 2] } }],
148
  },
149
  {
150
  id: 20, name: "盾擊", tag: "A", nextReq: "A", atk: 0, def: 0, rarity: "epic",
 
151
  onPlay: [{ op: "ADD_ATK", value: { var: "def" } }],
152
  onCombo: [{ op: "ADD_ATK", value: 1 }],
153
  },
154
  {
155
  id: 21, name: "破綻偵測", tag: "A", nextReq: "B", atk: 5, def: 0, rarity: "epic",
 
156
  // BaseATK +1:真·永久(整場累積、過關不重置)。原版只歸零 baseDef、不歸零 baseAtk,1:1 保留此不對稱。
157
  onCombo: [{ op: "ADD_BASE_ATK", value: 1 }],
158
  },
159
  {
160
  id: 22, name: "鋼鐵旋風", tag: "Any", nextReq: "Any", atk: 4, def: 4, rarity: "epic",
 
161
  onCombo: [{ op: "ADD_DEF", value: 4 }, { op: "ADD_ATK", value: 4 }],
162
  },
163
  {
164
  id: 23, name: "蓄勢", tag: "A", nextReq: "A", atk: 2, def: 0, rarity: "epic",
 
165
  onCombo: [{ op: "SET_FLAG", flag: "蓄勢" }],
166
  },
167
  {
168
  id: 37, name: "最後的攻勢", tag: "A", nextReq: "A", atk: 3, def: 0, rarity: "epic",
 
169
  onCombo: [
170
  { op: "ADD_ATK", value: { mul: [{ var: "coin" }, { var: "coin" }, 3] } },
171
  { op: "SET_COIN", value: 0 },
@@ -174,11 +204,13 @@ export const CARDS: readonly CardData[] = [
174
  },
175
  {
176
  id: 38, name: "強化訓練", tag: "B", nextReq: "A", atk: 0, def: 1, rarity: "epic",
 
177
  onPlay: [{ op: "ADD_DEF", value: { mul: [2, { var: "training" }] } }],
178
  onCombo: [{ op: "ADD_COUNTER", counter: "training", value: 1 }],
179
  },
180
  {
181
  id: 39, name: "幸運的硬幣之路", tag: "B", nextReq: "A", atk: 0, def: 0, rarity: "normal",
 
182
  // 即時:lucky=rand∈[0,1];0→Coin+=3,否則 DEF+=3*Coin
183
  onPlay: [
184
  { op: "RANDOM_SET", name: "lucky", lo: 0, hi: 1 },
@@ -202,6 +234,7 @@ export const CARDS: readonly CardData[] = [
202
  },
203
  {
204
  id: 40, name: "記憶之路", tag: "B", nextReq: "A", atk: 0, def: 1, rarity: "epic",
 
205
  onPlay: [{ op: "ADD_COIN", value: -1 }, { op: "DRAW", value: 1 }],
206
  onCombo: [{ op: "DRAW", value: 2 }],
207
  },
@@ -209,13 +242,15 @@ export const CARDS: readonly CardData[] = [
209
  // ===== C. 傳說卡(獎勵池:24–29)=====
210
  {
211
  id: 24, name: "絕對防禦", tag: "B", nextReq: "A", atk: 0, def: 15, rarity: "legend",
 
212
  onPlay: [{ op: "SET_FLAG", flag: "絕對防禦" }],
213
  onCombo: [{ op: "ADD_ATK", value: 1 }],
214
  exhaust: true, // 黑玫瑰·前設:用完進消耗堆
215
  },
216
  {
217
  id: 25, name: "命運之路的抉擇", tag: "Any", nextReq: "Any", atk: 5, def: 0, rarity: "legend",
218
- exhaust: true, // 焚燒
 
219
  // Combo(A):本回合 ATK 的 1/2 保留至下回合(用專屬「留攻」旗標,連擊中斷也不清除);B:抽 2;Any:抽 1 + ATK5
220
  onCombo: [
221
  {
@@ -228,32 +263,38 @@ export const CARDS: readonly CardData[] = [
228
  },
229
  {
230
  id: 26, name: "失控侵蝕", tag: "A", nextReq: "A", atk: 3, def: 0, rarity: "legend",
 
231
  // 焚燒(exhaust);出牌即 失控侵蝕:DEF 鎖 0(清當前 DEF)+ 連擊每 2 抽 1 + 加 DEF 一半轉 ATK;本場持續、下一關重置
232
  onPlay: [{ op: "SET_FLAG", flag: "失控侵蝕" }, { op: "SET_DEF", value: 0 }],
233
  exhaust: true,
234
  },
235
  {
236
  id: 27, name: "均衡天秤", tag: "B", nextReq: "None", atk: 5, def: 5, rarity: "legend",
 
237
  onPlay: [{ op: "SWAP_ATK_HP" }, { op: "END_COMBO" }],
238
  modeOverride: { PVP: { notes: "SWAP 後夾 HP ≥ 1(07 §4.5);M3+ 實作" } },
239
  },
240
  {
241
  id: 28, name: "傳說之證", tag: "Any", nextReq: "Any", atk: 5, def: 5, rarity: "legend",
 
242
  onPlay: [{ op: "SET_FLAG", flag: "傳說之證" }, { op: "SET_MAX_COIN", value: 1 }],
243
  exhaust: true, // 黑玫瑰·誓言:用完進消耗堆
244
  },
245
  {
246
  id: 29, name: "最後的決斷", tag: "A", nextReq: "A", atk: 0, def: 0, rarity: "legend",
 
247
  onPlay: [{ op: "ADD_ATK", value: { mul: [{ var: "playCardCount" }, 3] } }],
248
  },
249
 
250
  // ===== D. 升級專屬卡(不在獎勵池:34, 35)=====
251
  {
252
  id: 34, name: "血劍", tag: "A", nextReq: "A", atk: 8, def: 0, rarity: "upgrade",
 
253
  onCombo: [{ op: "ADD_COUNTER", counter: "blood", value: 1 }],
254
  },
255
  {
256
  id: 35, name: "終極一擊", tag: "A", nextReq: "A", atk: 20, def: 0, rarity: "upgrade",
 
257
  onPlay: [{ op: "ULT_WIN_CHECK" }],
258
  onCombo: [{ op: "ADD_COIN", value: 1 }],
259
  modeOverride: { PVP: { notes: "WIN → 無視對手 DEF 且 atk += 對手HP/2 半血處決(07 §4.5);M3+ 實作" } },
@@ -510,9 +551,9 @@ export const CARDS: readonly CardData[] = [
510
  onPlay: [{ op: "LOCK_N", value: 1, duration: 3 }],
511
  },
512
  {
513
- id: 165, classType: "BARBARIAN", name: "野性先手", tag: "None", nextReq: "None", atk: 15, def: 0, rarity: "epic",
514
- dmgText: "15", desc: "造成 15 點傷害;若為本回合第一張牌,本次不扣血,否則出牌計數 n 額外 +1。",
515
- onPlay: [{ op: "IF", cond: { kind: "nEq", value: 1 }, then: [{ op: "SUPPRESS_SELFDMG" }], else: [{ op: "ADD_N", value: 1 }] }],
516
  },
517
  {
518
  id: 166, classType: "BARBARIAN", name: "蠻荒震擊", tag: "None", nextReq: "None", atk: 8, def: 0, rarity: "epic",
@@ -568,8 +609,8 @@ export const CARDS: readonly CardData[] = [
568
  {
569
  id: 183, classType: "BARBARIAN", name: "死亡前的凝視", tag: "None", nextReq: "None", atk: 0, def: 0, rarity: "legend",
570
  exhaust: true,
571
- desc: "本回合若你將死亡,改為復活並回復至總生命上限的 50%。若觸發,本卡將被永久移除(連消耗堆都不留)。",
572
- onPlay: [{ op: "ARM_REVIVE", fraction: 0.5 }],
573
  },
574
  {
575
  id: 184, classType: "BARBARIAN", name: "Inverse", tag: "None", nextReq: "None", atk: 0, def: 0, rarity: "legend",
@@ -586,8 +627,8 @@ export const CARDS: readonly CardData[] = [
586
  {
587
  id: 186, classType: "BARBARIAN", name: "萬象寂滅", tag: "None", nextReq: "None", atk: 0, def: 0, rarity: "legend",
588
  exhaust: true,
589
- desc: "將棄牌堆中隨機 5 張卡牌直接移入消耗堆;將 10 張「專注」放在抽牌堆頂部。",
590
- onPlay: [{ op: "ANNIHILATE", token: 110, moveCount: 5, tokenCount: 10, position: "top" }],
591
  },
592
  {
593
  id: 187, classType: "BARBARIAN", name: "反刃血鎧", tag: "None", nextReq: "None", atk: 0, def: 0, rarity: "legend",
@@ -605,8 +646,8 @@ export const CARDS: readonly CardData[] = [
605
  {
606
  id: 110, classType: "BARBARIAN", name: "專注", tag: "None", nextReq: "None", atk: 0, def: 0, rarity: "normal",
607
  isToken: true, derived: true, exhaust: true,
608
- desc: "(Token)抽到即釋放:臨時血量上限 +1(並回 1 HP,不計入出牌數)。用完進消耗堆。",
609
- onDraw: [{ op: "ADD_TEMP_MAXHP", value: 1 }],
610
  },
611
  {
612
  id: 111, classType: "BARBARIAN", name: "蓄力", tag: "None", nextReq: "None", atk: 3, def: 0, rarity: "normal",
 
19
  // ===== A. 普通卡(獎勵池:0–12, 30, 31, 32, 33, 36)=====
20
  {
21
  id: 0, name: "閃躲", tag: "B", nextReq: "Any", atk: 0, def: 2, rarity: "normal",
22
+ desc: "連擊:抽 1 張,然後結束本次連擊。",
23
  onCombo: [{ op: "DRAW", value: 1 }, { op: "END_COMBO" }],
24
  },
25
  {
26
  id: 1, name: "瘋狂連打", tag: "A", nextReq: "None", atk: 0, def: 0, rarity: "normal",
27
+ desc: "連擊:ATK += 連擊數,然後結束本次連擊。",
28
  onCombo: [{ op: "ADD_ATK", value: { var: "combo" } }, { op: "END_COMBO" }],
29
  },
30
  {
31
  id: 2, name: "加固", tag: "B", nextReq: "B", atk: 0, def: 4, rarity: "normal",
32
+ desc: "連擊:基礎 DEF +1(本場戰鬥持續,過關重置)。",
33
  // BaseDEF +1:本局持續(過關時 initStates 把 baseDef 歸零而重置)。卡面即「此場戰鬥內 DEF+1」。
34
  onCombo: [{ op: "ADD_BASE_DEF", value: 1 }],
35
  },
36
  {
37
  id: 3, name: "好的開始", tag: "Any", nextReq: "Any", atk: 2, def: 0, rarity: "normal",
38
+ desc: "即時:若為起手(出牌前連擊數為 0)→ 抽 1 張。",
39
  // 抽牌只發生在「起手」這條路徑(01 §4.2)
40
  onPlay: [{ op: "IF", cond: { kind: "isStarter" }, then: [{ op: "DRAW", value: 1 }] }],
41
  },
42
  {
43
  id: 4, name: "重擊", tag: "A", nextReq: "A", atk: 6, def: 0, rarity: "normal",
44
+ desc: "即時:設下強制結束旗標(再打一張接不上即強制結束回合)。",
45
  // 只設旗標;「再打一張即強制結束」由引擎處理(Q2 拍板)
46
  onPlay: [{ op: "SET_FLAG", flag: "重擊" }],
47
  },
48
  {
49
  id: 5, name: "龜縮", tag: "B", nextReq: "B", atk: 0, def: 8, rarity: "normal",
50
+ desc: "即時:鎖 A,本回合無法再打出 A 標籤的牌。",
51
  onPlay: [{ op: "LOCK_TAG", tag: "A" }],
52
  },
53
  {
54
  id: 6, name: "捨身一擊", tag: "A", nextReq: "A", atk: 7, def: 0, rarity: "normal",
55
+ desc: "即時:HP -2,並鎖 B,本回合無法再打出 B 標籤的牌。連擊:ATK +3。",
56
  onPlay: [{ op: "ADD_HP", value: -2 }, { op: "LOCK_TAG", tag: "B" }],
57
  onCombo: [{ op: "ADD_ATK", value: 3 }],
58
  },
59
  {
60
  id: 7, name: "不穩定的格擋", tag: "Any", nextReq: "B", atk: 0, def: 0, rarity: "normal",
61
+ desc: "即時:DEF += 隨機 0~8(每次不同,可能毫無作用)。連擊:DEF -3。",
62
  onPlay: [{ op: "RANDOM_DEF_0_8" }],
63
  onCombo: [{ op: "ADD_DEF", value: -3 }],
64
  },
65
  {
66
  id: 8, name: "深呼吸", tag: "B", nextReq: "Any", atk: 0, def: 2, rarity: "normal",
67
+ desc: "連擊:若手牌中已無任何 A 標籤卡 → 抽 1。",
68
  onCombo: [{ op: "IF", cond: { kind: "noTagInHand", tag: "A" }, then: [{ op: "DRAW", value: 1 }] }],
69
  },
70
  {
71
  id: 9, name: "挑釁", tag: "Any", nextReq: "Any", atk: 3, def: 0, rarity: "normal",
72
+ desc: "即時:抽 1,並讓本回合怪物反擊 ATK +1。連擊:再抽 1。",
73
  onPlay: [{ op: "SET_FLAG", flag: "挑釁" }, { op: "DRAW", value: 1 }],
74
  onCombo: [{ op: "DRAW", value: 1 }],
75
  },
76
  {
77
  id: 10, name: "節奏感", tag: "A", nextReq: "Any", atk: 1, def: 0, rarity: "normal",
78
+ desc: "即時:若連擊數為偶數 → DEF +3,否則 ATK +3。",
79
  onPlay: [
80
  { op: "IF", cond: { kind: "comboEven" }, then: [{ op: "ADD_DEF", value: 3 }], else: [{ op: "ADD_ATK", value: 3 }] },
81
  ],
82
  },
83
  {
84
  id: 11, name: "餘裕", tag: "B", nextReq: "Any", atk: 0, def: 5, rarity: "normal",
85
+ desc: "即時:回合末若硬幣 >0 → HP +5、maxHP +5。",
86
  onPlay: [{ op: "SET_FLAG", flag: "餘裕" }],
87
  },
88
  {
89
  id: 12, name: "沉穩應對", tag: "B", nextReq: "Any", atk: 0, def: 4, rarity: "normal",
90
+ desc: "即時:若連擊數恰為 1(起手首張)→ 硬幣 +1。",
91
  // 名為 COMBO_0 但檢查 Combo==1(起手後 Combo 立即為 1,06 已知問題 #7,行為照舊)
92
  onPlay: [{ op: "IF", cond: { kind: "comboEq", value: 1 }, then: [{ op: "ADD_COIN", value: 1 }] }],
93
  },
94
  {
95
  id: 30, name: "終章決戰", tag: "None", nextReq: "None", atk: 5, def: 0, rarity: "normal",
96
+ desc: "即時:若硬幣為 0 且手牌已空 → ATK +15 並結束連擊。",
97
  onPlay: [
98
  {
99
  op: "IF",
 
104
  },
105
  {
106
  id: 31, name: "懸崖前的注視", tag: "A", nextReq: "Any", atk: 11, def: 0, rarity: "normal",
107
+ desc: "即時:ATK -= 當前手牌張數。連擊(依下一張 tag):A→ATK -2;B→DEF -4;Any→ATK -2 且 DEF -3。",
108
  onPlay: [{ op: "ADD_ATK", value: { mul: [-1, { var: "handCount" }] } }],
109
  onCombo: [
110
  {
 
117
  },
118
  {
119
  id: 32, name: "新月訓練", tag: "A", nextReq: "B", atk: 1, def: 0, rarity: "normal",
120
+ desc: "即時:ATK += 新月計數 × 2。連擊:新月計數 +1(本場累積)。",
121
  onPlay: [{ op: "ADD_ATK", value: { mul: [2, { var: "newmoon" }] } }],
122
  onCombo: [{ op: "ADD_COUNTER", counter: "newmoon", value: 1 }],
123
  },
124
  {
125
  id: 33, name: "斷��", tag: "A", nextReq: "A", atk: 0, def: 0, rarity: "normal",
126
+ desc: "連擊:斷劍計數 +(當前硬幣 + 1)(累積達 20 升級為血劍)。",
127
  // 連擊:鍛造(broken 計數)+(當前剩餘硬幣 + 1)
128
  onCombo: [{ op: "ADD_COUNTER", counter: "broken", value: { add: [{ var: "coin" }, 1] } }],
129
  },
130
  {
131
  id: 36, name: "應急", tag: "A", nextReq: "B", atk: 1, def: 0, rarity: "normal",
132
+ desc: "即時:手牌上限 -1、抽 2 張。連擊:DEF +2。",
133
  onPlay: [{ op: "ADD_MAX_HAND", value: -1 }, { op: "DRAW", value: 2 }],
134
  onCombo: [{ op: "ADD_DEF", value: 2 }],
135
  },
 
137
  // ===== B. 史詩卡(獎勵池:13–23, 37, 38, 39, 40)=====
138
  {
139
  id: 13, name: "連環爆發", tag: "Any", nextReq: "Any", atk: 7, def: 0, rarity: "epic",
140
+ desc: "連擊:ATK +5。",
141
  onCombo: [{ op: "ADD_ATK", value: 5 }],
142
  },
143
  {
144
  id: 14, name: "黃金律動", tag: "A", nextReq: "A", atk: 5, def: 0, rarity: "epic",
145
+ desc: "即時:若打出當下連擊數 ≥ 6 → 下回合硬幣回滿時額外 +1。",
146
  onPlay: [{ op: "IF", cond: { kind: "comboGte", value: 6 }, then: [{ op: "SET_FLAG", flag: "黃金律動" }] }],
147
  },
148
  {
149
  id: 15, name: "生命汲取", tag: "A", nextReq: "B", atk: 4, def: 0, rarity: "epic",
150
+ desc: "即時:本次出傷時回血 min(本波傷害÷2, 10)(夾當前生命上限)。",
151
  onPlay: [{ op: "SET_FLAG", flag: "生命汲取" }],
152
  },
153
  {
154
  id: 16, name: "快速裝填", tag: "Any", nextReq: "Any", atk: 1, def: 0, rarity: "epic",
155
+ desc: "連擊:抽 5 張。",
156
  onCombo: [{ op: "DRAW", value: 5 }],
157
  },
158
  {
159
  id: 17, name: "烈空斬", tag: "A", nextReq: "Any", atk: 6, def: 0, rarity: "epic",
160
+ desc: "即時:本次出傷額外 + 怪物當前 HP 的 30%(向下取整)。",
161
  onPlay: [{ op: "SET_FLAG", flag: "烈空斬" }],
162
  modeOverride: { PVP: { notes: "烈空斬上限綁對手 maxHP=floor(maxHP×3/10)(maxHP=200→60),見 pvpResolve outgoing()" } },
163
  },
164
  {
165
  id: 18, name: "盾牆", tag: "B", nextReq: "B", atk: 0, def: 3, rarity: "epic",
166
+ desc: "連擊:當前 DEF 翻倍(DEF += 當前 DEF)。",
167
  onCombo: [{ op: "ADD_DEF", value: { var: "def" } }], // 當前 DEF 翻倍
168
  },
169
  {
170
  id: 19, name: "連擊狂熱", tag: "A", nextReq: "A", atk: 1, def: 0, rarity: "epic",
171
+ desc: "即時:ATK += 連擊數 × 2。",
172
  onPlay: [{ op: "ADD_ATK", value: { mul: [{ var: "combo" }, 2] } }],
173
  },
174
  {
175
  id: 20, name: "盾擊", tag: "A", nextReq: "A", atk: 0, def: 0, rarity: "epic",
176
+ desc: "即時:ATK += 當前 DEF。連擊:ATK +1。",
177
  onPlay: [{ op: "ADD_ATK", value: { var: "def" } }],
178
  onCombo: [{ op: "ADD_ATK", value: 1 }],
179
  },
180
  {
181
  id: 21, name: "破綻偵測", tag: "A", nextReq: "B", atk: 5, def: 0, rarity: "epic",
182
+ desc: "連擊:基礎 ATK 永久 +1(整場累積、過關也不重置)。",
183
  // BaseATK +1:真·永久(整場累積、過關不重置)。原版只歸零 baseDef、不歸零 baseAtk,1:1 保留此不對稱。
184
  onCombo: [{ op: "ADD_BASE_ATK", value: 1 }],
185
  },
186
  {
187
  id: 22, name: "鋼鐵旋風", tag: "Any", nextReq: "Any", atk: 4, def: 4, rarity: "epic",
188
+ desc: "連擊:DEF +4、ATK +4。",
189
  onCombo: [{ op: "ADD_DEF", value: 4 }, { op: "ADD_ATK", value: 4 }],
190
  },
191
  {
192
  id: 23, name: "蓄勢", tag: "A", nextReq: "A", atk: 2, def: 0, rarity: "epic",
193
+ desc: "連擊:下一次出傷 +25%(無條件捨去)後消耗。",
194
  onCombo: [{ op: "SET_FLAG", flag: "蓄勢" }],
195
  },
196
  {
197
  id: 37, name: "最後的攻勢", tag: "A", nextReq: "A", atk: 3, def: 0, rarity: "epic",
198
+ desc: "連擊:ATK += 硬幣 × 硬幣 × 3,接著硬幣歸 0 並結束連擊。",
199
  onCombo: [
200
  { op: "ADD_ATK", value: { mul: [{ var: "coin" }, { var: "coin" }, 3] } },
201
  { op: "SET_COIN", value: 0 },
 
204
  },
205
  {
206
  id: 38, name: "強化訓練", tag: "B", nextReq: "A", atk: 0, def: 1, rarity: "epic",
207
+ desc: "即時:DEF += 2 × 訓練計數(本場累積)。連擊:訓練計數 +1。",
208
  onPlay: [{ op: "ADD_DEF", value: { mul: [2, { var: "training" }] } }],
209
  onCombo: [{ op: "ADD_COUNTER", counter: "training", value: 1 }],
210
  },
211
  {
212
  id: 39, name: "幸運的硬幣之路", tag: "B", nextReq: "A", atk: 0, def: 0, rarity: "normal",
213
+ desc: "即時:擲幸運硬幣(0/1)——0 則硬幣 +3,否則 DEF += 3 × 當前硬幣。連擊:結算相反那半,結束後幸運值歸 0。",
214
  // 即時:lucky=rand∈[0,1];0→Coin+=3,否則 DEF+=3*Coin
215
  onPlay: [
216
  { op: "RANDOM_SET", name: "lucky", lo: 0, hi: 1 },
 
234
  },
235
  {
236
  id: 40, name: "記憶之路", tag: "B", nextReq: "A", atk: 0, def: 1, rarity: "epic",
237
+ desc: "即時:硬幣 -1、抽 1 張。連擊:抽 2 張。",
238
  onPlay: [{ op: "ADD_COIN", value: -1 }, { op: "DRAW", value: 1 }],
239
  onCombo: [{ op: "DRAW", value: 2 }],
240
  },
 
242
  // ===== C. 傳說卡(獎勵池:24–29)=====
243
  {
244
  id: 24, name: "絕對防禦", tag: "B", nextReq: "A", atk: 0, def: 15, rarity: "legend",
245
+ desc: "即時:本回合 DEF 延後一回合才重置(多撐一回合)。連擊:ATK +1。(焚燒:用完進消耗堆)",
246
  onPlay: [{ op: "SET_FLAG", flag: "絕對防禦" }],
247
  onCombo: [{ op: "ADD_ATK", value: 1 }],
248
  exhaust: true, // 黑玫瑰·前設:用完進消耗堆
249
  },
250
  {
251
  id: 25, name: "命運之路的抉擇", tag: "Any", nextReq: "Any", atk: 5, def: 0, rarity: "legend",
252
+ desc: "連擊(依下一張 tag):A→本回合 ATK 半數保留到下回合(連擊中斷也保留);B→抽 2;Any→抽 1 並 ATK +5。",
253
+ // 取消焚燒:打出後比照正常卡洗入棄牌堆(可重複抽到再用),不進消耗堆。
254
  // Combo(A):本回合 ATK 的 1/2 保留至下回合(用專屬「留攻」旗標,連擊中斷也不清除);B:抽 2;Any:抽 1 + ATK5
255
  onCombo: [
256
  {
 
263
  },
264
  {
265
  id: 26, name: "失控侵蝕", tag: "A", nextReq: "A", atk: 3, def: 0, rarity: "legend",
266
+ desc: "即時:清空當前 DEF 並本場鎖 DEF=0;之後加 DEF 改以一半(四捨五入)轉 ATK,連擊改每 2 連抽 1。本場持續、下一關重置。(焚燒:用完進消耗堆)",
267
  // 焚燒(exhaust);出牌即 失控侵蝕:DEF 鎖 0(清當前 DEF)+ 連擊每 2 抽 1 + 加 DEF 一半轉 ATK;本場持續、下一關重置
268
  onPlay: [{ op: "SET_FLAG", flag: "失控侵蝕" }, { op: "SET_DEF", value: 0 }],
269
  exhaust: true,
270
  },
271
  {
272
  id: 27, name: "均衡天秤", tag: "B", nextReq: "None", atk: 5, def: 5, rarity: "legend",
273
+ desc: "即時:互換當前 ATK 與 HP 數值,並結束連擊。",
274
  onPlay: [{ op: "SWAP_ATK_HP" }, { op: "END_COMBO" }],
275
  modeOverride: { PVP: { notes: "SWAP 後夾 HP ≥ 1(07 §4.5);M3+ 實作" } },
276
  },
277
  {
278
  id: 28, name: "傳說之證", tag: "Any", nextReq: "Any", atk: 5, def: 5, rarity: "legend",
279
+ desc: "即時:本場任何卡都能接續連擊(無視標籤閘門),硬幣上限設為 1。(焚燒:用完進消耗堆)",
280
  onPlay: [{ op: "SET_FLAG", flag: "傳說之證" }, { op: "SET_MAX_COIN", value: 1 }],
281
  exhaust: true, // 黑玫瑰·誓言:用完進消耗堆
282
  },
283
  {
284
  id: 29, name: "最後的決斷", tag: "A", nextReq: "A", atk: 0, def: 0, rarity: "legend",
285
+ desc: "即時:ATK += 本場此卡前已出牌數 × 3。",
286
  onPlay: [{ op: "ADD_ATK", value: { mul: [{ var: "playCardCount" }, 3] } }],
287
  },
288
 
289
  // ===== D. 升級專屬卡(不在獎勵池:34, 35)=====
290
  {
291
  id: 34, name: "血劍", tag: "A", nextReq: "A", atk: 8, def: 0, rarity: "upgrade",
292
+ desc: "連擊:血劍計數 +1(本場累積,達 8 升級為終極一擊)。",
293
  onCombo: [{ op: "ADD_COUNTER", counter: "blood", value: 1 }],
294
  },
295
  {
296
  id: 35, name: "終極一擊", tag: "A", nextReq: "A", atk: 20, def: 0, rarity: "upgrade",
297
+ desc: "即時:依連擊數推進處決——連擊 1 時 winValue÷2、2÷3、3÷5、4÷7(由 210 起);整除到 1 時本回合出傷額外 +怪物當前 HP(斬殺)。連擊:硬幣 +1。",
298
  onPlay: [{ op: "ULT_WIN_CHECK" }],
299
  onCombo: [{ op: "ADD_COIN", value: 1 }],
300
  modeOverride: { PVP: { notes: "WIN → 無視對手 DEF 且 atk += 對手HP/2 半血處決(07 §4.5);M3+ 實作" } },
 
551
  onPlay: [{ op: "LOCK_N", value: 1, duration: 3 }],
552
  },
553
  {
554
+ id: 165, classType: "BARBARIAN", name: "野性先手", tag: "None", nextReq: "None", atk: 12, def: 0, rarity: "epic",
555
+ dmgText: "12", desc: "造成 12 點傷害;若為本回合第一張牌(n=1),出牌計數 n 變為 -2(n 為負時視為回血),否則 n 額外 +1。",
556
+ onPlay: [{ op: "IF", cond: { kind: "nEq", value: 1 }, then: [{ op: "SET_N", value: -2 }], else: [{ op: "ADD_N", value: 1 }] }],
557
  },
558
  {
559
  id: 166, classType: "BARBARIAN", name: "蠻荒震擊", tag: "None", nextReq: "None", atk: 8, def: 0, rarity: "epic",
 
609
  {
610
  id: 183, classType: "BARBARIAN", name: "死亡前的凝視", tag: "None", nextReq: "None", atk: 0, def: 0, rarity: "legend",
611
  exhaust: true,
612
+ desc: "本回合若你將死亡,改為:臨時生命上限 1:1 全數轉為永久生命,並以 100% 總生命復活。若觸發,本卡將被永久移除(連消耗堆都不留)。",
613
+ onPlay: [{ op: "ARM_REVIVE", fraction: 1.0 }],
614
  },
615
  {
616
  id: 184, classType: "BARBARIAN", name: "Inverse", tag: "None", nextReq: "None", atk: 0, def: 0, rarity: "legend",
 
627
  {
628
  id: 186, classType: "BARBARIAN", name: "萬象寂滅", tag: "None", nextReq: "None", atk: 0, def: 0, rarity: "legend",
629
  exhaust: true,
630
+ desc: "將棄牌堆中隨機 5 張卡牌直接移入消耗堆;將 10 張「專注」洗入棄牌堆。",
631
+ onPlay: [{ op: "ANNIHILATE", moveCount: 5 }, { op: "SHUFFLE_TOKEN", token: 110, pile: "discard", count: 10 }],
632
  },
633
  {
634
  id: 187, classType: "BARBARIAN", name: "反刃血鎧", tag: "None", nextReq: "None", atk: 0, def: 0, rarity: "legend",
 
646
  {
647
  id: 110, classType: "BARBARIAN", name: "專注", tag: "None", nextReq: "None", atk: 0, def: 0, rarity: "normal",
648
  isToken: true, derived: true, exhaust: true,
649
+ desc: "(Token)抽到即釋放:臨時血量上限 +2(並回 2 HP,不計入出牌數)。用完進消耗堆。",
650
+ onDraw: [{ op: "ADD_TEMP_MAXHP", value: 2 }],
651
  },
652
  {
653
  id: 111, classType: "BARBARIAN", name: "蓄力", tag: "None", nextReq: "None", atk: 3, def: 0, rarity: "normal",
packages/battle-core/src/deck.ts CHANGED
@@ -10,7 +10,7 @@ import { shuffle } from "./rng.js";
10
 
11
  /**
12
  * 抽到卡時的「on-draw」解析器(註冊式,避免 deck ↔ effects 循環相依)。
13
- * 回傳 consumed=true 表示該卡被自動釋放(如野蠻人「專注」抽到即 +1 臨時上限、進消耗堆),
14
  * 不進手牌、不佔抽牌數(會補抽下一張)。由 player.ts 在載入時註冊。
15
  */
16
  export type OnDrawResolver = (
 
10
 
11
  /**
12
  * 抽到卡時的「on-draw」解析器(註冊式,避免 deck ↔ effects 循環相依)。
13
+ * 回傳 consumed=true 表示該卡被自動釋放(如野蠻人「專注」抽到即 +2 臨時上限、進消耗堆),
14
  * 不進手牌、不佔抽牌數(會補抽下一張)。由 player.ts 在載入時註冊。
15
  */
16
  export type OnDrawResolver = (
packages/battle-core/src/effects.ts CHANGED
@@ -177,7 +177,7 @@ export function runOps(ops: EffectOp[] | undefined, ctx: EffectCtx): void {
177
  }
178
  break;
179
  }
180
- case "SET_N": p.n = Math.max(0, op.value); break;
181
  case "ADD_N": p.n = Math.max(op.min ?? 0, p.n + op.value); break;
182
  case "RANDOM_DISCARD": {
183
  let cnt = evalValue(op.count, p);
@@ -256,18 +256,13 @@ export function runOps(ops: EffectOp[] | undefined, ctx: EffectCtx): void {
256
  break;
257
  }
258
  case "ANNIHILATE": {
259
- // 棄牌堆隨機 moveCount 張 → 消耗堆(decisive,消耗亂數)
260
  const moveN = Math.min(op.moveCount, p.discard.length);
261
  for (let k = 0; k < moveN; k++) {
262
  const [idx, next] = nextInt(ctx.rng, p.discard.length);
263
  ctx.rng = next;
264
  p.burn.push(p.discard.splice(idx, 1)[0]!);
265
  }
266
- // 於牌庫生成 tokenCount 個 token:top=尾端(下次先抽到→手牌恆滿會即時釋放);bottom=index0(隨牌庫循環逐步釋放)
267
- for (let i = 0; i < op.tokenCount; i++) {
268
- if (op.position === "top") p.deck.push(op.token);
269
- else p.deck.unshift(op.token);
270
- }
271
  break;
272
  }
273
  case "MOVE_TOKEN": {
 
177
  }
178
  break;
179
  }
180
+ case "SET_N": p.n = op.value; break; // 可為負(野性先手 n→-2,負 n 於出牌結算回血)
181
  case "ADD_N": p.n = Math.max(op.min ?? 0, p.n + op.value); break;
182
  case "RANDOM_DISCARD": {
183
  let cnt = evalValue(op.count, p);
 
256
  break;
257
  }
258
  case "ANNIHILATE": {
259
+ // 萬象寂滅:棄牌堆隨機 moveCount 張 → 消耗堆(decisive,消耗亂數)。token 生成由卡片另接 SHUFFLE_TOKEN。
260
  const moveN = Math.min(op.moveCount, p.discard.length);
261
  for (let k = 0; k < moveN; k++) {
262
  const [idx, next] = nextInt(ctx.rng, p.discard.length);
263
  ctx.rng = next;
264
  p.burn.push(p.discard.splice(idx, 1)[0]!);
265
  }
 
 
 
 
 
266
  break;
267
  }
268
  case "MOVE_TOKEN": {
packages/battle-core/src/engine.ts CHANGED
@@ -5,7 +5,7 @@
5
  * step() 對 GameState 做 structuredClone 後在副本上修改,確保無副作用、可重播。
6
  */
7
 
8
- import type { Action, ClassType, GameEvent, GameState, StepResult } from "./types.js";
9
  import { makeRng, shuffle } from "./rng.js";
10
  import { drawCards } from "./deck.js";
11
  import { CLASS_INIT } from "./classes.js";
@@ -30,6 +30,7 @@ import {
30
  opponentTakeDamage,
31
  upgradeMonsterForLevel,
32
  } from "./opponent.js";
 
33
  import { rewardPoolFor, startingDeckFor } from "./cards.js";
34
  import type { GhostRecord } from "./types.js";
35
 
@@ -38,21 +39,24 @@ export const MAX_LEVEL = 11;
38
  /** 預設鬼影關 = 預設最後一關 + 1(僅供 UI/參考;實際以 state.maxLevel+1 為準)。 */
39
  export const GHOST_LEVEL = MAX_LEVEL + 1;
40
 
41
- export function createGame(opts: { classType: ClassType; seed: number; maxLevel?: number }): GameState {
42
  let rng = makeRng(opts.seed);
43
  const created = createPlayer(opts.classType, rng, startingDeckFor(opts.classType));
44
  rng = created.rng;
45
  const player = created.player;
46
  // 起手抽滿(戰士 5;野蠻人手牌恆滿亦為 5)
47
  rng = drawCards(player, rng, CLASS_INIT[opts.classType].handPerTurn, []);
48
- // maxLevel 為除錯旋鈕:預設 11;帶 maxLevel:3 可秒到最後一關驗證破關/結算/鬼影串接。正式版維持 11。
49
- const maxLevel = opts.maxLevel && opts.maxLevel > 0 ? Math.floor(opts.maxLevel) : MAX_LEVEL;
 
 
50
  return {
51
  level: 1,
52
  maxLevel,
 
53
  phase: "PLAYER_TURN",
54
  player,
55
- opponent: createMonster(),
56
  rng,
57
  turnLog: [],
58
  };
@@ -112,6 +116,7 @@ export function step(state: GameState, action: Action): StepResult {
112
  const res = playCard(next.player, next.rng, action.handIndex);
113
  next.rng = res.rng;
114
  events.push(...res.events);
 
115
  if (res.ok && next.player.specialWin) { // 蓄力 ×15 特殊勝利,優先於暫停/強制結束
116
  next.phase = "VICTORY";
117
  events.push({ type: "SPECIAL_WIN" }, { type: "VICTORY" });
@@ -220,12 +225,20 @@ function endTurnFlow(state: GameState, events: GameEvent[]): void {
220
  ghostBeginTurn(opp, (opp.ghost?.turnNo ?? 1) + 1); // 推進到下一回合攻防
221
  } else {
222
  monsterResetForNextTurn(opp, buff);
223
- const atkDealt = halveIfDebuffed(p, opp.atk); // 蠻荒震擊:敵下次攻擊減半
 
224
  playerTakeDamage(p, atkDealt);
225
  if (opp.hasBloodlust && atkDealt > p.def) {
226
  opp.hp = Math.min(opp.maxHp, opp.hp + 3); // 吸血
227
  }
228
  events.push({ type: "MONSTER_ATTACK", damage: atkDealt, hpAfter: p.hp });
 
 
 
 
 
 
 
229
  }
230
  } else {
231
  events.push({ type: "MONSTER_DEAD" });
@@ -283,9 +296,10 @@ function pickReward(state: GameState, choiceIndex: number, events: GameEvent[]):
283
  state.player.deck.push(cardId);
284
  events.push({ type: "REWARD_PICKED", cardId });
285
 
286
- // 推進下一關
287
  state.level += 1;
288
- upgradeMonsterForLevel(state.opponent, state.level);
 
289
  initStates(state.player);
290
  checkCardUpgrades(state.player, events);
291
  // 進新關後補滿手牌至「已重置的」上限:修正上一關 應急(ADD_MAX_HAND -1) 殘留,
 
5
  * step() 對 GameState 做 structuredClone 後在副本上修改,確保無副作用、可重播。
6
  */
7
 
8
+ import type { Action, Campaign, ClassType, GameEvent, GameState, StepResult } from "./types.js";
9
  import { makeRng, shuffle } from "./rng.js";
10
  import { drawCards } from "./deck.js";
11
  import { CLASS_INIT } from "./classes.js";
 
30
  opponentTakeDamage,
31
  upgradeMonsterForLevel,
32
  } from "./opponent.js";
33
+ import { accrueCardEnergy, createSanctus, SANCTUS_MAX_LEVEL, sanctusEnemyTurn, upgradeSanctusForLevel } from "./foes.js";
34
  import { rewardPoolFor, startingDeckFor } from "./cards.js";
35
  import type { GhostRecord } from "./types.js";
36
 
 
39
  /** 預設鬼影關 = 預設最後一關 + 1(僅供 UI/參考;實際以 state.maxLevel+1 為準)。 */
40
  export const GHOST_LEVEL = MAX_LEVEL + 1;
41
 
42
+ export function createGame(opts: { classType: ClassType; seed: number; maxLevel?: number; campaign?: Campaign }): GameState {
43
  let rng = makeRng(opts.seed);
44
  const created = createPlayer(opts.classType, rng, startingDeckFor(opts.classType));
45
  rng = created.rng;
46
  const player = created.player;
47
  // 起手抽滿(戰士 5;野蠻人手牌恆滿亦為 5)
48
  rng = drawCards(player, rng, CLASS_INIT[opts.classType].handPerTurn, []);
49
+ const campaign: Campaign = opts.campaign ?? "slime";
50
+ // maxLevel 為除錯旋鈕:預設史萊姆 11 / Sanctus 5;帶 maxLevel:3 可秒到最後一關驗證破關/結算。
51
+ const defaultMax = campaign === "sanctus" ? SANCTUS_MAX_LEVEL : MAX_LEVEL;
52
+ const maxLevel = opts.maxLevel && opts.maxLevel > 0 ? Math.floor(opts.maxLevel) : defaultMax;
53
  return {
54
  level: 1,
55
  maxLevel,
56
+ campaign,
57
  phase: "PLAYER_TURN",
58
  player,
59
+ opponent: campaign === "sanctus" ? createSanctus() : createMonster(),
60
  rng,
61
  turnLog: [],
62
  };
 
116
  const res = playCard(next.player, next.rng, action.handIndex);
117
  next.rng = res.rng;
118
  events.push(...res.events);
119
+ if (res.ok) accrueCardEnergy(next.opponent); // Sanctus:玩家每 2 張牌 → 怪物 +1 能量
120
  if (res.ok && next.player.specialWin) { // 蓄力 ×15 特殊勝利,優先於暫停/強制結束
121
  next.phase = "VICTORY";
122
  events.push({ type: "SPECIAL_WIN" }, { type: "VICTORY" });
 
225
  ghostBeginTurn(opp, (opp.ghost?.turnNo ?? 1) + 1); // 推進到下一回合攻防
226
  } else {
227
  monsterResetForNextTurn(opp, buff);
228
+ const skillBonus = sanctusEnemyTurn(opp, events); // Sanctus:能量 +2、執行意圖(升盾 / 一次性攻擊加成)、預告下回合;非 Sanctus 回 0
229
+ const atkDealt = halveIfDebuffed(p, opp.atk + skillBonus); // 蠻荒震擊:敵下次攻擊減半(含本回合技能加成)
230
  playerTakeDamage(p, atkDealt);
231
  if (opp.hasBloodlust && atkDealt > p.def) {
232
  opp.hp = Math.min(opp.maxHp, opp.hp + 3); // 吸血
233
  }
234
  events.push({ type: "MONSTER_ATTACK", damage: atkDealt, hpAfter: p.hp });
235
+ // Sanctus 審判:暫存反傷無視 DEF 直接扣 HP(無上限),於普攻後結算
236
+ if (opp.pendingReflect && opp.pendingReflect > 0) {
237
+ p.hp -= opp.pendingReflect;
238
+ if (p.hp < 0) p.hp = 0;
239
+ events.push({ type: "MONSTER_REFLECT", damage: opp.pendingReflect, hpAfter: p.hp });
240
+ opp.pendingReflect = 0;
241
+ }
242
  }
243
  } else {
244
  events.push({ type: "MONSTER_DEAD" });
 
296
  state.player.deck.push(cardId);
297
  events.push({ type: "REWARD_PICKED", cardId });
298
 
299
+ // 推進下一關(依路線升級:史萊姆數值放大 / Sanctus 解鎖技能 + 數值)
300
  state.level += 1;
301
+ if (state.campaign === "sanctus") upgradeSanctusForLevel(state.opponent, state.level);
302
+ else upgradeMonsterForLevel(state.opponent, state.level);
303
  initStates(state.player);
304
  checkCardUpgrades(state.player, events);
305
  // 進新關後補滿手牌至「已重置的」上限:修正上一關 應急(ADD_MAX_HAND -1) 殘留,
packages/battle-core/src/foes.ts ADDED
@@ -0,0 +1,206 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ /**
2
+ * Sanctus 路線(5 關)設定。史萊姆路線維持 opponent.ts 的 createMonster / upgradeMonsterForLevel。
3
+ *
4
+ * 設計(13/14 設計團 + 平均輸出實測校正,見 scripts/class-output-sim.ts):
5
+ * - 審判 Judgment:玩家「原始 ATK」超過審判線 → 溢出 ½ 無視 DEF 反傷(**無上限**),下次怪物攻擊結算。
6
+ * 審判線設在「高於戰士常態輸出(基礎 ~15、養成後 ~22)」,只懲罰刻意梭哈、不懲罰正常玩。
7
+ * - Aegis 護盾:疊加吸收層;由能量技能升起(Phase 2)。
8
+ * - 能量×技能×意圖:逐關解鎖(Phase 2)。
9
+ */
10
+ import type { GameEvent, OpponentState } from "./types.js";
11
+
12
+ /** 怪物技能(能量技能;資料驅動)。name/desc 供「意圖預告」與「地圖敵人詳情」顯示。 */
13
+ export interface MonsterSkill {
14
+ id: string;
15
+ name: string;
16
+ desc: string;
17
+ icon: string;
18
+ cost: number; // 能量成本
19
+ unlockLevel: number; // 第幾關解鎖
20
+ }
21
+
22
+ /** Sanctus 被動本體:審判(顯示用;實際結算在 opponentTakeDamage / endTurnFlow)。 */
23
+ export const SANCTUS_PASSIVE = {
24
+ name: "聖裁(被動)",
25
+ icon: "⚖️",
26
+ desc: "你單一回合的攻擊力超過「審判線」時,超出部分的一半會無視你的防禦反噬到你身上,沒有上限。",
27
+ } as const;
28
+
29
+ /** Sanctus 能量技能登錄表(逐關解鎖;數值好調)。 */
30
+ export const SANCTUS_SKILLS: Record<string, MonsterSkill> = {
31
+ aegis: { id: "aegis", name: "聖盾術", icon: "🛡️", cost: 3, unlockLevel: 1, desc: "升起聖盾,獲得護盾。護盾會吸收傷害,先於 HP 被扣掉。" },
32
+ smite: { id: "smite", name: "聖光裁斬", icon: "✦", cost: 4, unlockLevel: 2, desc: "普攻追加一道聖光,本回合造成額外傷害。" },
33
+ parry: { id: "parry", name: "格擋姿態", icon: "🛡", cost: 3, unlockLevel: 3, desc: "擺出格擋架式,下一回合防禦與護盾大幅提升。" },
34
+ verdict: { id: "verdict", name: "裁決斬", icon: "⚔️", cost: 7, unlockLevel: 4, desc: "蓄力一記裁決重擊,預告後於下回合落下高額傷害。" },
35
+ lastjudgment: { id: "lastjudgment", name: "神聖終審", icon: "☀️", cost: 10, unlockLevel: 5, desc: "降下神聖終審,造成大量傷害並同時升起聖盾。" },
36
+ };
37
+
38
+ export interface SanctusLevelConfig {
39
+ hp: number;
40
+ def: number;
41
+ baseAtk: number;
42
+ aegisCap: number;
43
+ maxEnergy: number;
44
+ judgeLine: number;
45
+ intentDepth: number; // 一次預告幾步(前期 1、後期 boss 2)
46
+ skills: string[]; // 該關已習得的能量技能 id
47
+ }
48
+
49
+ /** Sanctus 自己的 5 關曲線(數值錨定戰士每回合輸出,見上)。 */
50
+ export const SANCTUS_LEVELS: readonly SanctusLevelConfig[] = [
51
+ { hp: 28, def: 2, baseAtk: 5, aegisCap: 4, maxEnergy: 8, judgeLine: 18, intentDepth: 1, skills: ["aegis"] },
52
+ { hp: 42, def: 3, baseAtk: 6, aegisCap: 6, maxEnergy: 8, judgeLine: 21, intentDepth: 1, skills: ["aegis", "smite"] },
53
+ { hp: 58, def: 4, baseAtk: 7, aegisCap: 8, maxEnergy: 9, judgeLine: 24, intentDepth: 1, skills: ["aegis", "smite", "parry"] },
54
+ { hp: 78, def: 5, baseAtk: 8, aegisCap: 10, maxEnergy: 10, judgeLine: 27, intentDepth: 2, skills: ["aegis", "smite", "parry", "verdict"] },
55
+ { hp: 100, def: 6, baseAtk: 9, aegisCap: 12, maxEnergy: 10, judgeLine: 30, intentDepth: 2, skills: ["aegis", "smite", "parry", "verdict", "lastjudgment"] },
56
+ ] as const;
57
+
58
+ export const SANCTUS_MAX_LEVEL = SANCTUS_LEVELS.length;
59
+
60
+ const cfg = (level: number): SanctusLevelConfig => SANCTUS_LEVELS[Math.min(Math.max(level, 1), SANCTUS_MAX_LEVEL) - 1]!;
61
+
62
+ /** 套用某關設定到 opponent(生成與升級共用)。HP 回滿、Aegis/能量歸零、技能依關卡解鎖。 */
63
+ function applySanctusLevel(m: OpponentState, level: number): void {
64
+ const c = cfg(level);
65
+ m.maxHp = c.hp;
66
+ m.hp = c.hp;
67
+ m.baseAtk = c.baseAtk;
68
+ m.atk = c.baseAtk;
69
+ m.baseDef = c.def;
70
+ m.def = c.def;
71
+ m.aegisCap = c.aegisCap;
72
+ m.aegis = 0;
73
+ m.judgeLine = c.judgeLine;
74
+ m.pendingReflect = 0;
75
+ m.maxEnergy = c.maxEnergy;
76
+ m.energy = 0;
77
+ m.cardEnergyCounter = 0;
78
+ m.skills = c.skills.slice();
79
+ m.intent = [];
80
+ m.intentDepth = c.intentDepth;
81
+ m.isAlive = true;
82
+ }
83
+
84
+ /** 第 1 關 Sanctus。 */
85
+ export function createSanctus(): OpponentState {
86
+ const m: OpponentState = {
87
+ kind: "monster",
88
+ name: "Sanctus",
89
+ hp: 0,
90
+ maxHp: 0,
91
+ atk: 0,
92
+ def: 0,
93
+ baseAtk: 0,
94
+ baseDef: 0,
95
+ growAtk: 1, // 同一關內每回合 ATK 微升(沿用既有 ResetForNextTurn 行為)
96
+ growHp: 0,
97
+ isAlive: true,
98
+ hasBloodlust: false,
99
+ hasHardening: false,
100
+ };
101
+ applySanctusLevel(m, 1);
102
+ return m;
103
+ }
104
+
105
+ /** 過關升級:套用新關卡的設定(HP 回滿、技能解鎖、數值上升)。 */
106
+ export function upgradeSanctusForLevel(m: OpponentState, newLevel: number): void {
107
+ applySanctusLevel(m, newLevel);
108
+ }
109
+
110
+ /** 某關 Sanctus 已習得的技能(含介紹),供地圖詳情面板顯示。 */
111
+ export function sanctusSkillsForLevel(level: number): MonsterSkill[] {
112
+ return cfg(level).skills.map((id) => SANCTUS_SKILLS[id]).filter((s): s is MonsterSkill => Boolean(s));
113
+ }
114
+
115
+ /** 整條 Sanctus 路線會出現的全部技能(依解鎖關卡排序),供地圖詳情面板一覽。 */
116
+ export function allSanctusSkills(): MonsterSkill[] {
117
+ return Object.values(SANCTUS_SKILLS).sort((a, b) => a.unlockLevel - b.unlockLevel);
118
+ }
119
+
120
+ // ===== 能量 × 技能 × 意圖(執行)=====
121
+
122
+ /** 是否為「能量技能型」怪物(目前=Sanctus;史萊姆/鬼影無 maxEnergy)。 */
123
+ export function isSkillFoe(m: OpponentState): boolean {
124
+ return m.maxEnergy !== undefined;
125
+ }
126
+
127
+ /** 玩家每出 2 張牌 → 怪物 +1 能量(封頂 maxEnergy)。在「成功出牌」後呼叫。 */
128
+ export function accrueCardEnergy(m: OpponentState): void {
129
+ if (m.maxEnergy === undefined) return;
130
+ m.cardEnergyCounter = (m.cardEnergyCounter ?? 0) + 1;
131
+ if (m.cardEnergyCounter >= 2) {
132
+ m.cardEnergyCounter -= 2;
133
+ m.energy = Math.min(m.maxEnergy, (m.energy ?? 0) + 1);
134
+ }
135
+ }
136
+
137
+ const clampAegis = (m: OpponentState, v: number): number => Math.min(m.aegisCap ?? 0, Math.max(0, v));
138
+
139
+ /**
140
+ * 執行單一技能(已扣能量)。防禦類(升盾/格擋)直接改 opp;攻擊類(聖光斬/裁決斬/終審)
141
+ * 回傳「本回合一次性攻擊加成」由呼叫端加進這回合普攻——不可直接改 m.atk,否則加成會永久累積
142
+ * (monsterResetForNextTurn 只 += growAtk、不會把 atk 重置回 base)。
143
+ */
144
+ function applySanctusSkill(m: OpponentState, id: string, events: GameEvent[]): number {
145
+ let bonusAtk = 0;
146
+ switch (id) {
147
+ case "aegis": // 聖盾術:升盾
148
+ m.aegis = clampAegis(m, (m.aegis ?? 0) + 4);
149
+ break;
150
+ case "parry": // 格擋姿態:本回合 DEF+3、護盾+3(守住下一次玩家攻擊,下個敵方回合 reset 才消)
151
+ m.def += 3;
152
+ m.aegis = clampAegis(m, (m.aegis ?? 0) + 3);
153
+ break;
154
+ case "smite": // 聖光裁斬:本回合普攻追加 ≈baseAtk
155
+ bonusAtk = m.baseAtk;
156
+ break;
157
+ case "verdict": // 裁決斬:預告後的重擊(本回合普攻 +baseAtk×2)
158
+ bonusAtk = m.baseAtk * 2;
159
+ break;
160
+ case "lastjudgment": // 神聖終審:大傷 + 升盾
161
+ bonusAtk = m.baseAtk * 2;
162
+ m.aegis = clampAegis(m, (m.aegis ?? 0) + 6);
163
+ break;
164
+ default:
165
+ return 0;
166
+ }
167
+ const sk = SANCTUS_SKILLS[id];
168
+ events.push({ type: "SKILL_USED", skill: id, name: sk ? sk.name : id });
169
+ return bonusAtk;
170
+ }
171
+
172
+ /** 規劃下回合意圖:在「目前能量」內,貪婪挑最貴可負擔的技能(至多 intentDepth 個),設為意圖(不立即扣能量)。 */
173
+ function planSanctusIntent(m: OpponentState): void {
174
+ const depth = m.intentDepth ?? 1;
175
+ const owned = (m.skills ?? []).map((id) => SANCTUS_SKILLS[id]).filter((s): s is MonsterSkill => Boolean(s));
176
+ owned.sort((a, b) => b.cost - a.cost); // 貴的優先
177
+ let budget = m.energy ?? 0;
178
+ const picked: string[] = [];
179
+ for (const s of owned) {
180
+ if (picked.length >= depth) break;
181
+ if (budget >= s.cost) {
182
+ picked.push(s.id);
183
+ budget -= s.cost;
184
+ }
185
+ }
186
+ m.intent = picked;
187
+ }
188
+
189
+ /**
190
+ * Sanctus 敵方回合(在 monsterResetForNextTurn 之後、普攻結算之前呼叫):
191
+ * 1) 回合能量 +2;2) 執行上回合預告的意圖(扣能量、套效果,可能加普攻/升盾);3) 規劃並預告下回合意圖。
192
+ * 攻擊型技能(smite/verdict/終審)會墊高 m.atk,緊接著的普攻就會把加成一起打出去。
193
+ */
194
+ export function sanctusEnemyTurn(m: OpponentState, events: GameEvent[]): number {
195
+ if (m.maxEnergy === undefined) return 0;
196
+ m.energy = Math.min(m.maxEnergy, (m.energy ?? 0) + 2); // 回合能量
197
+ let bonusAtk = 0;
198
+ for (const id of m.intent ?? []) {
199
+ const sk = SANCTUS_SKILLS[id];
200
+ if (!sk || (m.energy ?? 0) < sk.cost) continue; // 付不起就略過
201
+ m.energy = (m.energy ?? 0) - sk.cost;
202
+ bonusAtk += applySanctusSkill(m, id, events);
203
+ }
204
+ planSanctusIntent(m); // 預告下回合
205
+ return bonusAtk;
206
+ }
packages/battle-core/src/index.ts CHANGED
@@ -56,6 +56,18 @@ export {
56
  buildGhostRecord,
57
  createGhostOpponent,
58
  } from "./opponent.js";
 
 
 
 
 
 
 
 
 
 
 
 
59
  export {
60
  PVP_DRAFT_PLAN,
61
  PVP_DRAFT_PICKS,
@@ -68,3 +80,5 @@ export {
68
  type DraftTier,
69
  } from "./pvpDraft.js";
70
  export { knifeProgress, type KnifeProgress } from "./progress.js";
 
 
 
56
  buildGhostRecord,
57
  createGhostOpponent,
58
  } from "./opponent.js";
59
+ export {
60
+ SANCTUS_SKILLS,
61
+ SANCTUS_PASSIVE,
62
+ SANCTUS_LEVELS,
63
+ SANCTUS_MAX_LEVEL,
64
+ sanctusSkillsForLevel,
65
+ allSanctusSkills,
66
+ createSanctus,
67
+ upgradeSanctusForLevel,
68
+ type MonsterSkill,
69
+ type SanctusLevelConfig,
70
+ } from "./foes.js";
71
  export {
72
  PVP_DRAFT_PLAN,
73
  PVP_DRAFT_PICKS,
 
80
  type DraftTier,
81
  } from "./pvpDraft.js";
82
  export { knifeProgress, type KnifeProgress } from "./progress.js";
83
+ export { previewPlayHpCost } from "./player.js";
84
+ export { cleanHeroName, containsProfanity, basicClean, HERO_NAME_MAX, HERO_NAME_FALLBACK } from "./nameFilter.js";
packages/battle-core/src/nameFilter.ts ADDED
@@ -0,0 +1,141 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ /**
2
+ * 勇者名字過濾(鬼影 meta.heroName 用)。零相依、決定性,前後端共用。
3
+ *
4
+ * 設計(經對抗式稽核強化):
5
+ * - basicClean:NFKC、去零寬/控制字元、collapse 空白、截長 16 → 「顯示用」字串(保留原文字母系,如俄文名)。
6
+ * - containsProfanity:先 fold(NFKD 去重音 + 同形字摺疊 + leet 還原 + ph→f)成 ascii/CJK 偵測字串,
7
+ * 英文用「詞邊界 + 容許字母間分隔/重複」的正則(避免 Matsushita/Scunthorpe 之類子字串誤殺,
8
+ * 同時擋 "f u c k" / "fück" / "fuсk(西里爾)" / "shiit");中文用「去重複後子字串」比對(含簡繁/知名同音)。
9
+ * - 命中 → 回退「無名勇者」。空字串 → ""(未命名)。
10
+ *
11
+ * 安全模型:客戶端可被繞過,**伺服器才是權威過濾點**(server.ts 上傳時 + repository 入庫/載入時)。
12
+ * 清單為「起始集」、可擴充;偵測只跑在「清理後(≤16 字)」字串上,天然界定 ReDoS 與避免截斷誤判。
13
+ * 已知殘留(語意級難解,接受):未列入的中文同音/拆字。
14
+ * 實作注意:所有正則一律用 ASCII 原始碼(\u 跳脫 / code-point 過濾),避免字面不可見字元造成隱性 bug。
15
+ */
16
+
17
+ export const HERO_NAME_MAX = 16;
18
+ export const HERO_NAME_FALLBACK = "無名勇者";
19
+
20
+ /** 英文敏感詞(fold 後比對;以詞邊界錨定,故可放含常見字根者,誤殺由白名單兜底)。 */
21
+ const BANNED_ASCII: string[] = [
22
+ "fuck", "motherfuck", "fvck", "fxck", "shit", "bullshit", "dipshit", "bitch", "cunt",
23
+ "asshole", "dickhead", "pussy", "bastard", "whore", "slut", "nigger", "nigga", "faggot",
24
+ "retard", "jackass", "wank", "bollocks", "cocksuck", "twat",
25
+ ];
26
+
27
+ /** 中文敏感詞(去重複後子字串比對;多字詞優先、含簡繁與知名同音,降低單字誤殺)。 */
28
+ const BANNED_CJK: string[] = [
29
+ "幹你娘", "幹妳娘", "幹你媽", "幹妳媽", "操你媽", "操你娘", "操你妈",
30
+ "干你娘", "干妳娘", "干你媽", "干你妈", "媽的", "妈的", "他媽", "他妈", "你媽死", "死全家",
31
+ "雞掰", "機掰", "鸡掰", "机掰", "雞巴", "鸡巴", "靠北", "靠腰", "靠杯", "婊子",
32
+ "賤人", "贱人", "賤貨", "贱货", "妓女", "屌你", "草泥馬", "草泥马",
33
+ "肏", "屄", "屌", "婊", "妓",
34
+ ];
35
+
36
+ /** 整個名字「剛好等於」這些單字才擋(避免 幹勁/操作/才幹 等正常詞誤殺)。 */
37
+ const EXACT_CJK = new Set(["幹", "操", "干", "屌", "婊", "妓", "肏", "屄"]);
38
+
39
+ /** 已知良性詞(含敏感子字串),整名相符即放行(修正 Scunthorpe 類誤殺)。 */
40
+ const ALLOWLIST = new Set<string>([
41
+ "scunthorpe", "cunthorpe", "matsushita", "ashitaka", "shitao", "shitake", "mishit",
42
+ "lightwater", "twatt", "wankel", "slutsky", "bastardo", "faggotini", "retardant",
43
+ "retardation", "niggard", "niggardly", "snigger", "sniggering", "pussycat", "pussyfoot",
44
+ "pussywillow", "whoreson", "shiitake", "dickson", "cassandra",
45
+ ]);
46
+
47
+ /** leet / 同形數字符號 → 字母。 */
48
+ const LEET: Record<string, string> = {
49
+ "0": "o", "1": "i", "3": "e", "4": "a", "5": "s", "7": "t", "8": "b",
50
+ "@": "a", "$": "s", "!": "i", "|": "i",
51
+ };
52
+
53
+ /** 同形字(西里爾/希臘/土耳其無點 i/帶斜線等)→ 拉丁小寫。重音類由 NFKD 去組合符號處理。 */
54
+ const CONFUSABLES: Record<string, string> = {
55
+ // 西里爾
56
+ "а": "a", "в": "b", "е": "e", "ё": "e", "к": "k", "м": "m", "н": "h", "о": "o", "р": "p",
57
+ "с": "c", "т": "t", "у": "y", "х": "x", "ѕ": "s", "і": "i", "ј": "j", "ԁ": "d", "ѵ": "v", "ў": "y",
58
+ // 希臘
59
+ "α": "a", "β": "b", "ε": "e", "η": "n", "ι": "i", "κ": "k", "μ": "u", "ν": "v", "ο": "o",
60
+ "ρ": "p", "σ": "s", "ς": "s", "τ": "t", "υ": "u", "χ": "x", "γ": "y", "ω": "w",
61
+ // 其他拉丁同形
62
+ "ı": "i", "ø": "o", "đ": "d", "ł": "l", "ƒ": "f", "ɢ": "g", "ɪ": "i", "ϲ": "c",
63
+ };
64
+
65
+ /** 不可見字元碼位:零寬空白~不連接、word-joiner、BOM、軟連字號。 */
66
+ const INVISIBLE_CP = new Set([0x200b, 0x200c, 0x200d, 0x2060, 0xfeff, 0x00ad]);
67
+
68
+ /** 去不可見字元(code-point 過濾,避免字面不可見字元)。 */
69
+ function stripInvisible(s: string): string {
70
+ let out = "";
71
+ for (const ch of s) if (!INVISIBLE_CP.has(ch.codePointAt(0)!)) out += ch;
72
+ return out;
73
+ }
74
+
75
+ /** 去 C0/C1 控制字元(0x00–0x1F 與 0x7F),保留空白(0x20)。 */
76
+ function stripControl(s: string): string {
77
+ let out = "";
78
+ for (const ch of s) {
79
+ const c = ch.codePointAt(0)!;
80
+ if (c > 0x1f && c !== 0x7f) out += ch;
81
+ }
82
+ return out;
83
+ }
84
+
85
+ /** 顯示用清理:NFKC、去零寬/控制字元、collapse 空白、截長。 */
86
+ export function basicClean(raw: string): string {
87
+ let s = (raw ?? "").normalize("NFKC");
88
+ s = stripInvisible(s);
89
+ s = stripControl(s);
90
+ s = s.replace(/\s+/g, " ").trim(); // collapse 空白
91
+ if (s.length > HERO_NAME_MAX) s = s.slice(0, HERO_NAME_MAX);
92
+ return s;
93
+ }
94
+
95
+ /** 偵���用摺疊:小寫、NFKD 去重音、去零寬、同形字→拉丁、leet 還原、ph→f。保留空白/標點/CJK(分隔由正則處理)。 */
96
+ function fold(raw: string): string {
97
+ let t = (raw ?? "").normalize("NFKD").toLowerCase();
98
+ t = t.replace(/[̀-ͯ]/g, ""); // 去組合附加符號 → ü/ç/é → u/c/e
99
+ t = stripInvisible(t);
100
+ t = Array.from(t).map((ch) => CONFUSABLES[ch] ?? ch).join(""); // 同形字 → 拉丁
101
+ t = t.replace(/[0134578@$!|]/g, (c) => LEET[c] ?? c); // leet
102
+ t = t.replace(/ph/g, "f"); // phuck → fuck
103
+ return t;
104
+ }
105
+
106
+ /** 字母間容許的分隔(非英數;破解 "f u c k" / "f.u.c.k")。 */
107
+ const SEP = "[^a-z0-9]*";
108
+ /** 由敏感詞建字邊界正則:每字母可重複(破解 "shiit")、字母間可夾分隔。前置 \b 防詞中誤殺。 */
109
+ const ASCII_PATTERNS: RegExp[] = BANNED_ASCII.map(
110
+ (w) => new RegExp("\\b" + Array.from(w).map((c) => c.replace(/[.*+?^${}()|[\]\\]/g, "\\$&") + "+").join(SEP)),
111
+ );
112
+
113
+ const NON_TOKEN = /[^a-z0-9一-鿿]/g; // 去分隔(保留英數與 CJK)
114
+ const CJK_REPEAT = /([一-鿿])\1+/g; // 收合 CJK 連續重複
115
+
116
+ /** 是否含敏感詞(已處理大小寫/空白/標點/leet/重複/同形字/簡繁/部分同音)。 */
117
+ export function containsProfanity(raw: string): boolean {
118
+ const folded = fold(raw).slice(0, 256); // 界定 ReDoS
119
+ const compact = folded.replace(NON_TOKEN, "");
120
+ if (ALLOWLIST.has(compact)) return false; // 整名為已知良性詞 → 放行
121
+ for (const re of ASCII_PATTERNS) if (re.test(folded)) return true;
122
+ const cjk = compact.replace(CJK_REPEAT, "$1"); // 破解 幹你你娘
123
+ for (const w of BANNED_CJK) if (cjk.includes(w)) return true;
124
+ if (EXACT_CJK.has(cjk)) return true; // 整名剛好是單字髒字
125
+ return false;
126
+ }
127
+
128
+ /**
129
+ * 清理勇者名字 → 安全顯示名稱。
130
+ * - 空/全空白 → ""(未命名)。
131
+ * - 含敏感詞 → "無名勇者"。
132
+ * - 其餘 → 清理後(截長 16、去控制/零寬字元、collapse 空白)。
133
+ *
134
+ * 偵測只跑在「清理後字串」:天然 ≤16 字(界定 ReDoS),且避免「截斷後不顯示的內容」造成誤判。
135
+ */
136
+ export function cleanHeroName(raw: string): string {
137
+ const cleaned = basicClean(raw);
138
+ if (!cleaned) return "";
139
+ if (containsProfanity(cleaned)) return HERO_NAME_FALLBACK;
140
+ return cleaned;
141
+ }
packages/battle-core/src/opponent.ts CHANGED
@@ -54,8 +54,18 @@ export function upgradeMonsterForLevel(m: OpponentState, newLevel: number): void
54
 
55
  /** 對手受玩家傷害(01 §5.2)。回傳實際扣血量。 */
56
  export function opponentTakeDamage(m: OpponentState, damage: number): number {
57
- let actual = Math.max(0, damage - m.def);
58
- if (m.hasHardening && actual > 35) actual = 35; // 硬化:單次受傷上限 35
 
 
 
 
 
 
 
 
 
 
59
  m.hp -= actual;
60
  if (m.hp < 0) m.hp = 0;
61
  if (m.hp === 0) m.isAlive = false;
@@ -95,21 +105,31 @@ export function createGhostRuntime(turns: { atk: number; def: number }[]): Ghost
95
  };
96
  }
97
 
98
- /** 鬼影第 n 回合(n 從 1)的攻防(01 §9 / 04 §4)。 */
 
 
 
 
 
 
 
 
99
  export function ghostTurnValues(g: GhostRuntime, n: number): { atk: number; def: number } {
100
  const k = g.turns.length;
101
  if (n <= k) {
102
  const t = g.turns[n - 1]!;
103
  return { atk: t.atk, def: t.def };
104
  }
105
- return { atk: g.avgAtk + n, def: g.avgDef + n };
106
  }
107
 
108
  /** 由破關後的 GameState 打包鬼影存檔(04 §4;不含 id,由伺服器產生)。 */
109
  export function buildGhostRecord(
110
  state: GameState,
111
- opts?: { seed?: number; actions?: Action[]; createdAt?: string; deckFinal?: number[] },
112
  ): GhostRecord {
 
 
113
  return {
114
  playerMaxHp: state.player.maxHp,
115
  turns: state.turnLog.map((t) => ({ atk: t.atk, def: t.def })),
@@ -117,7 +137,7 @@ export function buildGhostRecord(
117
  actions: opts?.actions,
118
  ruleVersion: RULE_VERSION,
119
  cardsHash: CARDS_HASH,
120
- meta: { classType: "WARRIOR", createdAt: opts?.createdAt, deckFinal: opts?.deckFinal },
121
  };
122
  }
123
 
@@ -134,7 +154,8 @@ export function ghostBeginTurn(opp: OpponentState, turnNo: number): void {
134
  export function createGhostOpponent(record: GhostRecord): OpponentState {
135
  return {
136
  kind: "ghost",
137
- name: "Ghost",
 
138
  hp: record.playerMaxHp,
139
  maxHp: record.playerMaxHp,
140
  atk: 0,
 
54
 
55
  /** 對手受玩家傷害(01 §5.2)。回傳實際扣血量。 */
56
  export function opponentTakeDamage(m: OpponentState, damage: number): number {
57
+ // 審判(Sanctus):用「未經任何減免的原始傷害」判定;溢出審判線 ½(無條件進位)無視 DEF 反傷、無上限,
58
+ // 暫存於 pendingReflect,待怪物下次攻擊時直接扣玩家 HP。
59
+ if (m.judgeLine !== undefined && damage > m.judgeLine) {
60
+ m.pendingReflect = (m.pendingReflect ?? 0) + Math.ceil((damage - m.judgeLine) / 2);
61
+ }
62
+ let actual = Math.max(0, damage - m.def); // 先扣 DEF
63
+ if (m.aegis !== undefined && m.aegis > 0) { // 再由 Aegis 護盾吸收,剩餘才進 HP
64
+ const absorbed = Math.min(m.aegis, actual);
65
+ m.aegis -= absorbed;
66
+ actual -= absorbed;
67
+ }
68
+ if (m.hasHardening && actual > 35) actual = 35; // 硬化:單次受傷上限 35(順序:DEF → Aegis → 硬化)
69
  m.hp -= actual;
70
  if (m.hp < 0) m.hp = 0;
71
  if (m.hp === 0) m.isAlive = false;
 
105
  };
106
  }
107
 
108
+ /**
109
+ * 鬼影第 n 回合(n 從 1)的攻防(01 §9 / 04 §4)。
110
+ * - `n ≤ k`:照抄紀錄那一回合。
111
+ * - `n > k`(紀錄用完):ATK 隨回合外推遞增(`avgAtk + n`),製造「越打越痛、逼速戰」的壓力;
112
+ * 但 DEF 維持在固定平均(`avgDef`),**不**隨 n 無限上升。
113
+ * 理由:若 DEF 也用 `avgDef + n`,鬼影防禦會每回合 +1 直到超過玩家攻擊力 → 玩家一點傷害都打不進去,
114
+ * 鬼影成為「永遠打不死」的無敵怪;且那是紀錄裡從未出現過的合成數值(玩家會看到「顯然不可能是過 11 關的人
115
+ * 打出來的」防禦值)。逼速戰的壓力交給 ATK 即可,DEF 不該爆走(原 spec 對稱外推 DEF 為設計疏漏)。
116
+ */
117
  export function ghostTurnValues(g: GhostRuntime, n: number): { atk: number; def: number } {
118
  const k = g.turns.length;
119
  if (n <= k) {
120
  const t = g.turns[n - 1]!;
121
  return { atk: t.atk, def: t.def };
122
  }
123
+ return { atk: g.avgAtk + n, def: g.avgDef };
124
  }
125
 
126
  /** 由破關後的 GameState 打包鬼影存檔(04 §4;不含 id,由伺服器產生)。 */
127
  export function buildGhostRecord(
128
  state: GameState,
129
+ opts?: { seed?: number; actions?: Action[]; createdAt?: string; deckFinal?: number[]; heroName?: string },
130
  ): GhostRecord {
131
+ // heroName 僅在非空時寫入(呼叫端應先過濾;伺服器上傳時會再權威過濾一次)。
132
+ const heroName = opts?.heroName && opts.heroName.length > 0 ? opts.heroName : undefined;
133
  return {
134
  playerMaxHp: state.player.maxHp,
135
  turns: state.turnLog.map((t) => ({ atk: t.atk, def: t.def })),
 
137
  actions: opts?.actions,
138
  ruleVersion: RULE_VERSION,
139
  cardsHash: CARDS_HASH,
140
+ meta: { classType: "WARRIOR", createdAt: opts?.createdAt, deckFinal: opts?.deckFinal, heroName },
141
  };
142
  }
143
 
 
154
  export function createGhostOpponent(record: GhostRecord): OpponentState {
155
  return {
156
  kind: "ghost",
157
+ name: record.meta?.heroName || "Ghost", // 第 12 關顯示鬼影主人的勇者名字(伺服器已過濾)
158
+
159
  hp: record.playerMaxHp,
160
  maxHp: record.playerMaxHp,
161
  atk: 0,
packages/battle-core/src/player.ts CHANGED
@@ -8,7 +8,7 @@ import { CLASS_INIT } from "./classes.js";
8
  import { getCard, STARTING_DECK, UPGRADE_BLOOD_TO_ULTIMATE, UPGRADE_BROKEN_TO_BLOOD } from "./cards.js";
9
  import { endCombo, runOps, gainDef, evalCondPlayer, healOnCarnage, type EffectCtx } from "./effects.js";
10
  import { drawCards, setOnDrawResolver, applyOnDraw } from "./deck.js";
11
- import { shuffle } from "./rng.js";
12
  import { getOppHp } from "./opponent.js";
13
 
14
  /** 戰士初始值(向後相容;= CLASS_INIT.WARRIOR)。 */
@@ -178,11 +178,18 @@ export function playCard(
178
  // 自傷:扣 max(0,n) 點 HP(無視 DEF;死亡於回合末判定)。野性先手可豁免本次;放手一搏(本回合 dec 模式)
179
  // 一律不扣血——含放手一搏本身與其後所有出牌(「不再扣血」自打出當下生效)。註:此為「被動出牌自傷」,
180
  // 卡牌自身明寫的代價(無腦傾瀉「額外受到 n」、血誓「-8」)屬該卡效果,不在此豁免。
181
- const selfDmg = player.suppressSelfDmgThisPlay || player.nMode === "dec" ? 0 : Math.max(0, player.n);
 
182
  player.suppressSelfDmgThisPlay = false;
 
 
183
  const hpBefore = player.hp;
184
  player.hp -= selfDmg;
185
  if (player.hp < 0) player.hp = 0;
 
 
 
 
186
  player.hpLostThisTurn += selfDmg; // 打擊:本回合因出牌失去的血
187
  player.persist.savageTrial += selfDmg; // 蠻性試煉:跨戰累積「因出牌(被動)所受傷害」
188
  if (player.flags.反傷) player.trueDamage += selfDmg; // 痛苦共鳴/血腥連結:扣血 → 敵等量真實傷害
@@ -388,12 +395,14 @@ export function resolveChoice(
388
  }
389
 
390
  /**
391
- * 死亡前的凝視:hp≤0 且已武裝 → 復活至 effMax×fraction、永久移除本卡(183,連消耗堆都不留)。
392
- * 回 true 表示有復活。單人引擎與 PvP 結算共用同一套(避免邏輯分歧)。
393
  */
394
  export function reviveIfArmed(p: PlayerState, events: GameEvent[]): boolean {
395
  if (p.hp > 0 || !p.reviveArmed) return false;
396
- p.hp = Math.max(1, Math.floor((p.maxHp + p.tempMaxHp) * p.reviveFraction));
 
 
397
  p.reviveArmed = false;
398
  const bi = p.burn.indexOf(183);
399
  if (bi >= 0) p.burn.splice(bi, 1);
@@ -420,6 +429,12 @@ export function onDealDamage(player: PlayerState, opponent: OpponentState, event
420
  player.flags.生命汲取 = false;
421
  events.push({ type: "HEAL", amount: heal, hpAfter: player.hp });
422
  }
 
 
 
 
 
 
423
  // 註:卡26 已改用「失控侵蝕」機制(鎖 DEF=0 + DEF→ATK),原「狂戰士之魂 出傷歸零 DEF」已被取代而移除。
424
  return dmg;
425
  }
@@ -437,11 +452,8 @@ export function onTurnEndResolve(player: PlayerState, opponent: OpponentState):
437
  if (player.flags.餘裕 && player.coin > 0) {
438
  player.hp += 5;
439
  player.maxHp += 5;
440
- } else if (player.flags.終極一擊) {
441
- // 01 §5.4 忠實:此處在「已扣血之後」加 ATK,且隨即被 §5.6 重置清掉。
442
- // 屬原版疑似 quirk(處決實際不生效),1:1 還原並由測試釘死;見回報。
443
- player.atk += getOppHp(opponent);
444
  }
 
445
  player.flags.餘裕 = false;
446
  player.flags.終極一擊 = false;
447
  }
@@ -605,3 +617,30 @@ function tryUpgrade(
605
  }
606
  // 找不到舊卡:保留計數,待該卡再次出現時升級。
607
  }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
8
  import { getCard, STARTING_DECK, UPGRADE_BLOOD_TO_ULTIMATE, UPGRADE_BROKEN_TO_BLOOD } from "./cards.js";
9
  import { endCombo, runOps, gainDef, evalCondPlayer, healOnCarnage, type EffectCtx } from "./effects.js";
10
  import { drawCards, setOnDrawResolver, applyOnDraw } from "./deck.js";
11
+ import { shuffle, makeRng } from "./rng.js";
12
  import { getOppHp } from "./opponent.js";
13
 
14
  /** 戰士初始值(向後相容;= CLASS_INIT.WARRIOR)。 */
 
178
  // 自傷:扣 max(0,n) 點 HP(無視 DEF;死亡於回合末判定)。野性先手可豁免本次;放手一搏(本回合 dec 模式)
179
  // 一律不扣血——含放手一搏本身與其後所有出牌(「不再扣血」自打出當下生效)。註:此為「被動出牌自傷」,
180
  // 卡牌自身明寫的代價(無腦傾瀉「額外受到 n」、血誓「-8」)屬該卡效果,不在此豁免。
181
+ // 出牌結算:n>0 扣血、n<0 回血(野性先手「n 為負視為回血」);放手一搏 dec 模式或 SUPPRESS_SELFDMG 時為 0。
182
+ const rawN = player.suppressSelfDmgThisPlay || player.nMode === "dec" ? 0 : player.n;
183
  player.suppressSelfDmgThisPlay = false;
184
+ const selfDmg = Math.max(0, rawN); // 真正失血(只計正值;供計數/反傷/反刃引用)
185
+ const selfHeal = Math.max(0, -rawN); // 負 n → 回血(夾 effMax)
186
  const hpBefore = player.hp;
187
  player.hp -= selfDmg;
188
  if (player.hp < 0) player.hp = 0;
189
+ if (selfHeal > 0) {
190
+ player.hp = Math.min(player.maxHp + player.tempMaxHp, player.hp + selfHeal);
191
+ events.push({ type: "HEAL", amount: selfHeal, hpAfter: player.hp });
192
+ }
193
  player.hpLostThisTurn += selfDmg; // 打擊:本回合因出牌失去的血
194
  player.persist.savageTrial += selfDmg; // 蠻性試煉:跨戰累積「因出牌(被動)所受傷害」
195
  if (player.flags.反傷) player.trueDamage += selfDmg; // 痛苦共鳴/血腥連結:扣血 → 敵等量真實傷害
 
395
  }
396
 
397
  /**
398
+ * 死亡前的凝視:hp≤0 且已武裝 → 臨時生命 1:1 轉永久 maxHp、再以 maxHp×fraction(現 1.0=滿血)復活、
399
+ * 永久移除本卡(183,連消耗堆都不留)。回 true 表示有復活。單人引擎與 PvP 結算共用同一套(避免邏輯分歧)。
400
  */
401
  export function reviveIfArmed(p: PlayerState, events: GameEvent[]): boolean {
402
  if (p.hp > 0 || !p.reviveArmed) return false;
403
+ p.maxHp += p.tempMaxHp; // 死亡前的凝視:臨時生命 1:1 全數轉為永久生命
404
+ p.tempMaxHp = 0;
405
+ p.hp = Math.max(1, Math.floor(p.maxHp * p.reviveFraction)); // fraction=1.0 → 以總生命滿血復活
406
  p.reviveArmed = false;
407
  const bi = p.burn.indexOf(183);
408
  if (bi >= 0) p.burn.splice(bi, 1);
 
429
  player.flags.生命汲取 = false;
430
  events.push({ type: "HEAL", amount: heal, hpAfter: player.hp });
431
  }
432
+ if (player.flags.終極一擊) {
433
+ // 終極一擊 處決(01 §5.4):本次出傷額外 += 怪物當前 HP → 等同斬殺。
434
+ // 必須在「出傷時」結算才生效(舊版誤在回合末 onTurnEndResolve 才加 ATK,已扣血後才補、隨即被重置清掉 → 處決失效)。
435
+ dmg += getOppHp(opponent);
436
+ player.flags.終極一擊 = false;
437
+ }
438
  // 註:卡26 已改用「失控侵蝕」機制(鎖 DEF=0 + DEF→ATK),原「狂戰士之魂 出傷歸零 DEF」已被取代而移除。
439
  return dmg;
440
  }
 
452
  if (player.flags.餘裕 && player.coin > 0) {
453
  player.hp += 5;
454
  player.maxHp += 5;
 
 
 
 
455
  }
456
+ // 終極一擊「處決」已改於 onDealDamage(出傷當下)結算 → 真正斬殺;不再於回合末事後加 ATK(該寫法處決不生效)。
457
  player.flags.餘裕 = false;
458
  player.flags.終極一擊 = false;
459
  }
 
617
  }
618
  // 找不到舊卡:保留計數,待該卡再次出現時升級。
619
  }
620
+
621
+ /**
622
+ * 預覽「現在打出手牌第 handIndex 張」會讓自己損失多少 HP(野蠻人被動 n 自傷 + 卡面自身扣血代價)。
623
+ * 純供 UI 顯示:在 player 的複本上跑一次「真正的」playCard 量測 hp 落差,因此與實際出牌邏輯零偏差
624
+ * ——自動涵蓋 +1 進位(n 先 +1 才結算自傷)、千刀萬剮 ADD_N、無腦傾瀉 ADD_HP(-n) 等所有情況。
625
+ *
626
+ * - 複本牌庫/棄牌清空:排除「補抽到『專注』回血」這種玩家看不到、又會稀釋代價的隱藏治療 → 顯示保守的「淨自傷」。
627
+ * - 若代價 ≥ 目前 HP,self-damage 會把 hp 夾到 0,回傳值即等於目前 HP(代表「打了就死」),這正是要警示的紅線。
628
+ *
629
+ * 回傳 HP 損失(>= 0);非野蠻人(戰士無此被動)或該牌當下不可打出(如狂怒 HP 不足)則回傳 null。
630
+ */
631
+ export function previewPlayHpCost(
632
+ player: PlayerState,
633
+ handIndex: number,
634
+ mode: "single" | "pvp" = "single",
635
+ ): number | null {
636
+ if (CLASS_INIT[player.classType].hasCoinGate) return null; // 戰士走硬幣/連擊路徑,無「出牌自傷」被動
637
+ if (handIndex < 0 || handIndex >= player.hand.length) return null;
638
+ const clone: PlayerState = JSON.parse(JSON.stringify(player)); // 深複本:所有變動只發生在複本上
639
+ clone.deck = [];
640
+ clone.discard = []; // 補抽抽不到牌(不觸發專注回血)→ 量到的是純自傷代價
641
+ const hpBefore = clone.hp;
642
+ const res = playCard(clone, makeRng(1), handIndex, mode); // 固定種子:RANDOM_DISCARD 等隨機只落在複本,不影響 hp 量測
643
+ if (!res.ok) return null; // 條件不符 → 不顯示代價
644
+ const cost = hpBefore - clone.hp;
645
+ return cost > 0 ? cost : 0;
646
+ }
packages/battle-core/src/types.ts CHANGED
@@ -121,7 +121,7 @@ export type EffectOp =
121
  | { op: "SPECIAL_WIN_CHECK"; cond: CondExpr } // 條件成立 → 特殊勝利(蓄力 ×15)
122
  | { op: "ARM_REVIVE"; fraction: number } // 死亡前的凝視:本回合若死亡,復活至 effMaxHp × fraction(一次性)
123
  | { op: "SET_HP"; value: ValueExpr } // Inverse:直接設定 HP(夾 [0, effMaxHp])
124
- | { op: "ANNIHILATE"; token: number; moveCount: number; tokenCount: number; position: "top" | "bottom" } // 萬象寂滅:棄牌堆隨機 moveCount 張進消耗堆,於牌庫 position 生成 tokenCount 個 token
125
  | { op: "RANDOM_DISCARD"; count: ValueExpr } // 隨機棄掉手牌 count 張(盲目亂揮/本能閃避)
126
  | { op: "DISCARD_HAND" } // 棄掉全部手牌(無腦傾瀉/雜念絕殺;打出的牌已先移出手牌)
127
  | { op: "BUFF_NEXT_ATTACK"; mult?: number; bonus?: number; self?: boolean } // 下一張攻擊卡:傷害 ×mult / +bonus(咆哮/專注湧現);self=改為攻擊自己(無盡怒火)
@@ -149,7 +149,7 @@ export interface CardModeOverride {
149
  }
150
 
151
  export interface CardData {
152
- id: number; // 戰士 0..40(對應 resources/<id>.png);野蠻人 100+(白底文字卡、無圖)
153
  /** 所屬職業(各職業卡牌獨立、不可混用);省略 = WARRIOR(相容既有 41 張)。 */
154
  classType?: ClassType;
155
  name: string;
@@ -166,7 +166,7 @@ export interface CardData {
166
  isToken?: boolean;
167
  /** 衍生卡:不進卡池(獎勵/draft),只由效果生成。 */
168
  derived?: boolean;
169
- /** 抽到即自動釋放的效果(專注:抽到 +1 臨時上限;不計入出牌 n);釋放後本卡進消耗堆。 */
170
  onDraw?: EffectOp[];
171
  /** 出牌前置條件(不滿足則無法打出);狂怒:HP<30% 才能打。 */
172
  playableIf?: CondExpr;
@@ -285,10 +285,24 @@ export interface OpponentState {
285
  isAlive: boolean;
286
  hasBloodlust: boolean; // 吸血:本次傷害 > player.DEF → 怪物 HP+3
287
  hasHardening: boolean; // 硬化:單次受傷上限 35
 
 
 
 
 
 
 
 
 
 
 
288
  /** 鬼影出招資料(kind==="ghost" 時存在)。 */
289
  ghost?: GhostRuntime;
290
  }
291
 
 
 
 
292
  export interface GhostRuntime {
293
  turns: { atk: number; def: number }[];
294
  avgAtk: number; // 用 k 筆固定算出,不隨外推變動
@@ -305,7 +319,7 @@ export interface GhostRecord {
305
  actions?: Action[]; // 完整動作序列(後端可重算驗證)
306
  ruleVersion: string; // 規則版本(B-4,版本不符則降級不校驗)
307
  cardsHash: string; // 卡表指紋(B-4)
308
- meta?: { createdAt?: string; classType: ClassType; deckFinal?: number[] };
309
  }
310
 
311
  export type BattlePhase =
@@ -338,7 +352,8 @@ export interface PendingChoice {
338
 
339
  export interface GameState {
340
  level: number; // 1..maxLevel(破關後 maxLevel+1 = 鬼影關)
341
- maxLevel: number; // 最後一關關卡數(預設 11;除錯可覆寫)。IsOnFinalLevel = level === maxLevel
 
342
  phase: BattlePhase;
343
  player: PlayerState;
344
  opponent: OpponentState;
@@ -380,6 +395,8 @@ export type GameEvent =
380
  | { type: "MONSTER_TAKE_DAMAGE"; actual: number; hpAfter: number }
381
  | { type: "MONSTER_DEAD" }
382
  | { type: "MONSTER_ATTACK"; damage: number; hpAfter: number }
 
 
383
  | { type: "HEAL"; amount: number; hpAfter: number }
384
  | { type: "CARD_UPGRADED"; from: number; to: number }
385
  | { type: "REVIVE"; hpAfter: number } // 死亡前的凝視:復活
 
121
  | { op: "SPECIAL_WIN_CHECK"; cond: CondExpr } // 條件成立 → 特殊勝利(蓄力 ×15)
122
  | { op: "ARM_REVIVE"; fraction: number } // 死亡前的凝視:本回合若死亡,復活至 effMaxHp × fraction(一次性)
123
  | { op: "SET_HP"; value: ValueExpr } // Inverse:直接設定 HP(夾 [0, effMaxHp])
124
+ | { op: "ANNIHILATE"; moveCount: number } // 萬象寂滅:棄牌堆隨機 moveCount 張進消耗堆(token 由卡片另接 SHUFFLE_TOKEN)
125
  | { op: "RANDOM_DISCARD"; count: ValueExpr } // 隨機棄掉手牌 count 張(盲目亂揮/本能閃避)
126
  | { op: "DISCARD_HAND" } // 棄掉全部手牌(無腦傾瀉/雜念絕殺;打出的牌已先移出手牌)
127
  | { op: "BUFF_NEXT_ATTACK"; mult?: number; bonus?: number; self?: boolean } // 下一張攻擊卡:傷害 ×mult / +bonus(咆哮/專注湧現);self=改為攻擊自己(無盡怒火)
 
149
  }
150
 
151
  export interface CardData {
152
+ id: number; // 戰士 0..40(對應 resources/cards/<id>.png);野蠻人 100+(白底文字卡、無圖)
153
  /** 所屬職業(各職業卡牌獨立、不可混用);省略 = WARRIOR(相容既有 41 張)。 */
154
  classType?: ClassType;
155
  name: string;
 
166
  isToken?: boolean;
167
  /** 衍生卡:不進卡池(獎勵/draft),只由效果生成。 */
168
  derived?: boolean;
169
+ /** 抽到即自動釋放的效果(專注:抽到 +2 臨時上限;不計入出牌 n);釋放後本卡進消耗堆。 */
170
  onDraw?: EffectOp[];
171
  /** 出牌前置條件(不滿足則無法打出);狂怒:HP<30% 才能打。 */
172
  playableIf?: CondExpr;
 
285
  isAlive: boolean;
286
  hasBloodlust: boolean; // 吸血:本次傷害 > player.DEF → 怪物 HP+3
287
  hasHardening: boolean; // 硬化:單次受傷上限 35
288
+ // ===== Sanctus(能量×技能×意圖系統):其餘怪物(史萊姆/鬼影)這些欄位留空=不啟用 =====
289
+ aegis?: number; // 當前護盾(疊加吸收層,先扣 DEF 再由護盾吸收,剩餘才進 HP)
290
+ aegisCap?: number; // 護盾上限
291
+ judgeLine?: number; // 審判線:玩家「原始 ATK」超過此值 → 溢出 ½ 無視 DEF 反傷(無上限)
292
+ pendingReflect?: number; // 暫存反傷,於下次怪物攻擊時無視 DEF 直接扣玩家 HP
293
+ energy?: number; // 能量(放技能用)
294
+ maxEnergy?: number; // 能量上限(滿 10)
295
+ cardEnergyCounter?: number; // 玩家每出 2 張牌 → +1 能量的計數器
296
+ skills?: string[]; // 已習得技能 id(逐關解鎖)
297
+ intent?: string[]; // 已規劃的下幾步技能 id(意圖預告)
298
+ intentDepth?: number; // 一次預告幾步(前期 1、後期 boss 2)
299
  /** 鬼影出招資料(kind==="ghost" 時存在)。 */
300
  ghost?: GhostRuntime;
301
  }
302
 
303
+ /** 單人路線:史萊姆 11 關(經典、無技能)/ Sanctus 5 關(能量×技能×意圖系統)。 */
304
+ export type Campaign = "slime" | "sanctus";
305
+
306
  export interface GhostRuntime {
307
  turns: { atk: number; def: number }[];
308
  avgAtk: number; // 用 k 筆固定算出,不隨外推變動
 
319
  actions?: Action[]; // 完整動作序列(後端可重算驗證)
320
  ruleVersion: string; // 規則版本(B-4,版本不符則降級不校驗)
321
  cardsHash: string; // 卡表指紋(B-4)
322
+ meta?: { createdAt?: string; classType: ClassType; deckFinal?: number[]; heroName?: string };
323
  }
324
 
325
  export type BattlePhase =
 
352
 
353
  export interface GameState {
354
  level: number; // 1..maxLevel(破關後 maxLevel+1 = 鬼影關)
355
+ maxLevel: number; // 最後一關關卡數(史萊姆 11;Sanctus 5;除錯可覆寫)。IsOnFinalLevel = level === maxLevel
356
+ campaign: Campaign; // 單人路線:史萊姆 / Sanctus
357
  phase: BattlePhase;
358
  player: PlayerState;
359
  opponent: OpponentState;
 
395
  | { type: "MONSTER_TAKE_DAMAGE"; actual: number; hpAfter: number }
396
  | { type: "MONSTER_DEAD" }
397
  | { type: "MONSTER_ATTACK"; damage: number; hpAfter: number }
398
+ | { type: "MONSTER_REFLECT"; damage: number; hpAfter: number } // Sanctus 審判:無視 DEF 的反傷
399
+ | { type: "SKILL_USED"; skill: string; name: string } // Sanctus 施展能量技能
400
  | { type: "HEAL"; amount: number; hpAfter: number }
401
  | { type: "CARD_UPGRADED"; from: number; to: number }
402
  | { type: "REVIVE"; hpAfter: number } // 死亡前的凝視:復活
packages/battle-core/src/version.ts CHANGED
@@ -5,7 +5,7 @@
5
  import { CARDS } from "./data/cards.js";
6
 
7
  /** 規則引擎版本。卡表或 EffectOp 語意變更時手動 bump。 */
8
- export const RULE_VERSION = "1.2.0"; // 1.2.0: 野蠻人全卡完成(id 100-191)— n鎖定/遞減、探牌、卡牌增益、跨戰計數(savageTrial/divinity)、變形鏈、特殊勝利(蓄力×15)、復活、Inverse、殲滅、本場旗標(地獄之門/狂神開眼/反刃血鎧)。1.1.0: 職業框架 + 野蠻人(n/手牌恆滿/無DEF)
9
 
10
  /** FNV-1a 32-bit,對卡表 JSON 取穩定指紋。 */
11
  function fnv1a(s: string): string {
 
5
  import { CARDS } from "./data/cards.js";
6
 
7
  /** 規則引擎版本。卡表或 EffectOp 語意變更時手動 bump。 */
8
+ export const RULE_VERSION = "1.4.0"; // 1.4.0: 野蠻人卡調整——野性先手(傷害15→12、首張 n→-2、負 n 視為回血)、死亡前的凝視(臨時生命 1:1 轉永久 + 100% 復活)、萬象寂滅(10 專注改洗入棄牌堆而非牌庫頂)。1.3.0: 專注臨時上限 +1→+2;命運之路的抉擇(25)取消焚燒(改洗回棄牌堆);終極一擊(35)處決改於出傷當下結算(真正斬殺,修正原本回合末才加ATK而失效的quirk);戰士全卡(0-40)補上效果敘述 desc(顯示用,不影響規則)。1.2.0: 野蠻人全卡完成(id 100-191)— n鎖定/遞減、探牌、卡牌增益、跨戰計數(savageTrial/divinity)、變形鏈、特殊勝利(蓄力×15)、復活、Inverse、殲滅、本場旗標(地獄之門/狂神開眼/反刃血鎧)。1.1.0: 職業框架 + 野蠻人(n/手牌恆滿/無DEF)
9
 
10
  /** FNV-1a 32-bit,對卡表 JSON 取穩定指紋。 */
11
  function fnv1a(s: string): string {
packages/battle-core/test/barbarian.test.ts CHANGED
@@ -79,14 +79,14 @@ describe("野蠻人 play 機制(P1:n / 手牌恆滿 / 無 DEF / 無閘門)
79
  expect(p.discard.filter((x) => x === 110).length).toBe(2);
80
  });
81
 
82
- it("P3 專注抽到即釋放:臨時上限 +1、進消耗堆、不入手牌、不佔抽牌數", () => {
83
  const { player: p, rng } = createPlayer("BARBARIAN", makeRng(1), []);
84
  p.hp = 100; p.hand = []; p.deck = [100, 110, 100]; // 中間是專注
85
  drawCards(p, rng, 5, []);
86
  expect(p.hand.length).toBe(2); // 兩張 100 入手;專注不入手、補抽
87
  expect(p.hand).not.toContain(110);
88
- expect(p.tempMaxHp).toBe(1); // 釋放 +1
89
- expect(p.hp).toBe(101); // 回 1
90
  expect(p.burn).toContain(110); // 釋放後進消耗堆
91
  });
92
 
@@ -102,7 +102,7 @@ describe("野蠻人 play 機制(P1:n / 手牌恆滿 / 無 DEF / 無閘門)
102
  const { player: p, rng } = createPlayer("BARBARIAN", makeRng(1), []);
103
  p.hand = [105]; p.deck = []; p.discard = [110, 110];
104
  playCard(p, rng, 0);
105
- expect(p.tempMaxHp).toBe(2); // 2 專注釋放各 +1
106
  expect(p.burn.filter((x) => x === 110).length).toBe(2);
107
  expect(p.discard.filter((x) => x === 110).length).toBe(0);
108
  });
@@ -318,20 +318,20 @@ describe("野蠻人 P7b:n 鎖定 / n 模式 / 探牌 / 卡牌增益 / 豁免 /
318
  expect(p.hp).toBe(94); // 96 -2
319
  });
320
 
321
- it("野性先手:首張(n==1)不扣血;非首張 n 額外 +1", () => {
322
  const a = createPlayer("BARBARIAN", makeRng(1), []);
323
- a.player.hp = 100; a.player.hand = [165]; a.player.deck = Array(10).fill(106);
324
- playCard(a.player, a.rng, 0); // 首張:suppress
325
- expect(a.player.atk).toBe(15);
326
- expect(a.player.hp).toBe(100); // 不扣血
327
- expect(a.player.n).toBe(1);
328
 
329
  const b = createPlayer("BARBARIAN", makeRng(1), []);
330
  b.player.hp = 100; b.player.hand = [106, 165]; b.player.deck = Array(10).fill(106);
331
  let r = playCard(b.player, b.rng, 0); // 106 n=1 hp99
332
  playCard(b.player, r.rng, b.player.hand.indexOf(165)); // 165 n=2→+1=3
333
  expect(b.player.n).toBe(3);
334
- expect(b.player.atk).toBe(22); // 7 + 15
335
  expect(b.player.hp).toBe(96); // 99 -3
336
  });
337
 
@@ -377,7 +377,7 @@ describe("野蠻人 P7b:n 鎖定 / n 模式 / 探牌 / 卡牌增益 / 豁免 /
377
  const fBefore = p.focusBurnedCount;
378
  resolveChoice(p, [2], r.pending!, r.rng, []); // 留候選 index2(110 專注)
379
  expect(p.hand).not.toContain(110); // ★ 不留在手上
380
- expect(p.tempMaxHp).toBe(tBefore + 1); // 釋放:+1 臨時上限
381
  expect(p.focusBurnedCount).toBe(fBefore + 1); // 計入「已消耗專注」
382
  expect(p.burn).toContain(110); // 釋放後進消耗堆
383
  });
@@ -556,14 +556,17 @@ describe("野蠻人 P7c:變形鏈 / 特殊勝利 / 復活 / Inverse / 衍生 /
556
  expect(events.some((e) => e.type === "SPECIAL_WIN")).toBe(true);
557
  });
558
 
559
- it("死亡前的凝視:本回合致死 → 復活至 50% 並永久移除本卡", () => {
560
  const g = createGame({ classType: "BARBARIAN", seed: 1 });
561
  g.player.hp = 3; // 低血
 
562
  g.player.hand[0] = 183;
563
  const s1 = step(g, { type: "PLAY_CARD", handIndex: 0 }).state; // 武裝復活(hp 3-1=2)
564
  const { state } = step(s1, { type: "END_TURN" }); // 怪物反擊致死 → 復活
565
  expect(state.phase).not.toBe("GAME_OVER");
566
- expect(state.player.hp).toBe(65); // floor(130 × 0.5)
 
 
567
  expect(state.player.burn).not.toContain(183); // 永久移除
568
  });
569
 
@@ -590,14 +593,14 @@ describe("野蠻人 P7c:變形鏈 / 特殊勝利 / 復活 / Inverse / 衍生 /
590
  expect(b.player.hand).not.toContain(112);
591
  });
592
 
593
- it("萬象寂滅:棄牌堆隨機 5 張進消耗堆、10 張專注放牌庫頂", () => {
594
  const { player: p } = createPlayer("BARBARIAN", makeRng(1), []);
595
  p.discard = [106, 106, 106, 106, 106, 106, 106]; p.deck = [100]; p.burn = [];
596
- runOps([{ op: "ANNIHILATE", token: 110, moveCount: 5, tokenCount: 10, position: "top" }], ctxOf(p));
597
- expect(p.discard.length).toBe(2); // 7 - 5
598
- expect(p.burn.length).toBe(5);
599
- expect(p.deck.filter((x) => x === 110).length).toBe(10);
600
- expect(p.deck.slice(-10).every((x) => x === 110)).toBe(true); // 10 專注在牌庫頂(尾端,先抽)
601
  });
602
 
603
  it("反刃血鎧:僅 hp 在臨時段(>maxHp)時抵擋扣血 → 2× 真實傷害", () => {
@@ -638,8 +641,8 @@ describe("野蠻人 P7c:變形鏈 / 特殊勝利 / 復活 / Inverse / 衍生 /
638
  drawCards(p, rng, 1, []);
639
  expect(p.discard).toContain(110); // 回棄牌堆
640
  expect(p.burn).not.toContain(110);
641
- expect(p.hp).toBe(100); // +1(臨時上限回血) -1(地獄之門)
642
- expect(p.tempMaxHp).toBe(1);
643
  expect(p.focusBurnedCount).toBe(0); // 未進消耗堆
644
  });
645
 
@@ -657,15 +660,6 @@ describe("野蠻人 P7c:變形鏈 / 特殊勝利 / 復活 / Inverse / 衍生 /
657
  expect(r.events.some((e) => e.type === "FORCED_END_TURN")).toBe(true);
658
  });
659
 
660
- it("萬象寂滅:token 生成於牌庫頂(position top,先抽到)", () => {
661
- const { player: p } = createPlayer("BARBARIAN", makeRng(1), []);
662
- p.discard = [106, 106, 101]; p.deck = [100, 100]; p.burn = [];
663
- runOps([{ op: "ANNIHILATE", token: 110, moveCount: 5, tokenCount: 10, position: "top" }], ctxOf(p));
664
- expect(p.deck.slice(0, 2)).toEqual([100, 100]); // 原牌在底(index 0..1,最後抽)
665
- expect(p.deck.slice(2).every((x) => x === 110)).toBe(true); // 10 專注在頂(尾端,先抽)
666
- expect(p.deck.length).toBe(12); // 2 + 10
667
- });
668
-
669
  it("出牌自傷使 HP≤0 → 出牌階段立即判負(GAME_OVER)", () => {
670
  const g = createGame({ classType: "BARBARIAN", seed: 1 });
671
  g.player.hp = 1; // 瀕死
@@ -682,7 +676,7 @@ describe("野蠻人 P7c:變形鏈 / 特殊勝利 / 復活 / Inverse / 衍生 /
682
  s1.player.hp = 1; s1.player.hand[0] = 106; // 瀕死後再出牌自傷
683
  const { state } = step(s1, { type: "PLAY_CARD", handIndex: 0 });
684
  expect(state.phase).not.toBe("GAME_OVER");
685
- expect(state.player.hp).toBe(65); // floor(130 × 0.5)
686
  expect(state.player.burn).not.toContain(183);
687
  });
688
 
 
79
  expect(p.discard.filter((x) => x === 110).length).toBe(2);
80
  });
81
 
82
+ it("P3 專注抽到即釋放:臨時上限 +2、進消耗堆、不入手牌、不佔抽牌數", () => {
83
  const { player: p, rng } = createPlayer("BARBARIAN", makeRng(1), []);
84
  p.hp = 100; p.hand = []; p.deck = [100, 110, 100]; // 中間是專注
85
  drawCards(p, rng, 5, []);
86
  expect(p.hand.length).toBe(2); // 兩張 100 入手;專注不入手、補抽
87
  expect(p.hand).not.toContain(110);
88
+ expect(p.tempMaxHp).toBe(2); // 釋放 +2
89
+ expect(p.hp).toBe(102); // 回 2
90
  expect(p.burn).toContain(110); // 釋放後進消耗堆
91
  });
92
 
 
102
  const { player: p, rng } = createPlayer("BARBARIAN", makeRng(1), []);
103
  p.hand = [105]; p.deck = []; p.discard = [110, 110];
104
  playCard(p, rng, 0);
105
+ expect(p.tempMaxHp).toBe(4); // 2 專注釋放各 +2
106
  expect(p.burn.filter((x) => x === 110).length).toBe(2);
107
  expect(p.discard.filter((x) => x === 110).length).toBe(0);
108
  });
 
318
  expect(p.hp).toBe(94); // 96 -2
319
  });
320
 
321
+ it("野性先手:首張(n==1) n 變 -2 並回血;非首張 n 額外 +1", () => {
322
  const a = createPlayer("BARBARIAN", makeRng(1), []);
323
+ a.player.hp = 100; a.player.hand = [165]; a.player.deck = Array(10).fill(106); // maxHp 130
324
+ playCard(a.player, a.rng, 0); // 首張:n→1→SET_N -2;負 n 回血 2
325
+ expect(a.player.atk).toBe(12);
326
+ expect(a.player.hp).toBe(102); // 100 +2(負 n 回血)
327
+ expect(a.player.n).toBe(-2);
328
 
329
  const b = createPlayer("BARBARIAN", makeRng(1), []);
330
  b.player.hp = 100; b.player.hand = [106, 165]; b.player.deck = Array(10).fill(106);
331
  let r = playCard(b.player, b.rng, 0); // 106 n=1 hp99
332
  playCard(b.player, r.rng, b.player.hand.indexOf(165)); // 165 n=2→+1=3
333
  expect(b.player.n).toBe(3);
334
+ expect(b.player.atk).toBe(19); // 7 + 12
335
  expect(b.player.hp).toBe(96); // 99 -3
336
  });
337
 
 
377
  const fBefore = p.focusBurnedCount;
378
  resolveChoice(p, [2], r.pending!, r.rng, []); // 留候選 index2(110 專注)
379
  expect(p.hand).not.toContain(110); // ★ 不留在手上
380
+ expect(p.tempMaxHp).toBe(tBefore + 2); // 釋放:+2 臨時上限
381
  expect(p.focusBurnedCount).toBe(fBefore + 1); // 計入「已消耗專注」
382
  expect(p.burn).toContain(110); // 釋放後進消耗堆
383
  });
 
556
  expect(events.some((e) => e.type === "SPECIAL_WIN")).toBe(true);
557
  });
558
 
559
+ it("死亡前的凝視:本回合致死 → 臨時生命1:1轉永久、100%復活、永久移除本卡", () => {
560
  const g = createGame({ classType: "BARBARIAN", seed: 1 });
561
  g.player.hp = 3; // 低血
562
+ g.player.tempMaxHp = 20; // 有臨時生命上限,復活時應 1:1 轉永久
563
  g.player.hand[0] = 183;
564
  const s1 = step(g, { type: "PLAY_CARD", handIndex: 0 }).state; // 武裝復活(hp 3-1=2)
565
  const { state } = step(s1, { type: "END_TURN" }); // 怪物反擊致死 → 復活
566
  expect(state.phase).not.toBe("GAME_OVER");
567
+ expect(state.player.maxHp).toBe(150); // 130 + 臨時 20 轉永久
568
+ expect(state.player.tempMaxHp).toBe(0); // 臨時生命已全數轉永久
569
+ expect(state.player.hp).toBe(150); // 100% 總生命復活
570
  expect(state.player.burn).not.toContain(183); // 永久移除
571
  });
572
 
 
593
  expect(b.player.hand).not.toContain(112);
594
  });
595
 
596
+ it("萬象寂滅:棄牌堆隨機 5 張進消耗堆、10 張專注洗入棄牌堆(不放牌庫)", () => {
597
  const { player: p } = createPlayer("BARBARIAN", makeRng(1), []);
598
  p.discard = [106, 106, 106, 106, 106, 106, 106]; p.deck = [100]; p.burn = [];
599
+ runOps([{ op: "ANNIHILATE", moveCount: 5 }, { op: "SHUFFLE_TOKEN", token: 110, pile: "discard", count: 10 }], ctxOf(p));
600
+ expect(p.burn.length).toBe(5); // 5 張移入消耗堆
601
+ expect(p.deck).toEqual([100]); // 牌庫不變(token 不再放牌庫)
602
+ expect(p.discard.filter((x) => x === 110).length).toBe(10); // 10 專注入棄牌堆
603
+ expect(p.discard.length).toBe(2 + 10); // 剩 2 原牌 + 10 專注
604
  });
605
 
606
  it("反刃血鎧:僅 hp 在臨時段(>maxHp)時抵擋扣血 → 2× 真實傷害", () => {
 
641
  drawCards(p, rng, 1, []);
642
  expect(p.discard).toContain(110); // 回棄牌堆
643
  expect(p.burn).not.toContain(110);
644
+ expect(p.hp).toBe(101); // +2(臨時上限回血) -1(地獄之門)
645
+ expect(p.tempMaxHp).toBe(2);
646
  expect(p.focusBurnedCount).toBe(0); // 未進消耗堆
647
  });
648
 
 
660
  expect(r.events.some((e) => e.type === "FORCED_END_TURN")).toBe(true);
661
  });
662
 
 
 
 
 
 
 
 
 
 
663
  it("出牌自傷使 HP≤0 → 出牌階段立即判負(GAME_OVER)", () => {
664
  const g = createGame({ classType: "BARBARIAN", seed: 1 });
665
  g.player.hp = 1; // 瀕死
 
676
  s1.player.hp = 1; s1.player.hand[0] = 106; // 瀕死後再出牌自傷
677
  const { state } = step(s1, { type: "PLAY_CARD", handIndex: 0 });
678
  expect(state.phase).not.toBe("GAME_OVER");
679
+ expect(state.player.hp).toBe(130); // 100% 復活(maxHp 130、無臨時生命)
680
  expect(state.player.burn).not.toContain(183);
681
  });
682
 
packages/battle-core/test/battle-core.test.ts CHANGED
@@ -152,6 +152,15 @@ describe("OnDealDamage 旗標(01 §5.1)", () => {
152
  expect(dmg).toBe(20 + 5); // 25
153
  });
154
 
 
 
 
 
 
 
 
 
 
155
  // 註:原「狂戰士之魂 出傷歸零 DEF」已由卡26「失控侵蝕」機制取代(鎖 DEF=0 + DEF→ATK),該旗標已移除。
156
  });
157
 
 
152
  expect(dmg).toBe(20 + 5); // 25
153
  });
154
 
155
+ it("終極一擊:旗標亮起 → dmg += 怪物當前 HP(處決真正生效,出傷當下結算)", () => {
156
+ const p = makePlayer({ atk: 20, flags: { 終極一擊: true } });
157
+ const m = createMonster();
158
+ m.hp = 100;
159
+ const dmg = onDealDamage(p, m, []);
160
+ expect(dmg).toBe(20 + 100); // 20 + 怪物當前 HP → 必死
161
+ expect(p.flags.終極一擊).toBe(false); // 用完即清
162
+ });
163
+
164
  // 註:原「狂戰士之魂 出傷歸零 DEF」已由卡26「失控侵蝕」機制取代(鎖 DEF=0 + DEF→ATK),該旗標已移除。
165
  });
166
 
packages/battle-core/test/ghost.test.ts CHANGED
@@ -26,12 +26,23 @@ describe("鬼影數值(01 §9)", () => {
26
  expect(g.avgDef).toBe(1); // floor(3/2)
27
  });
28
 
29
- it("n<=k 照抄;n>k 用 平均+n(整數)", () => {
30
  const g = createGhostRuntime([{ atk: 3, def: 1 }, { atk: 4, def: 2 }]);
31
  expect(ghostTurnValues(g, 1)).toEqual({ atk: 3, def: 1 });
32
  expect(ghostTurnValues(g, 2)).toEqual({ atk: 4, def: 2 });
33
- expect(ghostTurnValues(g, 3)).toEqual({ atk: 3 + 3, def: 1 + 3 }); // avg+n
34
- expect(ghostTurnValues(g, 5)).toEqual({ atk: 3 + 5, def: 1 + 5 });
 
 
 
 
 
 
 
 
 
 
 
35
  });
36
 
37
  it("createGhostOpponent:血量 = playerMaxHp,逐回合設攻防", () => {
 
26
  expect(g.avgDef).toBe(1); // floor(3/2)
27
  });
28
 
29
+ it("n<=k 照抄;n>k ATK 用 平均+n、DEF 固定平均(不爆走)", () => {
30
  const g = createGhostRuntime([{ atk: 3, def: 1 }, { atk: 4, def: 2 }]);
31
  expect(ghostTurnValues(g, 1)).toEqual({ atk: 3, def: 1 });
32
  expect(ghostTurnValues(g, 2)).toEqual({ atk: 4, def: 2 });
33
+ expect(ghostTurnValues(g, 3)).toEqual({ atk: 3 + 3, def: 1 }); // ATK=avg+n;DEF 固定 avgDef
34
+ expect(ghostTurnValues(g, 5)).toEqual({ atk: 3 + 5, def: 1 });
35
+ });
36
+
37
+ it("外推 DEF 有界:再長的回合鬼影防禦都不超過 avgDef → 永遠可被打死(避免無敵鬼影)", () => {
38
+ const g = createGhostRuntime([{ atk: 9, def: 5 }, { atk: 8, def: 5 }, { atk: 10, def: 5 }]);
39
+ // avgDef = floor(15/3) = 5。即使打到第 100 回合,DEF 仍夾在 avgDef,不會無限上升。
40
+ for (const n of [4, 10, 50, 100]) {
41
+ expect(ghostTurnValues(g, n).def).toBe(g.avgDef);
42
+ expect(ghostTurnValues(g, n).def).toBeLessThanOrEqual(g.avgDef);
43
+ }
44
+ // ATK 仍隨回合遞增,逼速戰壓力保留。
45
+ expect(ghostTurnValues(g, 50).atk).toBeGreaterThan(ghostTurnValues(g, 4).atk);
46
  });
47
 
48
  it("createGhostOpponent:血量 = playerMaxHp,逐回合設攻防", () => {
packages/battle-core/test/nameFilter.test.ts ADDED
@@ -0,0 +1,98 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ import { describe, it, expect } from "vitest";
2
+ import { cleanHeroName, containsProfanity, basicClean, HERO_NAME_FALLBACK, HERO_NAME_MAX } from "../src/nameFilter.js";
3
+ import { buildGhostRecord, createGhostOpponent } from "../src/opponent.js";
4
+ import { createGame } from "../src/engine.js";
5
+ import type { GhostRecord } from "../src/types.js";
6
+
7
+ describe("cleanHeroName:正常名字", () => {
8
+ it("一般中英文名字原樣保留", () => {
9
+ expect(cleanHeroName("Arthur")).toBe("Arthur");
10
+ expect(cleanHeroName("小明")).toBe("小明");
11
+ expect(cleanHeroName("龍騎士99")).toBe("龍騎士99");
12
+ });
13
+ it("去頭尾空白、collapse 連續空白", () => {
14
+ expect(cleanHeroName(" 小明 ")).toBe("小明");
15
+ expect(cleanHeroName("a b")).toBe("a b");
16
+ });
17
+ it("空字串 / 全空白 → 空(未命名)", () => {
18
+ expect(cleanHeroName("")).toBe("");
19
+ expect(cleanHeroName(" ")).toBe("");
20
+ });
21
+ it("超長截到 16", () => {
22
+ expect(cleanHeroName("a".repeat(40)).length).toBe(HERO_NAME_MAX);
23
+ });
24
+ });
25
+
26
+ describe("敏感詞 → 回退無名勇者(基本)", () => {
27
+ const banned = ["fuck", "FUCK", "F U C K", "f.u.c.k", "sh1t", "fuuuck", "@sshole", "b1tch", "n1gger", "幹你娘", "幹 你 娘", "媽的", "靠北", "雞掰"];
28
+ for (const w of banned) {
29
+ it(`「${w}」被過濾`, () => {
30
+ expect(containsProfanity(w)).toBe(true);
31
+ expect(cleanHeroName(w)).toBe(HERO_NAME_FALLBACK);
32
+ });
33
+ }
34
+ });
35
+
36
+ describe("繞過手法(稽核補強)", () => {
37
+ // 同形字(西里爾/希臘/土耳其無點 i/重音/組合符號)
38
+ const homoglyph = ["fuсk", "ѕhit", "bіtch", "сunt", "whоre", "bаstard", "fυck", "cυnt", "whοre", "shıt", "bıtch", "fück", "çunt", "f́úćḱ"];
39
+ for (const w of homoglyph) it(`同形字「${w}」被擋`, () => expect(containsProfanity(w)).toBe(true));
40
+
41
+ // 簡體 / 異體 / 知名同音
42
+ const cjkVariants = ["操你妈", "干你娘", "干你妈", "干你媽", "鸡巴", "鸡掰", "贱人", "贱货", "妈的", "他妈的", "草泥马", "靠杯"];
43
+ for (const w of cjkVariants) it(`中文變體「${w}」被擋`, () => expect(containsProfanity(w)).toBe(true));
44
+
45
+ // 單字整名 / 重複字母 / leet / ph / 字母替換
46
+ const misc = ["幹", "操", "干", "shiit", "幹你你娘", "phuck", "fvck", "fxck"];
47
+ for (const w of misc) it(`「${w}」被擋`, () => expect(containsProfanity(w)).toBe(true));
48
+ });
49
+
50
+ describe("不誤殺(Scunthorpe 類 + 中文正常詞)", () => {
51
+ const safe = [
52
+ "Cassandra", "Dickson", "classic", "assassin", "Matsushita", "Scunthorpe", "Ashitaka",
53
+ "Shitao", "Mishit", "Lightwater", "Twatt", "Wankel", "Slutsky", "Bastardo", "Faggotini",
54
+ "Retardant", "Niggard", "Snigger", "Pussycat", "Pussyfoot", "Whoreson", "Shiitake",
55
+ "操作員", "媽媽", "幹勁", "才幹", "骨幹", "幹活",
56
+ ];
57
+ for (const w of safe) {
58
+ it(`「${w}」不被誤判`, () => {
59
+ expect(containsProfanity(w)).toBe(false);
60
+ expect(cleanHeroName(w)).toBe(w);
61
+ });
62
+ }
63
+ });
64
+
65
+ describe("basicClean:去零寬/控制字元、保留空白", () => {
66
+ const ZW = String.fromCharCode(0x200b); // 零寬空白
67
+ const BELL = String.fromCharCode(0x07); // C0 控制字元
68
+ const DEL = String.fromCharCode(0x7f); // DEL 控制字元
69
+ it("去零寬空白", () => expect(basicClean("ze" + ZW + "ro")).toBe("zero"));
70
+ it("去 C0/DEL 控制字元", () => {
71
+ expect(basicClean("ab" + BELL + "c")).toBe("abc");
72
+ expect(basicClean("ab" + DEL + "c")).toBe("abc");
73
+ });
74
+ it("普通空白不被當控制字元刪除(只 collapse)", () => {
75
+ expect(basicClean("a b")).toBe("a b");
76
+ expect(basicClean("a b")).toBe("a b");
77
+ });
78
+ });
79
+
80
+ describe("鬼影 meta.heroName 串接", () => {
81
+ function victoryState() {
82
+ const s = createGame({ classType: "WARRIOR", seed: 1 });
83
+ s.turnLog = [{ atk: 5, def: 1 }];
84
+ return s;
85
+ }
86
+ it("buildGhostRecord 帶 heroName → 寫入 meta", () => {
87
+ expect(buildGhostRecord(victoryState(), { seed: 1, heroName: "小明" }).meta?.heroName).toBe("小明");
88
+ });
89
+ it("buildGhostRecord 空 heroName → meta.heroName 為 undefined", () => {
90
+ expect(buildGhostRecord(victoryState(), { seed: 1, heroName: "" }).meta?.heroName).toBeUndefined();
91
+ });
92
+ it("createGhostOpponent:有名字 → 用名字當對手名;沒名字 → Ghost", () => {
93
+ const base: Omit<GhostRecord, "meta"> = { playerMaxHp: 100, turns: [{ atk: 3, def: 1 }], seed: 1, ruleVersion: "x", cardsHash: "y" };
94
+ expect(createGhostOpponent({ ...base, meta: { classType: "WARRIOR", heroName: "小明" } }).name).toBe("小明");
95
+ expect(createGhostOpponent({ ...base }).name).toBe("Ghost");
96
+ expect(createGhostOpponent({ ...base, meta: { classType: "WARRIOR" } }).name).toBe("Ghost");
97
+ });
98
+ });
packages/battle-core/test/preview-cost.test.ts ADDED
@@ -0,0 +1,62 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ /**
2
+ * previewPlayHpCost:UI 顯示「現在打出這張牌會扣多少 HP」的真實代價(含 n 進位、ADD_N、卡面 ADD_HP、
3
+ * 無盡怒火自擊轉向等)。用複本跑真正的 playCard 量測,與出牌邏輯零偏差。
4
+ * 對應回報 bug:野蠻人在 ~10 血、N 看似安全時打牌卻暴斃 —— 代價必須在出牌前就看得見。
5
+ */
6
+ import { describe, it, expect } from "vitest";
7
+ import { createPlayer, previewPlayHpCost } from "../src/player.js";
8
+ import { makeRng } from "../src/rng.js";
9
+ import type { PlayerState } from "../src/types.js";
10
+
11
+ function barb(ov: Partial<PlayerState>): PlayerState {
12
+ const { player } = createPlayer("BARBARIAN", makeRng(1), []);
13
+ Object.assign(player, ov);
14
+ return player;
15
+ }
16
+
17
+ describe("previewPlayHpCost — 出牌真實自傷代價", () => {
18
+ it("一般牌(106) n=6 → 下一張實扣 7(修正 N 顯示 off-by-one)", () => {
19
+ expect(previewPlayHpCost(barb({ hp: 100, n: 6, hand: [106], deck: [], discard: [] }), 0)).toBe(7);
20
+ });
21
+
22
+ it("千刀萬剮(150) n=7 → 實扣 10(n+1 再 ADD_N+2)", () => {
23
+ expect(previewPlayHpCost(barb({ hp: 100, n: 7, hand: [150], deck: [], discard: [] }), 0)).toBe(10);
24
+ });
25
+
26
+ it("無腦傾瀉(131) n=6 充足 HP → 實扣 14(卡面 -n 疊被動 -n)", () => {
27
+ expect(previewPlayHpCost(barb({ hp: 50, n: 6, hand: [131, 1, 1, 1, 1], deck: [], discard: [] }), 0)).toBe(14);
28
+ });
29
+
30
+ it("代價 ≥ 目前 HP → 夾為目前 HP(致命紅線)", () => {
31
+ expect(previewPlayHpCost(barb({ hp: 10, n: 6, hand: [131, 1, 1, 1, 1], deck: [], discard: [] }), 0)).toBe(10);
32
+ });
33
+
34
+ it("回報情境:沸騰之血(101) + 無盡怒火 在 10 血時 → 預覽即顯示致命的扣 10", () => {
35
+ // 無盡怒火(158)使下一張攻擊改打自己;沸騰之血(101)傷害=5%血上限被轉向自身,再疊被動 n 自傷。
36
+ const p = barb({ hp: 10, n: 6, maxHp: 130, tempMaxHp: 70, hand: [101], deck: [], discard: [], nextAtkSelf: true });
37
+ expect(previewPlayHpCost(p, 0)).toBe(10); // = 目前 HP → 打了就死,出牌前就看得到
38
+ });
39
+
40
+ it("沒有無盡怒火時沸騰之血(101)只扣被動:10 血 n=6 → 只扣 7(不致命)", () => {
41
+ const p = barb({ hp: 10, n: 6, maxHp: 130, tempMaxHp: 70, hand: [101], deck: [], discard: [] });
42
+ expect(previewPlayHpCost(p, 0)).toBe(7);
43
+ });
44
+
45
+ it("補抽『專注』回血不稀釋代價:牌庫頂是專注仍顯示淨自傷 7", () => {
46
+ expect(previewPlayHpCost(barb({ hp: 100, n: 6, hand: [106], deck: [110, 110, 110, 110], discard: [] }), 0)).toBe(7);
47
+ });
48
+
49
+ it("純預覽不更動真實狀態", () => {
50
+ const p = barb({ hp: 100, n: 6, hand: [106], deck: [], discard: [] });
51
+ const before = JSON.stringify(p);
52
+ previewPlayHpCost(p, 0);
53
+ expect(JSON.stringify(p)).toBe(before);
54
+ });
55
+
56
+ it("戰士無此被動 → null;空手牌索引 → null", () => {
57
+ const { player: w } = createPlayer("WARRIOR", makeRng(1), []);
58
+ Object.assign(w, { hand: [1] });
59
+ expect(previewPlayHpCost(w, 0)).toBeNull();
60
+ expect(previewPlayHpCost(barb({ hand: [] }), 0)).toBeNull();
61
+ });
62
+ });
packages/battle-core/test/sanctus.test.ts ADDED
@@ -0,0 +1,134 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ import { describe, it, expect } from "vitest";
2
+ import { createGame, step } from "../src/engine.js";
3
+ import { accrueCardEnergy, createSanctus, sanctusEnemyTurn, upgradeSanctusForLevel } from "../src/foes.js";
4
+ import { opponentTakeDamage } from "../src/opponent.js";
5
+ import type { GameEvent } from "../src/types.js";
6
+
7
+ describe("Sanctus 路線(Phase 1:生成 / 審判 / Aegis / 升級)", () => {
8
+ it("createGame campaign=sanctus → Sanctus、maxLevel 5、有審判線", () => {
9
+ const g = createGame({ classType: "WARRIOR", seed: 1, campaign: "sanctus" });
10
+ expect(g.campaign).toBe("sanctus");
11
+ expect(g.maxLevel).toBe(5);
12
+ expect(g.opponent.name).toBe("Sanctus");
13
+ expect(g.opponent.judgeLine).toBe(18);
14
+ expect(g.opponent.hp).toBe(28);
15
+ expect(g.opponent.def).toBe(2);
16
+ });
17
+
18
+ it("史萊姆路線完全不受影響(無審判線/無 Aegis)", () => {
19
+ const g = createGame({ classType: "WARRIOR", seed: 1 });
20
+ expect(g.campaign).toBe("slime");
21
+ expect(g.maxLevel).toBe(11);
22
+ expect(g.opponent.judgeLine).toBeUndefined();
23
+ expect(g.opponent.aegis).toBeUndefined();
24
+ });
25
+
26
+ it("審判:原始 ATK 超過審判線 → 溢出 ½(無條件進位)暫存反傷、無上限", () => {
27
+ const a = createSanctus(); // judgeLine 18
28
+ opponentTakeDamage(a, 30); // 溢出 12 → 6
29
+ expect(a.pendingReflect).toBe(6);
30
+
31
+ const b = createSanctus();
32
+ opponentTakeDamage(b, 19); // 溢出 1 → ceil(1/2)=1
33
+ expect(b.pendingReflect).toBe(1);
34
+
35
+ const c = createSanctus();
36
+ opponentTakeDamage(c, 18); // 等於線,不觸發
37
+ expect(c.pendingReflect ?? 0).toBe(0);
38
+
39
+ const d = createSanctus();
40
+ opponentTakeDamage(d, 118); // 溢出 100 → 50(無上限)
41
+ expect(d.pendingReflect).toBe(50);
42
+ });
43
+
44
+ it("Aegis:先扣 DEF 再由護盾吸收,剩餘才進 HP", () => {
45
+ const m = createSanctus(); // def 2, hp 28
46
+ m.aegis = 5;
47
+ const actual = opponentTakeDamage(m, 12); // 12-2=10;護盾吸 5 → 5 進 HP
48
+ expect(m.aegis).toBe(0);
49
+ expect(actual).toBe(5);
50
+ expect(m.hp).toBe(23);
51
+ });
52
+
53
+ it("穿透(真實傷害)越過 DEF 與 Aegis 護盾,直接扣 HP", () => {
54
+ let g = createGame({ classType: "WARRIOR", seed: 9, campaign: "sanctus" });
55
+ g = JSON.parse(JSON.stringify(g)) as typeof g;
56
+ g.opponent.hp = 200; g.opponent.maxHp = 200; g.opponent.def = 5; g.opponent.aegis = 10;
57
+ g.player.atk = 0; // 只測真傷,無一般傷害
58
+ g.player.trueDamage = 8;
59
+ const r = step(g, { type: "END_TURN" });
60
+ expect(r.state.opponent.aegis).toBe(10); // 護盾完全沒被碰(被穿透)
61
+ expect(r.state.opponent.hp).toBe(192); // 真傷 8 直接扣 HP(越過 def5 / 盾10)
62
+ });
63
+
64
+ it("審判反傷在怪物普攻後無視 DEF 扣玩家 HP", () => {
65
+ let g = createGame({ classType: "WARRIOR", seed: 3, campaign: "sanctus" });
66
+ g = JSON.parse(JSON.stringify(g)) as typeof g;
67
+ g.opponent.hp = 200; g.opponent.maxHp = 200; // 確保不被打死、能反擊
68
+ g.player.atk = 30; // 原始 ATK 30 > 18 → 溢出 12 → 反傷 6
69
+ g.player.def = 99; // 擋掉 Sanctus 普攻,凸顯反傷無視 DEF
70
+ const hp0 = g.player.hp;
71
+ const r = step(g, { type: "END_TURN" });
72
+ const reflect = r.events.find((e) => e.type === "MONSTER_REFLECT");
73
+ expect(reflect).toBeTruthy();
74
+ expect(r.state.player.hp).toBe(hp0 - 6); // 普攻被 DEF 擋、僅反傷 6 生效
75
+ });
76
+
77
+ it("過關升級:逐關套用設定(HP / 審判線 / 技能解鎖)", () => {
78
+ const m = createSanctus();
79
+ expect(m.skills).toEqual(["aegis"]);
80
+ upgradeSanctusForLevel(m, 5);
81
+ expect(m.hp).toBe(100);
82
+ expect(m.judgeLine).toBe(30);
83
+ expect(m.skills).toEqual(["aegis", "smite", "parry", "verdict", "lastjudgment"]);
84
+ });
85
+ });
86
+
87
+ describe("Sanctus 路線(Phase 2:能量 / 意圖 / 技能執行)", () => {
88
+ it("能量:玩家每出 2 張牌 → +1", () => {
89
+ const m = createSanctus(); // energy 0, maxEnergy 8
90
+ accrueCardEnergy(m); expect(m.energy).toBe(0);
91
+ accrueCardEnergy(m); expect(m.energy).toBe(1);
92
+ accrueCardEnergy(m); accrueCardEnergy(m); expect(m.energy).toBe(2);
93
+ });
94
+
95
+ it("意圖:能量不足不預告,足夠則貪婪挑可負擔技能", () => {
96
+ const m = createSanctus(); // skills [aegis](cost3), intentDepth 1
97
+ sanctusEnemyTurn(m, []); // +2 → 2,不夠 aegis(3) → intent []
98
+ expect(m.intent).toEqual([]);
99
+ expect(m.energy).toBe(2);
100
+ m.energy = 5;
101
+ sanctusEnemyTurn(m, []); // +2 → 7,規劃 → ["aegis"]
102
+ expect(m.intent).toEqual(["aegis"]);
103
+ });
104
+
105
+ it("技能執行:聖盾術升盾、扣能量、發 SKILL_USED,非攻擊技無加成", () => {
106
+ const m = createSanctus();
107
+ m.energy = 6; m.intent = ["aegis"];
108
+ const ev: GameEvent[] = [];
109
+ const bonus = sanctusEnemyTurn(m, ev); // +2 → 8;exec aegis cost3 → energy5、aegis4
110
+ expect(m.aegis).toBe(4);
111
+ expect(m.energy).toBe(5);
112
+ expect(bonus).toBe(0);
113
+ expect(ev.some((e) => e.type === "SKILL_USED" && e.skill === "aegis")).toBe(true);
114
+ });
115
+
116
+ it("攻擊技能(裁決斬)只回傳一次性加成、不永久墊高 atk", () => {
117
+ const m = createSanctus();
118
+ upgradeSanctusForLevel(m, 4); // baseAtk 8、含 verdict(cost7)
119
+ const atk0 = m.atk;
120
+ m.energy = 9; m.intent = ["verdict"];
121
+ const bonus = sanctusEnemyTurn(m, []); // exec verdict → 加成 baseAtk×2 = 16
122
+ expect(bonus).toBe(16);
123
+ expect(m.atk).toBe(atk0); // m.atk 未被永久改動
124
+ });
125
+
126
+ it("整場 step:能量到位後 Sanctus 真的會放技能(升盾)", () => {
127
+ let g = createGame({ classType: "WARRIOR", seed: 7, campaign: "sanctus" });
128
+ g = JSON.parse(JSON.stringify(g)) as typeof g;
129
+ g.opponent.energy = 6; g.opponent.intent = ["aegis"]; g.opponent.hp = 200; g.opponent.maxHp = 200;
130
+ const r = step(g, { type: "END_TURN" });
131
+ expect(r.events.some((e) => e.type === "SKILL_USED" && e.skill === "aegis")).toBe(true);
132
+ expect(r.state.opponent.aegis).toBe(4);
133
+ });
134
+ });
packages/server/src/ghostService.ts CHANGED
@@ -23,6 +23,12 @@ export function validateGhostShape(body: unknown): string | null {
23
  if (!intInRange(r.seed, -0x80000000, 0xffffffff)) return "seed 必須是整數";
24
  if (typeof r.ruleVersion !== "string" || r.ruleVersion.length > 32) return "缺/非法 ruleVersion";
25
  if (typeof r.cardsHash !== "string" || r.cardsHash.length > 64) return "缺/非法 cardsHash";
 
 
 
 
 
 
26
  if (r.actions !== undefined) {
27
  if (!Array.isArray(r.actions)) return "actions 必須是陣列";
28
  if (r.actions.length > 20000) return "actions 過長"; // 防重播 DoS
 
23
  if (!intInRange(r.seed, -0x80000000, 0xffffffff)) return "seed 必須是整數";
24
  if (typeof r.ruleVersion !== "string" || r.ruleVersion.length > 32) return "缺/非法 ruleVersion";
25
  if (typeof r.cardsHash !== "string" || r.cardsHash.length > 64) return "缺/非法 cardsHash";
26
+ if (r.meta !== undefined) {
27
+ if (typeof r.meta !== "object" || r.meta === null) return "meta 必須是物件";
28
+ const hn = (r.meta as Record<string, unknown>).heroName;
29
+ // heroName 若有則必為字串、長度有界(防 DoS;實際內容由 cleanHeroName 截長/過濾)。
30
+ if (hn !== undefined && (typeof hn !== "string" || hn.length > 1000)) return "meta.heroName 非法";
31
+ }
32
  if (r.actions !== undefined) {
33
  if (!Array.isArray(r.actions)) return "actions 必須是陣列";
34
  if (r.actions.length > 20000) return "actions 過長"; // 防重播 DoS
packages/server/src/pvpMatch.ts CHANGED
@@ -9,6 +9,7 @@ import {
9
  createPvpPlayer,
10
  planTurn,
11
  resolveSimultaneous,
 
12
  pileView,
13
  DEFAULT_PVP_CONFIG,
14
  type Action,
@@ -34,6 +35,8 @@ export interface PvpView {
34
  coin: number; maxCoin: number; combo: number; nextReq: Tag; n: number;
35
  useA: boolean; useB: boolean; locked: boolean; forcedEnd: boolean;
36
  hand: number[];
 
 
37
  pending: { count: number; keep: boolean; scry?: number[] } | null; // 互動選牌待玩家選;scry=候選牌(野蠻直覺探牌)
38
  deckCount: number; deckView: PileEntry[];
39
  discardCount: number; discardView: PileEntry[];
@@ -247,6 +250,8 @@ export class PvpMatch {
247
  coin: s.coin, maxCoin: s.maxCoin, combo: s.combo, nextReq: s.nextReq, n: s.n,
248
  useA: s.useA, useB: s.useB, locked: mp.locked, forcedEnd: mp.current.forcedEnd,
249
  hand: [...s.hand],
 
 
250
  pending: mp.current.pending ? { count: mp.current.pending.count, keep: mp.current.pending.keep === true, scry: mp.current.pending.scry } : null,
251
  deckCount: s.deck.length, deckView: viewState(s, "deck"),
252
  discardCount: s.discard.length, discardView: viewState(s, "discard"),
 
9
  createPvpPlayer,
10
  planTurn,
11
  resolveSimultaneous,
12
+ previewPlayHpCost,
13
  pileView,
14
  DEFAULT_PVP_CONFIG,
15
  type Action,
 
35
  coin: number; maxCoin: number; combo: number; nextReq: Tag; n: number;
36
  useA: boolean; useB: boolean; locked: boolean; forcedEnd: boolean;
37
  hand: number[];
38
+ handCost: (number | null)[]; // 野蠻人:每張手牌「現在打出會扣多少 HP」(權威端算,含 +1/ADD_N/卡面自傷);非野蠻人為 null
39
+
40
  pending: { count: number; keep: boolean; scry?: number[] } | null; // 互動選牌待玩家選;scry=候選牌(野蠻直覺探牌)
41
  deckCount: number; deckView: PileEntry[];
42
  discardCount: number; discardView: PileEntry[];
 
250
  coin: s.coin, maxCoin: s.maxCoin, combo: s.combo, nextReq: s.nextReq, n: s.n,
251
  useA: s.useA, useB: s.useB, locked: mp.locked, forcedEnd: mp.current.forcedEnd,
252
  hand: [...s.hand],
253
+ handCost: s.hand.map((_, i) => previewPlayHpCost(s, i, "pvp")), // 每張牌的真實自傷代價(顯示用)
254
+
255
  pending: mp.current.pending ? { count: mp.current.pending.count, keep: mp.current.pending.keep === true, scry: mp.current.pending.scry } : null,
256
  deckCount: s.deck.length, deckView: viewState(s, "deck"),
257
  discardCount: s.discard.length, discardView: viewState(s, "discard"),
packages/server/src/repository.ts CHANGED
@@ -4,13 +4,21 @@
4
  import { randomUUID } from "node:crypto";
5
  import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
6
  import { dirname } from "node:path";
7
- import type { GhostRecord } from "@wcg/battle-core";
8
 
9
  export interface StoredGhost extends GhostRecord {
10
  id: string;
11
  verified: boolean;
12
  }
13
 
 
 
 
 
 
 
 
 
14
  export interface GhostRepository {
15
  add(record: GhostRecord, verified: boolean): StoredGhost;
16
  random(): StoredGhost | null;
@@ -32,6 +40,7 @@ export class InMemoryGhostRepository implements GhostRepository {
32
 
33
  add(record: GhostRecord, verified: boolean): StoredGhost {
34
  const stored: StoredGhost = { ...record, id: randomUUID(), verified };
 
35
  this.items.push(stored);
36
  if (this.items.length > InMemoryGhostRepository.MAX_GHOSTS) {
37
  this.items.splice(0, this.items.length - InMemoryGhostRepository.MAX_GHOSTS); // 淘汰最舊
@@ -126,6 +135,7 @@ export class UpstashGhostRepository extends InMemoryGhostRepository {
126
  /* 略過壞資料 */
127
  }
128
  }
 
129
  this.items = loaded;
130
  }
131
 
@@ -152,7 +162,10 @@ export class JsonFileGhostRepository extends InMemoryGhostRepository {
152
  try {
153
  const raw = readFileSync(file, "utf8");
154
  const parsed = JSON.parse(raw) as StoredGhost[];
155
- if (Array.isArray(parsed)) this.items = parsed;
 
 
 
156
  } catch {
157
  this.items = [];
158
  }
 
4
  import { randomUUID } from "node:crypto";
5
  import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
6
  import { dirname } from "node:path";
7
+ import { cleanHeroName, type GhostRecord } from "@wcg/battle-core";
8
 
9
  export interface StoredGhost extends GhostRecord {
10
  id: string;
11
  verified: boolean;
12
  }
13
 
14
+ /** 權威過濾勇者名字(防禦縱深:除上傳入口外,入庫/載入時亦清洗,涵蓋預先存在或手改的紀錄)。 */
15
+ function sanitizeHeroName(g: GhostRecord): void {
16
+ if (g.meta && typeof g.meta.heroName === "string") {
17
+ const c = cleanHeroName(g.meta.heroName);
18
+ g.meta.heroName = c.length > 0 ? c : undefined;
19
+ }
20
+ }
21
+
22
  export interface GhostRepository {
23
  add(record: GhostRecord, verified: boolean): StoredGhost;
24
  random(): StoredGhost | null;
 
40
 
41
  add(record: GhostRecord, verified: boolean): StoredGhost {
42
  const stored: StoredGhost = { ...record, id: randomUUID(), verified };
43
+ sanitizeHeroName(stored); // 入庫前再清洗一次(涵蓋未經上傳入口的呼叫,如測試/未來路徑)
44
  this.items.push(stored);
45
  if (this.items.length > InMemoryGhostRepository.MAX_GHOSTS) {
46
  this.items.splice(0, this.items.length - InMemoryGhostRepository.MAX_GHOSTS); // 淘汰最舊
 
135
  /* 略過壞資料 */
136
  }
137
  }
138
+ loaded.forEach(sanitizeHeroName); // 載入時清洗(Redis 內可能有舊/未過濾名字)
139
  this.items = loaded;
140
  }
141
 
 
162
  try {
163
  const raw = readFileSync(file, "utf8");
164
  const parsed = JSON.parse(raw) as StoredGhost[];
165
+ if (Array.isArray(parsed)) {
166
+ parsed.forEach(sanitizeHeroName); // 載入時清洗(手改/舊檔可能含未過濾名字)
167
+ this.items = parsed;
168
+ }
169
  } catch {
170
  this.items = [];
171
  }
packages/server/src/server.ts CHANGED
@@ -6,7 +6,7 @@ import Fastify, { type FastifyInstance } from "fastify";
6
  import fastifyStatic from "@fastify/static";
7
  import websocketPlugin from "@fastify/websocket";
8
  import { randomUUID } from "node:crypto";
9
- import type { GhostRecord } from "@wcg/battle-core";
10
  import type { GhostRepository } from "./repository.js";
11
  import { validateGhostShape, verifyGhost } from "./ghostService.js";
12
  import { PvpHub, type PvpConn } from "./pvpHub.js";
@@ -71,6 +71,11 @@ export function buildServer(opts: ServerOptions): FastifyInstance {
71
  if (requireVerified && !verdict.ok) {
72
  return reply.code(422).send({ error: "verification-failed", reason: verdict.reason });
73
  }
 
 
 
 
 
74
  const stored = repo.add(record, verdict.ok);
75
  return reply.code(201).send({ id: stored.id, verified: stored.verified, reason: verdict.reason });
76
  });
 
6
  import fastifyStatic from "@fastify/static";
7
  import websocketPlugin from "@fastify/websocket";
8
  import { randomUUID } from "node:crypto";
9
+ import { cleanHeroName, type GhostRecord } from "@wcg/battle-core";
10
  import type { GhostRepository } from "./repository.js";
11
  import { validateGhostShape, verifyGhost } from "./ghostService.js";
12
  import { PvpHub, type PvpConn } from "./pvpHub.js";
 
71
  if (requireVerified && !verdict.ok) {
72
  return reply.code(422).send({ error: "verification-failed", reason: verdict.reason });
73
  }
74
+ // 權威過濾勇者名字(客戶端可繞過 → 後端為準)。meta 不參與 verifyGhost,故在驗證後清洗不影響判定。
75
+ if (record.meta && typeof record.meta.heroName === "string") {
76
+ const cleaned = cleanHeroName(record.meta.heroName);
77
+ record.meta.heroName = cleaned.length > 0 ? cleaned : undefined;
78
+ }
79
  const stored = repo.add(record, verdict.ok);
80
  return reply.code(201).send({ id: stored.id, verified: stored.verified, reason: verdict.reason });
81
  });
packages/web/public/resources/barbarian/CardBack.png ADDED

Git LFS Details

  • SHA256: 4e83ecc79f39f84bf78a9fa5392f2eeb2fc80156a8d5110ec31971bc0edf4672
  • Pointer size: 132 Bytes
  • Size of remote file: 3.04 MB
packages/web/public/resources/{0.png → cards/0.png} RENAMED
File without changes
packages/web/public/resources/{1.png → cards/1.png} RENAMED
File without changes
packages/web/public/resources/{10.png → cards/10.png} RENAMED
File without changes
packages/web/public/resources/{11.png → cards/11.png} RENAMED
File without changes
packages/web/public/resources/{12.png → cards/12.png} RENAMED
File without changes
packages/web/public/resources/{13.png → cards/13.png} RENAMED
File without changes
packages/web/public/resources/{14.png → cards/14.png} RENAMED
File without changes
packages/web/public/resources/{15.png → cards/15.png} RENAMED
File without changes
packages/web/public/resources/{16.png → cards/16.png} RENAMED
File without changes
packages/web/public/resources/{17.png → cards/17.png} RENAMED
File without changes
packages/web/public/resources/{18.png → cards/18.png} RENAMED
File without changes
packages/web/public/resources/{19.png → cards/19.png} RENAMED
File without changes
packages/web/public/resources/{2.png → cards/2.png} RENAMED
File without changes
packages/web/public/resources/{20.png → cards/20.png} RENAMED
File without changes
packages/web/public/resources/{21.png → cards/21.png} RENAMED
File without changes
packages/web/public/resources/{22.png → cards/22.png} RENAMED
File without changes
packages/web/public/resources/{23.png → cards/23.png} RENAMED
File without changes
packages/web/public/resources/{24.png → cards/24.png} RENAMED
File without changes