src/index.ts

@@ -19,7 +19,7 @@ export type { Region, RegionAxis } from './core/region';
 export { createRegion, createRegionAxis, applyAlign, shuffle, moveToRegion } from './core/region';
 
 // Utils
-export type { Command, CommandDef, CommandResult, CommandSchema, CommandParamSchema, CommandOptionSchema, CommandFlagSchema } from './utils/command';
+export type { Command, CommandResult, CommandSchema, CommandParamSchema, CommandOptionSchema, CommandFlagSchema } from './utils/command';
 export { parseCommand, parseCommandSchema, validateCommand, parseCommandWithSchema, applyCommandSchema } from './utils/command';
 
 export type { CommandRunner, CommandRunnerHandler, CommandRunnerContext, PromptEvent, CommandRunnerEvents } from './utils/command';

src/samples/boop/commands.ts

@@ -23,7 +23,7 @@ export const registry = createGameCommandRegistry<BoopState>();
 /**
  * 放置棋子到棋盘
  */
-async function handlePlace(game: BoopGame, row: number, col: number, player: PlayerType, type: PieceType) {
+async function place(game: BoopGame, row: number, col: number, player: PlayerType, type: PieceType) {
     const value = game.value;
     // 从玩家supply中找到对应类型的棋子
     const part = findPartInRegion(game, player, type);
@@ -42,15 +42,12 @@ async function handlePlace(game: BoopGame, row: number, col: number, player: Pla
 
     return { row, col, player, type, partId };
 }
-const place = registry.register({
+const placeCommand = registry.asCommand( 'place <row:number> <col:number> <player> <type>', place);
-    schema: 'place <row:number> <col:number> <player> <type>',
-    run: handlePlace
-});
 
 /**
  * 执行boop - 推动周围棋子
  */
-async function handleBoop(game: BoopGame, row: number, col: number, type: PieceType) {
+async function boop(game: BoopGame, row: number, col: number, type: PieceType) {
     const booped: string[] = [];
 
     await game.produceAsync(state => {
@@ -88,15 +85,12 @@ async function handleBoop(game: BoopGame, row: number, col: number, type: PieceT
 
     return { booped };
 }
-const boop = registry.register({
+const boopCommand = registry.asCommand('boop <row:number> <col:number> <type>', boop);
-    schema: 'boop <row:number> <col:number> <type>',
-    run: handleBoop
-});
 
 /**
  * 检查是否有玩家获胜(三个猫连线)
  */
-async function handleCheckWin(game: BoopGame): Promise<WinnerType | null> {
+async function checkWin(game: BoopGame): Promise<WinnerType | null> {
     for(const line of getLineCandidates()){
         let whites = 0;
         let blacks = 0;
@@ -115,15 +109,12 @@ async function handleCheckWin(game: BoopGame): Promise<WinnerType | null> {
     }
     return null;
 }
-const checkWin = registry.register({
+const checkWinCommand = registry.asCommand('check-win', checkWin);
-    schema: 'check-win',
-    run: handleCheckWin
-});
 
 /**
  * 检查并执行小猫升级(三个小猫连线变成猫)
  */
-async function handleCheckGraduates(game: BoopGame){
+async function checkGraduates(game: BoopGame){
     const toUpgrade = new Set<string>();
     for(const line of getLineCandidates()){
         let whites = 0;
@@ -154,15 +145,12 @@ async function handleCheckGraduates(game: BoopGame){
         }
     });
 }
-const checkGraduates = registry.register({
+const checkGraduatesCommand = registry.asCommand('check-graduates', checkGraduates);
-    schema: 'check-graduates',
-    run: handleCheckGraduates
-});
 
-async function handleStart(game: BoopGame) {
+async function setup(game: BoopGame) {
     while (true) {
         const currentPlayer = game.value.currentPlayer;
-        const turnOutput = await turn(game, currentPlayer);
+        const turnOutput = await turnCommand(game, currentPlayer);
 
         await game.produceAsync(state => {
             state.winner = turnOutput.winner;
@@ -175,12 +163,9 @@ async function handleStart(game: BoopGame) {
 
     return game.value;
 }
-const start = registry.register({
+registry.asCommand('setup', setup);
-    schema: 'start',
-    run: handleStart
-});
 
-async function handleCheckFullBoard(game: BoopGame, turnPlayer: PlayerType){
+async function checkFullBoard(game: BoopGame, turnPlayer: PlayerType){
     // 检查8-piece规则: 如果玩家所有8个棋子都在棋盘上且没有获胜,强制升级一个小猫
     const playerPieces = Object.values(game.value.pieces).filter(
         p => p.player === turnPlayer && p.regionId === 'board'
@@ -216,12 +201,8 @@ async function handleCheckFullBoard(game: BoopGame, turnPlayer: PlayerType){
         moveToRegion(cat || part, null, state.regions[turnPlayer]);
     });
 }
-const checkFullBoard = registry.register({
-    schema: 'check-full-board <player:string>',
-    run: handleCheckFullBoard
-});
 
-async function handleTurn(game: BoopGame, turnPlayer: PlayerType) {
+async function turn(game: BoopGame, turnPlayer: PlayerType) {
     const {row, col, type} = await game.prompt(
         'play <player> <row:number> <col:number> [type:string]',
         (command) => {
@@ -248,16 +229,13 @@ async function handleTurn(game: BoopGame, turnPlayer: PlayerType) {
     );
     const pieceType = type === 'cat' ? 'cat' : 'kitten';
 
-    await place(game, row, col, turnPlayer, pieceType);
+    await placeCommand(game, row, col, turnPlayer, pieceType);
-    await boop(game, row, col, pieceType);
+    await boopCommand(game, row, col, pieceType);
-    const winner = await checkWin(game);
+    const winner = await checkWinCommand(game);
     if(winner) return { winner: winner };
     
-    await checkGraduates(game);
+    await checkGraduatesCommand(game);
     await checkFullBoard(game, turnPlayer);
     return { winner: null };
 }
-const turn = registry.register({
+const turnCommand = registry.asCommand('turn <player>', turn);
-    schema: 'turn <player:string>',
-    run: handleTurn
-});

src/samples/tic-tac-toe.ts

@@ -36,58 +36,54 @@ export type TicTacToeState = ReturnType<typeof createInitialState>;
 export type TicTacToeGame = IGameContext<TicTacToeState>;
 export const registry = createGameCommandRegistry<TicTacToeState>();
 
-registry.register({
+async function start(game: TicTacToeGame) {
-    schema: 'start',
+    while (true) {
-    async run(game: TicTacToeGame) {
+        const currentPlayer = game.value.currentPlayer;
-        while (true) {
+        const turnNumber = game.value.turn + 1;
-            const currentPlayer = game.value.currentPlayer;
+        const turnOutput = await turnCommand(game, currentPlayer, turnNumber);
-            const turnNumber = game.value.turn + 1;
-            const turnOutput = await turn(game, currentPlayer, turnNumber);
 
-            game.produce(state => {
+        game.produce(state => {
-                state.winner = turnOutput.winner;
+            state.winner = turnOutput.winner;
-                if (!state.winner) {
+            if (!state.winner) {
-                    state.currentPlayer = state.currentPlayer === 'X' ? 'O' : 'X';
+                state.currentPlayer = state.currentPlayer === 'X' ? 'O' : 'X';
-                    state.turn = turnNumber;
+                state.turn = turnNumber;
-                }
+            }
-            });
+        });
-            if (game.value.winner) break;
+        if (game.value.winner) break;
-        }
-
-        return game.value;
     }
-});
 
-const turn = registry.register({
+    return game.value;
-    schema: 'turn <player> <turnNumber:number>',
+}
-    async run(game: TicTacToeGame, turnPlayer: PlayerType, turnNumber: number) {
+registry.asCommand('start', start);
-        const {player, row, col} = await game.prompt(
-            'play <player> <row:number> <col:number>',
-            (command) => {
-                const [player, row, col] = command.params as [PlayerType, number, number];
 
-                if (player !== turnPlayer) {
+async function turn(game: TicTacToeGame, turnPlayer: PlayerType, turnNumber: number) {
-                    throw `Invalid player: ${player}. Expected ${turnPlayer}.`;
+    const {player, row, col} = await game.prompt(
-                } else if (!isValidMove(row, col)) {
+        'play <player> <row:number> <col:number>',
-                    throw `Invalid position: (${row}, ${col}). Must be between 0 and ${BOARD_SIZE - 1}.`;
+        (command) => {
-                } else if (isCellOccupied(game, row, col)) {
+            const [player, row, col] = command.params as [PlayerType, number, number];
-                    throw `Cell (${row}, ${col}) is already occupied.`;
-                } else {
-                    return { player, row, col };
-                }
-            },
-            game.value.currentPlayer
-        );
 
-        placePiece(game, row, col, turnPlayer);
+            if (player !== turnPlayer) {
+                throw `Invalid player: ${player}. Expected ${turnPlayer}.`;
+            } else if (!isValidMove(row, col)) {
+                throw `Invalid position: (${row}, ${col}). Must be between 0 and ${BOARD_SIZE - 1}.`;
+            } else if (isCellOccupied(game, row, col)) {
+                throw `Cell (${row}, ${col}) is already occupied.`;
+            } else {
+                return { player, row, col };
+            }
+        },
+        game.value.currentPlayer
+    );
 
-        const winner = checkWinner(game);
+    placePiece(game, row, col, turnPlayer);
-        if (winner) return { winner };
-        if (turnNumber >= MAX_TURNS) return { winner: 'draw' as WinnerType };
 
-        return { winner: null };
+    const winner = checkWinner(game);
-    }
+    if (winner) return { winner };
-});
+    if (turnNumber >= MAX_TURNS) return { winner: 'draw' as WinnerType };
+
+    return { winner: null };
+}
+const turnCommand = registry.asCommand('turn <player:string> <turnNumber:int>', turn);
 
 function isValidMove(row: number, col: number): boolean {
     return !isNaN(row) && !isNaN(col) && row >= 0 && row < BOARD_SIZE && col >= 0 && col < BOARD_SIZE;

src/utils/command/command-registry.ts

@@ -1,6 +1,5 @@
 import type { Command, CommandSchema } from './types';
 import type {
-    CommandDef, CommandFunction,
     CommandResult,
     CommandRunner,
     CommandRunnerContext,
@@ -17,17 +16,9 @@ type CanRunParsed = {
     runParsed<T=unknown>(command: Command): Promise<CommandResult<T>>,
 }
 
+type CmdFunc<TContext> = (ctx: TContext, ...args: any[]) => Promise<unknown>;
 export class CommandRegistry<TContext> extends Map<string, CommandRunner<TContext>>{
-    register<TFunc extends CommandFunction<TContext>>(...args: [schema: CommandSchema | string, run: TFunc] | [CommandDef<TContext, TFunc>]){
+    asCommand<TFunc extends CmdFunc<TContext> = CmdFunc<TContext>>(schema: CommandSchema | string, run: TFunc) {
-        let schema: CommandSchema | string;
-        let run: TFunc;
-        if(args.length === 1){
-            schema = args[0].schema;
-            run = args[0].run;
-        }else{
-            schema = args[0];
-            run = args[1];
-        }
         const parsedSchema = typeof schema === 'string' ? parseCommandSchema(schema) : schema;
         registerCommand(this, {
             schema: parsedSchema,

src/utils/command/command-runner.ts

@@ -51,9 +51,3 @@ export type CommandRunner<TContext, TResult = unknown> = {
     schema: CommandSchema;
     run: CommandRunnerHandler<TContext, TResult>;
 };
-
-export type CommandFunction<TContext> = (ctx: TContext, ...args: any[]) => Promise<unknown>;
-export type CommandDef<TContext,TFunc extends CommandFunction<TContext>> = {
-    schema: string | CommandSchema,
-    run: TFunc;
-}

src/utils/command/index.ts

@@ -18,5 +18,5 @@ export type {
     CommandFlagSchema,
     CommandSchema,
 } from './types';
-export type { CommandRunner, CommandDef, CommandResult, CommandRunnerHandler, CommandRunnerContext, PromptEvent, CommandRunnerEvents } from './command-runner';
+export type { CommandRunner, CommandResult, CommandRunnerHandler, CommandRunnerContext, PromptEvent, CommandRunnerEvents } from './command-runner';
 export type { CommandRegistry, CommandRunnerContextExport } from './command-registry';