board-game-engine 0.0.2 → 0.0.3

package/src/game/game.ts

@@ -1,362 +0,0 @@
-import cloneDeep from "lodash/cloneDeep.js";
-import matches from "lodash/matches.js";
-import merge from "lodash/merge.js";
-import get from "lodash/get.js";
-import boardFactory from "../board/board-factory.js";
-import Player from "../player/player";
-import roundFactory from "../round/round-factory.js";
-import conditionFactory from "../condition/condition-factory.js";
-import actionFactory from "../action/action-factory.js";
-import Pile from "../piece/pile.js";
-import findValuePath from "../utils/find-value-path.js";
-import { serialize, deserialize } from "wackson";
-import { registry } from "../registry.ts";
-
-export interface GameRules {
-  round: any;
-  player: any;
-  pieces: any[];
-  sharedBoard: Record<string, any>;
-  personalBoard?: Record<string, any>;
-  initialPlacements?: any[];
-  winCondition: any;
-  drawCondition?: any;
-}
-
-export interface GameOptions {
-  playerCount: number;
-  [key: string]: any;
-}
-
-export interface Move {
-  playerId: number;
-  type?: string;
-  piece?: {
-    id?: string;
-    name?: string;
-    player?: {
-      id: number;
-    };
-  };
-  board?: string[];
-  [key: string]: any;
-}
-
-export interface GameState {
-  currentPhaseIndex: number;
-  currentRoundIndex: number;
-  context: Record<string, any>;
-  status: 'waiting' | 'active' | 'done';
-  winner: Player | null;
-  sharedBoard: Record<string, any>;
-  players: Player[];
-  personalBoards: Record<string, any>;
-  pieces: Pile[];
-}
-
-function initializeState(state: GameState, rules: GameRules): GameState {
-  expandRules(rules)
-  state.sharedBoard = Object.entries(rules.sharedBoard).reduce(
-    (acc, [id, board]) => ({
-      ...acc,
-      [id]: boardFactory({ ...board, path: ["sharedBoard", id] }),
-    }),
-    {},
-  );
-
-  state.personalBoards = state.players.reduce(
-    (acc, player) => ({
-      ...acc,
-      [player.id]: Object.entries(rules.personalBoard || []).reduce(
-        (acc, [id, board]) => ({
-          ...acc,
-          [id]: boardFactory(
-            { ...board, path: ["sharedBoard", id] },
-            { player },
-          ),
-        }),
-        {},
-      ),
-    }),
-    {},
-  );
-
-  state.pieces = rules.pieces.reduce((acc, pieceRule) => {
-    if (pieceRule.perPlayer) {
-      return [
-        ...acc,
-        ...state.players.map((player) => new Pile(pieceRule, { player })),
-      ];
-    } else {
-      return [...acc, new Pile(pieceRule)];
-    }
-  }, []);
-
-  // Apply initial placements
-  rules.initialPlacements?.forEach((placement) => {
-    if (placement.perPlayer) {
-      state.players.forEach((player) => {
-        doInitialPlacement(placement, player, {
-          sharedBoard: state.sharedBoard,
-          personalBoards: state.personalBoards,
-          pieces: state.pieces,
-        });
-      });
-    } else {
-      doInitialPlacement(placement, null, {
-        sharedBoard: state.sharedBoard,
-        personalBoards: state.personalBoards,
-        pieces: state.pieces,
-      });
-    }
-  });
-
-  const currentRoundRule = rules.round.phases
-    ? rules.round.phases[0]
-    : rules.round;
-  state.currentRound = roundFactory(currentRoundRule, state);
-
-  state.status = 'active'
-
-  return state;
-}
-
-function checkWinner(state: GameState, rules: GameRules): Player | null {
-  return (
-    state.players.find((player) => {
-      const winCondition = {
-        ...rules.winCondition,
-        piece: {
-          ...rules.winCondition.piece,
-          player,
-        },
-      };
-      const condition = conditionFactory(winCondition, state);
-      return condition.isMet();
-    }) || null
-  );
-}
-
-function checkDraw(state: GameState, rules: GameRules): boolean {
-  return !!(
-    rules.drawCondition && conditionFactory(rules.drawCondition, state).isMet()
-  );
-}
-
-function expandActionPayload(move: Move, state: GameState, rules: GameRules) {
-  const player = state.players.find((p) => p.id === move.playerId);
-  if (!player && move.type !== 'join' && move.type !== 'start') {
-    throw new Error("Invalid player ID");
-  }
-
-  const pieceRule = rules.pieces.find((piece) => piece.name === move.piece?.name);
-
-  const expandedMove = cloneDeep(move)
-  if (pieceRule?.perPlayer && !expandedMove.player) {
-    expandedMove.piece.player = { id: player.id };
-  }
-
-  if (!expandedMove.board) {
-    expandedMove.board = getBoardPathContaining(expandedMove.piece, state);
-  }
-
-  expandedMove.board = normalizePath(expandedMove.board, { player });
-
-  return expandedMove;
-}
-
-function handlePlayerJoin(state, rules, move) {
-  if (state.players.length < rules.playerCountRange[1]) {
-    state.players.push(new Player(rules.player, state.players.length, move.playerId))
-  } else {
-    throw new Error('game is full!')
-  }
-}
-
-function handleStartGame(state,rules) {
-  if (state.players.length >= rules.playerCountRange[0]) {
-    initializeState(state, rules)
-  } else {
-    throw new Error('not enough players')
-  }
-}
-
-export function makeMove(
-  rules: GameRules,
-  _state?: GameState,
-  move?: Move,
-): GameState {
-  if (!_state) {
-    return serialize({
-      context: {},
-      winner: null,
-      status: 'waiting',
-      players: [],
-    })
-  } 
-
-  const state = deserializeState(_state)
-
-  if (state.status === 'done') {
-    throw new Error("Game is over!");
-  }
-
-  if (move === undefined) {
-    return serialize(state);
-  } else if (move?.type === 'join') {
-    handlePlayerJoin(state, rules, move)
-    return serialize(state)
-  } else if (move.type === 'start') {
-    handleStartGame(state, rules)
-    return serialize(state)
-  }
-
-
-  // Expand the move payload with defaults and normalizations
-  const expandedMove = expandActionPayload(move, state, rules);
-
-  const round = state.currentRound
-
-  round.doAction(expandedMove);
-  // Check if round is over and advance if needed
-  if (round.isOver(state)) {
-    if (rules.round.phases) {
-      // Get current phase rule
-      const currentPhaseRule = rules.round.phases[state.currentRound.currentPhaseIndex];
-
-      // Create round for current phase
-      const phaseRound = roundFactory(currentPhaseRule, state);
-
-      // If this phase is over, move to next phase
-      if (phaseRound.isOver(state)) {
-        state.currentRound.currentPhaseIndex++;
-
-        // If we've completed all phases, start new round
-        if (state.currentRound.currentPhaseIndex >= rules.round.phases.length) {
-          state.currentRound.currentPhaseIndex = 0;
-          state.currentRound.currentRoundIndex++;
-        }
-      }
-    } else {
-      // No phases, just increment round
-      state.currentRound.currentRoundIndex++;
-    }
-  }
-
-  // Check win/draw conditions
-  const winner = checkWinner(state, rules);
-  const isDraw = checkDraw(state, rules);
-
-  if (winner || isDraw) {
-    state.status = 'done'
-    state.winner = winner
-  }
-
-  return serialize(state)
-}
-
-function doInitialPlacement(
-  placement: {
-    action: any;
-    payload?: any;
-    count?: number;
-    rules: GameRules;
-  },
-  player: Player | null,
-  state: GameState,
-) {
-  const actionRule = placement.action;
-  const actionPayload = placement.payload || {};
-
-  if (player) {
-    actionPayload.player = player;
-  }
-
-  Array.from(new Array(placement.count || 1)).forEach(() => {
-    const action = actionFactory(actionRule, state);
-    action.do(expandActionPayload(actionPayload, state, rules));
-  });
-}
-
-function getBoardPathContaining(
-  piece: any,
-  state: GameState,
-  options?: any,
-): string[] {
-  return getPiecePaths(piece, state, options)[0];
-}
-
-function normalizePath(
-  path: string[],
-  options: { player?: Player } = {},
-): string[] {
-  return path[0] === "personalBoard" && options.player
-    ? ["personalBoards", options.player.id.toString(), ...path.slice(1)]
-    : path;
-}
-
-function getPiecePaths(
-  matcher: any,
-  state: GameState,
-  options?: any,
-): string[][] {
-  const placesPiecesCanBe = {
-    personalBoards: state.personalBoards,
-    sharedBoard: state.sharedBoard,
-    pieces: state.pieces,
-  };
-
-  return Array.from(findValuePath(placesPiecesCanBe, matches(matcher)))
-    .filter((a) => a[a.length - 1] !== "rule")
-    .sort((a) => (a[0] === "pieces" ? 1 : -1))
-    .map((path) => normalizePath(path, options));
-}
-
-function expandOptions(options) {
-  const defaultOptions = {
-    playerCount: 2,
-  };
-  return merge({}, defaultOptions, options);
-}
-
-// mutates rules
-function expandRules (rules) {
-  addPathToRules(rules)
-}
-
-// mutates rules
-export function addPathToRules (rules): void {
-  const CHILD_KEYS = ['phases', 'rounds'];
-
-  function annotate(node, pathSegs) {
-    if (!node || typeof node !== 'object') return;
-
-    // lodash.get path string, e.g. "round.phases.0.rounds.2"
-    node.path = pathSegs.join('.');
-
-    // recurse into either "phases" or "rounds" arrays if present
-    for (const key of CHILD_KEYS) {
-      const kids = node[key];
-      if (Array.isArray(kids)) {
-        kids.forEach((child, idx) => {
-          annotate(child, pathSegs.concat(key, idx));
-        });
-      }
-    }
-  }
-
-  // Top-level: support either "round" (object) or "rounds" (array), or both.
-  if (rules.round && typeof rules.round === 'object') {
-    annotate(rules.round, ['round']);
-  }
-  if (Array.isArray(rules.rounds)) {
-    rules.rounds.forEach((r, i) => annotate(r, ['rounds', i]));
-  }
-}
-
-function deserializeState (state) {
-  return deserialize(
-    state,
-    registry
-  )
-}

