build: include samples in prepare script

Replace subscribe with effect in assignSelector to ensure the
selector value is tracked and the callback is executed within
the reactive context.

package.json

@@ -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"

src/core/game-client.ts

@@ -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);
+    });
+  }
+}

src/core/game-host.ts

@@ -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 { createGameContext, IGameContext } from "./game";
-import {
-  createGameCommandRegistry,
-  createGameContext,
-  IGameContext,
-  PromptDef,
-} 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 prompts: PromptContext;
-  readonly activePromptPlayer: ReadonlySignal<string | null>;
-  readonly activePromptHint: ReadonlySignal<string | null>;
 
   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(
+  constructor(public readonly gameModule: TModule) {
-    registry: CommandRegistry<IGameContext<TState>>,
+    const { createInitialState, start } = gameModule;
-    createInitialState: () => TState,
-    start: (ctx: IGameContext<TState>) => Promise<TResult>,
-  ) {
     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> {
+  TModule extends GameModule<TState, TResult> = GameModule<TState, TResult>,
-  return new GameHost(
+>(gameModule: TModule): GameHost<TState, TResult, TModule> {
-    gameModule.registry || createGameCommandRegistry(),
+  return new GameHost(gameModule);
-    gameModule.createInitialState,
-    gameModule.start,
-  );
 }

src/core/game.ts

@@ -1,40 +1,29 @@
 import { MutableSignal, mutableSignal } from "@/utils/mutable-signal";
-import {
+import { CommandSchema, parseCommandSchema, PromptDef } from "@/utils/command";
-  Command,
-  CommandRegistry,
-  CommandResult,
-  CommandRunnerContextExport,
-  CommandSchema,
-  createCommandRegistry,
-  createCommandRunnerContext,
-  parseCommandSchema,
-} 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) {
+    prompt,
-      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,
-      );
-    },
 
     _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>>();
-}

src/index.ts

@@ -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";

src/samples/boop/commands/index.ts

@@ -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";
+import { boop } from "./boop";
-
+import { checkFullBoard } from "./full-board";
-export const registry = createGameCommandRegistry<BoopGame['value']>();
+import { checkGraduates } from "./graduate";
-
+import { place } from "./place";
-/**
+import { checkWin } from "./win";
- * 放置棋子到棋盘
- */
-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);
-    }
-});
 
 /**
  * 启动游戏主循环
@@ -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 {
+export { place, boop, checkWin, checkGraduates, checkFullBoard, turn };
-    placeCmd as place,
-    boopCmd as boop,
-    checkWinCmd as checkWin,
-    checkGraduatesCmd as checkGraduates,
-    checkFullBoardCmd as checkFullBoard,
-    turnCmd as turn
-};

src/samples/boop/index.ts

@@ -5,38 +5,30 @@ export type {
   WinnerType,
   RegionType,
   BoopPartMeta,
-    BoopPart
+  BoopPart,
-} from './types';
+} from "./types";
 
-export type {BoopGame} from './types-extensions';
+export type { BoopGame } from "./types-extensions";
 
 // Constants
-export {
+export { BOARD_SIZE, MAX_PIECES_PER_PLAYER, WIN_LENGTH } from "./constants";
-    BOARD_SIZE,
-    MAX_PIECES_PER_PLAYER,
-    WIN_LENGTH
-} from './constants';
 
 // State
-export {
+export { createInitialState, type BoopState } from "./state";
-    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
+  turn as turnCmd,
-} from './commands';
+} from "./commands";
 
 // Utils
 export {
@@ -45,5 +37,5 @@ export {
   isCellOccupied,
   getNeighborPositions,
   findPartInRegion,
-    findPartAtPosition
+  findPartAtPosition,
-} from './utils';
+} from "./utils";

src/samples/onitama/commands.ts

@@ -3,13 +3,10 @@ import {
   OnitamaState,
   PlayerType,
   prompts,
-    initializeCards
+  initializeCards,
 } from "./types";
-import {createGameCommandRegistry} from "@/core/game";
 import { moveToRegion } from "@/core/region";
 
-export const registry = createGameCommandRegistry<OnitamaState>();
-
 /**
  * 检查位置是否在棋盘范围内
  */
