freeguy2006 Claude Opus 4.8 commited on
Commit
b0001d9
·
1 Parent(s): 3d7a4cf

feat(barbarian): 野蠻直覺 完整互動探牌(自選留 1 + 自選棄 1)

Browse files

新增「牌庫探視選擇」互動框架(跨 battle-core/server/web):
- PendingChoice 型別統一,新增 scry(候選牌清單)與 then(多階段後續選擇)
- resolveChoice 改回傳 {rng, pending?},支援多階段;scry 階段:選 keepCount 入手、其餘燒毀
- CardData.scryChoose;野蠻直覺(168):看頂 3 → 自選 1 入手 → 自選棄 1 手牌 → 其餘燒毀
- engine/planTurn 處理後續 pending;pvp-sim autoPlan 迴圈解析 + scry 挑最高
- server viewFor 暴露 pending.scry;web 單人 Battle + PvP 皆加探牌候選面板(選候選非手牌)

battle-core 230 + server 35 測試全綠、全工作區 typecheck/build 通過。平衡不變(互動由 sim 自動解析)。

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

packages/battle-core/data/cards.json CHANGED
@@ -2100,15 +2100,12 @@
2100
  "atk": 0,
2101
  "def": 0,
2102
  "rarity": "epic",
2103
- "desc": "檢視牌庫頂 3 張,將其中 1 張加入手牌,其餘燒毀(進消耗堆)。",
2104
- "onPlay": [
2105
- {
2106
- "op": "SCRY",
2107
- "count": 3,
2108
- "keep": 1,
2109
- "rest": "burn"
2110
- }
2111
- ]
2112
  },
2113
  {
2114
  "id": 169,
 
2100
  "atk": 0,
2101
  "def": 0,
2102
  "rarity": "epic",
2103
+ "desc": "檢視牌庫頂 3 張,自選 1 張加入手牌(並自選棄掉原本 1 張),其餘燒毀。",
2104
+ "scryChoose": {
2105
+ "lookCount": 3,
2106
+ "keepCount": 1,
2107
+ "thenDiscard": 1
2108
+ }
 
 
 
2109
  },
