build: include samples in prepare script

refactor: use effect for assignSelector in BaseGameClient
Replace subscribe with effect in assignSelector to ensure the selector value is tracked and the callback is executed within the reactive context.
2026-04-28 16:52:03 +08:00 · 2026-04-28 15:50:00 +08:00 · 2026-04-28 15:29:08 +08:00 · 2026-04-25 17:58:16 +08:00 · 2026-04-25 17:54:21 +08:00 · 2026-04-25 17:31:15 +08:00
45 changed files with 2495 additions and 2062 deletions
@@ -18,7 +18,7 @@
  "scripts": {
    "build": "tsup",
    "build:samples": "tsup --config tsup.samples.config.ts",
-    "prepare": "npm run build",
+    "prepare": "npm run build && npm run build:samples",
    "test": "vitest",
    "test:run": "vitest run",
    "typecheck": "tsc --noEmit"
@@ -0,0 +1,118 @@
+import { createPromptContext, PromptDef } from "@/utils/command";
+import { computed, effect, signal } from "@preact/signals-core";
+import { createGameContext, IGameContext } from "./game";
+
+export enum ClientStatus {
+  Idle = "idle",
+  Running = "running",
+  Disposed = "disposed",
+}
+
+export type PromptInfo =
+  | {
+      hasPrompt: false;
+      player: string;
+    }
+  | {
+      hasPrompt: true;
+      player: string;
+      def: PromptDef<unknown[]>;
+      tryAnswer(...args: unknown[]): string | null;
+    };
+
+/**
+ * 1. create a client instance
+ * 2. setStatus("running")
+ * 3. select("selector", t => {}) for c# to capture game state
+ * 4. useClient("status" | "prompt") for c# to handle prompt / game status
+ */
+export abstract class BaseGameClient<
+  T extends Record<string, unknown> = Record<string, unknown>,
+  R = unknown,
+> {
+  protected _initialState: T;
+  protected _context: IGameContext<T>;
+  protected _prompts = createPromptContext();
+  protected _status = signal(ClientStatus.Idle);
+  protected _result = signal(null as null | R);
+  public get state() {
+    return this._context.value;
+  }
+  constructor(is: T) {
+    this._initialState = is;
+    this._context = createGameContext(this._prompts, is);
+  }
+
+  async setStatus(status: ClientStatus) {
+    this._status.value = status;
+    if (status === ClientStatus.Disposed) {
+      this._prompts.reset();
+    } else if (status === ClientStatus.Running) {
+      this._prompts.reset();
+      this._context._state.value = this._initialState;
+      this._result.value = null;
+      this._result.value = await this.start(this._context);
+      this.setStatus(ClientStatus.Idle);
+    }
+  }
+
+  abstract start(ctx: IGameContext<T>): Promise<R>;
+
+  assignSelector<S>(selector: (t: T) => S, callback: (s: S) => void) {
+    const selected = computed(() => selector(this._context.value));
+    return effect(() => {
+      callback(selected.value);
+    });
+  }
+
+  addInterruption() {
+    let resolve!: () => void;
+    const promise = new Promise<void>((resolver) => {
+      resolve = resolver;
+    });
+    this._context._state.addInterruption(promise);
+    return resolve;
+  }
+
+  selectPrompt(callback: (prompt: PromptInfo) => void) {
+    return this._prompts.handleCall.use(async (ctx, next) => {
+      function tryAnswer(...args: any[]) {
+        try {
+          const res = ctx.validator(...args);
+          ctx.resolve(res);
+          return null;
+        } catch (reason) {
+          if (typeof reason === "string") {
+            return reason;
+          }
+          throw reason;
+        }
+      }
+
+      try {
+        callback({
+          hasPrompt: true,
+          player: ctx.player || "global",
+          def: ctx.def,
+          tryAnswer,
+        });
+        return await next();
+      } finally {
+        callback({
+          hasPrompt: false,
+          player: ctx.player || "global",
+        });
+      }
+    });
+  }
+  selectStatus(callback: (status: ClientStatus) => void) {
+    return effect(() => {
+      callback(this._status.value);
+    });
+  }
+  selectResult(callback: (status: R | null) => void) {
+    return effect(() => {
+      callback(this._result.value);
+    });
+  }
+}
@@ -1,99 +1,39 @@
+import { createPromptContext } from "@/utils/command";
+import { PromptContext } from "@/utils/command/command-prompt";
 import { ReadonlySignal, Signal } from "@preact/signals-core";
-import { CommandSchema, CommandRegistry, PromptEvent } from "@/utils/command";
-import {
-  createGameCommandRegistry,
-  createGameContext,
-  IGameContext,
-  PromptDef,
-} from "./game";
+import { createGameContext, IGameContext } from "./game";

 export type GameHostStatus = "created" | "running" | "disposed";

 export class GameHost<
  TState extends Record<string, unknown>,
  TResult = unknown,
+  TModule extends GameModule<TState, TResult> = GameModule<TState, TResult>,
 > {
  readonly state: ReadonlySignal<TState>;
  readonly status: ReadonlySignal<GameHostStatus>;
-  readonly activePromptSchema: ReadonlySignal<CommandSchema | null>;
-  readonly activePromptPlayer: ReadonlySignal<string | null>;
-  readonly activePromptHint: ReadonlySignal<string | null>;
+  readonly prompts: PromptContext;

  private _context: IGameContext<TState>;
  private _start: (ctx: IGameContext<TState>) => Promise<TResult>;
  private _status: Signal<GameHostStatus>;
-  private _activePromptSchema: Signal<CommandSchema | null>;
-  private _activePromptPlayer: Signal<string | null>;
-  private _activePromptHint: Signal<string | null>;
  private _createInitialState: () => TState;
  private _eventListeners: Map<"start" | "dispose", Set<() => void>>;
  private _isDisposed = false;

-  constructor(
-    registry: CommandRegistry<IGameContext<TState>>,
-    createInitialState: () => TState,
-    start: (ctx: IGameContext<TState>) => Promise<TResult>,
-  ) {
+  constructor(public readonly gameModule: TModule) {
+    const { createInitialState, start } = gameModule;
    this._createInitialState = createInitialState;
    this._eventListeners = new Map();

+    this.prompts = createPromptContext();
    const initialState = createInitialState();
-    this._context = createGameContext(registry, initialState);
+    this._context = createGameContext(this.prompts, initialState);
    this._start = start;
    this.state = this._context._state;

    this._status = new Signal<GameHostStatus>("created");
    this.status = this._status;
-
-    this._activePromptSchema = new Signal<CommandSchema | null>(null);
-    this.activePromptSchema = this._activePromptSchema;
-
-    this._activePromptPlayer = new Signal<string | null>(null);
-    this.activePromptPlayer = this._activePromptPlayer;
-
-    this._activePromptHint = new Signal<string | null>(null);
-    this.activePromptHint = this._activePromptHint;
-
-    this._setupPromptTracking();
-  }
-
-  private _setupPromptTracking() {
-    let currentPromptEvent: PromptEvent | null = null;
-
-    this._context._commands.on("prompt", (e) => {
-      currentPromptEvent = e as PromptEvent;
-      this._activePromptSchema.value = currentPromptEvent.schema;
-      this._activePromptPlayer.value = currentPromptEvent.currentPlayer;
-      this._activePromptHint.value = currentPromptEvent.hintText || null;
-    });
-
-    this._context._commands.on("promptEnd", () => {
-      currentPromptEvent = null;
-      this._activePromptSchema.value = null;
-      this._activePromptPlayer.value = null;
-      this._activePromptHint.value = null;
-    });
-
-    // Initial state
-    this._activePromptSchema.value = null;
-    this._activePromptPlayer.value = null;
-    this._activePromptHint.value = null;
-  }
-
-  tryInput(input: string): string | null {
-    if (this._isDisposed) {
-      return "GameHost is disposed";
-    }
-    return this._context._commands._tryCommit(input);
-  }
-
-  tryAnswerPrompt<TArgs extends any[]>(def: PromptDef<TArgs>, ...args: TArgs) {
-    return this._context._commands._tryCommit({
-      name: def.schema.name,
-      params: args,
-      options: {},
-      flags: {},
-    });
  }

  /**
@@ -117,7 +57,7 @@ export class GameHost<
      throw new Error("GameHost is disposed");
    }

-    this._context._commands._cancel();
+    this.prompts.reset();

    const initialState = this._createInitialState();
    this._context._state.value = initialState as any;
@@ -138,7 +78,7 @@ export class GameHost<
    }

    this._isDisposed = true;
-    this._context._commands._cancel();
+    this.prompts.reset();
    this._status.value = "disposed";

    // Emit dispose event BEFORE clearing listeners
@@ -168,21 +108,17 @@ export class GameHost<
 }

 export type GameModule<
-  TState extends Record<string, unknown>,
+  TState extends Record<string, unknown> = Record<string, unknown>,
  TResult = unknown,
 > = {
-  registry?: CommandRegistry<IGameContext<TState>>;
  createInitialState: () => TState;
  start: (ctx: IGameContext<TState>) => Promise<TResult>;
 };

 export function createGameHost<
-  TState extends Record<string, unknown>,
+  TState extends Record<string, unknown> = Record<string, unknown>,
  TResult = unknown,
->(gameModule: GameModule<TState, TResult>): GameHost<TState, TResult> {
-  return new GameHost(
-    gameModule.registry || createGameCommandRegistry(),
-    gameModule.createInitialState,
-    gameModule.start,
-  );
+  TModule extends GameModule<TState, TResult> = GameModule<TState, TResult>,
+>(gameModule: TModule): GameHost<TState, TResult, TModule> {
+  return new GameHost(gameModule);
 }
@@ -1,40 +1,29 @@
 import { MutableSignal, mutableSignal } from "@/utils/mutable-signal";
-import {
-  Command,
-  CommandRegistry,
-  CommandResult,
-  CommandRunnerContextExport,
-  CommandSchema,
-  createCommandRegistry,
-  createCommandRunnerContext,
-  parseCommandSchema,
-} from "@/utils/command";
+import { CommandSchema, parseCommandSchema, PromptDef } from "@/utils/command";
 import { PromptValidator } from "@/utils/command/command-runner";
 import { Mulberry32RNG, ReadonlyRNG, RNG } from "@/utils/rng";
+import { PromptContext } from "@/utils/command/command-prompt";

 export interface IGameContext<TState extends Record<string, unknown> = {}> {
  get value(): TState;
  get rng(): ReadonlyRNG;
  produce(fn: (draft: TState) => undefined): void;
  produceAsync(fn: (draft: TState) => undefined): Promise<void>;
-  run<T>(input: string): Promise<CommandResult<T>>;
-  runParsed<T>(command: Command): Promise<CommandResult<T>>;
  prompt: <TResult, TArgs extends any[] = any[]>(
    def: PromptDef<TArgs>,
    validator: PromptValidator<TResult, TArgs>,
-    currentPlayer?: string | null,
+    player?: string,
  ) => Promise<TResult>;

  // test only
  _state: MutableSignal<TState>;
-  _commands: CommandRunnerContextExport<IGameContext<TState>>;
  _rng: RNG;
 }
 export type IGameContextExport<TState extends Record<string, unknown> = {}> =
  Omit<IGameContext<TState>, "_state" | "_commands" | "_rng">;

 export function createGameContext<TState extends Record<string, unknown> = {}>(
-  commandRegistry: CommandRegistry<IGameContext<TState>>,
+  promptContext: PromptContext,
  initialState?: TState | (() => TState),
 ): IGameContext<TState> {
  const stateValue =
@@ -42,7 +31,7 @@ export function createGameContext<TState extends Record<string, unknown> = {}>(
      ? initialState()
      : (initialState ?? ({} as TState));
  const state = mutableSignal(stateValue);
-  let commands: CommandRunnerContextExport<IGameContext<TState>> = null as any;
+  const { prompt } = promptContext;

  const context: IGameContext<TState> = {
    get value(): TState {
@@ -57,38 +46,15 @@ export function createGameContext<TState extends Record<string, unknown> = {}>(
    produceAsync(fn: (draft: TState) => undefined) {
      return state.produceAsync(fn);
    },
-    run<T>(input: string) {
-      return commands.run<T>(input);
-    },
-    runParsed<T>(command: Command) {
-      return commands.runParsed<T>(command);
-    },
-    prompt(def, validator, currentPlayer) {
-      return commands.prompt(
-        def.schema,
-        validator,
-        def.hintText,
-        currentPlayer,
-      );
-    },
+    prompt,

    _state: state,
-    _commands: commands,
    _rng: new Mulberry32RNG(),
  };

-  context._commands = commands = createCommandRunnerContext(
-    commandRegistry,
-    context,
-  );
-
  return context;
 }

-export type PromptDef<TArgs extends any[] = any[]> = {
-  schema: CommandSchema;
-  hintText?: string;
-};
 export function createPromptDef<TArgs extends any[] = any[]>(
  schema: CommandSchema | string,
  hintText?: string,
@@ -96,9 +62,3 @@ export function createPromptDef<TArgs extends any[] = any[]>(
  schema = typeof schema === "string" ? parseCommandSchema(schema) : schema;
  return { schema, hintText };
 }
-
-export function createGameCommandRegistry<
-  TState extends Record<string, unknown> = {},
->() {
-  return createCommandRegistry<IGameContext<TState>>();
-}
@@ -5,7 +5,7 @@

 // Core types
 export type { IGameContext } from "./core/game";
-export { createGameCommandRegistry, createPromptDef } from "./core/game";
+export { createPromptDef } from "./core/game";

 export type { GameHost, GameHostStatus, GameModule } from "./core/game-host";
 export { createGameHost } from "./core/game-host";
@@ -24,6 +24,8 @@ export {
  moveToRegion,
 } from "./core/region";

+export * from "./core/game-client";
+
 // Utils
 export type {
  Command,
@@ -71,4 +73,6 @@ export { createRNG, Mulberry32RNG } from "./utils/rng";
 export type { MiddlewareChain } from "./utils/middleware";
 export { createMiddlewareChain } from "./utils/middleware";

+export * from "./utils/spawner";
+
 export * from "@preact/signals-core";
@@ -1,75 +1,11 @@
-import {BoopGame} from "@/samples/boop/types-extensions";
-import {PlayerType} from "@/samples/boop/types";
-import {turn} from "@/samples/boop/commands/turn";
-import {createGameCommandRegistry} from "@/core/game";
-
-export const registry = createGameCommandRegistry<BoopGame['value']>();
-
-/**
- * 放置棋子到棋盘
- */
-const placeCmd = registry.register({
-    schema: 'place <row:number> <col:number> <player> <type>',
-    run: async (game, row, col, player, type) => {
-        const {place} = await import('./place');
-        return place(game, row, col, player, type);
-    }
-});
-
-/**
- * 执行boop - 推动周围棋子
- */
-const boopCmd = registry.register({
-    schema: 'boop <row:number> <col:number> <type>',
-    run: async (game, row, col, type) => {
-        const {boop} = await import('./boop');
-        return boop(game, row, col, type);
-    }
-});
-
-/**
- * 检查是否有玩家获胜(三个猫连线)
- */
-const checkWinCmd = registry.register({
-    schema: 'check-win',
-    run: async (game) => {
-        const {checkWin} = await import('./win');
-        return checkWin(game);
-    }
-});
-
-/**
- * 检查并执行小猫升级(三个小猫连线变成猫)
- */
-const checkGraduatesCmd = registry.register({
-    schema: 'check-graduates',
-    run: async (game) => {
-        const {checkGraduates} = await import('./graduate');
-        return checkGraduates(game);
-    }
-});
-
-/**
- * 检查并执行 8-piece 规则
- */
-const checkFullBoardCmd = registry.register({
-    schema: 'check-full-board <player:string>',
-    run: async (game, player) => {
-        const {checkFullBoard} = await import('./full-board');
-        return checkFullBoard(game, player);
-    }
-});
-
-/**
- * 处理一个回合
- */
-const turnCmd = registry.register({
-    schema: 'turn <player:string>',
-    run: async (game, player) => {
-        const {turn} = await import('./turn');
-        return turn(game, player);
-    }
-});
+import { BoopGame } from "@/samples/boop/types-extensions";
+import { PlayerType } from "@/samples/boop/types";
+import { turn } from "@/samples/boop/commands/turn";
+import { boop } from "./boop";
+import { checkFullBoard } from "./full-board";
+import { checkGraduates } from "./graduate";
+import { place } from "./place";
+import { checkWin } from "./win";

 /**
 * 启动游戏主循环
@@ -79,10 +15,11 @@ export async function start(game: BoopGame) {
    const currentPlayer = game.value.currentPlayer;
    const turnOutput = await turn(game, currentPlayer);

-        await game.produceAsync(state => {
+    await game.produceAsync((state) => {
      state.winner = turnOutput.winner;
      if (!state.winner) {
-                state.currentPlayer = state.currentPlayer === 'white' ? 'black' : 'white';
+        state.currentPlayer =
+          state.currentPlayer === "white" ? "black" : "white";
      }
    });
    if (game.value.winner) break;
@@ -91,11 +28,4 @@ export async function start(game: BoopGame) {
  return game.value;
 }

-export {
-    placeCmd as place,
-    boopCmd as boop,
-    checkWinCmd as checkWin,
-    checkGraduatesCmd as checkGraduates,
-    checkFullBoardCmd as checkFullBoard,
-    turnCmd as turn
-};
+export { place, boop, checkWin, checkGraduates, checkFullBoard, turn };
@@ -5,38 +5,30 @@ export type {
  WinnerType,
  RegionType,
  BoopPartMeta,
-    BoopPart
-} from './types';
+  BoopPart,
+} from "./types";

-export type {BoopGame} from './types-extensions';
+export type { BoopGame } from "./types-extensions";

 // Constants
-export {
-    BOARD_SIZE,
-    MAX_PIECES_PER_PLAYER,
-    WIN_LENGTH
-} from './constants';
+export { BOARD_SIZE, MAX_PIECES_PER_PLAYER, WIN_LENGTH } from "./constants";

 // State
-export {
-    createInitialState,
-    type BoopState
-} from './state';
+export { createInitialState, type BoopState } from "./state";

 // Prompts
-export {prompts} from './prompts';
+export { prompts } from "./prompts";

 // Commands
 export {
-    registry,
  start,
  place as placeCmd,
  boop as boopCmd,
  checkWin as checkWinCmd,
  checkGraduates as checkGraduatesCmd,
  checkFullBoard as checkFullBoardCmd,
-    turn as turnCmd
-} from './commands';
+  turn as turnCmd,
+} from "./commands";

 // Utils
 export {
@@ -45,5 +37,5 @@ export {
  isCellOccupied,
  getNeighborPositions,
  findPartInRegion,
-    findPartAtPosition
-} from './utils';
+  findPartAtPosition,
+} from "./utils";
@@ -3,12 +3,9 @@ import {
  OnitamaState,
  PlayerType,
  prompts,
-    initializeCards
+  initializeCards,
 } from "./types";
-import {createGameCommandRegistry} from "@/core/game";
-import {moveToRegion} from "@/core/region";
-
-export const registry = createGameCommandRegistry<OnitamaState>();
+import { moveToRegion } from "@/core/region";

 /**
 * 检查位置是否在棋盘范围内
@@ -29,8 +26,12 @@ function getPawnAtPosition(state: OnitamaState, x: number, y: number) {
 /**
 * 检查玩家是否拥有某张卡牌
 */
-function playerHasCard(state: OnitamaState, player: PlayerType, cardName: string): boolean {
-    const cardList = player === 'red' ? state.redCards : state.blackCards;
+function playerHasCard(
+  state: OnitamaState,
+  player: PlayerType,
+  cardName: string,
+): boolean {
+  const cardList = player === "red" ? state.redCards : state.blackCards;
  return cardList.includes(cardName);
 }

@@ -38,13 +39,17 @@ function playerHasCard(state: OnitamaState, player: PlayerType, cardName: string
 * 获取卡牌的移动候选项，根据玩家视角进行旋转
 * 黑方需要将卡牌旋转180度
 */
-export function getCardMoveCandidates(state: OnitamaState, cardName: string, player: PlayerType) {
+export function getCardMoveCandidates(
+  state: OnitamaState,
+  cardName: string,
+  player: PlayerType,
+) {
  const card = state.cards[cardName];
  const candidates = card.moveCandidates;

  // 黑方需要将卡牌旋转180度
-    if (player === 'black') {
-        return candidates.map(m => ({ dx: -m.dx, dy: -m.dy }));
+  if (player === "black") {
+    return candidates.map((m) => ({ dx: -m.dx, dy: -m.dy }));
  }

  return candidates;
@@ -53,7 +58,15 @@ export function getCardMoveCandidates(state: OnitamaState, cardName: string, pla
 /**
 * 检查移动是否合法
 */
-export function isValidMove(state: OnitamaState, cardName: string, fromX: number, fromY: number, toX: number, toY: number, player: PlayerType): string | null {
+export function isValidMove(
+  state: OnitamaState,
+  cardName: string,
+  fromX: number,
+  fromY: number,
+  toX: number,
+  toY: number,
+  player: PlayerType,
+): string | null {
  // 检查玩家是否拥有该卡牌
  if (!playerHasCard(state, player, cardName)) {
    return `玩家 ${player} 不拥有卡牌 ${cardName}`;
@@ -80,7 +93,7 @@ export function isValidMove(state: OnitamaState, cardName: string, fromX: number

  // 检查移动是否在卡牌的移动候选项中（黑方需要旋转180度）
  const candidates = getCardMoveCandidates(state, cardName, player);
-    const isValid = candidates.some(m => m.dx === dx && m.dy === dy);
+  const isValid = candidates.some((m) => m.dx === dx && m.dy === dy);
  if (!isValid) {
    return `卡牌 ${cardName} 不支持移动 (${dx}, ${dy})`;
  }
@@ -102,7 +115,15 @@ export function isValidMove(state: OnitamaState, cardName: string, fromX: number
 /**
 * 执行移动
 */
-async function handleMove(game: OnitamaGame, player: PlayerType, cardName: string, fromX: number, fromY: number, toX: number, toY: number) {
+async function move(
+  game: OnitamaGame,
+  player: PlayerType,
+  cardName: string,
+  fromX: number,
+  fromY: number,
+  toX: number,
+  toY: number,
+) {
  const state = game.value;

  // 验证移动
@@ -113,7 +134,7 @@ async function handleMove(game: OnitamaGame, player: PlayerType, cardName: strin

  const capturedPawnId = getPawnAtPosition(state, toX, toY)?.id || null;

-    await game.produceAsync(state => {
+  await game.produceAsync((state) => {
    const pawn = state.pawns[getPawnAtPosition(state, fromX, fromY)!.id];

    // 如果目标位置有敌方棋子，将其移除（吃掉）
@@ -127,41 +148,40 @@ async function handleMove(game: OnitamaGame, player: PlayerType, cardName: strin
  });

  // 交换卡牌
-    await handleSwapCard(game, player, cardName);
+  await swapCard(game, player, cardName);

  return {
    from: { x: fromX, y: fromY },
    to: { x: toX, y: toY },
    card: cardName,
-        captured: capturedPawnId 
+    captured: capturedPawnId,
  };
 }

-const move = registry.register({
-    schema: 'move <player> <card:string> <fromX:number> <fromY:number> <toX:number> <toY:number>',
-    run: handleMove
-});
-
 /**
 * 交换卡牌：将使用的卡牌与备用卡牌交换
 */
-async function handleSwapCard(game: OnitamaGame, player: PlayerType, usedCard: string) {
-    await game.produceAsync(state => {
+async function swapCard(
+  game: OnitamaGame,
+  player: PlayerType,
+  usedCard: string,
+) {
+  await game.produceAsync((state) => {
    const spareCard = state.spareCard;
    const usedCardData = state.cards[usedCard];
    const spareCardData = state.cards[spareCard];

    // 从玩家手牌中移除使用的卡牌
-        if (player === 'red') {
-            state.redCards = state.redCards.filter(c => c !== usedCard);
+    if (player === "red") {
+      state.redCards = state.redCards.filter((c) => c !== usedCard);
      state.redCards.push(spareCard);
    } else {
-            state.blackCards = state.blackCards.filter(c => c !== usedCard);
+      state.blackCards = state.blackCards.filter((c) => c !== usedCard);
      state.blackCards.push(spareCard);
    }

    // 更新卡牌区域
-        usedCardData.regionId = 'spare';
+    usedCardData.regionId = "spare";
    spareCardData.regionId = player;

    // 更新备用卡牌
@@ -169,75 +189,70 @@ async function handleSwapCard(game: OnitamaGame, player: PlayerType, usedCard: s
  });
 }

-const swapCard = registry.register({
-    schema: 'swap-card <player> <card:string>',
-    run: handleSwapCard
-});
-
 /**
 * 检查占领胜利条件：玩家的师父棋子到达对手的初始位置
 * 红色师父需要到达 (2, 4) - 黑色师父的初始位置
 * 黑色师父需要到达 (2, 0) - 红色师父的初始位置
 */
-async function handleCheckConquestWin(game: OnitamaGame): Promise<PlayerType | null> {
+async function checkConquestWin(game: OnitamaGame): Promise<PlayerType | null> {
  const state = game.value;

  // 红色师父到达 (2, 4)（黑色师父的初始位置）
-    const redMaster = state.pawns['red-master'];
-    if (redMaster && redMaster.regionId === 'board' && redMaster.position[0] === 2 && redMaster.position[1] === 4) {
-        return 'red';
+  const redMaster = state.pawns["red-master"];
+  if (
+    redMaster &&
+    redMaster.regionId === "board" &&
+    redMaster.position[0] === 2 &&
+    redMaster.position[1] === 4
+  ) {
+    return "red";
  }

  // 黑色师父到达 (2, 0)（红色师父的初始位置）
-    const blackMaster = state.pawns['black-master'];
-    if (blackMaster && blackMaster.regionId === 'board' && blackMaster.position[0] === 2 && blackMaster.position[1] === 0) {
-        return 'black';
+  const blackMaster = state.pawns["black-master"];
+  if (
+    blackMaster &&
+    blackMaster.regionId === "board" &&
+    blackMaster.position[0] === 2 &&
+    blackMaster.position[1] === 0
+  ) {
+    return "black";
  }

  return null;
 }

-const checkConquestWin = registry.register({
-    schema: 'check-conquest-win',
-    run: handleCheckConquestWin
-});
-
 /**
 * 检查吃掉胜利条件：对手的师父棋子被吃掉（不在棋盘上）
 */
-async function handleCheckCaptureWin(game: OnitamaGame): Promise<PlayerType | null> {
+async function checkCaptureWin(game: OnitamaGame): Promise<PlayerType | null> {
  const state = game.value;

  // 红色师父不在棋盘上，黑色获胜
-    const redMaster = state.pawns['red-master'];
-    if (!redMaster || redMaster.regionId !== 'board') {
-        return 'black';
+  const redMaster = state.pawns["red-master"];
+  if (!redMaster || redMaster.regionId !== "board") {
+    return "black";
  }

  // 黑色师父不在棋盘上，红色获胜
-    const blackMaster = state.pawns['black-master'];
-    if (!blackMaster || blackMaster.regionId !== 'board') {
-        return 'red';
+  const blackMaster = state.pawns["black-master"];
+  if (!blackMaster || blackMaster.regionId !== "board") {
+    return "red";
  }

  return null;
 }

-const checkCaptureWin = registry.register({
-    schema: 'check-capture-win',
-    run: handleCheckCaptureWin
-});
-
 /**
 * 综合胜利检测
 */
-async function handleCheckWin(game: OnitamaGame): Promise<PlayerType | null> {
-    const conquestWinner = await handleCheckConquestWin(game);
+async function checkWin(game: OnitamaGame): Promise<PlayerType | null> {
+  const conquestWinner = await checkConquestWin(game);
  if (conquestWinner) {
    return conquestWinner;
  }

-    const captureWinner = await handleCheckCaptureWin(game);
+  const captureWinner = await checkCaptureWin(game);
  if (captureWinner) {
    return captureWinner;
  }
@@ -245,22 +260,34 @@ async function handleCheckWin(game: OnitamaGame): Promise<PlayerType | null> {
  return null;
 }

-const checkWin = registry.register({
-    schema: 'check-win',
-    run: handleCheckWin
-});
-
 /**
 * 获取玩家可用的移动
 */
-export function getAvailableMoves(state: OnitamaState, player: PlayerType): Array<{card: string, fromX: number, fromY: number, toX: number, toY: number}> {
-    const moves: Array<{card: string, fromX: number, fromY: number, toX: number, toY: number}> = [];
+export function getAvailableMoves(
+  state: OnitamaState,
+  player: PlayerType,
+): Array<{
+  card: string;
+  fromX: number;
+  fromY: number;
+  toX: number;
+  toY: number;
+}> {
+  const moves: Array<{
+    card: string;
+    fromX: number;
+    fromY: number;
+    toX: number;
+    toY: number;
+  }> = [];

  // 获取玩家的所有卡牌
-    const cardNames = player === 'red' ? state.redCards : state.blackCards;
+  const cardNames = player === "red" ? state.redCards : state.blackCards;

  // 获取玩家的所有棋子
-    const playerPawns = Object.values(state.pawns).filter(p => p.owner === player && p.regionId === 'board');
+  const playerPawns = Object.values(state.pawns).filter(
+    (p) => p.owner === player && p.regionId === "board",
+  );

  // 对于每张卡牌
  for (const cardName of cardNames) {
@@ -294,7 +321,7 @@ export function getAvailableMoves(state: OnitamaState, player: PlayerType): Arra
 /**
 * 处理回合
 */
-async function handleTurn(game: OnitamaGame, turnPlayer: PlayerType) {
+async function turn(game: OnitamaGame, turnPlayer: PlayerType) {
  const state = game.value;
  const availableMoves = getAvailableMoves(state, turnPlayer);

@@ -313,7 +340,7 @@ async function handleTurn(game: OnitamaGame, turnPlayer: PlayerType) {
        }
        return card;
      },
-            turnPlayer
+      turnPlayer,
    );

    await swapCard(game, turnPlayer, cardToSwap);
@@ -334,19 +361,27 @@ async function handleTurn(game: OnitamaGame, turnPlayer: PlayerType) {

        return { player, card, fromX, fromY, toX, toY };
      },
-            turnPlayer
+      turnPlayer,
    );

-        await move(game, moveOutput.player, moveOutput.card, moveOutput.fromX, moveOutput.fromY, moveOutput.toX, moveOutput.toY);
+    await move(
+      game,
+      moveOutput.player,
+      moveOutput.card,
+      moveOutput.fromX,
+      moveOutput.fromY,
+      moveOutput.toX,
+      moveOutput.toY,
+    );
  }

  // 检查胜利
  const winner = await checkWin(game);

-    await game.produceAsync(state => {
+  await game.produceAsync((state) => {
    state.winner = winner;
    if (!winner) {
-            state.currentPlayer = state.currentPlayer === 'red' ? 'black' : 'red';
+      state.currentPlayer = state.currentPlayer === "red" ? "black" : "red";
      state.turn++;
    }
  });
@@ -354,11 +389,6 @@ async function handleTurn(game: OnitamaGame, turnPlayer: PlayerType) {
  return { winner, move: moveOutput };
 }

-const turn = registry.register({
-    schema: 'turn <player>',
-    run: handleTurn
-});
-
 /**
 * 开始游戏主循环
 */
@@ -1,37 +1,35 @@
-import {IGameContext} from "@/core/game";
-import {RegicideState} from "@/samples/regicide/state";
-import {createGameCommandRegistry} from "@/core/game";
-import {PlayerType, RegicideCard} from "@/samples/regicide/types";
-import {CARD_VALUES, FACE_CARDS} from "@/samples/regicide/constants";
-import {isEnemyDefeated} from "@/samples/regicide/utils";
+import { IGameContext } from "@/core/game";
+import { RegicideState } from "@/samples/regicide/state";
+import { PlayerType, RegicideCard } from "@/samples/regicide/types";
+import { CARD_VALUES, FACE_CARDS } from "@/samples/regicide/constants";
+import { isEnemyDefeated } from "@/samples/regicide/utils";

 export type RegicideGame = IGameContext<RegicideState>;

-export const registry = createGameCommandRegistry<RegicideState>();
-
 /**
 * 打出一张牌（对当前敌人造成伤害）
 */
-const playCmd = registry.register({
-    schema: 'play <player:string> <cardId:string>',
-    run: async (game: RegicideGame, player: string, cardId: string) => {
+async function playCmd(game: RegicideGame, player: string, cardId: string) {
  const state = game.value;
  const card = state.cards[cardId];

  if (!card) {
-            return {success: false, error: `卡牌 ${cardId} 不存在`};
+    return { success: false, error: `卡牌 ${cardId} 不存在` };
  }

  // 检查卡牌是否在玩家手牌中
  const playerKey = player as PlayerType;
  const playerHand = state.playerHands[playerKey];
  if (!playerHand || !playerHand.includes(cardId)) {
-            return {success: false, error: `卡牌 ${cardId} 不在玩家 ${player} 的手牌中`};
+    return {
+      success: false,
+      error: `卡牌 ${cardId} 不在玩家 ${player} 的手牌中`,
+    };
  }

  // 检查是否有当前敌人
  if (!state.currentEnemy) {
-            return {success: false, error: '没有活跃的敌人'};
+    return { success: false, error: "没有活跃的敌人" };
  }

  // 计算伤害（基础伤害为卡牌面值）
@@ -39,24 +37,27 @@ const playCmd = registry.register({
  let attackReduction = 0;

  // 梅花双倍伤害
-        if (card.suit === 'clubs') {
+  if (card.suit === "clubs") {
    damage *= 2;
  }

  // 黑桃降低敌人攻击力
-        if (card.suit === 'spades') {
+  if (card.suit === "spades") {
    attackReduction = card.value;
  }

  const enemyHpBefore = state.currentEnemy.hp;

-        await game.produce(state => {
+  await game.produceAsync((state) => {
    // 对敌人造成伤害
    state.currentEnemy!.hp -= damage;

    // 记录黑桃的攻击力降低
    if (attackReduction > 0) {
-                state.currentEnemy!.value = Math.max(0, state.currentEnemy!.value - attackReduction);
+      state.currentEnemy!.value = Math.max(
+        0,
+        state.currentEnemy!.value - attackReduction,
+      );
    }

    // 从手牌移除卡牌
@@ -67,15 +68,17 @@ const playCmd = registry.register({
    }

    // 将卡牌移到弃牌堆
-            state.cards[cardId].regionId = 'discardPile';
+    state.cards[cardId].regionId = "discardPile";

    // 红心能力：将弃牌堆洗回酒馆牌堆
-            if (card.suit === 'hearts') {
-                const discardIds = state.regions.discardPile.childIds.filter(id => id !== state.currentEnemy!.id);
+    if (card.suit === "hearts") {
+      const discardIds = state.regions.discardPile.childIds.filter(
+        (id) => id !== state.currentEnemy!.id,
+      );
      if (discardIds.length > 0) {
        // 将弃牌堆（除当前敌人外）移回酒馆牌堆
        for (const discardId of discardIds) {
-                        state.cards[discardId].regionId = 'tavernDeck';
+          state.cards[discardId].regionId = "tavernDeck";
        }
        state.regions.tavernDeck.childIds.push(...discardIds);
        state.regions.discardPile.childIds = [state.currentEnemy!.id];
@@ -83,7 +86,7 @@ const playCmd = registry.register({
    }

    // 方块能力：从酒馆牌堆抓牌
-            if (card.suit === 'diamonds') {
+    if (card.suit === "diamonds") {
      const tavernDeckCount = state.regions.tavernDeck.childIds.length;
      if (tavernDeckCount > 0) {
        const drawCardId = state.regions.tavernDeck.childIds.shift()!;
@@ -104,29 +107,31 @@ const playCmd = registry.register({
      enemyHpBefore,
      enemyHpAfter: game.value.currentEnemy!.hp,
      enemyDefeated,
-                suitAbility: card.suit
-            }
+      suitAbility: card.suit,
+    },
  };
-    }
-});
+}

 /**
 * 打出A配合另一张牌
 */
-const playWithACmd = registry.register({
-    schema: 'play-with-a <player:string> <aceCardId:string> <otherCardId:string>',
-    run: async (game: RegicideGame, player: string, aceCardId: string, otherCardId: string) => {
+async function playWithACmd(
+  game: RegicideGame,
+  player: string,
+  aceCardId: string,
+  otherCardId: string,
+) {
  const state = game.value;
  const aceCard = state.cards[aceCardId];
  const otherCard = state.cards[otherCardId];

  if (!aceCard || !otherCard) {
-            return {success: false, error: '卡牌不存在'};
+    return { success: false, error: "卡牌不存在" };
  }

  // 检查是否是A牌
-        if (aceCard.rank !== 'A') {
-            return {success: false, error: `第一张牌必须是A`};
+  if (aceCard.rank !== "A") {
+    return { success: false, error: `第一张牌必须是A` };
  }

  const playerKey = player as PlayerType;
@@ -134,36 +139,39 @@ const playWithACmd = registry.register({

  // 检查两张牌都在手牌中
  if (!playerHand.includes(aceCardId) || !playerHand.includes(otherCardId)) {
-            return {success: false, error: '卡牌不在手牌中'};
+    return { success: false, error: "卡牌不在手牌中" };
  }

  if (!state.currentEnemy) {
-            return {success: false, error: '没有活跃的敌人'};
+    return { success: false, error: "没有活跃的敌人" };
  }

  // 计算两张牌的总伤害
  let totalDamage = aceCard.value + otherCard.value;

  // 如果另一张牌是梅花，双倍伤害
-        if (otherCard.suit === 'clubs') {
+  if (otherCard.suit === "clubs") {
    totalDamage *= 2;
  }

  let attackReduction = 0;
-        if (aceCard.suit === 'spades') {
+  if (aceCard.suit === "spades") {
    attackReduction += aceCard.value;
  }
-        if (otherCard.suit === 'spades') {
+  if (otherCard.suit === "spades") {
    attackReduction += otherCard.value;
  }

-        await game.produce(state => {
+  await game.produceAsync((state) => {
    // 对敌人造成伤害
    state.currentEnemy!.hp -= totalDamage;

    // 记录黑桃的攻击力降低
    if (attackReduction > 0) {
-                state.currentEnemy!.value = Math.max(0, state.currentEnemy!.value - attackReduction);
+      state.currentEnemy!.value = Math.max(
+        0,
+        state.currentEnemy!.value - attackReduction,
+      );
    }

    // 从手牌移除两张牌
@@ -174,8 +182,8 @@ const playWithACmd = registry.register({
    if (otherIndex !== -1) hand.splice(otherIndex, 1);

    // 将卡牌移到弃牌堆
-            state.cards[aceCardId].regionId = 'discardPile';
-            state.cards[otherCardId].regionId = 'discardPile';
+    state.cards[aceCardId].regionId = "discardPile";
+    state.cards[otherCardId].regionId = "discardPile";
  });

  const enemyDefeated = isEnemyDefeated(state.currentEnemy);
@@ -186,33 +194,31 @@ const playWithACmd = registry.register({
      damage: totalDamage,
      attackReduction,
      enemyHp: state.currentEnemy!.hp,
-                enemyDefeated
-            }
+      enemyDefeated,
+    },
  };
-    }
-});
+}

 /**
 * 让过（不出牌）
 */
-const passCmd = registry.register({
-    schema: 'pass <player:string>',
-    run: async (game: RegicideGame, player: string) => {
+async function passCmd(game: RegicideGame, player: string) {
  // 即使让过，也会受到敌人反击（在回合结束时处理）
-        return {success: true, result: {message: `${player} 让过`}};
-    }
-});
+  return { success: true, result: { message: `${player} 让过` } };
+}

 /**
 * 敌人反击 - 玩家必须弃掉点数和 >= 敌人攻击力的牌
 */
-const enemyCounterattackCmd = registry.register({
-    schema: 'counterattack <player:string> <discardCards:string[]>',
-    run: async (game: RegicideGame, player: string, discardCards: string[]) => {
+async function enemyCounterattackCmd(
+  game: RegicideGame,
+  player: string,
+  discardCards: string[],
+) {
  const state = game.value;

  if (!state.currentEnemy) {
-            return {success: false, error: '没有活跃的敌人'};
+    return { success: false, error: "没有活跃的敌人" };
  }

  const playerKey = player as PlayerType;
@@ -221,7 +227,7 @@ const enemyCounterattackCmd = registry.register({
  // 检查要弃的牌都在手牌中
  for (const cardId of discardCards) {
    if (!playerHand.includes(cardId)) {
-                return {success: false, error: `卡牌 ${cardId} 不在手牌中`};
+      return { success: false, error: `卡牌 ${cardId} 不在手牌中` };
    }
  }

@@ -240,19 +246,19 @@ const enemyCounterattackCmd = registry.register({
  if (totalValue < enemyAttack) {
    return {
      success: false,
-                error: `弃牌点数和 (${totalValue}) 小于敌人攻击力 (${enemyAttack})，游戏失败`
+      error: `弃牌点数和 (${totalValue}) 小于敌人攻击力 (${enemyAttack})，游戏失败`,
    };
  }

  // 执行弃牌
-        await game.produce(state => {
+  await game.produceAsync((state) => {
    const hand = state.playerHands[playerKey];
    for (const cardId of discardCards) {
      const index = hand.indexOf(cardId);
      if (index !== -1) {
        hand.splice(index, 1);
      }
-                state.cards[cardId].regionId = 'discardPile';
+      state.cards[cardId].regionId = "discardPile";
    }
  });

@@ -261,30 +267,27 @@ const enemyCounterattackCmd = registry.register({
    result: {
      discardedCards: discardCards,
      totalValue,
-                enemyAttack
-            }
+      enemyAttack,
+    },
  };
-    }
-});
+}

 /**
 * 检查敌人是否被击败，如果击败则翻开下一个敌人
 */
-const checkEnemyDefeatedCmd = registry.register({
-    schema: 'check-enemy',
-    run: async (game: RegicideGame) => {
+async function checkEnemyDefeatedCmd(game: RegicideGame) {
  const state = game.value;

  if (!state.currentEnemy) {
-            return {success: false, error: '没有活跃的敌人'};
+    return { success: false as const, error: "没有活跃的敌人" };
  }

  const defeated = state.currentEnemy.hp <= 0;

  if (defeated) {
-            const defeatedEnemy = {...state.currentEnemy};
+    const defeatedEnemy = { ...state.currentEnemy };

-            await game.produce(state => {
+    await game.produceAsync((state) => {
      // 将当前敌人移到弃牌堆
      state.regions.discardPile.childIds.push(state.currentEnemy!.id);

@@ -300,20 +303,20 @@ const checkEnemyDefeatedCmd = registry.register({

    // 检查是否胜利（没有更多敌人）
    if (!game.value.currentEnemy) {
-                await game.produce(state => {
-                    state.phase = 'victory';
+      await game.produceAsync((state) => {
+        state.phase = "victory";
        state.winner = true;
      });
    }

    return {
-                success: true,
+      success: true as const,
      result: {
        defeated: true,
        defeatedEnemy,
        nextEnemy: game.value.currentEnemy,
-                    enemiesRemaining: game.value.enemyDeck.length
-                }
+        enemiesRemaining: game.value.enemyDeck.length,
+      },
    };
  }

@@ -321,27 +324,24 @@ const checkEnemyDefeatedCmd = registry.register({
    success: true,
    result: {
      defeated: false,
-                currentEnemy: {...state.currentEnemy},
-                enemiesRemaining: state.enemyDeck.length
-            }
+      currentEnemy: { ...state.currentEnemy },
+      enemiesRemaining: state.enemyDeck.length,
+    },
  };
-    }
-});
+}

 /**
 * 检查玩家是否有可出的牌
 */
-const checkCanPlayCmd = registry.register({
-    schema: 'check-can-play <player:string>',
-    run: async (game: RegicideGame, player: string) => {
+async function checkCanPlayCmd(game: RegicideGame, player: string) {
  const state = game.value;
  const playerKey = player as PlayerType;
  const playerHand = state.playerHands[playerKey];

  const canPlay = playerHand.length > 0;
-        const canPlayWithA = playerHand.some(cardId => {
+  const canPlayWithA = playerHand.some((cardId) => {
    const card = state.cards[cardId];
-            return card && card.rank === 'A' && playerHand.length > 1;
+    return card && card.rank === "A" && playerHand.length > 1;
  });

  return {
@@ -349,27 +349,26 @@ const checkCanPlayCmd = registry.register({
    result: {
      canPlay,
      canPlayWithA,
-                handSize: playerHand.length
-            }
+      handSize: playerHand.length,
+    },
  };
-    }
-});
+}

 /**
 * 检查酒馆牌堆是否为空
 */
-const checkTavernDeckCmd = registry.register({
-    schema: 'check-tavern-deck',
-    run: async (game: RegicideGame) => {
+async function checkTavernDeckCmd(game: RegicideGame) {
  const state = game.value;
  const isEmpty = state.regions.tavernDeck.childIds.length === 0;

  // 如果酒馆牌堆为空且所有玩家手牌也为空，则游戏失败
  if (isEmpty) {
-            const allHandsEmpty = Object.values(state.playerHands).every(hand => hand.length === 0);
+    const allHandsEmpty = Object.values(state.playerHands).every(
+      (hand) => hand.length === 0,
+    );
    if (allHandsEmpty) {
-                await game.produce(state => {
-                    state.phase = 'defeat';
+      await game.produceAsync((state) => {
+        state.phase = "defeat";
        state.winner = false;
      });
    }
@@ -379,35 +378,32 @@ const checkTavernDeckCmd = registry.register({
    success: true,
    result: {
      isEmpty,
-                cardsRemaining: state.regions.tavernDeck.childIds.length
-            }
+      cardsRemaining: state.regions.tavernDeck.childIds.length,
+    },
  };
-    }
-});
+}

 /**
 * 下一个玩家回合
 */
-const nextTurnCmd = registry.register({
-    schema: 'next-turn',
-    run: async (game: RegicideGame) => {
+async function nextTurnCmd(game: RegicideGame) {
  const state = game.value;
-        await game.produce(state => {
-            state.currentPlayerIndex = (state.currentPlayerIndex + 1) % state.playerCount;
+  await game.produce((state) => {
+    state.currentPlayerIndex =
+      (state.currentPlayerIndex + 1) % state.playerCount;
  });

-        const players: PlayerType[] = ['player1', 'player2', 'player3', 'player4'];
+  const players: PlayerType[] = ["player1", "player2", "player3", "player4"];
  const currentPlayer = players[game.value.currentPlayerIndex];

  return {
    success: true,
    result: {
      currentPlayer,
-                currentPlayerIndex: game.value.currentPlayerIndex
-            }
+      currentPlayerIndex: game.value.currentPlayerIndex,
+    },
  };
-    }
-});
+}

 export {
  playCmd as play,
@@ -1,8 +1,15 @@
-import {IGameContext} from "@/core/game";
-import {RegicideState} from "@/samples/regicide/state";
-import {buildEnemyDeck, buildTavernDeck, createAllCards, getPlayerHandRegionId} from "@/samples/regicide/utils";
-import {INITIAL_HAND_SIZE} from "@/samples/regicide/constants";
-import {Enemy, PlayerType, RegicideCard} from "@/samples/regicide/types";
+import { IGameContext } from "@/core/game";
+import { RegicideState } from "@/samples/regicide/state";
+import {
+  buildEnemyDeck,
+  buildTavernDeck,
+  createAllCards,
+  getPlayerHandRegionId,
+} from "@/samples/regicide/utils";
+import { INITIAL_HAND_SIZE } from "@/samples/regicide/constants";
+import { Enemy, PlayerType, RegicideCard } from "@/samples/regicide/types";
+import { checkEnemy, nextTurn, pass, playWithA } from "./commands";
+import { enemyCounterattackCmd, playCmd } from ".";

 export type RegicideGame = IGameContext<RegicideState>;

@@ -12,9 +19,13 @@ export type RegicideGame = IGameContext<RegicideState>;
 * @param playerCount 玩家数量（1-4）
 * @param seed 随机种子（可选）
 */
-export async function setupGame(game: RegicideGame, playerCount: number, seed?: number) {
+export async function setupGame(
+  game: RegicideGame,
+  playerCount: number,
+  seed?: number,
+) {
  if (playerCount < 1 || playerCount > 4) {
-        throw new Error('玩家数量必须为 1-4 人');
+    throw new Error("玩家数量必须为 1-4 人");
  }

  if (seed) {
@@ -31,7 +42,7 @@ export async function setupGame(game: RegicideGame, playerCount: number, seed?:
  const tavernDeck = buildTavernDeck(game._rng);

  // 初始化游戏状态
-    await game.produceAsync(state => {
+  await game.produceAsync((state) => {
    state.cards = allCards;
    state.playerCount = playerCount;
    state.currentPlayerIndex = 0;
@@ -39,15 +50,15 @@ export async function setupGame(game: RegicideGame, playerCount: number, seed?:

    // 设置酒馆牌堆区域
    for (const card of tavernDeck) {
-            card.regionId = 'tavernDeck';
+      card.regionId = "tavernDeck";
      state.regions.tavernDeck.childIds.push(card.id);
    }

    // 设置敌人牌堆区域（只存储ID，敌人是独立对象）
-        state.regions.enemyDeck.childIds = enemyDeck.map(e => e.id);
+    state.regions.enemyDeck.childIds = enemyDeck.map((e) => e.id);

    // 给每个玩家发牌
-        const players: PlayerType[] = ['player1', 'player2', 'player3', 'player4'];
+    const players: PlayerType[] = ["player1", "player2", "player3", "player4"];
    for (let i = 0; i < playerCount; i++) {
      const player = players[i];
      const regionId = getPlayerHandRegionId(player);
@@ -78,13 +89,13 @@ export async function start(game: RegicideGame) {

  // 检查游戏是否已设置
  if (!state.currentEnemy) {
-        throw new Error('请先调用 setupGame 初始化游戏');
+    throw new Error("请先调用 setupGame 初始化游戏");
  }

-    const players: PlayerType[] = ['player1', 'player2', 'player3', 'player4'];
+  const players: PlayerType[] = ["player1", "player2", "player3", "player4"];

  // 主游戏循环
-    while (state.phase === 'playing') {
+  while (state.phase === "playing") {
    const currentPlayerIndex = state.currentPlayerIndex;
    const currentPlayer = players[currentPlayerIndex];

@@ -92,8 +103,9 @@ export async function start(game: RegicideGame) {
    const currentHand = state.playerHands[currentPlayer];
    if (currentHand.length === 0) {
      // 玩家没有手牌，跳过回合
-            await game.produceAsync(state => {
-                state.currentPlayerIndex = (state.currentPlayerIndex + 1) % state.playerCount;
+      await game.produceAsync((state) => {
+        state.currentPlayerIndex =
+          (state.currentPlayerIndex + 1) % state.playerCount;
      });
      continue;
    }
@@ -113,31 +125,37 @@ export async function start(game: RegicideGame) {
 /**
 * 处理完整的玩家回合
 */
-export async function playTurn(game: RegicideGame, player: PlayerType, action: 'play' | 'pass', cardId?: string, secondCardId?: string) {
+export async function playTurn(
+  game: RegicideGame,
+  player: PlayerType,
+  action: "play" | "pass",
+  cardId?: string,
+  secondCardId?: string,
+) {
  const state = game.value;

-    if (state.phase !== 'playing') {
-        return {success: false, error: '游戏已结束'};
+  if (state.phase !== "playing") {
+    return { success: false, error: "游戏已结束" };
  }

  if (!state.currentEnemy) {
-        return {success: false, error: '没有活跃的敌人'};
+    return { success: false, error: "没有活跃的敌人" };
  }

  let playResult: any;

  // 执行玩家动作
-    if (action === 'play' && cardId) {
+  if (action === "play" && cardId) {
    // 检查是否是A配合另一张牌
    const card = state.cards[cardId];
-        if (card.rank === 'A' && secondCardId) {
-            playResult = await game.run(`play-with-a ${player} ${cardId} ${secondCardId}`);
+    if (card.rank === "A" && secondCardId) {
+      playResult = await playWithA(game, player, cardId, secondCardId);
    } else {
-            playResult = await game.run(`play ${player} ${cardId}`);
+      playResult = await playCmd(game, player, cardId);
    }
  } else {
    // 让过
-        playResult = await game.run(`pass ${player}`);
+    playResult = await pass(game, player);
  }

  if (!playResult.success) {
@@ -145,7 +163,7 @@ export async function playTurn(game: RegicideGame, player: PlayerType, action: '
  }

  // 检查敌人是否被击败
-    const checkResult = await game.run<{defeated: boolean; currentEnemy?: any; nextEnemy?: any; defeatedEnemy?: any; enemiesRemaining?: number}>('check-enemy');
+  const checkResult = await checkEnemy(game);
  if (!checkResult.success) {
    return checkResult;
  }
@@ -160,15 +178,19 @@ export async function playTurn(game: RegicideGame, player: PlayerType, action: '
        enemyDefeated: false,
        needsDiscard: true,
        enemyAttack: state.currentEnemy.value,
-                playerHand: state.playerHands[player]
-            }
+        playerHand: state.playerHands[player],
+      },
    };
  }

  // 敌人被击败，检查是否还有更多敌人
-    if (state.enemyDeck.length === 0 && state.currentEnemy && state.currentEnemy.hp <= 0) {
-        await game.produceAsync(state => {
-            state.phase = 'victory';
+  if (
+    state.enemyDeck.length === 0 &&
+    state.currentEnemy &&
+    state.currentEnemy.hp <= 0
+  ) {
+    await game.produceAsync((state) => {
+      state.phase = "victory";
      state.winner = true;
    });
    return {
@@ -176,41 +198,44 @@ export async function playTurn(game: RegicideGame, player: PlayerType, action: '
      result: {
        playResult: playResult.result,
        enemyDefeated: true,
-                gameWon: true
-            }
+        gameWon: true,
+      },
    };
  }

  // 切换到下一个玩家
-    await game.run('next-turn');
+  await nextTurn(game);

  return {
    success: true,
    result: {
      playResult: playResult.result,
      enemyDefeated: true,
-            nextEnemy: state.currentEnemy
-        }
+      nextEnemy: state.currentEnemy,
+    },
  };
 }

 /**
 * 处理反击阶段的弃牌
 */
-export async function handleCounterattack(game: RegicideGame, player: PlayerType, discardCardIds: string[]) {
-    const result = await game.run(`counterattack ${player} ${JSON.stringify(discardCardIds)}`);
-
+export async function handleCounterattack(
+  game: RegicideGame,
+  player: PlayerType,
+  discardCardIds: string[],
+) {
+  const result = await enemyCounterattackCmd(game, player, discardCardIds);
  if (!result.success) {
    // 弃牌失败（点数和不足），游戏失败
-        await game.produceAsync(state => {
-            state.phase = 'defeat';
+    await game.produceAsync((state) => {
+      state.phase = "defeat";
      state.winner = false;
    });
    return result;
  }

  // 弃牌成功，切换到下一个玩家
-    await game.run('next-turn');
+  await nextTurn(game);

  return result;
 }
@@ -223,17 +248,26 @@ export function getGameStatus(game: RegicideGame) {

  return {
    phase: state.phase,
-        currentPlayer: ['player1', 'player2', 'player3', 'player4'][state.currentPlayerIndex],
-        currentEnemy: state.currentEnemy ? {
+    currentPlayer: ["player1", "player2", "player3", "player4"][
+      state.currentPlayerIndex
+    ],
+    currentEnemy: state.currentEnemy
+      ? {
          ...state.currentEnemy,
-            hpPercent: Math.round((state.currentEnemy.hp / state.currentEnemy.maxHp) * 100)
-        } : null,
+          hpPercent: Math.round(
+            (state.currentEnemy.hp / state.currentEnemy.maxHp) * 100,
+          ),
+        }
+      : null,
    enemiesRemaining: state.enemyDeck.length,
    tavernDeckCount: state.regions.tavernDeck.childIds.length,
    discardPileCount: state.regions.discardPile.childIds.length,
    playerHands: Object.fromEntries(
-            Object.entries(state.playerHands).map(([player, hand]) => [player, hand.length])
+      Object.entries(state.playerHands).map(([player, hand]) => [
+        player,
+        hand.length,
+      ]),
    ),
-        winner: state.winner
+    winner: state.winner,
  };
 }
@@ -7,8 +7,8 @@ export type {
  RegicideCardMeta,
  RegicideCard,
  Enemy,
-    GamePhase
-} from './types';
+  GamePhase,
+} from "./types";

 // Constants
 export {
@@ -18,21 +18,17 @@ export {
  ALL_SUITS,
  ALL_RANKS,
  FACE_CARDS,
-    NUMBER_CARDS
-} from './constants';
+  NUMBER_CARDS,
+} from "./constants";

 // State
-export {
-    createInitialState,
-    type RegicideState
-} from './state';
+export { createInitialState, type RegicideState } from "./state";

 // Prompts
-export {prompts} from './prompts';
+export { prompts } from "./prompts";

 // Commands
 export {
-    registry,
  play as playCmd,
  playWithA as playWithACmd,
  pass as passCmd,
@@ -41,7 +37,7 @@ export {
  checkCanPlay as checkCanPlayCmd,
  checkTavernDeck as checkTavernDeckCmd,
  nextTurn as nextTurnCmd,
-} from './commands';
+} from "./commands";

 // Game
 export {
@@ -50,8 +46,8 @@ export {
  playTurn,
  handleCounterattack,
  getGameStatus,
-    type RegicideGame
-} from './game';
+  type RegicideGame,
+} from "./game";

 // Utils
 export {
@@ -63,5 +59,5 @@ export {
  buildTavernDeck,
  drawFromDeck,
  isEnemyDefeated,
-    getPlayerHandRegionId
-} from './utils';
+  getPlayerHandRegionId,
+} from "./utils";
@@ -2,37 +2,42 @@
 # type: 'item' = inventory item card, 'status' = status effect card
 # costType: 'energy' = costs energy per turn, 'uses' = limited uses, 'none' = free
 # targetType: 'single' = target one enemy, 'none' = no target
+
+# type CardType = 'item' | 'status'
+# type CardCostType = 'energy' | 'uses' | 'none'
+# type CardTargetType = 'player' | 'enemy' | 'enemies'
+
 # inject effects = ~cardEffect(card)

 id,name,desc,type,costType,costCount,targetType
-string,string,string,'item'|'status','energy'|'uses'|'none',int,'single'|'none'
-sword,剑,【攻击2】【攻击2】,item,energy,1,single
-greataxe,长斧,对全体【攻击5】,item,energy,2,none
-spear,长枪,【攻击2】【攻击2】【攻击2】,item,energy,1,single
-dagger,短刀,【攻击3】【攻击3】,item,energy,1,single
-dart,飞镖,【攻击1】抓一张牌,item,energy,0,single
-crossbow,十字弩,【攻击6】对同一目标打出其他十字弩,item,energy,2,single
-shield,盾,【防御3】,item,energy,1,none
-hat,斗笠,【防御8】,item,energy,2,none
-cape,披风,【防御2】下回合【防御2】,item,energy,1,none
-bracer,护腕,【防御1】抓1张牌,item,energy,0,none
-greatshield,大盾,【防御5】,item,energy,1,none
-chainmail,锁子甲,本回合受到伤害-3,item,energy,1,none
-bandage,绷带,从牌堆或弃牌堆随机移除1张伤口,item,uses,3,none
-poisonPotion,淬毒药剂,周围物品的【攻击】+2,item,uses,3,none
-fortifyPotion,强固药剂,周围物品的【防御】+2,item,uses,3,none
-vitalityPotion,活力药剂,获得1点能量,item,uses,3,none
-focusPotion,集中药剂,抓2张牌,item,uses,3,none
-healingPotion,治疗药剂,从牌堆或弃牌堆移除3张伤口,item,uses,3,none
-waterBag,水袋,下回合开始时获得1能量抓2张牌,item,energy,1,none
-rope,绳索,周围物品的牌【防御】+2直到打出,item,energy,1,none
-belt,腰带,从牌堆周围物品的牌当中选择一张加入手牌,item,energy,0,none
-torch,火把,下次打出周围物品的牌时将其消耗并获得1能量,item,energy,1,none
-whetstone,磨刀石,周围物品的牌【攻击】+3直到打出,item,energy,1,none
-blacksmithHammer,铁匠锤,从牌堆/弃牌堆选择一张牌随机变为一张周围物品的牌,item,energy,1,none
-wound,伤口,无效果占用手牌和牌堆,status,none,0,none
-venom,蛇毒,弃掉时受到3点伤害,status,none,0,none
-curse,诅咒,受攻击时物品攻击-1直到弃掉一张该物品的牌,status,none,0,none
-static,静电,在手里时受电击伤害+1,status,none,0,none
-fatigue,疲劳,占用手牌,status,none,0,none
-vultureEye,秃鹫之眼,抓到时获得3层暴露,status,none,0,none
+string,string,string,CardType,CardCostType,int,CardTargetType
+sword,剑,【攻击2】【攻击2】,item,energy,1,enemy
+greataxe,长斧,对全体【攻击5】,item,energy,2,enemies
+spear,长枪,【攻击2】【攻击2】【攻击2】,item,energy,1,enemy
+dagger,短刀,【攻击3】【攻击3】,item,energy,1,enemy
+dart,飞镖,【攻击1】抓一张牌,item,energy,0,enemy
+crossbow,十字弩,【攻击6】对同一目标打出其他十字弩,item,energy,2,enemy
+shield,盾,【防御3】,item,energy,1,player
+hat,斗笠,【防御8】,item,energy,2,player
+cape,披风,【防御2】下回合【防御2】,item,energy,1,player
+bracer,护腕,【防御1】抓1张牌,item,energy,0,player
+greatshield,大盾,【防御5】,item,energy,1,player
+chainmail,锁子甲,本回合受到伤害-3,item,energy,1,player
+bandage,绷带,从牌堆或弃牌堆随机移除1张伤口,item,uses,3,player
+poisonPotion,淬毒药剂,周围物品的【攻击】+2,item,uses,3,player
+fortifyPotion,强固药剂,周围物品的【防御】+2,item,uses,3,player
+vitalityPotion,活力药剂,获得1点能量,item,uses,3,player
+focusPotion,集中药剂,抓2张牌,item,uses,3,player
+healingPotion,治疗药剂,从牌堆或弃牌堆移除3张伤口,item,uses,3,player
+waterBag,水袋,下回合开始时获得1能量抓2张牌,item,energy,1,player
+rope,绳索,周围物品的牌【防御】+2直到打出,item,energy,1,player
+belt,腰带,从牌堆周围物品的牌当中选择一张加入手牌,item,energy,0,player
+torch,火把,下次打出周围物品的牌时将其消耗并获得1能量,item,energy,1,player
+whetstone,磨刀石,周围物品的牌【攻击】+3直到打出,item,energy,1,player
+blacksmithHammer,铁匠锤,从牌堆/弃牌堆选择一张牌随机变为一张周围物品的牌,item,energy,1,player
+wound,伤口,无效果占用手牌和牌堆,status,none,0,player
+venom,蛇毒,弃掉时受到3点伤害,status,none,0,player
+curse,诅咒,受攻击时物品攻击-1直到弃掉一张该物品的牌,status,none,0,player
+static,静电,在手里时受电击伤害+1,status,none,0,player
+fatigue,疲劳,占用手牌,status,none,0,player
+vultureEye,秃鹫之眼,抓到时获得3层暴露,status,none,0,player
@@ -1,13 +1,17 @@
 import type { CardEffect } from './cardEffect.csv';

+export type CardType = 'item' | 'status';
+export type CardCostType = 'energy' | 'uses' | 'none';
+export type CardTargetType = 'player' | 'enemy' | 'enemies';
+
 type CardTable = readonly {
    readonly id: string;
    readonly name: string;
    readonly desc: string;
-    readonly type: "item" | "status";
-    readonly costType: "energy" | "uses" | "none";
+    readonly type: CardType;
+    readonly costType: CardCostType;
    readonly costCount: number;
-    readonly targetType: "single" | "none";
+    readonly targetType: CardTargetType;
    readonly effects: CardEffect[];
 }[];

@@ -1,32 +1,36 @@
+# type CardEffectTrigger = 'onPlay' | 'onDraw' | 'onDiscard'
+# type CardEffectTarget = 'source' | 'eachTarget' | 'eachEnemy' | 'randomEnemy' | 'player'
+# type CardEffectList = [effect: @effect; stacks: number][]
+
 id,card,trigger,target,effects
-string,@card,'onPlay'|'onDraw'|'onDiscard','self'|'target'|'all'|'random',[@effect;number][]
-sword,sword,onPlay,target,[attack;2];[attack;2]
-greataxe,greataxe,onPlay,all,[attack;5]
-spear,spear,onPlay,target,[attack;2];[attack;2];[attack;2]
-dagger,dagger,onPlay,target,[attack;3];[attack;3]
-dart,dart,onPlay,target,[attack;1]
-dart-draw,dart,onPlay,self,[draw;1]
-crossbow,crossbow,onPlay,target,[attack;6]
-crossbow-combo,crossbow,onPlay,self,[crossbow;0]
-shield,shield,onPlay,self,[defend;3]
-hat,hat,onPlay,self,[defend;8]
-cape,cape,onPlay,self,[defend;2];[defendNext;2]
-bracer,bracer,onPlay,self,[defend;1];[draw;1]
-greatshield,greatshield,onPlay,self,[defend;5]
-chainmail,chainmail,onPlay,self,[damageReduce;3]
-bandage,bandage,onPlay,self,[removeWound;1]
-poisonPotion,poisonPotion,onPlay,self,[attackBuff;2]
-fortifyPotion,fortifyPotion,onPlay,self,[defendBuff;2]
-vitalityPotion,vitalityPotion,onPlay,self,[gainEnergy;1]
-focusPotion,focusPotion,onPlay,self,[draw;2]
-healingPotion,healingPotion,onPlay,self,[removeWound;3]
-waterBag,waterBag,onPlay,self,[energyNext;1];[drawNext;2]
-rope,rope,onPlay,self,[defendBuffUntilPlay;2]
-belt,belt,onPlay,self,[drawChoice;1]
-torch,torch,onPlay,self,[burnForEnergy;1]
-whetstone,whetstone,onPlay,self,[attackBuffUntilPlay;3]
-blacksmithHammer,blacksmithHammer,onPlay,self,[transformRandom;1]
-venom,venom,onDiscard,self,[attack;3]
-curse,curse,onDraw,self,[curse;1]
-static,static,onDraw,self,[static;1]
-vultureEye,vultureEye,onDraw,self,[expose;3]
+string,@card,CardEffectTrigger,CardEffectTarget,CardEffectList
+sword,sword,onPlay,eachTarget,[attack;2];[attack;2]
+greataxe,greataxe,onPlay,eachTarget,[attack;5]
+spear,spear,onPlay,eachTarget,[attack;2];[attack;2];[attack;2]
+dagger,dagger,onPlay,eachTarget,[attack;3];[attack;3]
+dart,dart,onPlay,eachTarget,[attack;1]
+dart-draw,dart,onPlay,source,[draw;1]
+crossbow,crossbow,onPlay,eachTarget,[attack;6]
+crossbow-combo,crossbow,onPlay,source,[crossbow;0]
+shield,shield,onPlay,source,[defend;3]
+hat,hat,onPlay,source,[defend;8]
+cape,cape,onPlay,source,[defend;2];[defendNext;2]
+bracer,bracer,onPlay,source,[defend;1];[draw;1]
+greatshield,greatshield,onPlay,source,[defend;5]
+chainmail,chainmail,onPlay,source,[damageReduce;3]
+bandage,bandage,onPlay,source,[removeWound;1]
+poisonPotion,poisonPotion,onPlay,source,[attackBuff;2]
+fortifyPotion,fortifyPotion,onPlay,source,[defendBuff;2]
+vitalityPotion,vitalityPotion,onPlay,source,[gainEnergy;1]
+focusPotion,focusPotion,onPlay,source,[draw;2]
+healingPotion,healingPotion,onPlay,source,[removeWound;3]
+waterBag,waterBag,onPlay,source,[energyNext;1];[drawNext;2]
+rope,rope,onPlay,source,[defendBuffUntilPlay;2]
+belt,belt,onPlay,source,[drawChoice;1]
+torch,torch,onPlay,source,[burnForEnergy;1]
+whetstone,whetstone,onPlay,source,[attackBuffUntilPlay;3]
+blacksmithHammer,blacksmithHammer,onPlay,source,[transformRandom;1]
+venom,venom,onDiscard,source,[attack;3]
+curse,curse,onDraw,source,[curse;1]
+static,static,onDraw,source,[static;1]
+vultureEye,vultureEye,onDraw,source,[expose;3]
@@ -1,12 +1,16 @@
 import type { Card } from './card.csv';
 import type { Effect } from './effect.csv';

+export type CardEffectTrigger = 'onPlay' | 'onDraw' | 'onDiscard';
+export type CardEffectTarget = 'source' | 'eachTarget' | 'eachEnemy' | 'randomEnemy' | 'player';
+export type CardEffectList = [effect: Effect, stacks: number][];
+
 type CardEffectTable = readonly {
    readonly id: string;
    readonly card: Card;
-    readonly trigger: "onPlay" | "onDraw" | "onDiscard";
-    readonly target: "self" | "target" | "all" | "random";
-    readonly effects: [Effect, number][];
+    readonly trigger: CardEffectTrigger;
+    readonly target: CardEffectTarget;
+    readonly effects: CardEffectList;
 }[];

 export type CardEffect = CardEffectTable[number];
@@ -11,40 +11,42 @@
 # itemUntilDiscard: 施加buff到周围物品，物品被弃掉后失效
 # itemPermanent: 施加buff到周围物品，持续整场冒险

-id, name, description, lifecycle
-string, string, string, 'instant'|'temporary'|'lingering'|'permanent'|'posture'|'item'|'itemTemporary'|'itemUntilPlay'|'itemUntilDiscard'|'itemPermanent'
-attack, 攻击, 对对手造成伤害, instant
-defend, 防御, 抵消下次行动前受到的伤害, posture
-spike, 尖刺, 对攻击者造成X点伤害, permanent
-venom, 蛇毒, 同名状态牌/1费：打出时移除此牌。弃掉时受到3点伤害, instant
-curse, 诅咒, 受攻击时物品攻击-1，直到弃掉一张该物品的牌, lingering
-aim, 瞄准, 造成双倍伤害，受伤时失去等量瞄准, posture
-roll, 滚动, 攻击时每消耗10点滚动造成等量伤害, posture
-rollDamage, 滚动攻击, 消耗滚动层数造成的伤害, instant
-vultureEye, 秃鹫之眼, 抓到时获得3层暴露（临时debuff，受到的伤害+1/每层）, instant
-tailSting, 尾刺, 攻击时，伤害提升X, posture
-energyDrain, 能量吸取, 受伤时，玩家失去X点能量, lingering
-molt, 脱皮, 若脱皮达到生命上限则怪物逃跑, posture
-discard, 劫掠, 回合开始时随机弃掉一张手牌, lingering
-storm, 风暴, 攻击时给玩家塞入1张静电, permanent
-static, 静电, 在手里时受电击伤害+1, permanent
-charge, 冲锋, 受到或造成的伤害翻倍并消耗等量冲锋, lingering
-summonMummy, 召唤木乃伊, 召唤1个木乃伊, instant
-summonSandwormLarva, 召唤幼沙虫, 召唤1个幼沙虫, instant
-reviveMummy, 复活木乃伊, 复活1个已死亡的木乃伊, instant
-draw, 抓牌, 抓X张牌, instant
-crossbow, 十字弩连击, 对同一目标打出其他十字弩, instant
-defendNext, 下回合防御, 下回合开始时获得防御, temporary
-damageReduce, 减伤, 本回合受到的伤害减少X, temporary
-removeWound, 移除伤口, 从牌堆或弃牌堆移除X张伤口, instant
-attackBuff, 攻击增益, 周围物品的攻击+X, itemUntilPlay
-defendBuff, 防御增益, 周围物品的防御+X, itemUntilPlay
-gainEnergy, 获得能量, 获得X点能量, instant
-energyNext, 下回合获能量, 下回合开始时获得X点能量, temporary
-drawNext, 下回合抓牌, 下回合开始时抓X张牌, temporary
-defendBuffUntilPlay, 防御增益直到打出, 周围物品的牌防御+X直到打出, itemUntilPlay
-drawChoice, 选择抓牌, 从牌堆周围物品的牌中选择一张加入手牌, instant
-burnForEnergy, 消耗获能量, 打出周围物品的牌时消耗并获得X能量, itemUntilPlay
-attackBuffUntilPlay, 攻击增益直到打出, 周围物品的牌攻击+X直到打出, itemUntilPlay
-transformRandom, 随机变牌, 选择一张牌随机变为周围物品的牌, instant
-expose, 暴露, 受到的伤害+1/每层, temporary
+# type EffectLifecycle = 'instant' | 'temporary' | 'lingering' | 'permanent' | 'posture' | 'item' | 'itemTemporary' | 'itemUntilPlay' | 'itemUntilDiscard' | 'itemPermanent'
+
+id, name, description, lifecycle, emoji
+string, string, string, EffectLifecycle, string
+attack, 攻击, 对对手造成伤害, instant, ⚔️
+defend, 防御, 抵消下次行动前受到的伤害, temporary, 🛡️
+spike, 尖刺, 对攻击者造成X点伤害, permanent, 🌵
+venom, 蛇毒, 同名状态牌/1费：打出时移除此牌。弃掉时受到3点伤害, instant, 🧪
+curse, 诅咒, 受攻击时物品攻击-1，直到弃掉一张该物品的牌, lingering, 💀
+aim, 瞄准, 造成双倍伤害，受伤时失去等量瞄准, posture, 🎯
+roll, 滚动, 攻击时每消耗10点滚动造成等量伤害, posture, 🎲
+rollDamage, 滚动攻击, 消耗滚动层数造成的伤害, instant, 💥
+vultureEye, 秃鹫之眼, 抓到时获得3层暴露（临时debuff，受到的伤害+1/每层）, instant, 👁️
+tailSting, 尾刺, 攻击时，伤害提升X, posture, 🦂
+energyDrain, 能量吸取, 受伤时，玩家失去X点能量, lingering, 🔋
+molt, 脱皮, 若脱皮达到生命上限则怪物逃跑, posture, 🐚
+discard, 劫掠, 回合开始时随机弃掉一张手牌, lingering, 🗑️
+storm, 风暴, 攻击时给玩家塞入1张静电, permanent, ⚡
+static, 静电, 在手里时受电击伤害+1, permanent, ⚡
+charge, 冲锋, 受到或造成的伤害翻倍并消耗等量冲锋, lingering, 🐎
+summonMummy, 召唤木乃伊, 召唤1个木乃伊, instant, 🧟
+summonSandwormLarva, 召唤幼沙虫, 召唤1个幼沙虫, instant, 🐛
+reviveMummy, 复活木乃伊, 复活1个已死亡的木乃伊, instant, 🌅
+draw, 抓牌, 抓X张牌, instant, 🃏
+crossbow, 十字弩连击, 对同一目标打出其他十字弩, instant, 🏹
+defendNext, 下回合防御, 下回合开始时获得防御, temporary, 🛡️
+damageReduce, 减伤, 本回合受到的伤害减少X, temporary, 📉
+removeWound, 移除伤口, 从牌堆或弃牌堆移除X张伤口, instant, 🩹
+attackBuff, 攻击增益, 周围物品的攻击+X, itemUntilPlay, ⬆️
+defendBuff, 防御增益, 周围物品的防御+X, itemUntilPlay, ⬆️
+gainEnergy, 获得能量, 获得X点能量, instant, ⚡
+energyNext, 下回合获能量, 下回合开始时获得X点能量, temporary, ⚡
+drawNext, 下回合抓牌, 下回合开始时抓X张牌, temporary, 🃏
+defendBuffUntilPlay, 防御增益直到打出, 周围物品的牌防御+X直到打出, itemUntilPlay, 🛡️
+drawChoice, 选择抓牌, 从牌堆周围物品的牌中选择一张加入手牌, instant, 🔍
+burnForEnergy, 消耗获能量, 打出周围物品的牌时消耗并获得X能量, itemUntilPlay, 🔥
+attackBuffUntilPlay, 攻击增益直到打出, 周围物品的牌攻击+X直到打出, itemUntilPlay, ⚔️
+transformRandom, 随机变牌, 选择一张牌随机变为周围物品的牌, instant, 🌀
+expose, 暴露, 受到的伤害+1/每层, temporary, 👁️
@@ -1,8 +1,11 @@
+export type EffectLifecycle = 'instant' | 'temporary' | 'lingering' | 'permanent' | 'posture' | 'item' | 'itemTemporary' | 'itemUntilPlay' | 'itemUntilDiscard' | 'itemPermanent';
+
 type EffectTable = readonly {
    readonly id: string;
    readonly name: string;
    readonly description: string;
-    readonly lifecycle: "instant" | "temporary" | "lingering" | "permanent" | "posture" | "item" | "itemTemporary" | "itemUntilPlay" | "itemUntilDiscard" | "itemPermanent";
+    readonly lifecycle: EffectLifecycle;
+    readonly emoji: string;
 }[];

 export type Effect = EffectTable[number];
@@ -6,8 +6,11 @@
 # curio (8): random pickup of treasure or resources
 # enemies: array of [enemyId; initialHp; buffs[]]

+# type EncounterType = 'minion' | 'elite' | 'event' | 'shop' | 'camp' | 'curio'
+# type EnemyList = [data: @enemy; hp: int; effects: [effect: @effect; stacks: int][]][]
+
 id,type,name,description,enemies,dialogue
-string,'minion'|'elite'|'event'|'shop'|'camp'|'curio',string,string,[data: @enemy; hp: int; effects: [effect: @effect;stacks: int][]][],string
+string,EncounterType,string,string,EnemyList,string
 cactus_pair,minion,仙人掌怪,概念：防+强化。【尖刺X】：对攻击者造成X点伤害。,[仙人掌怪;12;[]];[仙人掌怪;12;[]],
 snake_pair,minion,蛇,概念：攻+强化。给玩家塞入蛇毒牌（1费：打出时移除此牌。弃掉时受到3点伤害）。,[蛇;10;[]],
 mummy_cactus,minion,木乃伊,概念：攻+防。【诅咒】：受攻击时物品【攻击】-1，直到弃掉一张该物品的牌。,[木乃伊;14;[]];[仙人掌怪;12;[]],
@@ -1,12 +1,15 @@
 import type { Enemy } from './enemy.csv';
 import type { Effect } from './effect.csv';

+export type EncounterType = 'minion' | 'elite' | 'event' | 'shop' | 'camp' | 'curio';
+export type EnemyList = [data: Enemy, hp: int, effects: [effect: Effect, stacks: int][]][];
+
 type EncounterTable = readonly {
    readonly id: string;
-    readonly type: "minion" | "elite" | "event" | "shop" | "camp" | "curio";
+    readonly type: EncounterType;
    readonly name: string;
    readonly description: string;
-    readonly enemies: [data: Enemy, hp: number, effects: [effect: Effect, stacks: number][]][];
+    readonly enemies: EnemyList;
    readonly dialogue: string;
 }[];

@@ -1,5 +1,13 @@
 import getItems, { Item } from "./item.csv";

+export type * from "./card.csv";
+export type * from "./cardEffect.csv";
+export type * from "./effect.csv";
+export type * from "./encounter.csv";
+export type * from "./enemy.csv";
+export type * from "./intent.csv";
+export type * from "./item.csv";
+
 export { default as getCards } from "./card.csv";
 export { default as getEffects } from "./effect.csv";
 export { default as getEncounters } from "./encounter.csv";
@@ -6,46 +6,50 @@
 # initBuffs: initial buffs for this intent (applied when intent becomes active)
 # effects: effects executed when this intent is active

+# type IntentEffectTarget = 'source' | 'eachEnemy' | 'randomEnemy' | 'player'
+# type IntentEffect = [IntentEffectTarget;@effect;number]
+# type IntentEffectList = IntentEffect[]
+
 id,enemy,initialIntent,nextIntents,brokenIntent,effects
-string,@enemy,boolean,@intent[],@intent[],['self'|'player'|'team';@effect;number][]
-仙人掌怪-boost,仙人掌怪,true,仙人掌怪-boost;仙人掌怪-defend,,[self;spike;1];[self;defend;4]
-仙人掌怪-defend,仙人掌怪,false,仙人掌怪-attack,,[self;defend;8]
+string,@enemy,boolean,@intent[],@intent[],IntentEffectList
+仙人掌怪-boost,仙人掌怪,true,仙人掌怪-boost;仙人掌怪-defend,,[source;spike;1];[source;defend;4]
+仙人掌怪-defend,仙人掌怪,false,仙人掌怪-attack,,[source;defend;8]
 仙人掌怪-attack,仙人掌怪,false,仙人掌怪-boost,,[player;attack;5]
 蛇-poison,蛇,true,蛇-attack;蛇-attack,,[player;venom;1];[player;attack;4]
 蛇-attack,蛇,false,蛇-poison;蛇-boost,,[player;attack;6]
-蛇-boost,蛇,false,蛇-poison;蛇-attack,,[self;defend;3];[player;venom;1]
+蛇-boost,蛇,false,蛇-poison;蛇-attack,,[source;defend;3];[player;venom;1]
 木乃伊-attack,木乃伊,true,木乃伊-defend;木乃伊-curse,,[player;attack;6]
-木乃伊-defend,木乃伊,false,木乃伊-attack,,[self;defend;6]
+木乃伊-defend,木乃伊,false,木乃伊-attack,,[source;defend;6]
 木乃伊-curse,木乃伊,false,木乃伊-defend;木乃伊-attack,木乃伊-attack,[player;curse;1]
-枪手-aim,枪手,true,枪手-attack,,[self;aim;2]
+枪手-aim,枪手,true,枪手-attack,,[source;aim;2]
 枪手-attack,枪手,false,枪手-aim;枪手-defend,枪手-aim,[player;attack;8]
-枪手-defend,枪手,false,枪手-aim,枪手-aim,[self;defend;5]
-风卷草-boost,风卷草,true,风卷草-defend;风卷草-defend;风卷草-boost,,[self;roll;5];[self;defend;4]
-风卷草-defend,风卷草,false,风卷草-boost;风卷草-attack,,[self;defend;8]
+枪手-defend,枪手,false,枪手-aim,枪手-aim,[source;defend;5]
+风卷草-boost,风卷草,true,风卷草-defend;风卷草-defend;风卷草-boost,,[source;roll;5];[source;defend;4]
+风卷草-defend,风卷草,false,风卷草-boost;风卷草-attack,,[source;defend;8]
 风卷草-attack,风卷草,false,风卷草-boost,,[player;rollDamage;0]
 秃鹫-attack,秃鹫,true,秃鹫-defend;秃鹫-defend,,[player;attack;6];[player;vultureEye;1]
-秃鹫-defend,秃鹫,false,秃鹫-attack;秃鹫-attack,,[self;defend;5]
-沙蝎-boost,沙蝎,true,沙蝎-attack;沙蝎-attack,,[self;tailSting;2]
+秃鹫-defend,秃鹫,false,秃鹫-attack;秃鹫-attack,,[source;defend;5]
+沙蝎-boost,沙蝎,true,沙蝎-attack;沙蝎-attack,,[source;tailSting;2]
 沙蝎-attack,沙蝎,false,沙蝎-boost;沙蝎-attack,,[player;attack;6]
-幼沙虫-defend,幼沙虫,true,幼沙虫-defend;幼沙虫-boost,,[self;defend;6]
-幼沙虫-boost,幼沙虫,false,幼沙虫-attack;幼沙虫-defend,,[self;energyDrain;1];[self;defend;4]
+幼沙虫-defend,幼沙虫,true,幼沙虫-defend;幼沙虫-boost,,[source;defend;6]
+幼沙虫-boost,幼沙虫,false,幼沙虫-attack;幼沙虫-defend,,[source;energyDrain;1];[source;defend;4]
 幼沙虫-attack,幼沙虫,false,幼沙虫-defend;幼沙虫-defend,,[player;attack;5]
 蜥蜴-attack,蜥蜴,true,蜥蜴-defend;蜥蜴-molt,,[player;attack;5]
-蜥蜴-defend,蜥蜴,false,蜥蜴-attack;蜥蜴-attack,,[self;defend;6]
-蜥蜴-molt,蜥蜴,false,蜥蜴-defend;蜥蜴-attack,,[self;molt;3]
+蜥蜴-defend,蜥蜴,false,蜥蜴-attack;蜥蜴-attack,,[source;defend;6]
+蜥蜴-molt,蜥蜴,false,蜥蜴-defend;蜥蜴-attack,,[source;molt;3]
 沙匪-attack,沙匪,true,沙匪-attack;沙匪-heavyAttack,,[player;attack;6]
 沙匪-heavyAttack,沙匪,false,沙匪-attack;沙匪-attack;沙匪-debuff,,[player;attack;10]
 沙匪-debuff,沙匪,false,沙匪-attack;沙匪-attack,,[player;discard;1]
-风暴之灵-storm,风暴之灵,true,风暴之灵-attack;风暴之灵-storm,,[self;storm;2];[self;defend;3]
+风暴之灵-storm,风暴之灵,true,风暴之灵-attack;风暴之灵-storm,,[source;storm;2];[source;defend;3]
 风暴之灵-attack,风暴之灵,false,风暴之灵-storm;风暴之灵-defend,,[player;attack;8];[player;static;1]
-风暴之灵-defend,风暴之灵,false,风暴之灵-storm;风暴之灵-attack,,[self;defend;8]
-骑马枪手-charge,骑马枪手,true,骑马枪手-attack,,[self;charge;2]
+风暴之灵-defend,风暴之灵,false,风暴之灵-storm;风暴之灵-attack,,[source;defend;8]
+骑马枪手-charge,骑马枪手,true,骑马枪手-attack,,[source;charge;2]
 骑马枪手-attack,骑马枪手,false,骑马枪手-charge;骑马枪手-defend,骑马枪手-charge,[player;attack;6]
-骑马枪手-defend,骑马枪手,false,骑马枪手-charge;骑马枪手-attack,骑马枪手-charge,[self;defend;5]
-沙虫王-summon,沙虫王,true,沙虫王-attack;沙虫王-defend,,[self;summonSandwormLarva;18]
+骑马枪手-defend,骑马枪手,false,骑马枪手-charge;骑马枪手-attack,骑马枪手-charge,[source;defend;5]
+沙虫王-summon,沙虫王,true,沙虫王-attack;沙虫王-defend,,[source;summonSandwormLarva;18]
 沙虫王-attack,沙虫王,false,沙虫王-summon;沙虫王-defend,,[player;attack;9]
-沙虫王-defend,沙虫王,false,沙虫王-attack;沙虫王-summon,,[self;defend;6]
-沙漠守卫-summon,沙漠守卫,true,沙漠守卫-attack;沙漠守卫-defend,,[self;summonMummy;14]
+沙虫王-defend,沙虫王,false,沙虫王-attack;沙虫王-summon,,[source;defend;6]
+沙漠守卫-summon,沙漠守卫,true,沙漠守卫-attack;沙漠守卫-defend,,[source;summonMummy;14]
 沙漠守卫-attack,沙漠守卫,false,沙漠守卫-defend;沙漠守卫-summon,,[player;attack;8]
-沙漠守卫-defend,沙漠守卫,false,沙漠守卫-attack;沙漠守卫-revive,,[self;defend;8]
-沙漠守卫-revive,沙漠守卫,false,沙漠守卫-attack;沙漠守卫-summon,,[self;reviveMummy;1]
+沙漠守卫-defend,沙漠守卫,false,沙漠守卫-attack;沙漠守卫-revive,,[source;defend;8]
+沙漠守卫-revive,沙漠守卫,false,沙漠守卫-attack;沙漠守卫-summon,,[source;reviveMummy;1]
@@ -1,13 +1,17 @@
 import type { Enemy } from './enemy.csv';
 import type { Effect } from './effect.csv';

+export type IntentEffectTarget = 'source' | 'eachEnemy' | 'randomEnemy' | 'player';
+export type IntentEffect = [IntentEffectTarget, Effect, number];
+export type IntentEffectList = IntentEffect[];
+
 type IntentTable = readonly {
    readonly id: string;
    readonly enemy: Enemy;
    readonly initialIntent: boolean;
    readonly nextIntents: Intent[];
    readonly brokenIntent: Intent[];
-    readonly effects: ["self" | "player" | "team", Effect, number][];
+    readonly effects: IntentEffectList;
 }[];

 export type Intent = IntentTable[number];
@@ -30,9 +30,9 @@ export function addCardEventTriggers(triggers: Triggers, run: IRunContext) {
      for (let i = 0; i < storm; i++) {
        await triggers.onEffectApplied.execute(ctx.game, {
          effect: findEffect("static"),
-          entityKey: "player",
+          entityId: "player",
          stacks: 1,
-          sourceEntityKey: ctx.enemyId,
+          sourceEntityId: ctx.enemyId,
        });
      }
    }
@@ -52,7 +52,7 @@ export function addCardEventTriggers(triggers: Triggers, run: IRunContext) {
        await triggers.onCardPlayed.execute(ctx.game, {
          cardId: id,
          targetId: ctx.targetId,
-          sourceEntityKey: "player",
+          sourceEntityId: "player",
        });
      }
    }
@@ -113,17 +113,17 @@ export function addCardEventTriggers(triggers: Triggers, run: IRunContext) {
    await next();

    const dealt = ctx.amount - (ctx.prevented ?? 0);
-    if (dealt <= 0 || !ctx.sourceEntityKey) return;
+    if (dealt <= 0 || !ctx.sourceEntityId) return;

-    const attacker = getCombatEntity(ctx.game.value, ctx.sourceEntityKey);
+    const attacker = getCombatEntity(ctx.game.value, ctx.sourceEntityId);
    if (!attacker || !("enemy" in attacker) || attacker.enemy.id !== "秃鹫")
      return;

    await triggers.onEffectApplied.execute(ctx.game, {
      effect: findEffect("vultureEye"),
-      entityKey: "player",
+      entityId: "player",
      stacks: 1,
-      sourceEntityKey: ctx.sourceEntityKey,
+      sourceEntityId: ctx.sourceEntityId,
    });
  });
 }
@@ -3,7 +3,6 @@ import {
  addEntityEffect,
  getCombatEntity,
 } from "@/samples/slay-the-spire-like/system/combat/effects";
-import { CombatGameContext } from "@/samples/slay-the-spire-like/system/combat/types";
 import { EffectData } from "@/samples/slay-the-spire-like/system/types";
 import getEffects from "../effect.csv";

@@ -13,23 +12,22 @@ export function addDamageTriggers(triggers: Triggers) {
  function findEffect(id: string): EffectData {
    const found = effects.find((e: EffectData) => e.id === id);
    if (found) return found;
-        return { id, name: id, description: "", lifecycle: "instant" } as EffectData;
+    return {
+      id,
+      name: id,
+      description: "",
+      lifecycle: "instant",
+    } as EffectData;
  }

  // block / damage prevention
  triggers.onDamage.use(async (ctx, next) => {
-        const entity = getCombatEntity(ctx.game.value, ctx.entityKey);
+    const entity = getCombatEntity(ctx.game.value, ctx.entityId);
    if (!entity) return;

    let preventable = ctx.amount - (ctx.prevented ?? 0);

-        const blocks = entity.effects.defend?.stacks ?? 0;
-        const blocked = Math.min(blocks, preventable);
-        if (blocked) {
-            ctx.prevented = (ctx.prevented ?? 0) + blocked;
-            preventable -= blocked;
-        }
-
+    // 1. apply damageReduce before block
    const damageReduce = entity.effects.damageReduce?.stacks ?? 0;
    if (damageReduce > 0) {
      const reduced = Math.min(damageReduce, preventable);
@@ -37,6 +35,18 @@ export function addDamageTriggers(triggers: Triggers) {
      preventable -= reduced;
    }

+    // 2. consume defend for damage prevented
+    const blocks = entity.effects.defend?.stacks ?? 0;
+    const blocked = Math.min(blocks, preventable);
+    if (blocked > 0) {
+      ctx.prevented = (ctx.prevented ?? 0) + blocked;
+      preventable -= blocked;
+      await ctx.game.produceAsync((draft) => {
+        const e = getCombatEntity(draft, ctx.entityId);
+        if (e) addEntityEffect(e, findEffect("defend"), -blocked);
+      });
+    }
+
    const expose = entity.effects.expose?.stacks ?? 0;
    if (expose > 0) {
      ctx.amount += expose;
@@ -45,35 +55,19 @@ export function addDamageTriggers(triggers: Triggers) {
    await next();
  });

-    // spike: damage attacker
-    triggers.onDamage.use(async (ctx, next) => {
-        await next();
-
-        if (ctx.amount - (ctx.prevented ?? 0) <= 0) return;
-
-        const entity = getCombatEntity(ctx.game.value, ctx.entityKey);
-        if (!entity || !entity.isAlive) return;
-
-        const spike = entity.effects.spike?.stacks ?? 0;
-        if (spike > 0 && ctx.sourceEntityKey) {
-            await triggers.onDamage.execute(ctx.game, {
-                entityKey: ctx.sourceEntityKey,
-                amount: spike,
-                sourceEntityKey: ctx.entityKey,
-            });
-        }
-    });
-
  // energyDrain: player loses energy when enemy takes damage
  triggers.onDamage.use(async (ctx, next) => {
-        const entity = getCombatEntity(ctx.game.value, ctx.entityKey);
+    const entity = getCombatEntity(ctx.game.value, ctx.entityId);
    if (!entity) return;

    const energyDrain = entity.effects.energyDrain?.stacks ?? 0;
-        if (energyDrain > 0 && ctx.entityKey !== "player") {
-            const dealt = Math.min(Math.max(0, entity.hp), ctx.amount - (ctx.prevented ?? 0));
+    if (energyDrain > 0 && ctx.entityId !== "player") {
+      const dealt = Math.min(
+        Math.max(0, entity.hp),
+        ctx.amount - (ctx.prevented ?? 0),
+      );
      if (dealt > 0) {
-                await ctx.game.produceAsync(draft => {
+        await ctx.game.produceAsync((draft) => {
          draft.player.energy = Math.max(0, draft.player.energy - energyDrain);
        });
      }
@@ -84,7 +78,7 @@ export function addDamageTriggers(triggers: Triggers) {

  // molt: enemy flees if molt >= maxHp
  triggers.onDamage.use(async (ctx, next) => {
-        const entity = getCombatEntity(ctx.game.value, ctx.entityKey);
+    const entity = getCombatEntity(ctx.game.value, ctx.entityId);
    if (!entity || !entity.isAlive) {
      await next();
      return;
@@ -92,13 +86,15 @@ export function addDamageTriggers(triggers: Triggers) {

    const molt = entity.effects.molt?.stacks ?? 0;
    if (molt >= entity.maxHp) {
-            await ctx.game.produceAsync(draft => {
-                const e = draft.enemies.find(en => en.id === ctx.entityKey);
+      await ctx.game.produceAsync((draft) => {
+        const e = draft.enemies.find((en) => en.id === ctx.entityId);
        if (e) {
          e.isAlive = false;
          e.hp = 0;
        }
-                draft.result = draft.enemies.every(en => !en.isAlive) ? "victory" : null;
+        draft.result = draft.enemies.every((en) => !en.isAlive)
+          ? "victory"
+          : null;
      });
      if (ctx.game.value.result) throw ctx.game.value;
      return;
@@ -109,7 +105,7 @@ export function addDamageTriggers(triggers: Triggers) {

  // aim: double damage, lose aim on damage
  triggers.onDamage.use(async (ctx, next) => {
-        if (ctx.sourceEntityKey === "player") {
+    if (ctx.sourceEntityId === "player") {
      const player = ctx.game.value.player;
      const aim = player.effects.aim?.stacks ?? 0;
      if (aim > 0) {
@@ -121,13 +117,13 @@ export function addDamageTriggers(triggers: Triggers) {

  // roll: consume 10 roll per 10 damage
  triggers.onDamage.use(async (ctx, next) => {
-        if (ctx.sourceEntityKey === "player") {
+    if (ctx.sourceEntityId === "player") {
      const player = ctx.game.value.player;
      const roll = player.effects.roll?.stacks ?? 0;
      if (roll >= 10) {
        const rollDamage = Math.floor(roll / 10) * 10;
        ctx.amount += rollDamage;
-                await ctx.game.produceAsync(draft => {
+        await ctx.game.produceAsync((draft) => {
          addEntityEffect(draft.player, findEffect("roll"), -rollDamage);
        });
      }
@@ -137,8 +133,8 @@ export function addDamageTriggers(triggers: Triggers) {

  // tailSting: bonus damage on attack
  triggers.onDamage.use(async (ctx, next) => {
-        if (ctx.sourceEntityKey && ctx.sourceEntityKey !== "player") {
-            const attacker = getCombatEntity(ctx.game.value, ctx.sourceEntityKey);
+    if (ctx.sourceEntityId && ctx.sourceEntityId !== "player") {
+      const attacker = getCombatEntity(ctx.game.value, ctx.sourceEntityId);
      if (attacker) {
        const tailSting = attacker.effects.tailSting?.stacks ?? 0;
        if (tailSting > 0) {
@@ -151,35 +147,41 @@ export function addDamageTriggers(triggers: Triggers) {

  // charge: double damage dealt/received, consume equal charge
  triggers.onDamage.use(async (ctx, next) => {
-        const entity = getCombatEntity(ctx.game.value, ctx.entityKey);
+    const entity = getCombatEntity(ctx.game.value, ctx.entityId);
    if (entity) {
      const charge = entity.effects.charge?.stacks ?? 0;
      if (charge > 0) {
-                const dealt = Math.min(Math.max(0, entity.hp), ctx.amount - (ctx.prevented ?? 0));
+        const dealt = Math.min(
+          Math.max(0, entity.hp),
+          ctx.amount - (ctx.prevented ?? 0),
+        );
        const consumed = Math.min(charge, dealt);
        ctx.amount += dealt;
        if (consumed > 0) {
-                    await ctx.game.produceAsync(draft => {
-                        const e = getCombatEntity(draft, ctx.entityKey);
+          await ctx.game.produceAsync((draft) => {
+            const e = getCombatEntity(draft, ctx.entityId);
            if (e) addEntityEffect(e, findEffect("charge"), -consumed);
          });
        }
      }
    }

-        if (ctx.sourceEntityKey) {
-            const attacker = getCombatEntity(ctx.game.value, ctx.sourceEntityKey);
+    if (ctx.sourceEntityId) {
+      const attacker = getCombatEntity(ctx.game.value, ctx.sourceEntityId);
      if (attacker) {
        const charge = attacker.effects.charge?.stacks ?? 0;
        if (charge > 0) {
          const baseAmount = ctx.amount;
-                    const targetEntity = getCombatEntity(ctx.game.value, ctx.entityKey);
-                    const dealt = Math.min(Math.max(0, targetEntity?.hp ?? 0), baseAmount - (ctx.prevented ?? 0));
+          const targetEntity = getCombatEntity(ctx.game.value, ctx.entityId);
+          const dealt = Math.min(
+            Math.max(0, targetEntity?.hp ?? 0),
+            baseAmount - (ctx.prevented ?? 0),
+          );
          const consumed = Math.min(charge, dealt);
          ctx.amount += dealt;
          if (consumed > 0) {
-                        await ctx.game.produceAsync(draft => {
-                            const a = getCombatEntity(draft, ctx.sourceEntityKey!);
+            await ctx.game.produceAsync((draft) => {
+              const a = getCombatEntity(draft, ctx.sourceEntityId!);
              if (a) addEntityEffect(a, findEffect("charge"), -consumed);
            });
          }
@@ -1,13 +0,0 @@
-import { IRunContext } from "@/samples/slay-the-spire-like/system/combat/types";
-import { Triggers } from "@/samples/slay-the-spire-like/system/combat/triggers";
-import { addInstantEffectTriggers } from "./instant";
-import { addDamageTriggers } from "./damage";
-import { addTurnStartTriggers } from "./turn-start";
-import { addCardEventTriggers } from "./card-events";
-
-export function addDesertTriggers(triggers: Triggers, run: IRunContext) {
-  addInstantEffectTriggers(triggers);
-  addDamageTriggers(triggers);
-  addTurnStartTriggers(triggers);
-  addCardEventTriggers(triggers, run);
-}
@@ -1 +1,15 @@
-export { addDesertTriggers as addTriggers } from './effect';
+import { addInstantEffectTriggers } from "./instant";
+import { addDamageTriggers } from "./damage";
+import { addTurnStartTriggers } from "./turn-start";
+import { addCardEventTriggers } from "./card-events";
+import {
+  IRunContext,
+  Triggers,
+} from "@/samples/slay-the-spire-like/system/combat";
+
+export function addTriggers(triggers: Triggers, run: IRunContext) {
+  addInstantEffectTriggers(triggers);
+  addDamageTriggers(triggers);
+  addTurnStartTriggers(triggers);
+  addCardEventTriggers(triggers, run);
+}
@@ -1,27 +1,24 @@
 import { Triggers } from "@/samples/slay-the-spire-like/system/combat/triggers";
-import { addEntityEffect } from "@/samples/slay-the-spire-like/system/combat/effects";
+import {
+  addEntityEffect,
+  getCombatEntity,
+} from "@/samples/slay-the-spire-like/system/combat/effects";
 import { moveToRegion } from "@/core/region";
 import { CombatGameContext } from "@/samples/slay-the-spire-like/system/combat/types";
-import { EffectData } from "@/samples/slay-the-spire-like/system/types";
 import { GameCard } from "@/samples/slay-the-spire-like/system/deck";
-import getEffects from "../effect.csv";
 import getCards from "../card.csv";

 export function addInstantEffectTriggers(triggers: Triggers) {
-    const effects = getEffects();
  const cards = getCards();

-    function findEffect(id: string): EffectData {
-        const found = effects.find((e: EffectData) => e.id === id);
-        if (found) return found;
-        return { id, name: id, description: "", lifecycle: "instant" } as EffectData;
-    }
-
  function findCard(id: string) {
-        return cards.find(c => c.id === id);
+    return cards.find((c) => c.id === id);
  }

-    function createStatusCard(draft: CombatGameContext["value"], cardId: string): void {
+  function createStatusCard(
+    draft: CombatGameContext["value"],
+    cardId: string,
+  ): void {
    const cardData = findCard(cardId);
    if (!cardData) return;

@@ -48,7 +45,7 @@ export function addInstantEffectTriggers(triggers: Triggers) {

  function getAllEnemyDataFromState(state: CombatGameContext["value"]) {
    const seen = new Set<string>();
-        const result: typeof state.enemies[number]["enemy"][] = [];
+    const result: (typeof state.enemies)[number]["enemy"][] = [];
    for (const enemy of state.enemies) {
      if (!seen.has(enemy.enemy.id)) {
        seen.add(enemy.enemy.id);
@@ -58,16 +55,24 @@ export function addInstantEffectTriggers(triggers: Triggers) {
    return result;
  }

-    function summonEnemy(draft: CombatGameContext["value"], enemyId: string, hp: number) {
+  function summonEnemy(
+    draft: CombatGameContext["value"],
+    enemyId: string,
+    hp: number,
+  ) {
    for (const enemyData of getAllEnemyDataFromState(draft)) {
      if (enemyData.id === enemyId) {
-                const existing = draft.enemies.find(e => e.enemy.id === enemyId && !e.isAlive);
+        const existing = draft.enemies.find(
+          (e) => e.enemy.id === enemyId && !e.isAlive,
+        );
        if (existing) {
          existing.isAlive = true;
          existing.hp = existing.maxHp;
          return;
        }
-                const intent = enemyData.intents.find(i => i.initialIntent) ?? enemyData.intents[0];
+        const intent =
+          enemyData.intents.find((i) => i.initialIntent) ??
+          enemyData.intents[0];
        const instanceId = `${enemyData.id}-${draft.enemies.length}`;
        const intents: Record<string, typeof intent> = {};
        for (const i of enemyData.intents) {
@@ -91,18 +96,28 @@ export function addInstantEffectTriggers(triggers: Triggers) {
  triggers.onEffectApplied.use(async (ctx, next) => {
    if (ctx.effect.id === "attack") {
      await triggers.onDamage.execute(ctx.game, {
-                entityKey: ctx.entityKey,
+        entityId: ctx.entityId,
        amount: ctx.stacks,
-                sourceEntityKey: ctx.sourceEntityKey ?? ctx.entityKey === "player" ? undefined : "player",
+        sourceEntityId: ctx.sourceEntityId,
      });
+
+      const entity = getCombatEntity(ctx.game.value, ctx.entityId);
+      const spike = entity?.effects.spike?.stacks ?? 0;
+      if (spike > 0 && ctx.sourceEntityId) {
+        await triggers.onDamage.execute(ctx.game, {
+          entityId: ctx.sourceEntityId,
+          amount: spike,
+          sourceEntityId: ctx.entityId,
+        });
+      }
    } else if (ctx.effect.id === "draw") {
      await triggers.onDraw.execute(ctx.game, { count: ctx.stacks });
    } else if (ctx.effect.id === "gainEnergy") {
-            await ctx.game.produceAsync(draft => {
+      await ctx.game.produceAsync((draft) => {
        draft.player.energy += ctx.stacks;
      });
    } else if (ctx.effect.id === "removeWound") {
-            await ctx.game.produceAsync(draft => {
+      await ctx.game.produceAsync((draft) => {
        const { cards, regions } = draft.player.deck;
        let removed = 0;
        const allPileIds = [
@@ -113,7 +128,10 @@ export function addInstantEffectTriggers(triggers: Triggers) {
          if (removed >= ctx.stacks) break;
          const card = cards[cardId];
          if (card && card.cardData.id === "wound") {
-                        const sourceRegion = card.regionId === "drawPile" ? regions.drawPile : regions.discardPile;
+            const sourceRegion =
+              card.regionId === "drawPile"
+                ? regions.drawPile
+                : regions.discardPile;
            moveToRegion(card, sourceRegion, null);
            delete cards[cardId];
            removed++;
@@ -121,35 +139,37 @@ export function addInstantEffectTriggers(triggers: Triggers) {
        }
      });
    } else if (ctx.effect.id === "venom") {
-            await ctx.game.produceAsync(draft => {
+      await ctx.game.produceAsync((draft) => {
        createStatusCard(draft, "venom");
      });
    } else if (ctx.effect.id === "vultureEye") {
-            await ctx.game.produceAsync(draft => {
+      await ctx.game.produceAsync((draft) => {
        createStatusCard(draft, "vultureEye");
      });
    } else if (ctx.effect.id === "static") {
-            await ctx.game.produceAsync(draft => {
+      await ctx.game.produceAsync((draft) => {
        createStatusCard(draft, "static");
      });
    } else if (ctx.effect.id === "summonMummy") {
-            await ctx.game.produceAsync(draft => {
+      await ctx.game.produceAsync((draft) => {
        summonEnemy(draft, "木乃伊", ctx.stacks);
      });
    } else if (ctx.effect.id === "summonSandwormLarva") {
-            await ctx.game.produceAsync(draft => {
+      await ctx.game.produceAsync((draft) => {
        summonEnemy(draft, "幼沙虫", ctx.stacks);
      });
    } else if (ctx.effect.id === "reviveMummy") {
-            await ctx.game.produceAsync(draft => {
-                const deadMummy = draft.enemies.find(e => e.enemy.id === "木乃伊" && !e.isAlive);
+      await ctx.game.produceAsync((draft) => {
+        const deadMummy = draft.enemies.find(
+          (e) => e.enemy.id === "木乃伊" && !e.isAlive,
+        );
        if (deadMummy) {
          deadMummy.isAlive = true;
          deadMummy.hp = deadMummy.maxHp;
        }
      });
    } else if (ctx.effect.id === "curse") {
-            await ctx.game.produceAsync(draft => {
+      await ctx.game.produceAsync((draft) => {
        addEntityEffect(draft.player, ctx.effect, ctx.stacks);
      });
    }
@@ -7,14 +7,19 @@ export function addTurnStartTriggers(triggers: Triggers) {
  const effects = getEffects();

  function findEffect(id: string): EffectData {
-        const found = effects.find(e => e.id === id);
+    const found = effects.find((e) => e.id === id);
    if (found) return found;
-        return { id, name: id, description: "", lifecycle: "instant" } as EffectData;
+    return {
+      id,
+      name: id,
+      description: "",
+      lifecycle: "instant",
+    } as EffectData;
  }

  // discard: random discard at turn start
  triggers.onTurnStart.use(async (ctx, next) => {
-        if (ctx.entityKey !== "player") {
+    if (ctx.entityId !== "player") {
      await next();
      return;
    }
@@ -25,7 +30,9 @@ export function addTurnStartTriggers(triggers: Triggers) {
      if (handIds.length > 0) {
        const randomIndex = ctx.game.rng.nextInt(handIds.length);
        const randomCardId = handIds[randomIndex];
-                await triggers.onCardDiscarded.execute(ctx.game, { cardId: randomCardId });
+        await triggers.onCardDiscarded.execute(ctx.game, {
+          cardId: randomCardId,
+        });
      }
    }

@@ -33,33 +40,30 @@ export function addTurnStartTriggers(triggers: Triggers) {
  });

  // defendNext: gain block next turn
+  // record how many defendNext there is, before buff update
+  // then apply after buff update
  triggers.onTurnStart.use(async (ctx, next) => {
-        if (ctx.entityKey !== "player") {
+    const defendNext = ctx.game.value.player.effects.defendNext;
+    if (!defendNext || defendNext.stacks <= 0) {
      await next();
      return;
    }
-
-        const defendNext = ctx.game.value.player.effects.defendNext;
-        if (defendNext && defendNext.stacks > 0) {
-            await ctx.game.produceAsync(draft => {
-                addEntityEffect(draft.player, findEffect("defend"), defendNext.stacks);
-                addEntityEffect(draft.player, defendNext.data, -defendNext.stacks);
-            });
-        }
-
    await next();
+    await ctx.game.produceAsync((draft) => {
+      addEntityEffect(draft.player, findEffect("defend"), defendNext.stacks);
+    });
  });

  // energyNext: gain energy next turn
  triggers.onTurnStart.use(async (ctx, next) => {
-        if (ctx.entityKey !== "player") {
+    if (ctx.entityId !== "player") {
      await next();
      return;
    }

    const energyNext = ctx.game.value.player.effects.energyNext;
    if (energyNext && energyNext.stacks > 0) {
-            await ctx.game.produceAsync(draft => {
+      await ctx.game.produceAsync((draft) => {
        draft.player.energy += energyNext.stacks;
        addEntityEffect(draft.player, energyNext.data, -energyNext.stacks);
      });
@@ -70,14 +74,14 @@ export function addTurnStartTriggers(triggers: Triggers) {

  // drawNext: draw extra cards next turn
  triggers.onTurnStart.use(async (ctx, next) => {
-        if (ctx.entityKey !== "player") {
+    if (ctx.entityId !== "player") {
      await next();
      return;
    }

    const drawNext = ctx.game.value.player.effects.drawNext;
    if (drawNext && drawNext.stacks > 0) {
-            await ctx.game.produceAsync(draft => {
+      await ctx.game.produceAsync((draft) => {
        addEntityEffect(draft.player, drawNext.data, -drawNext.stacks);
      });
      await triggers.onDraw.execute(ctx.game, { count: drawNext.stacks });
@@ -1,23 +1,18 @@
 import { LoadResult as YarnDialogues } from "yarn-spinner-loader";
-import {
-  CardData,
-  EffectData,
-  EncounterData,
-  EnemyData,
-  IntentData,
-  ItemData,
-} from "../system/types";
 import { Triggers } from "../system/combat/triggers";

-export type ContentModule = {
-  getCards: () => CardData[];
-  getEffects: () => EffectData[];
-  getEncounters: () => EncounterData[];
-  getEnemies: () => EnemyData[];
-  getIntents: () => IntentData[];
-  getItems: () => ItemData[];
-  getStartingItems: () => ItemData[];
+import type * as desert from "./desert";
+import { IRunContext } from "../system/combat";

-  dialogues: YarnDialogues;
-  addTriggers: (triggers: Triggers) => void;
+export type ContentModule = {
+  readonly getCards: () => readonly desert.Card[];
+  readonly getEffects: () => readonly desert.Effect[];
+  readonly getEncounters: () => readonly desert.Encounter[];
+  readonly getEnemies: () => readonly desert.Enemy[];
+  readonly getIntents: () => readonly desert.Intent[];
+  readonly getItems: () => readonly desert.Item[];
+  readonly getStartingItems: () => readonly desert.Item[];
+
+  readonly dialogues: YarnDialogues;
+  readonly addTriggers: (triggers: Triggers, run: IRunContext) => void;
 };
@@ -9,9 +9,8 @@ import {
 import {
  CardData,
  CardEffectTarget,
-  CardTargetType,
  EffectData,
-  EffectTarget,
+  IntentEffectTarget,
 } from "@/samples/slay-the-spire-like/system/types";

 export function addEffect(
@@ -104,25 +103,25 @@ export function* getAliveEnemies(state: CombatState) {
 }

 export function* getEffectTargets(
-  target: CardEffectTarget | EffectTarget,
+  target: CardEffectTarget | IntentEffectTarget,
  game: CombatGameContext,
  targetId?: string,
  sourceEntityKey: "player" | string = "player",
 ) {
-  if (target === "all" || target === "team") {
+  if (target === "eachEnemy") {
    for (const enemy of getAliveEnemies(game.value)) {
      yield enemy;
    }
-  } else if (target === "self") {
+  } else if (target === "source") {
    const entity = getCombatEntity(game.value, sourceEntityKey);
    if (entity) yield entity;
  } else if (target === "player") {
    yield game.value.player;
-  } else if (target === "target") {
+  } else if (target === "eachTarget") {
    if (!targetId) return;
    const entity = getCombatEntity(game.value, targetId);
    if (entity) yield entity;
-  } else if (target === "random") {
+  } else if (target === "randomEnemy") {
    const aliveEnemies = [...getAliveEnemies(game.value)];
    if (aliveEnemies.length === 0) return;
    const index = game.rng.nextInt(aliveEnemies.length);
@@ -38,12 +38,12 @@ export async function promptMainAction(
    }

    const { targetType } = cardData;
-    if (targetType === "single") {
+    if (targetType === "enemy") {
      if (!targetId) throw `请指定目标`;
      const target = game.value.enemies.find((e) => e.id === targetId);
      if (!target) throw `目标"${targetId}"不存在`;
      if (!target.isAlive) throw `目标"${targetId}"已死亡`;
-    } else if (targetType === "none") {
+    } else if (targetType === "enemies" || targetType === "player") {
      if (targetId) throw `目标"${targetId}"无效`;
    }

@@ -19,48 +19,51 @@ import { EffectData } from "@/samples/slay-the-spire-like/system/types";

 type TriggerTypes = {
  onCombatStart: {};
-  onTurnStart: { entityKey: "player" | string };
-  onTurnEnd: { entityKey: "player" | string };
+  onTurnStart: { entityId: "player" | string };
+  onTurnEnd: { entityId: "player" | string };
  onShuffle: {};
  onCardPlayed: {
    cardId: string;
    targetId?: string;
-    sourceEntityKey?: "player" | string;
+    sourceEntityId?: "player" | string;
  };
-  onCardDiscarded: { cardId: string; sourceEntityKey?: "player" | string };
-  onCardDrawn: { cardId: string; sourceEntityKey?: "player" | string };
+  onCardDiscarded: { cardId: string; sourceEntityId?: "player" | string };
+  onCardDrawn: { cardId: string; sourceEntityId?: "player" | string };
  onDraw: { count: number };
  onEffectApplied: {
    effect: EffectData;
-    entityKey: "player" | string;
+    entityId: "player" | string;
    stacks: number;
    cardId?: string;
-    sourceEntityKey?: "player" | string;
+    sourceEntityId?: "player" | string;
    targetId?: string;
  };
-  onHpChange: { entityKey: "player" | string; amount: number };
+  onHpChange: { entityId: "player" | string; amount: number };
  onDamage: {
-    entityKey: "player" | string;
+    entityId: "player" | string;
    amount: number;
    prevented?: number;
-    sourceEntityKey?: "player" | string;
+    sourceEntityId?: "player" | string;
  };
-  onEnemyIntent: { enemyId: string; sourceEntityKey?: "player" | string };
+  onEnemyIntent: { enemyId: string; sourceEntityId?: "player" | string };
  onIntentUpdate: { enemyId: string };
 };

 export function createTriggers(run: IRunContext) {
  const triggers = {
-    onCombatStart: createTrigger("onCombatStart"),
+    onCombatStart: createTrigger("onCombatStart", async (ctx) => {
+      await triggers.onShuffle.execute(ctx.game, {});
+      await triggers.onDraw.execute(ctx.game, { count: 5 });
+    }),
    onTurnStart: createTrigger("onTurnStart", async (ctx) => {
      await ctx.game.produceAsync((draft) => {
-        const entity = getCombatEntity(draft, ctx.entityKey);
+        const entity = getCombatEntity(draft, ctx.entityId);
        if (entity) onEntityEffectUpkeep(entity);
        if (entity === draft.player) onPlayerItemEffectUpkeep(draft.player);
      });
    }),
    onTurnEnd: createTrigger("onTurnEnd", async (ctx) => {
-      if (ctx.entityKey !== "player") return;
+      if (ctx.entityId !== "player") return;
      const { regions } = ctx.game.value.player.deck;
      for (const cardId of Object.values(regions.hand.childIds)) {
        await triggers.onCardDiscarded.execute(ctx.game, { cardId });
@@ -94,7 +97,7 @@ export function createTriggers(run: IRunContext) {
      });
      const { cards, regions } = ctx.game.value.player.deck;
      const card = cards[ctx.cardId];
-      const source = ctx.sourceEntityKey ?? "player";
+      const source = ctx.sourceEntityId ?? "player";
      for (const { trigger, target, effects } of card.cardData.effects) {
        if (trigger !== "onPlay") continue;
        for (const [effect, stacks] of effects)
@@ -106,10 +109,10 @@ export function createTriggers(run: IRunContext) {
          ))
            await triggers.onEffectApplied.execute(ctx.game, {
              effect,
-              entityKey: entity.id,
+              entityId: entity.id,
              stacks,
              cardId: ctx.cardId,
-              sourceEntityKey: source,
+              sourceEntityId: source,
              targetId: ctx.targetId,
            });
      }
@@ -122,7 +125,7 @@ export function createTriggers(run: IRunContext) {
      });
      const { cards, regions } = ctx.game.value.player.deck;
      const card = cards[ctx.cardId];
-      const source = ctx.sourceEntityKey ?? "player";
+      const source = ctx.sourceEntityId ?? "player";
      for (const { trigger, target, effects } of card.cardData.effects) {
        if (trigger !== "onDiscard") continue;
        for (const [effect, stacks] of effects)
@@ -134,10 +137,10 @@ export function createTriggers(run: IRunContext) {
          ))
            await triggers.onEffectApplied.execute(ctx.game, {
              effect,
-              entityKey: entity.id,
+              entityId: entity.id,
              stacks,
              cardId: ctx.cardId,
-              sourceEntityKey: source,
+              sourceEntityId: source,
            });
      }
    }),
@@ -148,7 +151,7 @@ export function createTriggers(run: IRunContext) {
      });
      const { cards, regions } = ctx.game.value.player.deck;
      const card = cards[ctx.cardId];
-      const source = ctx.sourceEntityKey ?? "player";
+      const source = ctx.sourceEntityId ?? "player";
      for (const { trigger, target, effects } of card.cardData.effects) {
        if (trigger !== "onDraw") continue;
        for (const [effect, stacks] of effects)
@@ -160,10 +163,10 @@ export function createTriggers(run: IRunContext) {
          ))
            await triggers.onEffectApplied.execute(ctx.game, {
              effect,
-              entityKey: entity.id,
+              entityId: entity.id,
              stacks,
              cardId: ctx.cardId,
-              sourceEntityKey: source,
+              sourceEntityId: source,
            });
      }
    }),
@@ -201,18 +204,18 @@ export function createTriggers(run: IRunContext) {

      await ctx.game.produceAsync((draft) => {
        const entity =
-          ctx.entityKey === "player"
+          ctx.entityId === "player"
            ? draft.player
-            : draft.enemies.find((e) => e.id === ctx.entityKey);
+            : draft.enemies.find((e) => e.id === ctx.entityId);
        if (entity) addEntityEffect(entity, ctx.effect, ctx.stacks);
      });
    }),
    onHpChange: createTrigger("onHpChange", async (ctx) => {
      await ctx.game.produceAsync((draft) => {
        const entity =
-          ctx.entityKey === "player"
+          ctx.entityId === "player"
            ? draft.player
-            : draft.enemies.find((e) => e.id === ctx.entityKey);
+            : draft.enemies.find((e) => e.id === ctx.entityId);
        if (!entity) return;
        entity.hp += ctx.amount;
        entity.isAlive = entity.hp > 0;
@@ -226,9 +229,9 @@ export function createTriggers(run: IRunContext) {
    }),
    onDamage: createTrigger("onDamage", async (ctx) => {
      const entity =
-        ctx.entityKey === "player"
+        ctx.entityId === "player"
          ? ctx.game.value.player
-          : ctx.game.value.enemies.find((e) => e.id === ctx.entityKey);
+          : ctx.game.value.enemies.find((e) => e.id === ctx.entityId);
      if (!entity || !entity.isAlive) return;
      const dealt = Math.min(
        Math.max(0, entity.hp),
@@ -238,7 +241,7 @@ export function createTriggers(run: IRunContext) {
        onEntityPostureDamage(entity, dealt);
      });
      await triggers.onHpChange.execute(ctx.game, {
-        entityKey: ctx.entityKey,
+        entityId: ctx.entityId,
        amount: -dealt,
      });
    }),
@@ -249,7 +252,7 @@ export function createTriggers(run: IRunContext) {
      const intent = enemy.currentIntent;
      if (!intent) return;

-      const source = ctx.sourceEntityKey ?? enemy.id;
+      const source = ctx.sourceEntityId ?? enemy.id;
      for (const [target, effect, stacks] of intent.effects) {
        for (const entity of getEffectTargets(
          target,
@@ -259,9 +262,9 @@ export function createTriggers(run: IRunContext) {
        ))
          await triggers.onEffectApplied.execute(ctx.game, {
            effect,
-            entityKey: entity.id,
+            entityId: entity.id,
            stacks,
-            sourceEntityKey: source,
+            sourceEntityId: source,
          });
      }
    }),
@@ -284,18 +287,13 @@ export function createTriggers(run: IRunContext) {
  return triggers;
 }
 export type Triggers = ReturnType<typeof createTriggers>;
-export function createStartWith(
-  build: (triggers: Triggers, run: IRunContext) => void,
-  run: IRunContext,
-) {
-  const triggers = createTriggers(run);
-  build(triggers, run);
+export function createStart(triggers: Triggers, run: IRunContext) {
  return async function (game: CombatGameContext) {
    await triggers.onCombatStart.execute(game, {});

    try {
      while (true) {
-        await triggers.onTurnStart.execute(game, { entityKey: "player" });
+        await triggers.onTurnStart.execute(game, { entityId: "player" });
        while (true) {
          const action = await promptMainAction(game, run);
          if (action.action === "end-turn") break;
@@ -303,17 +301,17 @@ export function createStartWith(
            await triggers.onCardPlayed.execute(game, action);
          }
        }
-        await triggers.onTurnEnd.execute(game, { entityKey: "player" });
+        await triggers.onTurnEnd.execute(game, { entityId: "player" });

        for (const enemy of getAliveEnemies(game.value)) {
-          await triggers.onTurnStart.execute(game, { entityKey: enemy.id });
+          await triggers.onTurnStart.execute(game, { entityId: enemy.id });
        }
        for (const enemy of getAliveEnemies(game.value)) {
          await triggers.onEnemyIntent.execute(game, { enemyId: enemy.id });
          await triggers.onIntentUpdate.execute(game, { enemyId: enemy.id });
        }
        for (const enemy of getAliveEnemies(game.value)) {
-          await triggers.onTurnEnd.execute(game, { entityKey: enemy.id });
+          await triggers.onTurnEnd.execute(game, { entityId: enemy.id });
        }
      }
    } catch (e) {
@@ -1,89 +1,25 @@
-export type EffectData = {
-  readonly id: string;
-  readonly name: string;
-  readonly description: string;
-  readonly lifecycle: EffectLifecycle;
-};
-export type EffectLifecycle =
-  | "instant"
-  | "temporary"
-  | "lingering"
-  | "permanent"
-  | "posture"
-  | "item"
-  | "itemTemporary"
-  | "itemUntilPlay"
-  | "itemUntilDiscard"
-  | "itemPermanent";
+import {
+  Card,
+  Effect,
+  Encounter,
+  EncounterType,
+  Enemy,
+  Intent,
+  Item,
+} from "../data/desert";

-export type EnemyData = {
-  readonly id: string;
-  readonly name: string;
-  readonly intents: readonly IntentData[];
-  readonly description: string;
-};
+export type CardData = Card;
+export type ItemData = Item;
+export type EffectData = Effect;
+export type IntentData = Intent;
+export type EnemyData = Enemy;
+export type EncounterData<T extends EncounterType = EncounterType> =
+  Encounter & { type: T };

-export type CardType = "item" | "status";
-export type CardCostType = "energy" | "uses" | "none";
-export type CardTargetType = "single" | "none";
-export type EffectTarget = "self" | "player" | "team";
+export {
+  CardTargetType,
+  CardEffectTarget,
+  IntentEffectTarget,
+} from "../data/desert";

-export type CardEffectTrigger = "onPlay" | "onDraw" | "onDiscard";
-export type CardEffectTarget = "self" | "target" | "all" | "random";
-
-export type CardEffect = {
-  readonly id: string;
-  readonly trigger: CardEffectTrigger;
-  readonly target: CardEffectTarget;
-  readonly effects: readonly [EffectData, number][];
-};
-
-export type CardData = {
-  readonly id: string;
-  readonly name: string;
-  readonly desc: string;
-  readonly type: CardType;
-  readonly costType: CardCostType;
-  readonly costCount: number;
-  readonly targetType: CardTargetType;
-  readonly effects: readonly CardEffect[];
-};
-
-export type EncounterType =
-  | "minion"
-  | "elite"
-  | "event"
-  | "shop"
-  | "camp"
-  | "curio";
-export type EncounterData<T extends EncounterType = EncounterType> = {
-  readonly id: string;
-  readonly type: T;
-  readonly name: string;
-  readonly description: string;
-  readonly enemies: readonly [
-    data: EnemyData,
-    hp: number,
-    effects: [EffectData, stacks: number][],
-  ][];
-  readonly dialogue: string;
-};
-
-export type IntentData = {
-  readonly id: string;
-  readonly enemy: EnemyData;
-  readonly initialIntent: boolean;
-  readonly nextIntents: readonly IntentData[];
-  readonly brokenIntent: readonly IntentData[];
-  readonly effects: readonly [EffectTarget, EffectData, number][];
-};
-
-export type ItemData = {
-  readonly id: string;
-  readonly type: string;
-  readonly name: string;
-  readonly shape: string;
-  readonly card: CardData;
-  readonly price: number;
-  readonly description: string;
-};
+export { ContentModule } from "../data";
@@ -1,10 +1,8 @@
 import { Part } from "@/core/part";
-import { createRegion } from "@/core/region";
-import {
-  createGameCommandRegistry,
-  createPromptDef,
-  IGameContext,
-} from "@/core/game";
+import { createRegion, Region } from "@/core/region";
+import { createPromptDef, IGameContext } from "@/core/game";
+import { BaseGameClient } from "@/core/game-client";
+import { createMiddlewareChain } from "@/utils/middleware";

 const BOARD_SIZE = 3;
 const MAX_TURNS = BOARD_SIZE * BOARD_SIZE;
@@ -69,7 +67,6 @@ export function createInitialState() {
 }
 export type TicTacToeState = ReturnType<typeof createInitialState>;
 export type TicTacToeGame = IGameContext<TicTacToeState>;
-export const registry = createGameCommandRegistry<TicTacToeState>();
 export const prompts = {
  play: createPromptDef<[PlayerType, number, number]>(
    "play <player> <row:number> <col:number>",
@@ -82,7 +79,7 @@ export async function start(game: TicTacToeGame) {
    const turnNumber = game.value.turn + 1;
    const turnOutput = await turn(game, currentPlayer, turnNumber);

-    game.produce((state) => {
+    await game.produceAsync((state) => {
      state.winner = turnOutput.winner;
      if (!state.winner) {
        state.currentPlayer = state.currentPlayer === "X" ? "O" : "X";
@@ -95,9 +92,11 @@ export async function start(game: TicTacToeGame) {
  return game.value;
 }

-const turn = registry.register({
-  schema: "turn <player> <turnNumber:number>",
-  async run(game: TicTacToeGame, turnPlayer: PlayerType, turnNumber: number) {
+async function turn(
+  game: TicTacToeGame,
+  turnPlayer: PlayerType,
+  turnNumber: number,
+) {
  const { player, row, col } = await game.prompt(
    prompts.play,
    (player, row, col) => {
@@ -114,15 +113,14 @@ const turn = registry.register({
    game.value.currentPlayer,
  );

-    placePiece(game, row, col, turnPlayer);
+  await placePiece(game, row, col, turnPlayer);

  const winner = checkWinner(game);
  if (winner) return { winner };
  if (turnNumber >= MAX_TURNS) return { winner: "draw" as WinnerType };

  return { winner: null };
-  },
-});
+}

 function isValidMove(row: number, col: number): boolean {
  return (
@@ -167,7 +165,7 @@ export function checkWinner(host: TicTacToeGame): WinnerType {
  return null;
 }

-export function placePiece(
+export async function placePiece(
  host: TicTacToeGame,
  row: number,
  col: number,
@@ -181,9 +179,52 @@ export function placePiece(
    player,
    id: `piece-${player}-${moveNumber}`,
  };
-  host.produce((state) => {
+  await host.produceAsync((state) => {
    state.parts[piece.id] = piece;
    board.childIds.push(piece.id);
    board.partMap[`${row},${col}`] = piece.id;
  });
 }
+
+export class Client extends BaseGameClient<TicTacToeState> {
+  private onTurn = createMiddlewareChain(
+    async (ctx: { player: PlayerType; turn: number }) => {
+      return await turn(this._context, ctx.player, ctx.turn);
+    },
+  );
+
+  constructor() {
+    super(createInitialState());
+  }
+
+  async start(game: IGameContext<TicTacToeState>): Promise<TicTacToeState> {
+    while (true) {
+      const currentPlayer = game.value.currentPlayer;
+      const turnNumber = game.value.turn + 1;
+      const turnOutput = await this.onTurn.execute({
+        player: currentPlayer,
+        turn: turnNumber,
+      });
+
+      await game.produceAsync((state) => {
+        state.winner = turnOutput.winner;
+        if (!state.winner) {
+          state.currentPlayer = state.currentPlayer === "X" ? "O" : "X";
+          state.turn = turnNumber;
+        }
+      });
+      if (game.value.winner) break;
+    }
+
+    return game.value;
+  }
+  selectPart(id: string, callback: (t: TicTacToePart) => void): () => void {
+    return this.assignSelector((state) => state.parts[id], callback);
+  }
+  selectTurn(callback: (turns: number) => void): () => void {
+    return this.assignSelector((s) => s.turn, callback);
+  }
+  selectCurrentPlayer(callback: (player: PlayerType) => void) {
+    return this.assignSelector((s) => s.currentPlayer, callback);
+  }
+}
@@ -0,0 +1,105 @@
+import { createMiddlewareChain } from "../middleware";
+import { PromptValidator } from "./command-runner";
+import { CommandSchema } from "./types";
+
+export interface PromptDef<TArgs extends any[]> {
+  schema: CommandSchema;
+  hintText?: string;
+}
+
+export interface PromptCall<TArgs extends any[] = unknown[], TRes = unknown> {
+  def: PromptDef<TArgs>;
+  player?: string;
+  validator: PromptValidator<TRes, TArgs>;
+
+  resolve(res: TRes): void;
+  reject(reason: string): void;
+  promise: Promise<TRes>;
+}
+
+export type PromptTryResult =
+  | {
+      ok: false;
+      reason: string;
+    }
+  | {
+      ok: true;
+    };
+
+export type PromptContext = ReturnType<typeof createPromptContext>;
+export function createPromptContext() {
+  const map = new Map<string, PromptCall>();
+  const handleCall = createMiddlewareChain(async (call: PromptCall) => {
+    const key = call.player ?? "global";
+    const existing = map.get(key);
+    if (existing) {
+      existing.reject("Prompt overriden");
+    }
+
+    map.set(key, call);
+    try {
+      return await call.promise;
+    } finally {
+      if (map.get(key) === call) map.delete(key);
+    }
+  });
+
+  function tryCommit<TArgs extends any[]>(
+    def: PromptDef<TArgs>,
+    player: string,
+    ...args: TArgs
+  ): PromptTryResult {
+    const call = map.get(player);
+    if (!call) return { ok: false, reason: "No Prompt" };
+
+    try {
+      const res = call.validator(...args);
+      call.resolve(res);
+      return { ok: true };
+    } catch (reason) {
+      if (typeof reason === "string") return { ok: false, reason };
+      throw reason;
+    }
+  }
+
+  function cancel(player: string, reason = "Prompt Cancelled") {
+    map.get(player)?.reject(reason);
+  }
+
+  async function prompt<TArgs extends any[], TRes>(
+    def: PromptDef<TArgs>,
+    validator: PromptValidator<TRes, TArgs>,
+    player?: string,
+  ) {
+    let resolve: (res: TRes) => void;
+    let reject: (reason: string) => void;
+    const promise = new Promise<TRes>((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    const call = {
+      def,
+      player,
+      validator,
+      resolve: resolve!,
+      reject: reject!,
+      promise,
+    } as PromptCall<unknown[], unknown>;
+    return (await handleCall.execute(call)) as TRes;
+  }
+
+  function reset() {
+    for (const call of map.values()) {
+      call.reject("Prompt Reset");
+    }
+    map.clear();
+  }
+
+  return {
+    prompt,
+    tryCommit,
+    cancel,
+    handleCall,
+    reset,
+  };
+}
@@ -1,6 +1,10 @@
-export { parseCommand } from './command-parse';
-export { parseCommandSchema } from './schema-parse';
-export { validateCommand, parseCommandWithSchema, applyCommandSchema } from './command-validate';
+export { parseCommand } from "./command-parse";
+export { parseCommandSchema } from "./schema-parse";
+export {
+  validateCommand,
+  parseCommandWithSchema,
+  applyCommandSchema,
+} from "./command-validate";
 export {
  createCommandRegistry,
  registerCommand,
@@ -10,13 +14,28 @@ export {
  runCommand,
  runCommandParsed,
  createCommandRunnerContext,
-} from './command-registry';
+} from "./command-registry";
 export type {
  Command,
  CommandParamSchema,
  CommandOptionSchema,
  CommandFlagSchema,
  CommandSchema,
-} from './types';
-export type { CommandRunner, CommandDef, CommandResult, CommandRunnerHandler, CommandRunnerContext, PromptEvent, CommandRunnerEvents } from './command-runner';
-export type { CommandRegistry, CommandRunnerContextExport } from './command-registry';
+} from "./types";
+export type {
+  CommandRunner,
+  CommandDef,
+  CommandResult,
+  CommandRunnerHandler,
+  CommandRunnerContext,
+  PromptEvent,
+  CommandRunnerEvents,
+} from "./command-runner";
+export type {
+  CommandRegistry,
+  CommandRunnerContextExport,
+} from "./command-registry";
+
+export type { PromptDef, PromptTryResult, PromptCall } from "./command-prompt";
+
+export { createPromptContext } from "./command-prompt";
@@ -1,28 +1,38 @@
 type Middleware<TContext, TReturn> = (
  context: TContext,
-  next: () => Promise<TReturn>
+  next: () => Promise<TReturn>,
 ) => Promise<TReturn>;

 export type MiddlewareChain<TContext, TReturn> = {
-  use: (middleware: Middleware<TContext, TReturn>) => void;
+  use: (middleware: Middleware<TContext, TReturn>) => () => void;
  execute: (context: TContext) => Promise<TReturn>;
 };

-export function createMiddlewareChain<TContext extends object, TReturn=TContext>(
-  fallback?: (context: TContext) => Promise<TReturn>
+export function createMiddlewareChain<
+  TContext extends object,
+  TReturn = TContext,
+>(
+  fallback?: (context: TContext) => Promise<TReturn>,
 ): MiddlewareChain<TContext, TReturn> {
  const middlewares: Middleware<TContext, TReturn>[] = [];

  return {
    use(middleware: Middleware<TContext, TReturn>) {
      middlewares.push(middleware);
+
+      return function () {
+        const index = middlewares.indexOf(middleware);
+        if (index !== -1) {
+          middlewares.splice(index, 1);
+        }
+      };
    },
    async execute(context: TContext) {
      let index = 0;

      async function dispatch(ctx: TContext): Promise<TReturn> {
        if (index >= middlewares.length) {
-          return fallback ? fallback(ctx) : ctx as unknown as TReturn;
+          return fallback ? fallback(ctx) : (ctx as unknown as TReturn);
        }
        const current = middlewares[index++];
        return current(ctx, () => dispatch(ctx));
@@ -1,7 +1,14 @@
 import { Signal, SignalOptions } from "@preact/signals-core";
 import { create } from "mutative";

-export class MutableSignal<T> extends Signal<T> {
+export interface MutableSignal<T> extends Signal<T> {
+  produce(fn: (draft: T) => undefined): void;
+  addInterruption(promise: Promise<void>): void;
+  clearInterruptions(): void;
+  produceAsync(fn: (draft: T) => undefined): Promise<void>;
+}
+
+class MutableSignalImpl<T> extends Signal<T> {
  private _interruptions: Promise<void>[] = [];

  public constructor(t?: T, options?: SignalOptions<T>) {
@@ -41,5 +48,5 @@ export function mutableSignal<T>(
  initial?: T,
  options?: SignalOptions<T>,
 ): MutableSignal<T> {
-  return new MutableSignal<T>(initial, options);
+  return new MutableSignalImpl<T>(initial, options);
 }
@@ -0,0 +1,39 @@
+import { effect } from "@preact/signals-core";
+
+export type SpawnerFunction = (id: string) => () => void;
+
+export function createSpawner(spawner: SpawnerFunction) {
+  const entries = new Map<string, () => void>();
+
+  function update(set: Set<string>) {
+    for (const key of set) {
+      if (!entries.has(key)) {
+        entries.set(key, spawner(key));
+      }
+    }
+
+    for (const [key, entry] of entries) {
+      if (!set.has(key)) {
+        entry();
+        entries.delete(key);
+      }
+    }
+  }
+
+  return update;
+}
+
+export function spawnerEffect(
+  iterable: () => Iterable<string>,
+  spawner: SpawnerFunction,
+) {
+  const update = createSpawner(spawner);
+
+  return effect(() => {
+    const set = new Set<string>();
+    for (const each of iterable()) {
+      set.add(each);
+    }
+    update(set);
+  });
+}
@@ -33,6 +33,7 @@ import type {
 import type { GameItemMeta } from "@/samples/slay-the-spire-like/system/grid-inventory/types";
 import type { ParsedShape } from "@/samples/slay-the-spire-like/system/utils/parse-shape";
 import type { Transform2D } from "@/samples/slay-the-spire-like/system/utils/shape-collision";
+import { CardEffect } from "@/samples/slay-the-spire-like/data/desert";

 function createRunContext(
  items: Map<string, InventoryItem<GameItemMeta>>,
@@ -63,7 +64,7 @@ function createEffect(
  id: string,
  lifecycle: EffectData["lifecycle"],
 ): EffectData {
-  return { id, name: id, description: "", lifecycle };
+  return { id, name: id, description: "", lifecycle, emoji: "" };
 }

 function createCard(
@@ -78,8 +79,8 @@ function createCard(
    type: "item" as const,
    costType,
    costCount,
-    targetType: "none" as const,
-    effects: [] as const,
+    targetType: "player" as const,
+    effects: [] as CardEffect[],
  };
 }

@@ -6,7 +6,6 @@ import {
 } from "@/core/game";
 import { createRegion } from "@/core/region";
 import {
-  createStartWith,
  createTriggers,
  Triggers,
 } from "@/samples/slay-the-spire-like/system/combat/triggers";
@@ -27,19 +26,14 @@ import {
  InventoryItem,
 } from "@/samples/slay-the-spire-like/system/grid-inventory/types";
 import { GameItemMeta } from "@/samples/slay-the-spire-like/system/grid-inventory/types";
-import { ParsedShape } from "@/samples/slay-the-spire-like/system/utils/parse-shape";
-import { Transform2D } from "@/samples/slay-the-spire-like/system/utils/shape-collision";
 import {
+  CardEffect,
  getCards,
  getEffects,
-  getEncounters,
  getEnemies,
-  getItems,
 } from "@/samples/slay-the-spire-like/data/desert";
 const cards = getCards();
 const effects = getEffects();
-const encounters = getEncounters();
-const items = getItems();
 const enemies = getEnemies();

 function createEffect(
@@ -48,7 +42,7 @@ function createEffect(
 ): EffectData {
  const found = effects.find((e) => e.id === id);
  if (found) return found;
-  return { id, name: id, description: "", lifecycle };
+  return { id, name: id, description: "", lifecycle, emoji: "" };
 }

 function createDeckRegions(): DeckRegions {
@@ -73,8 +67,8 @@ function createCard(
    type: "item" as const,
    costType,
    costCount,
-    targetType: "none" as const,
-    effects: [],
+    targetType: "player" as const,
+    effects: [] as CardEffect[],
  };
  return {
    id,
@@ -211,9 +205,9 @@ describe("desert triggers", () => {

      await triggers.onEffectApplied.execute(ctx, {
        effect: attackEffect,
-        entityKey: "player",
+        entityId: "player",
        stacks: 5,
-        sourceEntityKey: "enemy-0",
+        sourceEntityId: "enemy-0",
      });

      expect(ctx.value.player.hp).toBe(25);
@@ -229,7 +223,7 @@ describe("desert triggers", () => {

      await triggers.onEffectApplied.execute(ctx, {
        effect: drawEffect,
-        entityKey: "player",
+        entityId: "player",
        stacks: 2,
      });

@@ -245,7 +239,7 @@ describe("desert triggers", () => {
      const initialEnergy = ctx.value.player.energy;
      await triggers.onEffectApplied.execute(ctx, {
        effect: gainEnergyEffect,
-        entityKey: "player",
+        entityId: "player",
        stacks: 2,
      });

@@ -267,7 +261,7 @@ describe("desert triggers", () => {

      await triggers.onEffectApplied.execute(ctx, {
        effect: removeWoundEffect,
-        entityKey: "player",
+        entityId: "player",
        stacks: 2,
      });

@@ -285,20 +279,20 @@ describe("desert triggers", () => {
        }),
      );
      const triggers = getTriggers();
-      const defendEffect = createEffect("defend", "posture");
+      const defendEffect = createEffect("defend", "temporary");

      ctx._state.produce((draft) => {
        draft.player.effects.defend = { data: defendEffect, stacks: 5 };
      });

      await triggers.onDamage.execute(ctx, {
-        entityKey: "player",
+        entityId: "player",
        amount: 8,
-        sourceEntityKey: "enemy-0",
+        sourceEntityId: "enemy-0",
      });

      expect(ctx.value.player.hp).toBe(27);
-      expect(ctx.value.player.effects.defend?.stacks).toBe(2);
+      expect(ctx.value.player.effects.defend?.stacks).toBe(undefined);
    });

    it("should reduce damage with damageReduce", async () => {
@@ -318,9 +312,9 @@ describe("desert triggers", () => {
      });

      await triggers.onDamage.execute(ctx, {
-        entityKey: "player",
+        entityId: "player",
        amount: 8,
-        sourceEntityKey: "enemy-0",
+        sourceEntityId: "enemy-0",
      });

      expect(ctx.value.player.hp).toBe(25);
@@ -340,9 +334,9 @@ describe("desert triggers", () => {
      });

      await triggers.onDamage.execute(ctx, {
-        entityKey: "player",
+        entityId: "player",
        amount: 5,
-        sourceEntityKey: "enemy-0",
+        sourceEntityId: "enemy-0",
      });

      expect(ctx.value.player.hp).toBe(23);
@@ -358,16 +352,18 @@ describe("desert triggers", () => {
      );
      const triggers = getTriggers();
      const spikeEffect = createEffect("spike", "permanent");
+      const attackEffect = createEffect("attack", "instant");

      ctx._state.produce((draft) => {
        const enemy = draft.enemies[0];
        enemy.effects.spike = { data: spikeEffect, stacks: 3 };
      });

-      await triggers.onDamage.execute(ctx, {
-        entityKey: "仙人掌怪-0",
-        amount: 5,
-        sourceEntityKey: "player",
+      await triggers.onEffectApplied.execute(ctx, {
+        effect: attackEffect,
+        entityId: "仙人掌怪-0",
+        stacks: 5,
+        sourceEntityId: "player",
      });

      expect(ctx.value.player.hp).toBe(27);
@@ -408,9 +404,9 @@ describe("desert triggers", () => {
      });

      await triggers.onDamage.execute(ctx, {
-        entityKey: "幼沙虫-0",
+        entityId: "幼沙虫-0",
        amount: 5,
-        sourceEntityKey: "player",
+        sourceEntityId: "player",
      });

      expect(ctx.value.player.energy).toBe(2);
@@ -435,9 +431,9 @@ describe("desert triggers", () => {
      let threw = false;
      try {
        await triggers.onDamage.execute(ctx, {
-          entityKey: "蜥蜴-0",
+          entityId: "蜥蜴-0",
          amount: 1,
-          sourceEntityKey: "player",
+          sourceEntityId: "player",
        });
      } catch (e) {
        threw = true;
@@ -463,7 +459,7 @@ describe("desert triggers", () => {
        draft.player.effects.discard = { data: discardEffect, stacks: 1 };
      });

-      await triggers.onTurnStart.execute(ctx, { entityKey: "player" });
+      await triggers.onTurnStart.execute(ctx, { entityId: "player" });

      expect(ctx.value.player.deck.regions.hand.childIds.length).toBe(2);
      expect(ctx.value.player.deck.regions.discardPile.childIds.length).toBe(1);
@@ -480,7 +476,7 @@ describe("desert triggers", () => {
        draft.player.effects.defendNext = { data: defendNextEffect, stacks: 5 };
      });

-      await triggers.onTurnStart.execute(ctx, { entityKey: "player" });
+      await triggers.onTurnStart.execute(ctx, { entityId: "player" });

      expect(ctx.value.player.effects.defend?.stacks).toBe(5);
      expect(ctx.value.player.effects.defendNext).toBeUndefined();
@@ -495,7 +491,7 @@ describe("desert triggers", () => {
        draft.player.effects.energyNext = { data: energyNextEffect, stacks: 2 };
      });

-      await triggers.onTurnStart.execute(ctx, { entityKey: "player" });
+      await triggers.onTurnStart.execute(ctx, { entityId: "player" });

      expect(ctx.value.player.energy).toBe(5);
      expect(ctx.value.player.effects.energyNext).toBeUndefined();
@@ -514,7 +510,7 @@ describe("desert triggers", () => {
        draft.player.effects.drawNext = { data: drawNextEffect, stacks: 2 };
      });

-      await triggers.onTurnStart.execute(ctx, { entityKey: "player" });
+      await triggers.onTurnStart.execute(ctx, { entityId: "player" });

      expect(ctx.value.player.deck.regions.hand.childIds.length).toBe(2);
      expect(ctx.value.player.effects.drawNext).toBeUndefined();
@@ -536,9 +532,9 @@ describe("desert triggers", () => {
      });

      await triggers.onDamage.execute(ctx, {
-        entityKey: "仙人掌怪-0",
+        entityId: "仙人掌怪-0",
        amount: 5,
-        sourceEntityKey: "player",
+        sourceEntityId: "player",
      });

      expect(ctx.value.enemies[0].hp).toBe(2);
@@ -558,9 +554,9 @@ describe("desert triggers", () => {
      });

      await triggers.onDamage.execute(ctx, {
-        entityKey: "仙人掌怪-0",
+        entityId: "仙人掌怪-0",
        amount: 5,
-        sourceEntityKey: "player",
+        sourceEntityId: "player",
      });

      expect(ctx.value.enemies[0].hp).toBe(74);
@@ -582,9 +578,9 @@ describe("desert triggers", () => {
      });

      await triggers.onDamage.execute(ctx, {
-        entityKey: "player",
+        entityId: "player",
        amount: 5,
-        sourceEntityKey: "沙蝎-0",
+        sourceEntityId: "沙蝎-0",
      });

      expect(ctx.value.player.hp).toBe(23);
@@ -605,9 +601,9 @@ describe("desert triggers", () => {
      });

      await triggers.onDamage.execute(ctx, {
-        entityKey: "player",
+        entityId: "player",
        amount: 5,
-        sourceEntityKey: "骑马枪手-0",
+        sourceEntityId: "骑马枪手-0",
      });

      expect(ctx.value.player.hp).toBe(20);
@@ -629,10 +625,10 @@ describe("desert triggers", () => {

      await triggers.onEffectApplied.execute(ctx, {
        effect: crossbowEffect,
-        entityKey: "player",
+        entityId: "player",
        stacks: 0,
        cardId: "crossbow-1",
-        sourceEntityKey: "player",
+        sourceEntityId: "player",
        targetId: "仙人掌怪-0",
      });

@@ -653,7 +649,7 @@ describe("desert triggers", () => {

      await triggers.onCardDiscarded.execute(ctx, {
        cardId: "fatigue-1",
-        sourceEntityKey: "player",
+        sourceEntityId: "player",
      });

      expect(ctx.value.enemies[0].hp).toBe(40);
@@ -670,9 +666,9 @@ describe("desert triggers", () => {
      const triggers = getTriggers();

      await triggers.onDamage.execute(ctx, {
-        entityKey: "player",
+        entityId: "player",
        amount: 5,
-        sourceEntityKey: "秃鹫-0",
+        sourceEntityId: "秃鹫-0",
      });

      const vultureEyeCards = Object.values(ctx.value.player.deck.cards).filter(
@@ -33,7 +33,7 @@ function createTestCardData(id: string, name: string, desc: string): CardData {
    type: "item",
    costType: "energy",
    costCount: 1,
-    targetType: "single",
+    targetType: "enemy",
    effects: [],
  };
 }
@@ -12,7 +12,6 @@ import {
  getItemAtCell,
  getAdjacentItems,
  validatePlacement,
-  type GridInventory,
  type InventoryItem,
 } from "@/samples/slay-the-spire-like/system/grid-inventory";
 import { createItemIn } from "@/samples/slay-the-spire-like/system/grid-inventory/factory";
@@ -36,7 +35,7 @@ function createTestCardData(id: string, name: string, desc: string): CardData {
    type: "item",
    costType: "energy",
    costCount: 1,
-    targetType: "single",
+    targetType: "enemy",
    effects: [],
  };
 }
@@ -0,0 +1,219 @@
+import { describe, it, expect } from "vitest";
+import { createPromptContext } from "@/utils/command/command-prompt";
+import type { CommandSchema } from "@/utils/command/types";
+
+const mockSchema: CommandSchema = {
+  name: "test",
+  params: [{ name: "value", required: true, variadic: false }],
+  options: {},
+  flags: {},
+};
+
+describe("createPromptContext", () => {
+  describe("prompt", () => {
+    it("should store prompt and return promise", async () => {
+      const ctx = createPromptContext();
+      const validator = (value: string) => value;
+
+      const promise = ctx.prompt({ schema: mockSchema }, validator);
+      await new Promise((r) => setTimeout(r, 0));
+
+      const result = ctx.tryCommit("global", "hello");
+      expect(result).toEqual({ ok: true });
+      await expect(promise).resolves.toBe("hello");
+    });
+
+    it("should associate prompt with specific player", async () => {
+      const ctx = createPromptContext();
+      const validator = (value: string) => value;
+
+      const promise = ctx.prompt({ schema: mockSchema }, validator, "player1");
+      await new Promise((r) => setTimeout(r, 0));
+
+      const result = ctx.tryCommit("player1", "hello");
+      expect(result).toEqual({ ok: true });
+      await expect(promise).resolves.toBe("hello");
+    });
+
+    it("should cancel existing prompt when new prompt starts for same player", async () => {
+      const ctx = createPromptContext();
+      const validator = (value: string) => value;
+
+      const promise1 = ctx.prompt({ schema: mockSchema }, validator, "player1");
+      await new Promise((r) => setTimeout(r, 0));
+
+      const promise2 = ctx.prompt({ schema: mockSchema }, validator, "player1");
+
+      // Resolve promise2 first, then both will settle
+      ctx.tryCommit("player1", "test");
+      const [result1, result2] = await Promise.allSettled([promise1, promise2]);
+
+      expect(result1.status).toBe("rejected");
+      expect((result1 as PromiseRejectedResult).reason).toBe(
+        "Prompt overriden",
+      );
+      expect(result2.status).toBe("fulfilled");
+    });
+
+    it("should allow different players to have independent prompts", async () => {
+      const ctx = createPromptContext();
+      const validator = (value: string) => value;
+
+      const promise1 = ctx.prompt({ schema: mockSchema }, validator, "player1");
+      const promise2 = ctx.prompt({ schema: mockSchema }, validator, "player2");
+      await new Promise((r) => setTimeout(r, 0));
+
+      ctx.tryCommit("player1", "hello");
+      ctx.tryCommit("player2", "world");
+
+      await expect(promise1).resolves.toBe("hello");
+      await expect(promise2).resolves.toBe("world");
+    });
+  });
+
+  describe("tryCommit", () => {
+    it("should return ok:true when prompt exists and validation passes", () => {
+      const ctx = createPromptContext();
+      const validator = (value: string) => value.toUpperCase();
+
+      ctx.prompt({ schema: mockSchema }, validator, "player1");
+      const result = ctx.tryCommit("player1", "hello");
+
+      expect(result).toEqual({ ok: true });
+    });
+
+    it("should return ok:false with reason when no prompt exists", () => {
+      const ctx = createPromptContext();
+      const result = ctx.tryCommit("nonexistent", "hello");
+
+      expect(result).toEqual({ ok: false, reason: "No Prompt" });
+    });
+
+    it("should return ok:false when validator throws string", () => {
+      const ctx = createPromptContext();
+      const validator = (value: string) => {
+        if (value.length < 3) throw "Value too short";
+        return value;
+      };
+
+      ctx.prompt({ schema: mockSchema }, validator, "player1");
+      const result = ctx.tryCommit("player1", "ab");
+
+      expect(result).toEqual({ ok: false, reason: "Value too short" });
+    });
+
+    it("should throw when validator throws non-string error", () => {
+      const ctx = createPromptContext();
+      const validator = () => {
+        throw new Error("unexpected");
+      };
+
+      ctx.prompt({ schema: mockSchema }, validator, "player1");
+      expect(() => ctx.tryCommit("player1", "test")).toThrow("unexpected");
+    });
+
+    it("should pass validator return value to promise resolver", async () => {
+      const ctx = createPromptContext();
+      const validator = (a: number, b: number) => a + b;
+
+      const promise = ctx.prompt({ schema: mockSchema }, validator, "player1");
+      await new Promise((r) => setTimeout(r, 0));
+
+      ctx.tryCommit("player1", 2, 3);
+      await expect(promise).resolves.toBe(5);
+    });
+  });
+
+  describe("cancel", () => {
+    it("should reject promise with default message", async () => {
+      const ctx = createPromptContext();
+      const validator = (value: string) => value;
+
+      const promise = ctx.prompt({ schema: mockSchema }, validator, "player1");
+      await new Promise((r) => setTimeout(r, 0));
+
+      ctx.cancel("player1");
+
+      const result = await Promise.allSettled([promise]);
+      expect(result[0].status).toBe("rejected");
+      expect((result[0] as PromiseRejectedResult).reason).toBe(
+        "Prompt Cancelled",
+      );
+    });
+
+    it("should reject promise with custom reason", async () => {
+      const ctx = createPromptContext();
+      const validator = (value: string) => value;
+
+      const promise = ctx.prompt({ schema: mockSchema }, validator, "player1");
+      await new Promise((r) => setTimeout(r, 0));
+
+      ctx.cancel("player1", "Custom cancel reason");
+
+      const result = await Promise.allSettled([promise]);
+      expect(result[0].status).toBe("rejected");
+      expect((result[0] as PromiseRejectedResult).reason).toBe(
+        "Custom cancel reason",
+      );
+    });
+
+    it("should do nothing when no prompt exists for player", () => {
+      const ctx = createPromptContext();
+      ctx.cancel("nonexistent");
+    });
+
+    it("should only cancel prompt for specific player", async () => {
+      const ctx = createPromptContext();
+      const validator = (value: string) => value;
+
+      const promise1 = ctx.prompt({ schema: mockSchema }, validator, "player1");
+      const promise2 = ctx.prompt({ schema: mockSchema }, validator, "player2");
+      await new Promise((r) => setTimeout(r, 0));
+
+      ctx.cancel("player1");
+      ctx.tryCommit("player2", "test");
+
+      const [result1, result2] = await Promise.allSettled([promise1, promise2]);
+      expect(result1.status).toBe("rejected");
+      expect((result1 as PromiseRejectedResult).reason).toBe(
+        "Prompt Cancelled",
+      );
+
+      expect(result2.status).toBe("fulfilled");
+    });
+  });
+
+  describe("handleCall", () => {
+    it("should be a middleware chain that can be extended", async () => {
+      const ctx = createPromptContext();
+      const validator = (value: string) => value;
+
+      let middlewareCalled = false;
+      ctx.handleCall.use(async (call, next) => {
+        middlewareCalled = true;
+        return next();
+      });
+
+      const promise = ctx.prompt({ schema: mockSchema }, validator);
+      await new Promise((r) => setTimeout(r, 0));
+
+      expect(middlewareCalled).toBe(true);
+      ctx.tryCommit("global", "test");
+      await expect(promise).resolves.toBe("test");
+    });
+
+    it("should remove prompt from map after resolution", async () => {
+      const ctx = createPromptContext();
+      const validator = (value: string) => value;
+
+      const promise = ctx.prompt({ schema: mockSchema }, validator);
+      await new Promise((r) => setTimeout(r, 0));
+
+      ctx.tryCommit("global", "test");
+      await promise;
+
+      const result = ctx.tryCommit("global", "another");
+      expect(result).toEqual({ ok: false, reason: "No Prompt" });
+    });
+  });
+});
@@ -1,174 +1,176 @@
-import { describe, it, expect } from 'vitest';
-import { parseCommand, type Command } from '@/utils/command';
+import { describe, it, expect } from "vitest";
+import { parseCommand, type Command } from "@/utils/command";

-describe('parseCommand', () => {
-    it('should parse empty string', () => {
-        const result = parseCommand('');
+describe("parseCommand", () => {
+  it("should parse empty string", () => {
+    const result = parseCommand("");
    expect(result).toEqual({
-            name: '',
+      name: "",
      flags: {},
      options: {},
-            params: []
+      params: [],
    });
  });

-    it('should parse command name only', () => {
-        const result = parseCommand('move');
+  it("should parse command name only", () => {
+    const result = parseCommand("move");
    expect(result).toEqual({
-            name: 'move',
+      name: "move",
      flags: {},
      options: {},
-            params: []
+      params: [],
    });
  });

-    it('should parse command with params', () => {
-        const result = parseCommand('move meeple1 region1');
+  it("should parse command with params", () => {
+    const result = parseCommand("move meeple1 region1");
    expect(result).toEqual({
-            name: 'move',
+      name: "move",
      flags: {},
      options: {},
-            params: ['meeple1', 'region1']
+      params: ["meeple1", "region1"],
    });
  });

-    it('should parse command with long flags', () => {
-        const result = parseCommand('move meeple1 --force --quiet');
+  it("should parse command with long flags", () => {
+    const result = parseCommand("move meeple1 --force --quiet");
    expect(result).toEqual({
-            name: 'move',
+      name: "move",
      flags: { force: true, quiet: true },
      options: {},
-            params: ['meeple1']
+      params: ["meeple1"],
    });
  });

-    it('should parse command with short flags', () => {
-        const result = parseCommand('move meeple1 -f -q');
+  it("should parse command with short flags", () => {
+    const result = parseCommand("move meeple1 -f -q");
    expect(result).toEqual({
-            name: 'move',
+      name: "move",
      flags: { f: true, q: true },
      options: {},
-            params: ['meeple1']
+      params: ["meeple1"],
    });
  });

-    it('should parse command with long options', () => {
-        const result = parseCommand('move meeple1 --x 10 --y 20');
+  it("should parse command with long options", () => {
+    const result = parseCommand("move meeple1 --x 10 --y 20");
    expect(result).toEqual({
-            name: 'move',
+      name: "move",
      flags: {},
-            options: { x: '10', y: '20' },
-            params: ['meeple1']
+      options: { x: "10", y: "20" },
+      params: ["meeple1"],
    });
  });

-    it('should parse command with short options', () => {
-        const result = parseCommand('move meeple1 -x 10 -y 20');
+  it("should parse command with short options", () => {
+    const result = parseCommand("move meeple1 -x 10 -y 20");
    expect(result).toEqual({
-            name: 'move',
+      name: "move",
      flags: {},
-            options: { x: '10', y: '20' },
-            params: ['meeple1']
+      options: { x: "10", y: "20" },
+      params: ["meeple1"],
    });
  });

-    it('should parse command with mixed flags和选项', () => {
-        const result = parseCommand('move meeple1 region1 --force -x 10 -q');
+  it("should parse command with mixed flags和选项", () => {
+    const result = parseCommand("move meeple1 region1 --force -x 10 -q");
    expect(result).toEqual({
-            name: 'move',
+      name: "move",
      flags: { force: true, q: true },
-            options: { x: '10' },
-            params: ['meeple1', 'region1']
+      options: { x: "10" },
+      params: ["meeple1", "region1"],
    });
  });

-    it('should handle extra whitespace', () => {
-        const result = parseCommand('  move   meeple1   --force  ');
+  it("should handle extra whitespace", () => {
+    const result = parseCommand("  move   meeple1   --force  ");
    expect(result).toEqual({
-            name: 'move',
+      name: "move",
      flags: { force: true },
      options: {},
-            params: ['meeple1']
+      params: ["meeple1"],
    });
  });

-    it('should parse complex command', () => {
-        const result = parseCommand('place meeple1 board --x 5 --y 3 --rotate 90 --force');
+  it("should parse complex command", () => {
+    const result = parseCommand(
+      "place meeple1 board --x 5 --y 3 --rotate 90 --force",
+    );
    expect(result).toEqual({
-            name: 'place',
+      name: "place",
      flags: { force: true },
-            options: { x: '5', y: '3', rotate: '90' },
-            params: ['meeple1', 'board']
+      options: { x: "5", y: "3", rotate: "90" },
+      params: ["meeple1", "board"],
    });
  });

-    it('should treat negative number as option value', () => {
-        const result = parseCommand('set --value -10');
+  it("should treat negative number as option value", () => {
+    const result = parseCommand("set --value -10");
    expect(result).toEqual({
-            name: 'set',
+      name: "set",
      flags: {},
-            options: { value: '-10' },
-            params: []
+      options: { value: "-10" },
+      params: [],
    });
  });

-    it('should parse quoted string with double quotes', () => {
+  it("should parse quoted string with double quotes", () => {
    const result = parseCommand('place tile "large castle" --x 5');
    expect(result).toEqual({
-            name: 'place',
+      name: "place",
      flags: {},
-            options: { x: '5' },
-            params: ['tile', 'large castle']
+      options: { x: "5" },
+      params: ["tile", "large castle"],
    });
  });

-    it('should parse quoted string with single quotes', () => {
+  it("should parse quoted string with single quotes", () => {
    const result = parseCommand("place tile 'large castle' --x 5");
    expect(result).toEqual({
-            name: 'place',
+      name: "place",
      flags: {},
-            options: { x: '5' },
-            params: ['tile', 'large castle']
+      options: { x: "5" },
+      params: ["tile", "large castle"],
    });
  });

-    it('should handle escaped quotes', () => {
+  it("should handle escaped quotes", () => {
    const result = parseCommand('say "hello \\"world\\""');
    expect(result).toEqual({
-            name: 'say',
+      name: "say",
      flags: {},
      options: {},
-            params: ['hello "world"']
+      params: ['hello "world"'],
    });
  });

-    it('should handle escaped backslash', () => {
+  it("should handle escaped backslash", () => {
    const result = parseCommand('set path "C:\\\\Users"');
    expect(result).toEqual({
-            name: 'set',
+      name: "set",
      flags: {},
      options: {},
-            params: ['path', 'C:\\Users']
+      params: ["path", "C:\\Users"],
    });
  });

-    it('should handle mixed quotes', () => {
-        const result = parseCommand('cmd "hello world" \'foo bar\' --flag');
+  it("should handle mixed quotes", () => {
+    const result = parseCommand("cmd \"hello world\" 'foo bar' --flag");
    expect(result).toEqual({
-            name: 'cmd',
+      name: "cmd",
      flags: { flag: true },
      options: {},
-            params: ['hello world', 'foo bar']
+      params: ["hello world", "foo bar"],
    });
  });

-    it('should handle quote in middle of argument', () => {
+  it("should handle quote in middle of argument", () => {
    const result = parseCommand('cmd "hello\'s world"');
    expect(result).toEqual({
-            name: 'cmd',
+      name: "cmd",
      flags: {},
      options: {},
-            params: ["hello's world"]
+      params: ["hello's world"],
    });
  });
 });
Author	SHA1	Message	Date
hypercross	9ed23295ae	build: include samples in prepare script	2026-04-28 16:52:03 +08:00
hypercross	ca86bfc427	refactor: use effect for assignSelector in BaseGameClient Replace subscribe with effect in assignSelector to ensure the selector value is tracked and the callback is executed within the reactive context.	2026-04-28 15:50:00 +08:00
hypercross	09c3fc443b	feat(core): wrap prompt middleware in try-finally block Ensure the prompt status is cleared even if the middleware chain throws an error.	2026-04-28 15:29:08 +08:00
hypercross	a0b2003c65	refactor(samples/tic-tac-toe): simplify Client implementation Remove generic EntityMap and TriggerMap types in favor of explicit selector methods. This simplifies the Client class by removing unnecessary interface implementations and conditional logic in selectors.	2026-04-25 17:58:16 +08:00
hypercross	03db1e8a06	refactor: simplify GameClient API using signals Replaces the middleware-based `useClient` system with a more direct reactive API using Preact signals. - Replace `_setStatus` middleware with a `_status` signal - Replace `useClient` with `selectPrompt`, `selectStatus`, and `selectResult` - Implement `selectPrompt` to provide a `tryAnswer` function for handling prompt resolutions - Add `_result` signal to track game completion results - Simplify `setStatus` logic to manage lifecycle and state resets	2026-04-25 17:54:21 +08:00
hypercross	20993d3b72	feat: add BaseGameClient for external integration Introduces `BaseGameClient` to allow external environments (like C#) to interact with the game engine. It provides mechanisms for: - Reactive state selection via `select` - Async event interception via `use` - Lifecycle management and status tracking - Interruption handling for async game loops Updated `middleware.ts` to allow unregistering middleware via the returned function from `use`.	2026-04-25 17:31:15 +08:00
hypercross	59391c74d9	refactor(samples): use produceAsync in tic-tac-toe Update the tic-tac-toe sample to use `produceAsync` instead of `produce` to ensure state mutations correctly await interruption promises.	2026-04-25 15:58:10 +08:00
hyper	fb3c98b1ef	refactor: update GameHost to use generic state and result types Decouple GameHost from GameState and GameResult types by introducing generic parameters for TState and TResult. This improves type safety and flexibility when defining GameModules.	2026-04-23 16:03:49 +08:00
hyper	5c1ef232fd	export GameState and GameResult types from game-host	2026-04-23 15:36:25 +08:00
hyper	f5df1c26dc	refactor: remove registry from Boop and Regicide index files	2026-04-23 15:29:14 +08:00
hyper	2014162819	refactor: update Regicide commands and improve code style	2026-04-23 15:28:45 +08:00
hyper	d932c2f5e2	refactor: remove Boop command registry and simplify exports Remove the command registry from the Boop sample and export command functions directly. This simplifies the command structure and replaces dynamic imports with static imports.	2026-04-23 15:21:13 +08:00
hyper	1bd49c32e0	refactor: format Onitama commands and Tic-Tac-Toe imports	2026-04-23 15:18:37 +08:00
hyper	b009189b9a	Extract PromptContext from GameHost into separate module The prompt system is now managed by a dedicated PromptContext instead of being embedded in GameHost. This simplifies the API by removing individual prompt signals and consolidating prompt logic into a reusable context that can be shared between components.	2026-04-23 15:09:06 +08:00
hyper	59b99d2042	Fix command prompt to properly return promise results Add comprehensive tests for createPromptContext covering prompt, tryCommit, cancel, and handleCall middleware.	2026-04-23 14:44:24 +08:00
hyper	32408c3cee	feat: add command prompt context with middleware support	2026-04-23 14:22:17 +08:00
hypercross	23ac09ff21	refactor: simplify GameHost constructor to use GameModule Update `GameHost` to accept a `GameModule` directly instead of individual parameters. This simplifies the `createGameHost` factory and improves type safety by preserving the module type. Also apply `readonly` modifiers to `ContentModule` in the slay-the-spire-like sample.	2026-04-23 10:37:28 +08:00
hypercross	e8c995f74f	feat: add spawner utility Introduce `createSpawner` and `spawnerEffect` to manage the lifecycle of side effects based on a collection of IDs. `spawnerEffect` uses Preact signals to automatically trigger spawners when IDs are added to an iterable and cleanup functions when they are removed.	2026-04-23 10:20:13 +08:00
hypercross	bbab3cc43b	feat(slay-the-spire-like): implement CombatGameHost Introduce CombatGameHost to manage the combat lifecycle and integrate ContentModule triggers with the combat run context.	2026-04-23 09:45:56 +08:00
hypercross	2e2ddebec4	refactor(slay-the-spire-like): simplify desert trigger registration Remove the intermediate `effect.ts` file and consolidate the `addTriggers` logic directly into the desert triggers index file.	2026-04-23 09:37:05 +08:00
hypercross	0d7a84edee	test: update desert triggers test to use onEffectApplied	2026-04-23 01:04:27 +08:00
hypercross	bedde1ef4b	refactor(slay-the-spire-like): move spike damage logic to instant effects	2026-04-23 00:58:15 +08:00
hypercross	359e7b7485	fix(slay-the-spire-like): pass correct sourceEntityId in instant triggers Simplify the sourceEntityId logic to use the context value directly.	2026-04-23 00:53:05 +08:00
hypercross	63e55a828e	refactor: rename entityKey to entityId in combat triggers Rename `entityKey` and `sourceEntityKey` to `entityId` and `sourceEntityId` across the slay-the-spire-like sample to improve naming consistency with the rest of the project.	2026-04-23 00:38:10 +08:00
hypercross	8ec95cbf81	refactor: rename 'user' target to 'source' in slay-the-spire-like Updates the card effect and intent target types from 'user' to 'source' within the desert data files and combat effect system to maintain consistency. Also reformat command tests to use 2-space indentation.	2026-04-23 00:35:28 +08:00
hypercross	f4c96a4a72	refactor: update turn start triggers in desert sample Fixes logic in `defendNext` to ensure effects are applied after buff updates by calling `next()` before mutation. Also updates indentation and formatting to match project style guidelines.	2026-04-22 20:13:31 +08:00
hypercross	a5e2e4888e	refactor(slay-the-spire-like): update combat targeting and effect logic Refactor combat targeting types and effect application logic in the Slay the Spire-like sample. - Update `getEffectTargets` to use `IntentEffectTarget` and more descriptive target keys (e.g., `eachEnemy`, `randomEnemy`). - Update `promptMainAction` to use `enemy` instead of `single` for card target types. - Refactor `addInstantEffectTriggers` to remove unused effect loading and improve enemy/card instantiation logic	2026-04-22 19:35:37 +08:00
hypercross	38fd46618e	refactor(slay-the-spire-like): use data definitions in system types Remove redundant type definitions in `system/types.ts` and instead import them from the generated CSV declaration files. Also update declaration files to use single quotes for consistency with project style rules.	2026-04-22 19:26:58 +08:00
hypercross	72647a8268	refactor(samples): export desert data types Export type definitions from desert CSV declaration files and update the content module to use these exported types instead of generic system types.	2026-04-22 16:48:54 +08:00
hypercross	dbbbba14e2	refactor(slay-the-spire-like): update card effect and intent schemas Refactor the data schemas for desert card effects and intents to use dedicated type aliases for triggers, targets, and effect lists. This improves type safety and consistency across the sample data.	2026-04-22 16:13:48 +08:00
hypercross	888b7b822d	refactor(slay-the-spire-like): extract types in desert data schemas	2026-04-22 16:00:15 +08:00
hypercross	bb4528cd27	refactor(samples): update desert card and effect schemas	2026-04-22 15:59:41 +08:00
hypercross	877cc9d779	refactor: update schema definitions in slay-the-spire-like data Refactor CSV schema headers in the desert sample to use named type aliases instead of inline union strings. This improves readability and maintains consistency with the project's use of `inline-schema`. Changes include: - Updating `card.csv` to use `CardType`, `CardCostType`, and `CardTargetType`. - Updating `encounter.csv` to use `EncounterType` and `EnemyList`. - Updating `intent.csv` to use `IntentEffectTarget` and replacing `self` with `user` for effect targets.	2026-04-22 15:57:52 +08:00
hypercross	2eec668851	refactor: update damage triggers and combat start logic - Update `defend` effect lifecycle to `temporary` in desert data - Refactor `onDamage` triggers to improve readability and logic flow - Implement shuffle and draw actions on `onCombatStart` trigger	2026-04-22 11:06:19 +08:00