package/src/index.ts

@@ -1 +0,0 @@
-export { makeMove } from "./game/game";

package/src/piece/piece-factory.js

@@ -1,5 +0,0 @@
-import Piece from "./piece.ts";
-
-export default function pieceFactory(pieceRule, options) {
-  return new Piece(pieceRule, options);
-}

package/src/piece/piece.ts

@@ -1,25 +0,0 @@
-import type { PieceRule, PieceRuleMatcher } from "../../types";
-import type Player from "../player/player";
-
-interface Options {
-  player?: Player;
-}
-
-export default class Piece {
-  rule: PieceRule;
-  player: Player;
-  constructor(pieceRule: PieceRule, options: Options) {
-    this.rule = pieceRule;
-    this.id = `${Math.random()}`
-    if (options.player !== undefined) {
-      ({ player: this.player } = options);
-    }
-  }
-
-  doesRuleMatch(matcher: PieceRuleMatcher): boolean {
-    if (matcher.player !== undefined) {
-      return matcher.player === this.player;
-    }
-    return true;
-  }
-}

package/src/piece/pile.js

@@ -1,70 +0,0 @@
-import pieceFactory from './piece-factory.js'
-
-// all this extra complication is to support arbitrary (infinite) piles of pieces
-class Pile {
-  constructor (pieceRule, options = {}) {
-    this.pieceRule = pieceRule
-    this.name = pieceRule.name
-    this.id = `${Math.random()}`
-    if (options.player) {
-      this.player = options.player
-    }
-    this.options = options
-    this.pool = (
-      pieceRule.variants ? Object.entries(pieceRule.variants) : []
-    ).reduce((acc, [variantId, variant]) => {
-      const count = variant.count || 1
-      return [
-        ...acc,
-        ...Array.from(Array(count)).map((_) =>
-          pieceFactory(
-            { ...{ ...pieceRule, variantId }, ...variant },
-            this.options
-          )
-        )
-      ]
-    }, [])
-
-    if (pieceRule.shuffled) {
-      this.pool = this.pool
-        .map((value) => ({ value, sort: Math.random() }))
-        .sort((a, b) => a.sort - b.sort)
-        .map(({ value }) => value)
-    }
-
-    this.count = this.pool.length || pieceRule.count
-  }
-
-  getOne () {
-    return this.getMultiple(1)[0]
-  }
-
-  getMultiple (count) {
-    const toReturn = []
-    if (this.count === undefined || this.count >= count) {
-      if (this.count) {
-        this.count -= count
-      }
-      const remainder = count - this.pool.length
-      toReturn.push(...this.pool.splice(0, count))
-
-      if (remainder > 0) {
-        toReturn.push(
-          ...Array.from(new Array(remainder)).map(() =>
-            pieceFactory(this.pieceRule, this.options)
-          )
-        )
-      }
-    }
-    return toReturn
-  }
-
-  put (piece) {
-    if (this.count !== undefined) {
-      this.count += 1
-    }
-    this.pool.push(piece)
-  }
-}
-
-export default Pile

