refactor: even tighter api

2026-04-02 14:46:34 +08:00
parent b2b35c3a99
commit e945d28fc3
3 changed files with 134 additions and 97 deletions
@@ -1,120 +1,143 @@
-import {createGameCommand, createGameCommandRegistry, IGameContext} from '../core/game';
+import {createGameCommandRegistry} from '../core/game';
 import type { Part } from '../core/part';
+import {Entity, entity} from "../utils/entity";
+import {Region} from "../core/region";
+
+const BOARD_SIZE = 3;
+const MAX_TURNS = BOARD_SIZE * BOARD_SIZE;
+const WINNING_LINES: number[][][] = [
+    [[0, 0], [0, 1], [0, 2]],
+    [[1, 0], [1, 1], [1, 2]],
+    [[2, 0], [2, 1], [2, 2]],
+    [[0, 0], [1, 0], [2, 0]],
+    [[0, 1], [1, 1], [2, 1]],
+    [[0, 2], [1, 2], [2, 2]],
+    [[0, 0], [1, 1], [2, 2]],
+    [[0, 2], [1, 1], [2, 0]],
+];

 type PlayerType = 'X' | 'O';
-type WinnerType = 'X' | 'O' | 'draw' | null;
+type WinnerType = PlayerType | 'draw' | null;
+
+type TicTacToePart = Part & { player: PlayerType };
+
 export function createInitialState() {
    return {
-        currentPlayer: 'O' as PlayerType,
+        board: entity<Region>('board', {
+            id: 'board',
+            axes: [
+                { name: 'x', min: 0, max: BOARD_SIZE - 1 },
+                { name: 'y', min: 0, max: BOARD_SIZE - 1 },
+            ],
+            children: [],
+        }),
+        parts: [] as Entity<TicTacToePart>[],
+        currentPlayer: 'X' as PlayerType,
        winner: null as WinnerType,
        turn: 0,
    };
 }
 export type TicTacToeState = ReturnType<typeof createInitialState>;