@@ -29,8 +26,12 @@ function getPawnAtPosition(state: OnitamaState, x: number, y: number) {
 /**
  * 检查玩家是否拥有某张卡牌
  */
-function playerHasCard(state: OnitamaState, player: PlayerType, cardName: string): boolean {
+function playerHasCard(
-    const cardList = player === 'red' ? state.redCards : state.blackCards;
+  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') {
+  if (player === "black") {
-        return candidates.map(m => ({ dx: -m.dx, dy: -m.dy }));
+    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) {
+async function swapCard(
-    await game.produceAsync(state => {
+  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') {
+    if (player === "red") {
-            state.redCards = state.redCards.filter(c => c !== usedCard);
+      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'];
+  const redMaster = state.pawns["red-master"];
-    if (redMaster && redMaster.regionId === 'board' && redMaster.position[0] === 2 && redMaster.position[1] === 4) {
+  if (
-        return 'red';
+    redMaster &&
+    redMaster.regionId === "board" &&
+    redMaster.position[0] === 2 &&
+    redMaster.position[1] === 4
+  ) {
+    return "red";
   }
 
   // 黑色师父到达 (2, 0)（红色师父的初始位置）
-    const blackMaster = state.pawns['black-master'];
+  const blackMaster = state.pawns["black-master"];
-    if (blackMaster && blackMaster.regionId === 'board' && blackMaster.position[0] === 2 && blackMaster.position[1] === 0) {
+  if (
-        return 'black';
+    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'];
+  const redMaster = state.pawns["red-master"];
-    if (!redMaster || redMaster.regionId !== 'board') {
+  if (!redMaster || redMaster.regionId !== "board") {
-        return 'black';
+    return "black";
   }
 
   // 黑色师父不在棋盘上，红色获胜
-    const blackMaster = state.pawns['black-master'];
+  const blackMaster = state.pawns["black-master"];
-    if (!blackMaster || blackMaster.regionId !== 'board') {
+  if (!blackMaster || blackMaster.regionId !== "board") {
-        return 'red';
+    return "red";
   }
 
   return null;
 }
 
-const checkCaptureWin = registry.register({
-    schema: 'check-capture-win',
-    run: handleCheckCaptureWin
-});
-
 /**
  * 综合胜利检测
  */
-async function handleCheckWin(game: OnitamaGame): Promise<PlayerType | null> {
+async function checkWin(game: OnitamaGame): Promise<PlayerType | null> {
-    const conquestWinner = await handleCheckConquestWin(game);
+  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}> {
+export function getAvailableMoves(
-    const moves: Array<{card: string, fromX: number, fromY: number, toX: number, toY: number}> = [];
+  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
-});
-
 /**
  * 开始游戏主循环
  */

src/samples/regicide/commands/index.ts

@@ -1,20 +1,15 @@
 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";
 
 export type RegicideGame = IGameContext<RegicideState>;
 
-export const registry = createGameCommandRegistry<RegicideState>();
-
 /**
  * 打出一张牌（对当前敌人造成伤害）
  */
-const playCmd = registry.register({
+async function playCmd(game: RegicideGame, player: string, cardId: string) {
-    schema: 'play <player:string> <cardId:string>',
-    run: async (game: RegicideGame, player: string, cardId: string) => {
   const state = game.value;
   const card = state.cards[cardId];
 
@@ -26,12 +21,15 @@ const playCmd = registry.register({
   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') {
+    if (card.suit === "hearts") {
-                const discardIds = state.regions.discardPile.childIds.filter(id => id !== state.currentEnemy!.id);
+      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,28 +107,30 @@ const playCmd = registry.register({
       enemyHpBefore,
       enemyHpAfter: game.value.currentEnemy!.hp,
       enemyDefeated,
-                suitAbility: card.suit
+      suitAbility: card.suit,
-            }
+    },
   };
 }
-});
 
 /**
  * 打出A配合另一张牌
  */
-const playWithACmd = registry.register({
+async function playWithACmd(
-    schema: 'play-with-a <player:string> <aceCardId:string> <otherCardId:string>',
+  game: RegicideGame,
-    run: async (game: RegicideGame, player: string, aceCardId: string, otherCardId: string) => {
+  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') {
+  if (aceCard.rank !== "A") {
     return { success: false, error: `第一张牌必须是A` };
   }
 
@@ -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[aceCardId].regionId = "discardPile";
-            state.cards[otherCardId].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({
+async function passCmd(game: RegicideGame, player: string) {
-    schema: 'pass <player:string>',
-    run: async (game: RegicideGame, player: string) => {
   // 即使让过，也会受到敌人反击（在回合结束时处理）
   return { success: true, result: { message: `${player} 让过` } };
 }
-});
 
 /**
  * 敌人反击 - 玩家必须弃掉点数和 >= 敌人攻击力的牌
  */
-const enemyCounterattackCmd = registry.register({
+async function enemyCounterattackCmd(
-    schema: 'counterattack <player:string> <discardCards:string[]>',
+  game: RegicideGame,
-    run: async (game: RegicideGame, player: string, discardCards: string[]) => {
+  player: string,
+  discardCards: string[],
+) {
   const state = game.value;
 
   if (!state.currentEnemy) {
-            return {success: false, error: '没有活跃的敌人'};
+    return { success: false, error: "没有活跃的敌人" };
   }
 
   const playerKey = player as PlayerType;
@@ -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,22 +267,19 @@ const enemyCounterattackCmd = registry.register({
     result: {
       discardedCards: discardCards,
       totalValue,
-                enemyAttack
+      enemyAttack,
-            }
+    },
   };
 }
-});
 
 /**
  * 检查敌人是否被击败，如果击败则翻开下一个敌人
  */
-const checkEnemyDefeatedCmd = registry.register({
+async function checkEnemyDefeatedCmd(game: RegicideGame) {
-    schema: 'check-enemy',
-    run: async (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;
@@ -284,7 +287,7 @@ const checkEnemyDefeatedCmd = registry.register({
   if (defeated) {
     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 => {
+      await game.produceAsync((state) => {
-                    state.phase = 'victory';
+        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,
-                }
+      },
     };
   }
 
@@ -322,26 +325,23 @@ const checkEnemyDefeatedCmd = registry.register({
     result: {
       defeated: false,
       currentEnemy: { ...state.currentEnemy },
-                enemiesRemaining: state.enemyDeck.length
+      enemiesRemaining: state.enemyDeck.length,
-            }
+    },
   };
 }
-});
 
 /**
  * 检查玩家是否有可出的牌
  */
-const checkCanPlayCmd = registry.register({
+async function checkCanPlayCmd(game: RegicideGame, player: string) {
-    schema: 'check-can-play <player:string>',
-    run: async (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({
+async function checkTavernDeckCmd(game: RegicideGame) {
-    schema: 'check-tavern-deck',
-    run: async (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 => {
+      await game.produceAsync((state) => {
-                    state.phase = 'defeat';
+        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({
+async function nextTurnCmd(game: RegicideGame) {
-    schema: 'next-turn',
-    run: async (game: RegicideGame) => {
   const state = game.value;
-        await game.produce(state => {
+  await game.produce((state) => {
-            state.currentPlayerIndex = (state.currentPlayerIndex + 1) % state.playerCount;
+    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,

src/samples/regicide/game.ts

@@ -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 {
+  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 => {
+      await game.produceAsync((state) => {
-                state.currentPlayerIndex = (state.currentPlayerIndex + 1) % state.playerCount;
+        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') {
+  if (state.phase !== "playing") {
-        return {success: false, error: '游戏已结束'};
+    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) {
+    if (card.rank === "A" && secondCardId) {
-            playResult = await game.run(`play-with-a ${player} ${cardId} ${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) {
+  if (
-        await game.produceAsync(state => {
+    state.enemyDeck.length === 0 &&
-            state.phase = 'victory';
+    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[]) {
+export async function handleCounterattack(
-    const result = await game.run(`counterattack ${player} ${JSON.stringify(discardCardIds)}`);
+  game: RegicideGame,
-
+  player: PlayerType,
+  discardCardIds: string[],
+) {
+  const result = await enemyCounterattackCmd(game, player, discardCardIds);
   if (!result.success) {
     // 弃牌失败（点数和不足），游戏失败
-        await game.produceAsync(state => {
+    await game.produceAsync((state) => {
-            state.phase = 'defeat';
+      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],
+    currentPlayer: ["player1", "player2", "player3", "player4"][
-        currentEnemy: state.currentEnemy ? {
+      state.currentPlayerIndex
+    ],
+    currentEnemy: state.currentEnemy
+      ? {
           ...state.currentEnemy,
-            hpPercent: Math.round((state.currentEnemy.hp / state.currentEnemy.maxHp) * 100)
+          hpPercent: Math.round(
-        } : null,
+            (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,
   };
 }

src/samples/regicide/index.ts

@@ -7,8 +7,8 @@ export type {
   RegicideCardMeta,
   RegicideCard,
   Enemy,
-    GamePhase
+  GamePhase,
-} from './types';
+} from "./types";
 
 // Constants
 export {
@@ -18,21 +18,17 @@ export {
   ALL_SUITS,
   ALL_RANKS,
   FACE_CARDS,
-    NUMBER_CARDS
+  NUMBER_CARDS,
-} from './constants';
+} from "./constants";
 
 // State
-export {
+export { createInitialState, type RegicideState } from "./state";
-    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
+  type RegicideGame,
-} from './game';
+} from "./game";
 
 // Utils
 export {
@@ -63,5 +59,5 @@ export {
   buildTavernDeck,
   drawFromDeck,
   isEnemyDefeated,
-    getPlayerHandRegionId
+  getPlayerHandRegionId,
-} from './utils';
+} from "./utils";

src/samples/slay-the-spire-like/data/desert/card.csv

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

src/samples/slay-the-spire-like/data/desert/card.csv.d.ts

@@ -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 type: CardType;
-    readonly costType: "energy" | "uses" | "none";
+    readonly costType: CardCostType;
     readonly costCount: number;
-    readonly targetType: "single" | "none";
+    readonly targetType: CardTargetType;
     readonly effects: CardEffect[];
 }[];
 

src/samples/slay-the-spire-like/data/desert/cardEffect.csv

@@ -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][]
+string,@card,CardEffectTrigger,CardEffectTarget,CardEffectList
-sword,sword,onPlay,target,[attack;2];[attack;2]
+sword,sword,onPlay,eachTarget,[attack;2];[attack;2]
-greataxe,greataxe,onPlay,all,[attack;5]
+greataxe,greataxe,onPlay,eachTarget,[attack;5]
-spear,spear,onPlay,target,[attack;2];[attack;2];[attack;2]
+spear,spear,onPlay,eachTarget,[attack;2];[attack;2];[attack;2]
-dagger,dagger,onPlay,target,[attack;3];[attack;3]
+dagger,dagger,onPlay,eachTarget,[attack;3];[attack;3]
-dart,dart,onPlay,target,[attack;1]
+dart,dart,onPlay,eachTarget,[attack;1]
-dart-draw,dart,onPlay,self,[draw;1]
+dart-draw,dart,onPlay,source,[draw;1]
-crossbow,crossbow,onPlay,target,[attack;6]
+crossbow,crossbow,onPlay,eachTarget,[attack;6]
-crossbow-combo,crossbow,onPlay,self,[crossbow;0]
+crossbow-combo,crossbow,onPlay,source,[crossbow;0]
-shield,shield,onPlay,self,[defend;3]
+shield,shield,onPlay,source,[defend;3]
-hat,hat,onPlay,self,[defend;8]
+hat,hat,onPlay,source,[defend;8]
-cape,cape,onPlay,self,[defend;2];[defendNext;2]
+cape,cape,onPlay,source,[defend;2];[defendNext;2]
-bracer,bracer,onPlay,self,[defend;1];[draw;1]
+bracer,bracer,onPlay,source,[defend;1];[draw;1]
-greatshield,greatshield,onPlay,self,[defend;5]
+greatshield,greatshield,onPlay,source,[defend;5]
-chainmail,chainmail,onPlay,self,[damageReduce;3]
+chainmail,chainmail,onPlay,source,[damageReduce;3]
-bandage,bandage,onPlay,self,[removeWound;1]
+bandage,bandage,onPlay,source,[removeWound;1]
-poisonPotion,poisonPotion,onPlay,self,[attackBuff;2]
+poisonPotion,poisonPotion,onPlay,source,[attackBuff;2]
-fortifyPotion,fortifyPotion,onPlay,self,[defendBuff;2]
+fortifyPotion,fortifyPotion,onPlay,source,[defendBuff;2]
-vitalityPotion,vitalityPotion,onPlay,self,[gainEnergy;1]
+vitalityPotion,vitalityPotion,onPlay,source,[gainEnergy;1]
-focusPotion,focusPotion,onPlay,self,[draw;2]
+focusPotion,focusPotion,onPlay,source,[draw;2]
-healingPotion,healingPotion,onPlay,self,[removeWound;3]
+healingPotion,healingPotion,onPlay,source,[removeWound;3]
-waterBag,waterBag,onPlay,self,[energyNext;1];[drawNext;2]
+waterBag,waterBag,onPlay,source,[energyNext;1];[drawNext;2]
-rope,rope,onPlay,self,[defendBuffUntilPlay;2]
+rope,rope,onPlay,source,[defendBuffUntilPlay;2]
-belt,belt,onPlay,self,[drawChoice;1]
+belt,belt,onPlay,source,[drawChoice;1]
-torch,torch,onPlay,self,[burnForEnergy;1]
+torch,torch,onPlay,source,[burnForEnergy;1]
-whetstone,whetstone,onPlay,self,[attackBuffUntilPlay;3]
+whetstone,whetstone,onPlay,source,[attackBuffUntilPlay;3]
-blacksmithHammer,blacksmithHammer,onPlay,self,[transformRandom;1]
+blacksmithHammer,blacksmithHammer,onPlay,source,[transformRandom;1]
-venom,venom,onDiscard,self,[attack;3]
+venom,venom,onDiscard,source,[attack;3]
-curse,curse,onDraw,self,[curse;1]
+curse,curse,onDraw,source,[curse;1]
-static,static,onDraw,self,[static;1]
+static,static,onDraw,source,[static;1]
-vultureEye,vultureEye,onDraw,self,[expose;3]
+vultureEye,vultureEye,onDraw,source,[expose;3]

src/samples/slay-the-spire-like/data/desert/cardEffect.csv.d.ts

@@ -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 trigger: CardEffectTrigger;
-    readonly target: "self" | "target" | "all" | "random";
+    readonly target: CardEffectTarget;
-    readonly effects: [Effect, number][];
+    readonly effects: CardEffectList;
 }[];
 
 export type CardEffect = CardEffectTable[number];

src/samples/slay-the-spire-like/data/desert/effect.csv

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

src/samples/slay-the-spire-like/data/desert/effect.csv.d.ts

@@ -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];

src/samples/slay-the-spire-like/data/desert/encounter.csv

@@ -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;[]],

src/samples/slay-the-spire-like/data/desert/encounter.csv.d.ts

@@ -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;
 }[];
 

src/samples/slay-the-spire-like/data/desert/index.ts

@@ -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";

src/samples/slay-the-spire-like/data/desert/intent.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][]
+string,@enemy,boolean,@intent[],@intent[],IntentEffectList
-仙人掌怪-boost,仙人掌怪,true,仙人掌怪-boost;仙人掌怪-defend,,[self;spike;1];[self;defend;4]
+仙人掌怪-boost,仙人掌怪,true,仙人掌怪-boost;仙人掌怪-defend,,[source;spike;1];[source;defend;4]
-仙人掌怪-defend,仙人掌怪,false,仙人掌怪-attack,,[self;defend;8]
+仙人掌怪-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]
+枪手-defend,枪手,false,枪手-aim,枪手-aim,[source;defend;5]
-风卷草-boost,风卷草,true,风卷草-defend;风卷草-defend;风卷草-boost,,[self;roll;5];[self;defend;4]
+风卷草-boost,风卷草,true,风卷草-defend;风卷草-defend;风卷草-boost,,[source;roll;5];[source;defend;4]
-风卷草-defend,风卷草,false,风卷草-boost;风卷草-attack,,[self;defend;8]
+风卷草-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]
+秃鹫-defend,秃鹫,false,秃鹫-attack;秃鹫-attack,,[source;defend;5]
-沙蝎-boost,沙蝎,true,沙蝎-attack;沙蝎-attack,,[self;tailSting;2]
+沙蝎-boost,沙蝎,true,沙蝎-attack;沙蝎-attack,,[source;tailSting;2]
 沙蝎-attack,沙蝎,false,沙蝎-boost;沙蝎-attack,,[player;attack;6]
-幼沙虫-defend,幼沙虫,true,幼沙虫-defend;幼沙虫-boost,,[self;defend;6]
+幼沙虫-defend,幼沙虫,true,幼沙虫-defend;幼沙虫-boost,,[source;defend;6]
-幼沙虫-boost,幼沙虫,false,幼沙虫-attack;幼沙虫-defend,,[self;energyDrain;1];[self;defend;4]
+幼沙虫-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]
+蜥蜴-defend,蜥蜴,false,蜥蜴-attack;蜥蜴-attack,,[source;defend;6]
-蜥蜴-molt,蜥蜴,false,蜥蜴-defend;蜥蜴-attack,,[self;molt;3]
+蜥蜴-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]
+风暴之灵-defend,风暴之灵,false,风暴之灵-storm;风暴之灵-attack,,[source;defend;8]
-骑马枪手-charge,骑马枪手,true,骑马枪手-attack,,[self;charge;2]
+骑马枪手-charge,骑马枪手,true,骑马枪手-attack,,[source;charge;2]
 骑马枪手-attack,骑马枪手,false,骑马枪手-charge;骑马枪手-defend,骑马枪手-charge,[player;attack;6]
-骑马枪手-defend,骑马枪手,false,骑马枪手-charge;骑马枪手-attack,骑马枪手-charge,[self;defend;5]
+骑马枪手-defend,骑马枪手,false,骑马枪手-charge;骑马枪手-attack,骑马枪手-charge,[source;defend;5]
-沙虫王-summon,沙虫王,true,沙虫王-attack;沙虫王-defend,,[self;summonSandwormLarva;18]
+沙虫王-summon,沙虫王,true,沙虫王-attack;沙虫王-defend,,[source;summonSandwormLarva;18]
 沙虫王-attack,沙虫王,false,沙虫王-summon;沙虫王-defend,,[player;attack;9]
-沙虫王-defend,沙虫王,false,沙虫王-attack;沙虫王-summon,,[self;defend;6]
+沙虫王-defend,沙虫王,false,沙虫王-attack;沙虫王-summon,,[source;defend;6]
-沙漠守卫-summon,沙漠守卫,true,沙漠守卫-attack;沙漠守卫-defend,,[self;summonMummy;14]
+沙漠守卫-summon,沙漠守卫,true,沙漠守卫-attack;沙漠守卫-defend,,[source;summonMummy;14]
 沙漠守卫-attack,沙漠守卫,false,沙漠守卫-defend;沙漠守卫-summon,,[player;attack;8]
-沙漠守卫-defend,沙漠守卫,false,沙漠守卫-attack;沙漠守卫-revive,,[self;defend;8]
+沙漠守卫-defend,沙漠守卫,false,沙漠守卫-attack;沙漠守卫-revive,,[source;defend;8]
-沙漠守卫-revive,沙漠守卫,false,沙漠守卫-attack;沙漠守卫-summon,,[self;reviveMummy;1]
+沙漠守卫-revive,沙漠守卫,false,沙漠守卫-attack;沙漠守卫-summon,,[source;reviveMummy;1]

src/samples/slay-the-spire-like/data/desert/intent.csv.d.ts

@@ -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];

src/samples/slay-the-spire-like/data/desert/triggers/card-events.ts

@@ -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,
     });
   });
 }

src/samples/slay-the-spire-like/data/desert/triggers/damage.ts

@@ -22,7 +22,7 @@ export function addDamageTriggers(triggers: Triggers) {
 
   // 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);
@@ -42,7 +42,7 @@ export function addDamageTriggers(triggers: Triggers) {
       ctx.prevented = (ctx.prevented ?? 0) + blocked;
       preventable -= blocked;
       await ctx.game.produceAsync((draft) => {
-        const e = getCombatEntity(draft, ctx.entityKey);
+        const e = getCombatEntity(draft, ctx.entityId);
         if (e) addEntityEffect(e, findEffect("defend"), -blocked);
       });
     }
@@ -55,32 +55,13 @@ 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") {
+    if (energyDrain > 0 && ctx.entityId !== "player") {
       const dealt = Math.min(
         Math.max(0, entity.hp),
         ctx.amount - (ctx.prevented ?? 0),
@@ -97,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;
@@ -106,7 +87,7 @@ 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);
+        const e = draft.enemies.find((en) => en.id === ctx.entityId);
         if (e) {
           e.isAlive = false;
           e.hp = 0;
@@ -124,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) {
@@ -136,7 +117,7 @@ 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) {
@@ -152,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") {
+    if (ctx.sourceEntityId && ctx.sourceEntityId !== "player") {
-      const attacker = getCombatEntity(ctx.game.value, ctx.sourceEntityKey);
+      const attacker = getCombatEntity(ctx.game.value, ctx.sourceEntityId);
       if (attacker) {
         const tailSting = attacker.effects.tailSting?.stacks ?? 0;
         if (tailSting > 0) {
@@ -166,7 +147,7 @@ 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) {
@@ -178,20 +159,20 @@ export function addDamageTriggers(triggers: Triggers) {
         ctx.amount += dealt;
         if (consumed > 0) {
           await ctx.game.produceAsync((draft) => {
-            const e = getCombatEntity(draft, ctx.entityKey);
+            const e = getCombatEntity(draft, ctx.entityId);
             if (e) addEntityEffect(e, findEffect("charge"), -consumed);
           });
         }
       }
     }
 
-    if (ctx.sourceEntityKey) {
+    if (ctx.sourceEntityId) {
-      const attacker = getCombatEntity(ctx.game.value, ctx.sourceEntityKey);
+      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 targetEntity = getCombatEntity(ctx.game.value, ctx.entityId);
           const dealt = Math.min(
             Math.max(0, targetEntity?.hp ?? 0),
             baseAmount - (ctx.prevented ?? 0),
@@ -200,7 +181,7 @@ export function addDamageTriggers(triggers: Triggers) {
           ctx.amount += dealt;
           if (consumed > 0) {
             await ctx.game.produceAsync((draft) => {
-              const a = getCombatEntity(draft, ctx.sourceEntityKey!);
+              const a = getCombatEntity(draft, ctx.sourceEntityId!);
               if (a) addEntityEffect(a, findEffect("charge"), -consumed);
             });
           }

src/samples/slay-the-spire-like/data/desert/triggers/effect.ts

@@ -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);
-}

src/samples/slay-the-spire-like/data/desert/triggers/index.ts

@@ -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);
+}

src/samples/slay-the-spire-like/data/desert/triggers/instant.ts

@@ -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 => {
+      await ctx.game.produceAsync((draft) => {
-                const deadMummy = draft.enemies.find(e => e.enemy.id === "木乃伊" && !e.isAlive);
+        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);
       });
     }

src/samples/slay-the-spire-like/data/desert/triggers/turn-start.ts

@@ -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 });

src/samples/slay-the-spire-like/data/types.ts

@@ -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 = {
+import type * as desert from "./desert";
-  getCards: () => CardData[];
+import { IRunContext } from "../system/combat";
-  getEffects: () => EffectData[];
-  getEncounters: () => EncounterData[];
-  getEnemies: () => EnemyData[];
-  getIntents: () => IntentData[];
-  getItems: () => ItemData[];
-  getStartingItems: () => ItemData[];
 
-  dialogues: YarnDialogues;
+export type ContentModule = {
-  addTriggers: (triggers: Triggers) => void;
+  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;
 };

src/samples/slay-the-spire-like/system/combat/effects.ts

@@ -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);

src/samples/slay-the-spire-like/system/combat/prompts.ts

@@ -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}"无效`;
     }
 

src/samples/slay-the-spire-like/system/combat/triggers.ts

@@ -19,33 +19,33 @@ import { EffectData } from "@/samples/slay-the-spire-like/system/types";
 
 type TriggerTypes = {
   onCombatStart: {};
-  onTurnStart: { entityKey: "player" | string };
+  onTurnStart: { entityId: "player" | string };
-  onTurnEnd: { entityKey: "player" | string };
+  onTurnEnd: { entityId: "player" | string };
   onShuffle: {};
   onCardPlayed: {
     cardId: string;
     targetId?: string;
-    sourceEntityKey?: "player" | string;
+    sourceEntityId?: "player" | string;
   };
-  onCardDiscarded: { cardId: string; sourceEntityKey?: "player" | string };
+  onCardDiscarded: { cardId: string; sourceEntityId?: "player" | string };
-  onCardDrawn: { cardId: string; sourceEntityKey?: "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 };
 };
 
@@ -57,13 +57,13 @@ export function createTriggers(run: IRunContext) {
     }),
     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 });
@@ -97,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)
@@ -109,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,
             });
       }
@@ -125,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)
@@ -137,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,
             });
       }
     }),
@@ -151,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)
@@ -163,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,
             });
       }
     }),
@@ -204,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;
@@ -229,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),
@@ -241,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,
       });
     }),
@@ -252,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,
@@ -262,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,
           });
       }
     }),
@@ -287,18 +287,13 @@ export function createTriggers(run: IRunContext) {
   return triggers;
 }
 export type Triggers = ReturnType<typeof createTriggers>;
-export function createStartWith(
+export function createStart(triggers: Triggers, run: IRunContext) {
-  build: (triggers: Triggers, run: IRunContext) => void,
-  run: IRunContext,
-) {
-  const triggers = createTriggers(run);
-  build(triggers, run);
   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;
@@ -306,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) {

src/samples/slay-the-spire-like/system/types.ts

@@ -1,89 +1,25 @@
-export type EffectData = {
+import {
-  readonly id: string;
+  Card,
-  readonly name: string;
+  Effect,
-  readonly description: string;
+  Encounter,
-  readonly lifecycle: EffectLifecycle;
+  EncounterType,
-};
+  Enemy,
-export type EffectLifecycle =
+  Intent,
-  | "instant"
+  Item,
-  | "temporary"
+} from "../data/desert";
-  | "lingering"
-  | "permanent"
-  | "posture"
-  | "item"
-  | "itemTemporary"
-  | "itemUntilPlay"
-  | "itemUntilDiscard"
-  | "itemPermanent";
 
-export type EnemyData = {
+export type CardData = Card;
-  readonly id: string;
+export type ItemData = Item;
-  readonly name: string;
+export type EffectData = Effect;
-  readonly intents: readonly IntentData[];
+export type IntentData = Intent;
-  readonly description: string;
+export type EnemyData = Enemy;
-};
+export type EncounterData<T extends EncounterType = EncounterType> =
+  Encounter & { type: T };
 
-export type CardType = "item" | "status";
+export {
-export type CardCostType = "energy" | "uses" | "none";
+  CardTargetType,
-export type CardTargetType = "single" | "none";
+  CardEffectTarget,
-export type EffectTarget = "self" | "player" | "team";
+  IntentEffectTarget,
+} from "../data/desert";
 
-export type CardEffectTrigger = "onPlay" | "onDraw" | "onDiscard";
+export { ContentModule } from "../data";
-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;
-};

src/samples/tic-tac-toe.ts

@@ -1,10 +1,8 @@
 import { Part } from "@/core/part";
-import { createRegion } from "@/core/region";
+import { createRegion, Region } from "@/core/region";
-import {
+import { createPromptDef, IGameContext } from "@/core/game";
-  createGameCommandRegistry,
+import { BaseGameClient } from "@/core/game-client";
-  createPromptDef,
+import { createMiddlewareChain } from "@/utils/middleware";
-  IGameContext,
-} from "@/core/game";
 
 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({
+async function turn(
-  schema: "turn <player> <turnNumber:number>",
+  game: TicTacToeGame,
-  async run(game: TicTacToeGame, turnPlayer: PlayerType, turnNumber: number) {
+  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);
+  }
+}

src/utils/command/command-prompt.ts

@@ -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,
+  };
+}

src/utils/command/index.ts

@@ -1,6 +1,10 @@
-export { parseCommand } from './command-parse';
+export { parseCommand } from "./command-parse";
-export { parseCommandSchema } from './schema-parse';
+export { parseCommandSchema } from "./schema-parse";
-export { validateCommand, parseCommandWithSchema, applyCommandSchema } from './command-validate';
+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';
+} from "./types";
-export type { CommandRunner, CommandDef, CommandResult, CommandRunnerHandler, CommandRunnerContext, PromptEvent, CommandRunnerEvents } from './command-runner';
+export type {
-export type { CommandRegistry, CommandRunnerContextExport } from './command-registry';
+  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";

src/utils/middleware.ts

@@ -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>(
+export function createMiddlewareChain<
-  fallback?: (context: TContext) => Promise<TReturn>
+  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));

src/utils/mutable-signal.ts

@@ -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);
 }

src/utils/spawner.ts

@@ -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);
+  });
+}

tests/samples/slay-the-spire-like/combat/effects.test.ts

@@ -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,
+    targetType: "player" as const,
-    effects: [] as const,
+    effects: [] as CardEffect[],
   };
 }
 

tests/samples/slay-the-spire-like/combat/triggers.test.ts

@@ -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,
+    targetType: "player" as const,
-    effects: [],
+    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, {
+      await triggers.onEffectApplied.execute(ctx, {
-        entityKey: "仙人掌怪-0",
+        effect: attackEffect,
-        amount: 5,
+        entityId: "仙人掌怪-0",
-        sourceEntityKey: "player",
+        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(

tests/samples/slay-the-spire-like/deck/factory.test.ts

@@ -33,7 +33,7 @@ function createTestCardData(id: string, name: string, desc: string): CardData {
     type: "item",
     costType: "energy",
     costCount: 1,
-    targetType: "single",
+    targetType: "enemy",
     effects: [],
   };
 }

tests/samples/slay-the-spire-like/grid-inventory.test.ts

@@ -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: [],
   };
 }

tests/utils/command-prompt.test.ts

@@ -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" });
+    });
+  });
+});

tests/utils/command.test.ts

@@ -1,174 +1,176 @@
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect } from "vitest";
-import { parseCommand, type Command } from '@/utils/command';
+import { parseCommand, type Command } from "@/utils/command";
 
-describe('parseCommand', () => {
+describe("parseCommand", () => {
-    it('should parse empty string', () => {
+  it("should parse empty string", () => {
-        const result = parseCommand('');
+    const result = parseCommand("");
     expect(result).toEqual({
-            name: '',
+      name: "",
       flags: {},
       options: {},
-            params: []
+      params: [],
     });
   });
 
-    it('should parse command name only', () => {
+  it("should parse command name only", () => {
-        const result = parseCommand('move');
+    const result = parseCommand("move");
     expect(result).toEqual({
-            name: 'move',
+      name: "move",
       flags: {},
       options: {},
-            params: []
+      params: [],
     });
   });
 
-    it('should parse command with params', () => {
+  it("should parse command with params", () => {
-        const result = parseCommand('move meeple1 region1');
+    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', () => {
+  it("should parse command with long flags", () => {
-        const result = parseCommand('move meeple1 --force --quiet');
+    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', () => {
+  it("should parse command with short flags", () => {
-        const result = parseCommand('move meeple1 -f -q');
+    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', () => {
+  it("should parse command with long options", () => {
-        const result = parseCommand('move meeple1 --x 10 --y 20');
+    const result = parseCommand("move meeple1 --x 10 --y 20");
     expect(result).toEqual({
-            name: 'move',
+      name: "move",
       flags: {},
-            options: { x: '10', y: '20' },
+      options: { x: "10", y: "20" },
-            params: ['meeple1']
+      params: ["meeple1"],
     });
   });
 
-    it('should parse command with short options', () => {
+  it("should parse command with short options", () => {
-        const result = parseCommand('move meeple1 -x 10 -y 20');
+    const result = parseCommand("move meeple1 -x 10 -y 20");
     expect(result).toEqual({
-            name: 'move',
+      name: "move",
       flags: {},
-            options: { x: '10', y: '20' },
+      options: { x: "10", y: "20" },
-            params: ['meeple1']
+      params: ["meeple1"],
     });
   });
 
-    it('should parse command with mixed flags和选项', () => {
+  it("should parse command with mixed flags和选项", () => {
-        const result = parseCommand('move meeple1 region1 --force -x 10 -q');
+    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' },
+      options: { x: "10" },
-            params: ['meeple1', 'region1']
+      params: ["meeple1", "region1"],
     });
   });
 
-    it('should handle extra whitespace', () => {
+  it("should handle extra whitespace", () => {
-        const result = parseCommand('  move   meeple1   --force  ');
+    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', () => {
+  it("should parse complex command", () => {
-        const result = parseCommand('place meeple1 board --x 5 --y 3 --rotate 90 --force');
+    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' },
+      options: { x: "5", y: "3", rotate: "90" },
-            params: ['meeple1', 'board']
+      params: ["meeple1", "board"],
     });
   });
 
-    it('should treat negative number as option value', () => {
+  it("should treat negative number as option value", () => {
-        const result = parseCommand('set --value -10');
+    const result = parseCommand("set --value -10");
     expect(result).toEqual({
-            name: 'set',
+      name: "set",
       flags: {},
-            options: { value: '-10' },
+      options: { value: "-10" },
-            params: []
+      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' },
+      options: { x: "5" },
-            params: ['tile', 'large castle']
+      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' },
+      options: { x: "5" },
-            params: ['tile', 'large castle']
+      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', () => {
+  it("should handle mixed quotes", () => {
-        const result = parseCommand('cmd "hello world" \'foo bar\' --flag');
+    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"],
     });
   });
 });