2110
  {
2111
  "id": 169,
packages/battle-core/scripts/pvp-sim.ts CHANGED
@@ -17,8 +17,13 @@ import type { ClassType, PlayerState } from "../src/types.js";
17
  const clone = (p: PlayerState): PlayerState => JSON.parse(JSON.stringify(p));
18
  const cardVal = (s: PlayerState, id: number): number => getCard(id).atk + (s.cardBuffs[id] ?? 0);
19
 
20
- /** 互動選牌:keep→強化 atk 最高;否則棄 atk 最低的 count 張(以手牌索引)。 */
21
- function pickChoice(s: PlayerState, pending: { count: number; keep?: boolean }): number[] {
 
 
 
 
 
22
  const order = s.hand.map((id, i) => ({ i, v: cardVal(s, id) }));
23
  order.sort((x, y) => (pending.keep ? y.v - x.v : x.v - y.v)); // keep:高→低;棄:低→高
24
  return order.slice(0, Math.min(pending.count, s.hand.length)).map((o) => o.i);
@@ -49,8 +54,11 @@ function autoPlan(slot: PvpSlot): PvpSlot {
49
  if (!res.ok) break; // 戰士硬幣/標籤閘門打不出 → 停手
50
  if (s.specialWin) break;
51
  if (s.hp <= 0) break; // 自傷致死(結算會判負)
52
- if (res.pending) {
53
- rng = resolveChoice(s, pickChoice(s, res.pending), res.pending, rng, []);
 
 
 
54
  }
55
  if (res.forcedEnd) break;
56
  }
 
17
  const clone = (p: PlayerState): PlayerState => JSON.parse(JSON.stringify(p));
18
  const cardVal = (s: PlayerState, id: number): number => getCard(id).atk + (s.cardBuffs[id] ?? 0);
19
 
20
+ /** 互動選牌:scry→留 atk 最高;keep→強化 atk 最高;否則棄 atk 最低的 count 張。回傳對應清單索引。 */
21
+ function pickChoice(s: PlayerState, pending: { count: number; keep?: boolean; scry?: number[] }): number[] {
22
+ if (pending.scry) {
23
+ const order = pending.scry.map((id, i) => ({ i, v: getCard(id).atk }));
24
+ order.sort((x, y) => y.v - x.v); // 留 atk 最高
25
+ return order.slice(0, Math.min(pending.count, pending.scry.length)).map((o) => o.i);
26
+ }
27
  const order = s.hand.map((id, i) => ({ i, v: cardVal(s, id) }));
28
  order.sort((x, y) => (pending.keep ? y.v - x.v : x.v - y.v)); // keep:高→低;棄:低→高
29
  return order.slice(0, Math.min(pending.count, s.hand.length)).map((o) => o.i);
 
54
  if (!res.ok) break; // 戰士硬幣/標籤閘門打不出 → 停手
55
  if (s.specialWin) break;
56
  if (s.hp <= 0) break; // 自傷致死(結算會判負)
57
+ let pend = res.pending;
58
+ while (pend) { // 多階段(野蠻直覺):scry 留牌 → 棄手牌
59
+ const rc = resolveChoice(s, pickChoice(s, pend), pend, rng, []);
60
+ rng = rc.rng;
61
+ pend = rc.pending;
62
  }
63
  if (res.forcedEnd) break;
64
  }
packages/battle-core/src/data/cards.ts CHANGED
@@ -526,9 +526,8 @@ export const CARDS: readonly CardData[] = [
526
  },
527
  {
528
  id: 168, classType: "BARBARIAN", name: "野蠻直覺", tag: "None", nextReq: "None", atk: 0, def: 0, rarity: "epic",
529
- // TODO(自選):目前自動留最高 atk;完整「玩家自選留哪張+棄原本哪張」需牌庫探視互動 UI(待補)
530
- desc: "檢視牌庫頂 3 張,將其中 1 張加入手牌,其餘燒毀(進消耗堆)。",
531
- onPlay: [{ op: "SCRY", count: 3, keep: 1, rest: "burn" }],
532
  },
533
  {
534
  id: 169, classType: "BARBARIAN", name: "血誓契約", tag: "None", nextReq: "None", atk: 0, def: 0, rarity: "epic",
 
526
  },
527
  {
528
  id: 168, classType: "BARBARIAN", name: "野蠻直覺", tag: "None", nextReq: "None", atk: 0, def: 0, rarity: "epic",
529
+ desc: "檢視牌庫頂 3 張,自選 1 張加入手牌(並自選棄掉原本 1 張),其餘燒毀。",
530
+ scryChoose: { lookCount: 3, keepCount: 1, thenDiscard: 1 },
 
531
  },
532
  {
533
  id: 169, classType: "BARBARIAN", name: "血誓契約", tag: "None", nextReq: "None", atk: 0, def: 0, rarity: "epic",
packages/battle-core/src/engine.ts CHANGED
@@ -132,7 +132,9 @@ export function step(state: GameState, action: Action): StepResult {
132
  case "CHOOSE_CARDS": {
133
  if (next.phase !== "PENDING_CHOICE" || !next.pendingChoice) return { state: next, events };
134
  const forcedEndPending = next.pendingChoice.forcedEnd === true; // 出牌當下已觸發的強制結束(放手一搏)
135
- next.rng = resolveChoice(next.player, action.indices, next.pendingChoice, next.rng, events);
 
 
136
  next.pendingChoice = undefined;
137
  next.phase = "PLAYER_TURN";
138
  if (next.player.specialWin) { // 選牌後達特殊勝利(防禦性)
 
132
  case "CHOOSE_CARDS": {
133
  if (next.phase !== "PENDING_CHOICE" || !next.pendingChoice) return { state: next, events };
134
  const forcedEndPending = next.pendingChoice.forcedEnd === true; // 出牌當下已觸發的強制結束(放手一搏)
135
+ const rc = resolveChoice(next.player, action.indices, next.pendingChoice, next.rng, events);
136
+ next.rng = rc.rng;
137
+ if (rc.pending) { next.pendingChoice = rc.pending; return { state: next, events }; } // 多階段選擇(野蠻直覺):續選,仍 PENDING_CHOICE
138
  next.pendingChoice = undefined;
139
  next.phase = "PLAYER_TURN";
140
  if (next.player.specialWin) { // 選牌後達特殊勝利(防禦性)
packages/battle-core/src/player.ts CHANGED
@@ -3,7 +3,7 @@
3
  * 純函式風格:在傳入的 player draft 上就地修改,回傳推進後的 rng 與事件。
4
  */
5
 
6
- import type { ClassType, EffectOp, GameEvent, OpponentState, PlayerState, RngState } from "./types.js";
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";
@@ -116,8 +116,8 @@ export interface PlayCardResult {
116
  forcedEnd: boolean; // Q2:重擊之後再打一張即強制結束
117
  rng: RngState;
118
  events: GameEvent[];
119
- /** 互動選棄:本卡需玩家選 count 張手牌棄掉;引擎進 PENDING_CHOICE,選完才把本卡入堆 + 補手牌。keep=選而不棄(血誓契約);forcedEnd=本卡打出時已觸發強制結束(放手一搏 dec n≤0),選完後須結束回合。 */
120
- pending?: { cardId: number; count: number; onChosen?: EffectOp[]; exhaust?: boolean; keep?: boolean; forcedEnd?: boolean };
121
  }
122
 
123
  /**
@@ -192,6 +192,19 @@ export function playCard(
192
  // 強制結束回合:放手一搏(dec n<=0) 或 野蠻人被動(n>=20 出牌計數過高)。
193
  const forcedEnd = (player.nMode === "dec" && player.n <= 0) || player.n >= 20;
194
  // 互動選棄/選牌:暫停(本卡先不入堆、不補手牌),由引擎進 PENDING_CHOICE、選完才完成。
 
 
 
 
 
 
 
 
 
 
 
 
 
195
  if (card.chooseDiscard) {
196
  return {
197
  ok: true, forcedEnd, rng: ctx.rng, events,
@@ -306,31 +319,48 @@ export function playCard(
306
 
307
  /**
308
  * 解析互動選牌(CHOOSE_CARDS):
 
 
309
  * - 預設(棄牌,如重整/狂風):移出選定手牌入棄牌堆。
310
- * - keep(血誓契約):選定牌保留在手,只記 chosenCardId 供 onChosen(BUFF_CARD)使用。
311
- * 之後跑 onChosen(可讀 var chosenCount / chosenCardId)→ 打出的牌入堆 → 補手牌。回傳 rng。
312
  */
313
  export function resolveChoice(
314
  player: PlayerState,
315
  indices: number[],
316
- pending: { cardId: number; count: number; onChosen?: EffectOp[]; exhaust?: boolean; keep?: boolean; forcedEnd?: boolean },
317
  rng: RngState,
318
  events: GameEvent[],
319
  mode: "single" | "pvp" = "single",
320
- ): RngState {
321
- const valid = [...new Set(indices)]
322
- .filter((i) => Number.isInteger(i) && i >= 0 && i < player.hand.length)
323
- .slice(0, pending.count);
324
- if (pending.keep) {
325
- // 選而不棄:記第一張選中的卡 id(BUFF_CARD 目標);牌留在手。
326
- player.chosenCardId = valid.length > 0 ? player.hand[valid[0]!]! : null;
327
- player.chosenCount = valid.length;
 
 
 
 
 
 
 
328
  } else {
329
- const removed: number[] = [];
330
- for (const i of [...valid].sort((a, b) => b - a)) removed.push(player.hand.splice(i, 1)[0]!); // 由大到小移除避免位移
331
- player.discard.push(...removed);
332
- healOnCarnage(player, removed.length); // 血腥狂歡:選棄每張回 2 HP
333
- player.chosenCount = removed.length;
 
 
 
 
 
 
 
 
334
  }
335
  let cur = rng;
336
  if (pending.onChosen) {
@@ -340,11 +370,14 @@ export function resolveChoice(
340
  }
341
  player.chosenCount = 0;
342
  player.chosenCardId = null;
 
 
 
343
  if (pending.exhaust) player.burn.push(pending.cardId);
344
  else player.discard.push(pending.cardId);
345
  const cinit = CLASS_INIT[player.classType];
346
  if (cinit.handAlwaysFull) cur = drawCards(player, cur, player.maxHandSize - player.hand.length, events, true); // 手牌恆滿(標記首張補抽)
347
- return cur;
348
  }
349
 
350
  /**
 
3
  * 純函式風格:在傳入的 player draft 上就地修改,回傳推進後的 rng 與事件。
4
  */
5
 
6
+ import type { ClassType, EffectOp, GameEvent, OpponentState, PendingChoice, PlayerState, RngState } from "./types.js";
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";
 
116
  forcedEnd: boolean; // Q2:重擊之後再打一張即強制結束
117
  rng: RngState;
118
  events: GameEvent[];
119
+ /** 互動選牌:本卡需玩家選牌;引擎進 PENDING_CHOICE,選完才把本卡入堆 + 補手牌。詳見 PendingChoice。 */
120
+ pending?: PendingChoice;
121
  }
122
 
123
  /**
 
192
  // 強制結束回合:放手一搏(dec n<=0) 或 野蠻人被動(n>=20 出牌計數過高)。
193
  const forcedEnd = (player.nMode === "dec" && player.n <= 0) || player.n >= 20;
194
  // 互動選棄/選牌:暫停(本卡先不入堆、不補手牌),由引擎進 PENDING_CHOICE、選完才完成。
195
+ if (card.scryChoose) {
196
+ // 野蠻直覺:取牌庫頂 lookCount 張為候選(deck 尾端=頂),玩家選 keepCount 入手、其餘燒毀;thenDiscard 再選棄手牌。
197
+ const look = card.scryChoose.lookCount;
198
+ const scry = player.deck.splice(Math.max(0, player.deck.length - look), look);
199
+ const then: PendingChoice | undefined =
200
+ card.scryChoose.thenDiscard && card.scryChoose.thenDiscard > 0
201
+ ? { cardId, count: card.scryChoose.thenDiscard, exhaust: card.exhaust, forcedEnd }
202
+ : undefined;
203
+ return {
204
+ ok: true, forcedEnd, rng: ctx.rng, events,
205
+ pending: { cardId, count: card.scryChoose.keepCount, scry, exhaust: card.exhaust, keep: false, forcedEnd, then },
206
+ };
207
+ }
208
  if (card.chooseDiscard) {
209
  return {
210
  ok: true, forcedEnd, rng: ctx.rng, events,
 
319
 
320
  /**
321
  * 解析互動選牌(CHOOSE_CARDS):
322
+ * - scry(野蠻直覺):indices 指向 pending.scry 候選清單;選 count 張入手、其餘進消耗堆。
323
+ * - keep(血誓契約):選定手牌保留在手,記 chosenCardId 供 onChosen(BUFF_CARD)。
324
  * - 預設(棄牌,如重整/狂風):移出選定手牌入棄牌堆。
325
+ * 跑 onChosen → 若有 then(多階段,如野蠻直覺留牌後再棄手牌)則回傳後續 pending(本卡尚未入堆);
326
+ * 否則打出的牌入堆 → 補手牌。回傳 { rng, pending? }。
327
  */
328
  export function resolveChoice(
329
  player: PlayerState,
330
  indices: number[],
331
+ pending: PendingChoice,
332
  rng: RngState,
333
  events: GameEvent[],
334
  mode: "single" | "pvp" = "single",
335
+ ): { rng: RngState; pending?: PendingChoice } {
336
+ if (pending.scry) {
337
+ // 探牌:從候選清單選 count 張入手(手牌未滿才入,否則進棄牌堆),其餘進消耗堆。
338
+ const cand = pending.scry;
339
+ const keepIdx = new Set(
340
+ [...new Set(indices)].filter((i) => Number.isInteger(i) && i >= 0 && i < cand.length).slice(0, pending.count),
341
+ );
342
+ cand.forEach((id, i) => {
343
+ if (keepIdx.has(i)) {
344
+ if (player.hand.length < player.maxHandSize) player.hand.push(id);
345
+ else player.discard.push(id);
346
+ } else {
347
+ player.burn.push(id); // 其餘燒毀
348
+ }
349
+ });
350
  } else {
351
+ const valid = [...new Set(indices)]
352
+ .filter((i) => Number.isInteger(i) && i >= 0 && i < player.hand.length)
353
+ .slice(0, pending.count);
354
+ if (pending.keep) {
355
+ player.chosenCardId = valid.length > 0 ? player.hand[valid[0]!]! : null;
356
+ player.chosenCount = valid.length;
357
+ } else {
358
+ const removed: number[] = [];
359
+ for (const i of [...valid].sort((a, b) => b - a)) removed.push(player.hand.splice(i, 1)[0]!); // 由大到小移除避免位移
360
+ player.discard.push(...removed);
361
+ healOnCarnage(player, removed.length); // 血腥狂歡:選棄每張回 2 HP
362
+ player.chosenCount = removed.length;
363
+ }
364
  }
365
  let cur = rng;
366
  if (pending.onChosen) {
 
370
  }
371
  player.chosenCount = 0;
372
  player.chosenCardId = null;
373
+ // 多階段:尚有後續選擇(野蠻直覺:留牌後再選棄 1 張)→ 回傳後續 pending,本卡先不入堆。
374
+ if (pending.then) return { rng: cur, pending: pending.then };
375
+ // 最終階段:打出的牌入堆 → 補手牌。
376
  if (pending.exhaust) player.burn.push(pending.cardId);
377
  else player.discard.push(pending.cardId);
378
  const cinit = CLASS_INIT[player.classType];
379
  if (cinit.handAlwaysFull) cur = drawCards(player, cur, player.maxHandSize - player.hand.length, events, true); // 手牌恆滿(標記首張補抽)
380
+ return { rng: cur, pending: undefined };
381
  }
382
 
383
  /**
packages/battle-core/src/pvpResolve.ts CHANGED
@@ -181,8 +181,10 @@ export function planTurn(
181
  } else if (a.type === "CHOOSE_CARDS") {
182
  if (!pending) continue;
183
  const fe = pending.forcedEnd === true;
184
- cur = resolveChoice(s, a.indices, pending, cur, events, "pvp");
185
- pending = null;
 
 
186
  if (s.specialWin) { stop = true; break; }
187
  if (s.hp <= 0) { stop = true; break; }
188
  if (fe || (s.nMode === "dec" && s.n <= 0)) forced = true;
 
181
  } else if (a.type === "CHOOSE_CARDS") {
182
  if (!pending) continue;
183
  const fe = pending.forcedEnd === true;
184
+ const rc = resolveChoice(s, a.indices, pending, cur, events, "pvp");
185
+ cur = rc.rng;
186
+ pending = rc.pending ?? null; // 多階段(野蠻直覺):仍有後續選擇則 pending 續開
187
+ if (pending) continue; // 等待下一個 CHOOSE_CARDS
188
  if (s.specialWin) { stop = true; break; }
189
  if (s.hp <= 0) { stop = true; break; }
190
  if (fe || (s.nMode === "dec" && s.n <= 0)) forced = true;
packages/battle-core/src/types.ts CHANGED
@@ -174,6 +174,8 @@ export interface CardData {
174
  chooseDiscard?: { count: number };
175
  /** 互動:選中的牌保留在手(不棄);供 BUFF_CARD 讀 chosenCardId(血誓契約)。 */
176
  keepChosen?: boolean;
 
 
177
  /** 互動選牌完成後執行的效果(可讀 var chosenCount = 實際選/棄牌數、chosenCardId)。 */
178
  onChosen?: EffectOp[];
179
  onPlay?: EffectOp[]; // 即時效果(02「即時效果」欄)
@@ -318,6 +320,22 @@ export interface RngState {
318
  cursor: number; // 已消費的亂數個數;可從 seed 重現
319
  }
320
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
321
  export interface GameState {
322
  level: number; // 1..maxLevel(破關後 maxLevel+1 = 鬼影關)
323
  maxLevel: number; // 最後一關關卡數(預設 11;除錯可覆寫)。IsOnFinalLevel = level === maxLevel
@@ -327,7 +345,7 @@ export interface GameState {
327
  rng: RngState;
328
  rewardChoices?: number[]; // 目前的三選一卡 id
329
  /** 互動選牌暫停態(phase=PENDING_CHOICE):待玩家選 count 張手牌棄掉,之後跑 onChosen + 完成出牌。 */
330
- pendingChoice?: { cardId: number; count: number; onChosen?: EffectOp[]; exhaust?: boolean; keep?: boolean; forcedEnd?: boolean };
331
  /** 鬼影模式:整場每回合的 atk/def 紀錄(破關後打包成 GhostRecord)。 */
332
  turnLog: { atk: number; def: number }[];
333
  }
 
174
  chooseDiscard?: { count: number };
175
  /** 互動:選中的牌保留在手(不棄);供 BUFF_CARD 讀 chosenCardId(血誓契約)。 */
176
  keepChosen?: boolean;
177
+ /** 互動探牌(野蠻直覺):看牌庫頂 lookCount 張、玩家選 keepCount 張入手、其餘燒毀;thenDiscard>0 則再選棄該數量手牌。 */
178
+ scryChoose?: { lookCount: number; keepCount: number; thenDiscard?: number };
179
  /** 互動選牌完成後執行的效果(可讀 var chosenCount = 實際選/棄牌數、chosenCardId)。 */
180
  onChosen?: EffectOp[];
181
  onPlay?: EffectOp[]; // 即時效果(02「即時效果」欄)
 
320
  cursor: number; // 已消費的亂數個數;可從 seed 重現
321
  }
322
 
323
+ /**
324
+ * 互動選牌暫停態。預設:從手牌選 count 張棄掉(重整/狂風…)。
325
+ * keep=選而不棄(血誓契約);scry=改從這組牌(牌庫頂探視,非手牌)選 count 張保留入手、其餘進消耗堆(野蠻直覺);
326
+ * then=本階段解析後接續的下一個選擇(野蠻直覺:留牌後再選棄 1 張手牌)。
327
+ */
328
+ export interface PendingChoice {
329
+ cardId: number;
330
+ count: number;
331
+ onChosen?: EffectOp[];
332
+ exhaust?: boolean;
333
+ keep?: boolean;
334
+ forcedEnd?: boolean;
335
+ scry?: number[];
336
+ then?: PendingChoice;
337
+ }
338
+
339
  export interface GameState {
340
  level: number; // 1..maxLevel(破關後 maxLevel+1 = 鬼影關)
341
  maxLevel: number; // 最後一關關卡數(預設 11;除錯可覆寫)。IsOnFinalLevel = level === maxLevel
 
345
  rng: RngState;
346
  rewardChoices?: number[]; // 目前的三選一卡 id
347
  /** 互動選牌暫停態(phase=PENDING_CHOICE):待玩家選 count 張手牌棄掉,之後跑 onChosen + 完成出牌。 */
348
+ pendingChoice?: PendingChoice;
349
  /** 鬼影模式:整場每回合的 atk/def 紀錄(破關後打包成 GhostRecord)。 */
350
  turnLog: { atk: number; def: number }[];
351
  }
packages/battle-core/test/barbarian.test.ts CHANGED
@@ -157,8 +157,7 @@ describe("野蠻人 play 機制(P1:n / 手牌恆滿 / 無 DEF / 無閘門)
157
  expect(r.ok).toBe(true);
158
  expect(r.pending?.count).toBe(1);
159
  expect(p.hand).toEqual([100, 100]); // 重整移出、尚未補(暫停)
160
- const cur = resolveChoice(p, [0], r.pending!, r.rng, []);
161
- void cur;
162
  expect(p.tempMaxHp).toBe(1); // onChosen 臨時上限+1
163
  expect(p.discard).toContain(104); // 重整本卡入棄牌堆
164
  expect(p.hand.length).toBe(5); // 補滿
@@ -351,16 +350,20 @@ describe("野蠻人 P7b:n 鎖定 / n 模式 / 探牌 / 卡牌增益 / 豁免 /
351
  expect(b.player.atk).toBe(5);
352
  });
353
 
354
- it("野蠻直覺:探牌庫頂 3、留傷害最高 1 張入手、其餘燒毀", () => {
355
  const { player: p, rng } = createPlayer("BARBARIAN", makeRng(1), []);
356
- p.hp = 100; p.hand = [168];
357
- // 牌庫頂 = 陣列尾端。頂 3 = [144(0),106(7),109(12)] → 留 109
358
- p.deck = [101, 101, 144, 106, 109];
359
- playCard(p, rng, 0);
360
- expect(p.hand).toContain(109); // 最高傷害入手
 
 
361
  expect(p.burn).toContain(144);
362
  expect(p.burn).toContain(106);
363
- expect(p.burn).not.toContain(109);
 
 
364
  });
365
 
366
  it("血誓契約:失 8 HP + 選中卡本場 +8 傷害", () => {
@@ -369,7 +372,7 @@ describe("野蠻人 P7b:n 鎖定 / n 模式 / 探牌 / 卡牌增益 / 豁免 /
369
  const r = playCard(p, rng, 0); // onPlay ADD_HP-8 → 92,再扣 n=1 → 91;pending keep
370
  expect(r.pending?.keep).toBe(true);
371
  expect(p.hp).toBe(91);
372
- const rng2 = resolveChoice(p, [0], r.pending!, r.rng, []); // 選 index0(106)加成
373
  expect(p.cardBuffs[106]).toBe(8);
374
  playCard(p, rng2, p.hand.indexOf(106)); // 該 106:7 + 8 = 15
375
  expect(p.atk).toBe(15);
 
157
  expect(r.ok).toBe(true);
158
  expect(r.pending?.count).toBe(1);
159
  expect(p.hand).toEqual([100, 100]); // 重整移出、尚未補(暫停)
160
+ resolveChoice(p, [0], r.pending!, r.rng, []);
 
161
  expect(p.tempMaxHp).toBe(1); // onChosen 臨時上限+1
162
  expect(p.discard).toContain(104); // 重整本卡入棄牌堆
163
  expect(p.hand.length).toBe(5); // 補滿
 
350
  expect(b.player.atk).toBe(5);
351
  });
352
 
353
+ it("野蠻直覺:互動探牌庫頂 3、自選留 1 入手、其餘燒毀、再自選棄 1 手牌", () => {
354
  const { player: p, rng } = createPlayer("BARBARIAN", makeRng(1), []);
355
+ p.hp = 100; p.hand = [168, 100, 100]; p.deck = [101, 101, 101, 101, 101, 144, 106, 109]; // 底5張避免補抽洗牌
356
+ const r = playCard(p, rng, 0); // 野蠻直覺 → 階段1 scry pending(候選=牌庫頂3)
357
+ expect(r.pending?.scry).toEqual([144, 106, 109]); // 頂3(陣列尾端)
358
+ expect(r.pending?.count).toBe(1);
359
+ // 階段1:留候選 index2(109),其餘(144/106)燒毀 → 回傳階段2 pending(棄1手牌)
360
+ const rc1 = resolveChoice(p, [2], r.pending!, r.rng, []);
361
+ expect(p.hand).toContain(109);
362
  expect(p.burn).toContain(144);
363
  expect(p.burn).toContain(106);
364
+ expect(rc1.pending?.count).toBe(1); // 階段2:棄 1 張手牌
365
+ resolveChoice(p, [0], rc1.pending!, rc1.rng, []); // 階段2:棄手牌 index0
366
+ expect(p.discard).toContain(168); // 本卡最終入棄牌堆
367
  });
368
 
369
  it("血誓契約:失 8 HP + 選中卡本場 +8 傷害", () => {
 
372
  const r = playCard(p, rng, 0); // onPlay ADD_HP-8 → 92,再扣 n=1 → 91;pending keep
373
  expect(r.pending?.keep).toBe(true);
374
  expect(p.hp).toBe(91);
375
+ const rng2 = resolveChoice(p, [0], r.pending!, r.rng, []).rng; // 選 index0(106)加成
376
  expect(p.cardBuffs[106]).toBe(8);
377
  playCard(p, rng2, p.hand.indexOf(106)); // 該 106:7 + 8 = 15
378
  expect(p.atk).toBe(15);
packages/server/src/pvpMatch.ts CHANGED
@@ -34,7 +34,7 @@ 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 } | null; // 互動選牌(野蠻人 chooseDiscard)待玩家選
38
  deckCount: number; deckView: PileEntry[];
39
  discardCount: number; discardView: PileEntry[];
40
  burnCount: number; burnView: PileEntry[];
@@ -50,7 +50,7 @@ interface MatchPlayer {
50
  playerId: string;
51
  turnStart: PvpSlot; // 本回合起始(immutable 輸入)
52
  actions: Action[]; // 本回合已送出的 PLAY_CARD / CHOOSE_CARDS
53
- current: { state: PlayerState; rng: PvpSlot["rng"]; events: GameEvent[]; forcedEnd: boolean; pending?: { cardId: number; count: number; keep?: boolean } };
54
  locked: boolean;
55
  connected: boolean;
56
  }
@@ -243,7 +243,7 @@ export class PvpMatch {
243
  coin: s.coin, maxCoin: s.maxCoin, combo: s.combo, nextReq: s.nextReq, n: s.n,
244
  useA: s.useA, useB: s.useB, locked: mp.locked, forcedEnd: mp.current.forcedEnd,
245
  hand: [...s.hand],
246
- pending: mp.current.pending ? { count: mp.current.pending.count, keep: mp.current.pending.keep === true } : null,
247
  deckCount: s.deck.length, deckView: viewState(s, "deck"),
248
  discardCount: s.discard.length, discardView: viewState(s, "discard"),
249
  burnCount: s.burn.length, burnView: viewState(s, "burn"),
 
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[];
40
  burnCount: number; burnView: PileEntry[];
 
50
  playerId: string;
51
  turnStart: PvpSlot; // 本回合起始(immutable 輸入)
52
  actions: Action[]; // 本回合已送出的 PLAY_CARD / CHOOSE_CARDS
53
+ current: { state: PlayerState; rng: PvpSlot["rng"]; events: GameEvent[]; forcedEnd: boolean; pending?: { cardId: number; count: number; keep?: boolean; scry?: number[] } };
54
  locked: boolean;
55
  connected: boolean;
56
  }
 
243
  coin: s.coin, maxCoin: s.maxCoin, combo: s.combo, nextReq: s.nextReq, n: s.n,
244
  useA: s.useA, useB: s.useB, locked: mp.locked, forcedEnd: mp.current.forcedEnd,
245
  hand: [...s.hand],
246
+ pending: mp.current.pending ? { count: mp.current.pending.count, keep: mp.current.pending.keep === true, scry: mp.current.pending.scry } : null,
247
  deckCount: s.deck.length, deckView: viewState(s, "deck"),
248
  discardCount: s.discard.length, discardView: viewState(s, "discard"),
249
  burnCount: s.burn.length, burnView: viewState(s, "burn"),
packages/web/src/App.tsx CHANGED
@@ -144,9 +144,10 @@ function Battle({
144
  const p = game.player;
145
  const m = game.opponent;
146
  const [openPile, setOpenPile] = useState<PileName | null>(null);
147
- const [chosen, setChosen] = useState<number[]>([]); // 互動選牌:已選手牌索引
148
  const choosing = game.phase === "PENDING_CHOICE";
149
- const chooseCount = game.pendingChoice ? Math.min(game.pendingChoice.count, p.hand.length) : 0;
 
150
  const toggleChosen = (i: number) =>
151
  setChosen((c) => {
152
  if (c.includes(i)) return c.filter((x) => x !== i); // 再按同一張 → 取消選取
@@ -210,8 +211,9 @@ function Battle({
210
  key={`${id}-${i}`}
211
  id={id}
212
  locked={!choosing && isTagLocked(getCard(id).tag, p.useA, p.useB)}
213
- selected={choosing && chosen.includes(i)}
214
- onClick={() => (choosing ? toggleChosen(i) : dispatch({ type: "PLAY_CARD", handIndex: i }))}
 
215
  />
216
  ))}
217
  </div>
@@ -224,8 +226,21 @@ function Battle({
224
  </button>
225
  )}
226
 
 
 
 
 
 
 
 
 
 
 
 
 
 
227
  {/* 互動選牌提示列(不蓋手牌);keep=選而不棄(血誓契約強化) */}
228
- {choosing && game.pendingChoice && (
229
  <div className="choice-bar">
230
  {game.pendingChoice.keep ? (
231
  <>
 
144
  const p = game.player;
145
  const m = game.opponent;
146
  const [openPile, setOpenPile] = useState<PileName | null>(null);
147
+ const [chosen, setChosen] = useState<number[]>([]); // 互動選牌:已選索引(手牌或探牌候選)
148
  const choosing = game.phase === "PENDING_CHOICE";
149
+ const scry = choosing ? (game.pendingChoice?.scry ?? null) : null; // 野蠻直覺:探牌候選(改選候選而非手牌)
150
+ const chooseCount = game.pendingChoice ? Math.min(game.pendingChoice.count, scry ? scry.length : p.hand.length) : 0;
151
  const toggleChosen = (i: number) =>
152
  setChosen((c) => {
153
  if (c.includes(i)) return c.filter((x) => x !== i); // 再按同一張 → 取消選取
 
211
  key={`${id}-${i}`}
212
  id={id}
213
  locked={!choosing && isTagLocked(getCard(id).tag, p.useA, p.useB)}
214
+ selected={choosing && !scry && chosen.includes(i)}
215
+ disabled={!!scry} /* 探牌階段:手牌不可選(改選候選牌) */
216
+ onClick={() => (scry ? undefined : choosing ? toggleChosen(i) : dispatch({ type: "PLAY_CARD", handIndex: i }))}
217
  />
218
  ))}
219
  </div>
 
226
  </button>
227
  )}
228
 
229
+ {/* 野蠻直覺:探牌候選面板(選 keepCount 張入手,其餘燒毀) */}
230
+ {choosing && scry && (
231
+ <Overlay className="reward">
232
+ <h2>野蠻直覺 · 選 {chooseCount} 張加入手牌(其餘燒毀)</h2>
233
+ <div className="hand">
234
+ {scry.map((id, i) => (
235
+ <CardView key={`scry-${id}-${i}`} id={id} big selected={chosen.includes(i)} onClick={() => toggleChosen(i)} />
236
+ ))}
237
+ </div>
238
+ <button className="btn primary" disabled={chosen.length !== chooseCount} onClick={confirmChoice}>確認(已選 {chosen.length}/{chooseCount})</button>
239
+ </Overlay>
240
+ )}
241
+
242
  {/* 互動選牌提示列(不蓋手牌);keep=選而不棄(血誓契約強化) */}
243
+ {choosing && !scry && game.pendingChoice && (
244
  <div className="choice-bar">
245
  {game.pendingChoice.keep ? (
246
  <>
packages/web/src/PvpScreen.tsx CHANGED
@@ -191,9 +191,10 @@ function PvpBattle({ pvp }: { pvp: ReturnType<typeof usePvp> }) {
191
  const youEffMax = you.maxHp + you.tempMaxHp;
192
  const oppEffMax = v.opponent.maxHp + v.opponent.tempMaxHp;
193
 
194
- // 互動選牌(野蠻人 chooseDiscard / 血誓契約):pending 開啟時手牌改為「選取」而非出牌。
195
  const pending = you.pending;
196
- const chooseCount = pending ? Math.min(pending.count, you.hand.length) : 0;
 
197
  const [chosen, setChosen] = useState<number[]>([]);
198
  useEffect(() => { if (!pending) setChosen([]); }, [pending, v.turnNo]);
199
  const toggleChosen = (i: number) =>
@@ -244,8 +245,21 @@ function PvpBattle({ pvp }: { pvp: ReturnType<typeof usePvp> }) {
244
  {!isBarb && <span className="stat def">🛡 {you.def}</span>}
245
  </div>
246
 
247
- {/* 互動選牌提示列 */}
248
- {pending && (
 
 
 
 
 
 
 
 
 
 
 
 
 
249
  <div className="choice-bar">
250
  {pending.keep ? (
251
  <>
@@ -266,10 +280,10 @@ function PvpBattle({ pvp }: { pvp: ReturnType<typeof usePvp> }) {
266
  <div className="hand">
267
  {you.hand.map((id, i) => {
268
  const tagLocked = isTagLocked(getCard(id).tag, you.useA, you.useB);
269
- if (pending) {
270
  return <CardView key={`${id}-${i}`} id={id} selected={chosen.includes(i)} onClick={() => toggleChosen(i)} />;
271
  }
272
- return <CardView key={`${id}-${i}`} id={id} locked={tagLocked} disabled={locked || tagLocked} onClick={() => pvp.play(i)} />;
273
  })}
274
  </div>
275
  </div>
 
191
  const youEffMax = you.maxHp + you.tempMaxHp;
192
  const oppEffMax = v.opponent.maxHp + v.opponent.tempMaxHp;
193
 
194
+ // 互動選牌(野蠻人 chooseDiscard / 血誓契約 / 野蠻直覺探牌):pending 開啟時改為「選取」。
195
  const pending = you.pending;
196
+ const scry = pending?.scry ?? null; // 野蠻直覺:探牌候選(選候選而非手牌)
197
+ const chooseCount = pending ? Math.min(pending.count, scry ? scry.length : you.hand.length) : 0;
198
  const [chosen, setChosen] = useState<number[]>([]);
199
  useEffect(() => { if (!pending) setChosen([]); }, [pending, v.turnNo]);
200
  const toggleChosen = (i: number) =>
 
245
  {!isBarb && <span className="stat def">🛡 {you.def}</span>}
246
  </div>
247
 
248
+ {/* 野蠻直覺:探牌候選面板(選 keepCount 入手、其餘燒毀) */}
249
+ {scry && (
250
+ <div className="choice-bar choice-scry">
251
+ <span>野蠻直覺 · 選 {chooseCount} 張加入手牌(其餘燒毀)(已選 {chosen.length}/{chooseCount})</span>
252
+ <div className="hand">
253
+ {scry.map((id, i) => (
254
+ <CardView key={`scry-${id}-${i}`} id={id} selected={chosen.includes(i)} onClick={() => toggleChosen(i)} />
255
+ ))}
256
+ </div>
257
+ <button className="btn primary" disabled={chosen.length !== chooseCount} onClick={confirmChoice}>確認</button>
258
+ </div>
259
+ )}
260
+
261
+ {/* 互動選牌提示列(手牌選棄/強化) */}
262
+ {pending && !scry && (
263
  <div className="choice-bar">
264
  {pending.keep ? (
265
  <>
 
280
  <div className="hand">
281
  {you.hand.map((id, i) => {
282
  const tagLocked = isTagLocked(getCard(id).tag, you.useA, you.useB);
283
+ if (pending && !scry) {
284
  return <CardView key={`${id}-${i}`} id={id} selected={chosen.includes(i)} onClick={() => toggleChosen(i)} />;
285
  }
286
+ return <CardView key={`${id}-${i}`} id={id} locked={tagLocked} disabled={locked || !!pending || tagLocked} onClick={() => pvp.play(i)} />;
287
  })}
288
  </div>
289
  </div>
packages/web/src/pvpClient.ts CHANGED
@@ -12,7 +12,7 @@ export interface PvpView {
12
  coin: number; maxCoin: number; combo: number; nextReq: Tag; n: number;
13
  useA: boolean; useB: boolean; locked: boolean; forcedEnd: boolean;
14
  hand: number[];
15
- pending: { count: number; keep: boolean } | null;
16
  deckCount: number; deckView: PileEntry[];
17
  discardCount: number; discardView: PileEntry[];
18
  burnCount: number; burnView: PileEntry[];
 
12
  coin: number; maxCoin: number; combo: number; nextReq: Tag; n: number;
13
  useA: boolean; useB: boolean; locked: boolean; forcedEnd: boolean;
14
  hand: number[];
15
+ pending: { count: number; keep: boolean; scry?: number[] } | null;
16
  deckCount: number; deckView: PileEntry[];
17
  discardCount: number; discardView: PileEntry[];
18
  burnCount: number; burnView: PileEntry[];