boardgame-phaser/packages/sample-game/src/game/tic-tac-toe.ts

import {
  createGameCommandRegistry,
  type Part,
  createRegion,
  type MutableSignal,
} from 'boardgame-core';

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

export type PlayerType = 'X' | 'O';
export type WinnerType = PlayerType | 'draw' | null;

export type TicTacToePart = Part<{ player: PlayerType }>;

export function createInitialState() {
  return {
    board: createRegion('board', [
      { name: 'x', min: 0, max: BOARD_SIZE - 1 },
      { name: 'y', min: 0, max: BOARD_SIZE - 1 },
    ]),
    parts: {} as Record<string, TicTacToePart>,
    currentPlayer: 'X' as PlayerType,
    winner: null as WinnerType,
    turn: 0,
  };
}
export type TicTacToeState = ReturnType<typeof createInitialState>;

const registration = createGameCommandRegistry<TicTacToeState>();
export const registry = registration.registry;

registration.add('setup', async function () {
  const { context } = this;
  while (true) {
    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);

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

  return context.value;
});

registration.add('reset', async function () {
  const { context } = this;
  context.produce(state => {
    state.parts = {};
    state.board.childIds = [];
    state.board.partMap = {};
    state.currentPlayer = 'X';
    state.winner = null;
    state.turn = 0;
  });
  return { success: true };
});

registration.add('turn <player> <turn:number>', async function (cmd) {
  const [turnPlayer, turnNumber] = cmd.params as [PlayerType, number];

  const playCmd = await this.prompt(
    'play <player> <row:number> <col:number>',
    (command) => {
      const [player, row, col] = command.params as [PlayerType, number, number];

      if (player !== turnPlayer) {
        return `Invalid player: ${player}. Expected ${turnPlayer}.`;
      }
      if (row < 0 || row >= BOARD_SIZE || col < 0 || col >= BOARD_SIZE) {
        return `Invalid position: (${row}, ${col}).`;
      }
      const state = this.context.value;
      const partId = state.board.partMap[`${row},${col}`];
      if (partId) {
        return `Cell (${row}, ${col}) is already occupied.`;
      }
      return null;
    },
  );
  const [player, row, col] = playCmd.params as [PlayerType, number, number];

  placePiece(this.context, row, col, turnPlayer);

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

  return { winner: null };
});

export function isCellOccupied(host: MutableSignal<TicTacToeState>, row: number, col: number): boolean {
  return !!host.value.board.partMap[`${row},${col}`];
}

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

export function checkWinner(host: MutableSignal<TicTacToeState>): WinnerType {
  const parts = host.value.parts;

  const xPositions = Object.values(parts).filter((p: TicTacToePart) => p.player === 'X').map((p: TicTacToePart) => p.position);
  const oPositions = Object.values(parts).filter((p: TicTacToePart) => p.player === 'O').map((p: TicTacToePart) => p.position);

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

  return null;
}

export function placePiece(host: MutableSignal<TicTacToeState>, row: number, col: number, player: PlayerType) {
  const moveNumber = Object.keys(host.value.parts).length + 1;
  const piece: TicTacToePart = {
    id: `piece-${player}-${moveNumber}`,
    regionId: 'board',
    position: [row, col],
    player,
  };
  host.produce(state => {
    state.parts[piece.id] = piece;
    state.board.childIds.push(piece.id);
    state.board.partMap[`${row},${col}`] = piece.id;
  });
}