-export const registry = createGameCommandRegistry<TicTacToeState>();
-
-createGameCommand(registry, 'setup', async function() {
-    const {regions, state} = this.context;
-    regions.add({
-        id: 'board',
-        axes: [
-            { name: 'x', min: 0, max: 2 },
-            { name: 'y', min: 0, max: 2 },
-        ],
-        children: [],
-    });
+const registration = createGameCommandRegistry<TicTacToeState>();
+export const registry = registration.registry;

+registration.add('setup', async function() {
+    const {context} = this;
    while (true) {
-        let player = 'X' as PlayerType;
-        let turn = 0;
-        state.produce(state => {
-            player = state.currentPlayer = state.currentPlayer === 'X' ? 'O' : 'X';
-            turn = ++state.turn;
-        });
-        const turnOutput = await this.run<{winner: WinnerType}>(`turn ${player} ${turn}`);
+        const currentPlayer = context.value.currentPlayer;
+        const turnNumber = context.value.turn + 1;
+        const turnOutput = await this.run<{winner: WinnerType}>(`turn ${currentPlayer} ${turnNumber}`);
        if (!turnOutput.success) throw new Error(turnOutput.error);

-        state.produce(state => {
+        context.produce(state => {
            state.winner = turnOutput.result.winner;
+            if (!state.winner) {
+                state.currentPlayer = state.currentPlayer === 'X' ? 'O' : 'X';
+                state.turn = turnNumber;
+            }
        });
-        if (state.value.winner) break;
+        if (context.value.winner) break;
    }

-    return state.value;
+    return context.value;
 });

-createGameCommand(registry, 'turn <player> <turn:number>', async function(cmd) {
-    const [turnPlayer, turnNumber] = cmd.params as [string, number];
-    while (true) {
-        const playCmd = await this.prompt('play <player> <row:number> <col:number>');
-        const [player, row, col] = playCmd.params as [string, number, number];
-        if(turnPlayer !== player) continue;
+registration.add('turn <player> <turn:number>', async function(cmd) {
+    const [turnPlayer, turnNumber] = cmd.params as [PlayerType, number];
+    const maxRetries = MAX_TURNS * 2;
+    let retries = 0;

-        if (isNaN(row) || isNaN(col) || row < 0 || row > 2 || col < 0 || col > 2) continue;
+    while (retries < maxRetries) {
+        retries++;
+        const playCmd = await this.prompt('play <player> <row:number> <col:number>');
+        const [player, row, col] = playCmd.params as [PlayerType, number, number];
+
+        if (player !== turnPlayer) continue;
+        if (!isValidMove(row, col)) continue;
        if (isCellOccupied(this.context, row, col)) continue;

-        placePiece(this.context, row, col, turnNumber);
+        placePiece(this.context, row, col, turnPlayer);

        const winner = checkWinner(this.context);
-        if (winner) return { winner : winner as WinnerType };
+        if (winner) return { winner };
+        if (turnNumber >= MAX_TURNS) return { winner: 'draw' as WinnerType };

-        if (turnNumber >= 9) return { winner: 'draw' as WinnerType};
+        return { winner: null };
    }
+
+    throw new Error('Too many invalid attempts');
 });

-export function getBoardRegion(host: IGameContext<TicTacToeState>) {
-    return host.regions.get('board');
+function isValidMove(row: number, col: number): boolean {
+    return !isNaN(row) && !isNaN(col) && row >= 0 && row < BOARD_SIZE && col >= 0 && col < BOARD_SIZE;
 }

-export function isCellOccupied(host: IGameContext<TicTacToeState>, row: number, col: number): boolean {
+export function getBoardRegion(host: Entity<TicTacToeState>) {
+    return host.value.board;
+}
+
+export function isCellOccupied(host: Entity<TicTacToeState>, row: number, col: number): boolean {
    const board = getBoardRegion(host);
    return board.value.children.some(
-        part => {
-            return part.value.position[0] === row && part.value.position[1] === col;
-        }
+        part => part.value.position[0] === row && part.value.position[1] === col
    );
 }

 export function hasWinningLine(positions: number[][]): boolean {
-    const lines = [
-        [[0, 0], [0, 1], [0, 2]],
-        [[1, 0], [1, 1], [1, 2]],
-        [[2, 0], [2, 1], [2, 2]],
-        [[0, 0], [1, 0], [2, 0]],
-        [[0, 1], [1, 1], [2, 1]],
-        [[0, 2], [1, 2], [2, 2]],
-        [[0, 0], [1, 1], [2, 2]],
-        [[0, 2], [1, 1], [2, 0]],
-    ];
-
-    return lines.some(line =>
+    return WINNING_LINES.some(line =>
        line.every(([r, c]) =>
            positions.some(([pr, pc]) => pr === r && pc === c)
        )
    );
 }

-export function checkWinner(host: IGameContext<TicTacToeState>): 'X' | 'O' | 'draw' | null {
-    const parts = Object.values(host.parts.collection.value).map((s: { value: Part }) => s.value);
+export function checkWinner(host: Entity<TicTacToeState>): WinnerType {
+    const parts = host.value.parts.map((e: Entity<TicTacToePart>) => e.value);

-    const xPositions = parts.filter((_: Part, i: number) => i % 2 === 0).map((p: Part) => p.position);
-    const oPositions = parts.filter((_: Part, i: number) => i % 2 === 1).map((p: Part) => p.position);
+    const xPositions = parts.filter((p: TicTacToePart) => p.player === 'X').map((p: TicTacToePart) => p.position);
+    const oPositions = parts.filter((p: TicTacToePart) => p.player === 'O').map((p: TicTacToePart) => p.position);

    if (hasWinningLine(xPositions)) return 'X';
    if (hasWinningLine(oPositions)) return 'O';
+    if (parts.length >= MAX_TURNS) return 'draw';

    return null;
 }

-export function placePiece(host: IGameContext<TicTacToeState>, row: number, col: number, moveCount: number) {
+export function placePiece(host: Entity<TicTacToeState>, row: number, col: number, player: PlayerType) {
    const board = getBoardRegion(host);
-    const piece: Part = {
-        id: `piece-${moveCount}`,
+    const moveNumber = host.value.parts.length + 1;
+    const piece: TicTacToePart = {
+        id: `piece-${player}-${moveNumber}`,
        region: board,
        position: [row, col],
+        player,
    };
-    host.parts.add(piece);
-    board.produce(draft => {
-        draft.children.push(host.parts.get(piece.id));
+    host.produce(state => {
+        const e = entity(piece.id, piece)
+        state.parts.push(e);
+        board.produce(draft => {
+            draft.children.push(e);
+        });
    });
-}
+}