package/src/player/player.ts

@@ -1,13 +0,0 @@
-import type { PlayerRule } from "../../types";
-
-class Player {
-  rule: PlayerRule;
-  index: number;
-  constructor(rule: PlayerRule, index: number, id: string) {
-    this.rule = rule;
-    this.index = index;
-    this.id = id || `${Math.random()}`
-  }
-}
-
-export default Player;

package/src/registry.ts

@@ -1,51 +0,0 @@
-import Cls0 from "./action/action.js";
-import Cls1 from "./action/move-piece-action.js";
-import Cls2 from "./action/select-piece-action.js";
-import Cls3 from "./action/swap-action.js";
-import Cls4 from "./board/board-group.js";
-import Cls5 from "./board/board.js";
-import Cls6 from "./board/grid.js";
-import Cls7 from "./board/stack.js";
-import Cls8 from "./condition/action-type-matches-condition.js";
-import Cls9 from "./condition/bingo-condition.js";
-import Cls10 from "./condition/blackout-condition.js";
-import Cls11 from "./condition/condition.js";
-import Cls12 from "./condition/contains-condition.js";
-import Cls13 from "./condition/does-not-contain-condition.js";
-import Cls14 from "./condition/is-valid-player-condition.js";
-import Cls15 from "./condition/piece-matches-condition.js";
-import Cls16 from "./condition/relative-move-condition.js";
-import Cls17 from "./condition/some-condition.js";
-import Cls18 from "./piece/piece.ts";
-import Cls19 from "./piece/pile.js";
-import Cls20 from "./player/player.ts";
-import Cls21 from "./round/round.js";
-import Cls22 from "./round/sequential-player-turn.js";
-import Cls24 from "./space/space.ts";
-
-export const registry = {
-  "Action": Cls0,
-  "MovePieceAction": Cls1,
-  "SelectPieceAction": Cls2,
-  "SwapAction": Cls3,
-  "BoardGroup": Cls4,
-  "Board": Cls5,
-  "Grid": Cls6,
-  "Stack": Cls7,
-  "ActionTypeMatchesCondition": Cls8,
-  "BingoCondition": Cls9,
-  "BlackoutCondition": Cls10,
-  "Condition": Cls11,
-  "ContainsCondition": Cls12,
-  "DoesNotContainCondition": Cls13,
-  "IsValidPlayerCondition": Cls14,
-  "PieceMatchesCondition": Cls15,
-  "RelativeMoveCondition": Cls16,
-  "SomeCondition": Cls17,
-  "Piece": Cls18,
-  "Pile": Cls19,
-  "Player": Cls20,
-  "Round": Cls21,
-  "SequentialPlayerTurn": Cls22,
-  "Space": Cls24
-};

package/src/round/round-factory.js

@@ -1,7 +0,0 @@
-import SequentialPlayerTurn from "./sequential-player-turn.js";
-
-export default function roundFactory(roundRule, game) {
-  if (roundRule.type === "sequentialPlayerTurn") {
-    return new SequentialPlayerTurn(roundRule, game);
-  }
-}

package/src/round/round.js

@@ -1,41 +0,0 @@
-import actionFactory from '../action/action-factory.js'
-
-const DEBUG = true
-
-export default class Round {
-  constructor (rules, game) {
-    this.rules = rules
-    this.game = game
-    this.history = []
-    this.id = `${Math.random()}`
-    this.actions = rules.actions?.map((actionRule) =>
-      actionFactory(actionRule, this.game)
-    )
-  }
-
-  getCorrectAction (actionPayload) {
-    for (const action of this.actions) {
-      try {
-        action.assertIsValid(actionPayload)
-        return action
-      } catch (e) {
-        if (DEBUG) {
-          throw e
-        }
-      }
-    }
-    throw new Error(`Invalid Action: ${JSON.stringify(actionPayload)}`)
-  }
-
-  doAction (actionPayload) {
-    this.getCorrectAction(actionPayload).do(actionPayload, this.game)
-    this.afterDoAction()
-    this.history.push(actionPayload)
-  }
-
-  isOver () {
-    return true
-  }
-
-  afterDoAction () {}
-}

package/src/round/sequential-player-turn.js

@@ -1,18 +0,0 @@
-import Round from "./round.js";
-
-export default class SequentialPlayerTurn extends Round {
-  constructor(rules, game) {
-    super(rules, game);
-    this.currentPlayerIndex = 0;
-  }
-
-  afterDoAction() {
-    this.currentPlayerIndex = (this.currentPlayerIndex + 1) % this.game.players.length;
-  }
-
-  isOver() {
-    return this.game.players.every((player) =>
-      this.history.some((p) => p === player),
-    );
-  }
-}

package/src/space/space.ts

@@ -1,22 +0,0 @@
-import type Piece from "../piece/piece";
-
-type Coordinates = [number, number];
-
-export default class Space {
-  coordinates: Coordinates;
-  pieces: Piece[];
-
-  constructor(coordinates: Coordinates, startingPieces: Piece[] = []) {
-    this.coordinates = coordinates;
-    this.pieces = startingPieces;
-    this.id = `${Math.random()}`
-  }
-
-  placePiece(piece: Piece): void {
-    this.pieces.push(piece);
-  }
-
-  isEmpty(): boolean {
-    return this.pieces.length === 0;
-  }
-}

package/src/utils/find-value-path.js

@@ -1,37 +0,0 @@
-// todo: return found object along w/ path
-export default function findValuePath(
-  obj,
-  compare,
-  currentPath = [],
-  visited = new Set(),
-  results = new Set(),
-) {
-  // Check for circular reference
-  if (visited.has(obj)) {
-    return results; // Circular reference detected, short-circuit
-  }
-
-  visited.add(obj); // Mark the current object as visited
-
-  if (compare(obj)) {
-    results.add(currentPath);
-  }
-
-  if (typeof obj === "object" && obj !== null) {
-    for (const key in obj) {
-      const newPath = [...currentPath, key];
-      const result = findValuePath(
-        obj[key],
-        compare,
-        newPath,
-        visited,
-        results,
-      );
-      if (result.length) {
-        results.add(currentPath);
-      }
-    }
-  }
-
-  return results;
-}

package/src/utils/resolve-board.ts

@@ -1,38 +0,0 @@
-import get from 'lodash/get.js'
-
-export default function resolveBoard (board, gameState) {
-  // Case 1: if board is an array treat it as a path
-  if (Array.isArray(board)) {
-    return get(gameState, board)
-  }
-
-  const visited = new WeakSet()
-
-  function search (node) {
-    if (!node || typeof node !== 'object') return null
-
-    // Prevent infinite loops by tracking visited objects
-    if (visited.has(node)) return null
-    visited.add(node)
-
-    if (node.id === board.id) return node
-
-    if (node.grid && Array.isArray(node.grid)) {
-      for (const row of node.grid) {
-        for (const cell of row) {
-          const found = search(cell)
-          if (found) return found
-        }
-      }
-    }
-
-    for (const value of Object.values(node)) {
-      const found = search(value)
-      if (found) return found
-    }
-
-    return null
-  }
-
-  return search(gameState)
-}