board-game-engine 2.0.0 → 2.0.1

package/src/game-factory/condition/would-condition.ts

@@ -0,0 +1,104 @@
+import type { Condition as ConditionRule } from "../../types/bagel-types.js";
+import Condition from "./condition.js";
+import checkConditions from "../../utils/check-conditions.js";
+import simulateMove from "../../utils/simulate-move.js";
+import type { BgioResolveState } from "../../utils/bgio-resolve-types.js";
+
+const argNameMap: Record<string, string[]> = {
+  PlaceNew: ["destination"],
+  RemoveEntity: ["entity"],
+  MoveEntity: ["entity", "destination"],
+  TakeFrom: ["source", "destination"],
+  SetState: ["entity", "state"],
+};
+
+export default class WouldCondition extends Condition {
+  checkCondition (
+    bgioArguments: unknown,
+    rule: unknown,
+    conditionPayload: Record<string, unknown>,
+    context: Record<string, unknown>
+  ) {
+    const target = conditionPayload.target;
+    const targets = (conditionPayload.targets as unknown[] | undefined) ?? [target];
+
+    const moveType = (context.moveInstance as { rule: { moveType: string } } | undefined)?.rule?.moveType;
+    const argNames = moveType ? argNameMap[moveType] : undefined;
+    const payload = {
+      arguments: targets.reduce<Record<string, unknown>>((acc, t, i) => {
+        const key = argNames?.[i] ?? `arg${i}`;
+        return { ...acc, [key]: t };
+      }, {}),
+    };
+
+    const simulatedG = simulateMove(
+      bgioArguments as BgioResolveState,
+      payload as Parameters<typeof simulateMove>[1],
+      context as Parameters<typeof simulateMove>[2]
+    ) as { bank: { locate: (id: unknown) => unknown } };
+
+    let simulatedConditionsPayload: Record<string, unknown> = {};
+    if (target) {
+      simulatedConditionsPayload = {
+        target: simulatedG.bank.locate((target as { entityId: unknown }).entityId),
+      };
+    } else if (targets) {
+      simulatedConditionsPayload = {
+        targets: targets.map((t) => simulatedG.bank.locate((t as { entityId: unknown }).entityId)),
+      };
+    }
+
+    const conditionResults = checkConditions(
+      { ...(bgioArguments as BgioResolveState), G: simulatedG } as BgioResolveState,
+      (rule as { conditions?: ConditionRule[] }).conditions,
+      simulatedConditionsPayload,
+      context
+    );
+
+    const conditionIsMet = conditionResults.conditionsAreMet;
+
+    const results = conditionIsMet
+      ? restoreReferences(
+        conditionResults.results,
+        (entityId: unknown) =>
+          (bgioArguments as { G: { bank: { locate: (id: unknown) => unknown } } }).G.bank.locate(entityId)
+      )
+      : conditionResults.results;
+
+    return {
+      results,
+      conditionIsMet,
+    };
+  }
+}
+
+function restoreReferences (
+  obj: unknown,
+  getOriginalEntity: (id: unknown) => unknown,
+  seen = new WeakSet<object>()
+): unknown {
+  if (typeof obj !== "object" || obj === null) {
+    return obj;
+  }
+
+  if (seen.has(obj)) {
+    return obj;
+  }
+  seen.add(obj);
+
+  if ((obj as { entityId?: unknown }).entityId !== undefined) {
+    return getOriginalEntity((obj as { entityId: unknown }).entityId);
+  }
+
+  if (Array.isArray(obj)) {
+    return obj.map((item) => restoreReferences(item, getOriginalEntity, seen));
+  }
+
+  const restored: Record<string, unknown> = {};
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      restored[key] = restoreReferences((obj as Record<string, unknown>)[key], getOriginalEntity, seen);
+    }
+  }
+  return restored;
+}

package/src/game-factory/entity.ts

@@ -0,0 +1,37 @@
+export default class Entity {
+  rule: Record<string, unknown>;
+  entityId: number;
+  state: Record<string, unknown>;
+
+  constructor (
+    options: { fromBank?: boolean; initialStateGroups?: Record<string, string> } | undefined,
+    rule: Record<string, unknown>,
+    id: number
+  ) {
+    if (!options?.fromBank) {
+      throw new Error(`Do not create entities directly. Go through the Bank. rule: ${JSON.stringify(rule)}`);
+    }
+    this.rule = rule;
+    this.entityId = id;
+    this.state = {};
+    if (this.rule.stateGroups) {
+      Object.entries(this.rule.stateGroups as Record<string, Record<string, Record<string, unknown>>>)
+        .forEach(([stateGroupName, stateGroupValues]) => {
+          const stateGroupValueName = options?.initialStateGroups?.[stateGroupName]
+            ?? Object.keys(stateGroupValues)[0];
+          Object.assign(this.state, stateGroupValues[stateGroupValueName]);
+        });
+    }
+    if (this.rule.state) {
+      Object.assign(this.state, this.rule.state as Record<string, unknown>);
+    }
+  }
+
+  get attributes () {
+    return {
+      ...this.rule,
+      ...this,
+      ...this.state,
+    };
+  }
+}

package/src/game-factory/expand-game-rules.ts

@@ -0,0 +1,263 @@
+import find from "lodash/find.js";
+import type { Entity, EntityMatcher, EntityAttributes, GameFactoryInput, ExpandedGameRules, MoveDefinition } from "../types/bagel-types.js";
+import transformJSON from "../utils/json-transformer.js";
+
+type TransformRule = {
+  test: (val: unknown) => boolean;
+  replace: (val: unknown) => unknown;
+};
+
+const invariantEntities = [
+  {
+    entityType: "Space",
+    count: "Infinity",
+  },
+  {
+    entityType: "Board",
+    name: "sharedBoard",
+  },
+  {
+    name: "playerMarker",
+    perPlayer: true,
+    count: "Infinity",
+  },
+] as Entity[];
+
+function expandEntities (rules: { entities: Entity[] }) {
+  rules.entities = [
+    ...invariantEntities,
+    ...(rules.entities || []),
+  ];
+}
+
+function expandInitialPlacements (rules: Record<string, unknown>, entities: Entity[]) {
+  if (rules.sharedBoard) {
+    const sharedBoard = rules.sharedBoard as EntityMatcher<EntityAttributes<Entity>>[];
+    const sharedBoardPlacements = sharedBoard.map((matcher) => ({ entity: matcher, destination: { name: "sharedBoard" } }));
+    if (!rules.initialPlacements) rules.initialPlacements = [];
+    (rules.initialPlacements as unknown[]).unshift(...sharedBoardPlacements);
+  }
+
+  if (rules.personalBoard) {
+    entities.push({
+      entityType: "Board",
+      name: "personalBoard",
+      perPlayer: true,
+    });
+    const personalBoard = rules.personalBoard as EntityMatcher<EntityAttributes<Entity>>[];
+    const personalBoardPlacements = personalBoard.map((matcher) => ({
+      entity: matcher,
+      destination: {
+        name: "personalBoard",
+      },
+    }));
+    if (!rules.initialPlacements) rules.initialPlacements = [];
+    (rules.initialPlacements as unknown[]).unshift(...personalBoardPlacements);
+  }
+
+  if (rules.initialPlacements) {
+    const initialPlacementMoves = (rules.initialPlacements as Array<{ entity: Record<string, unknown>; destination: { index?: number; name?: string } }>).map((placement) => {
+      const { state, ...matcher } = placement.entity;
+      const entityDefinition = find(entities, matcher) as Entity | undefined;
+
+      if (placement.destination.name === "personalBoard") {
+        return {
+          moveType: "ForEach",
+          arguments: {
+            targets: {
+              type: "ctxPath",
+              path: ["playOrder"],
+            },
+          },
+          move: {
+            moveType: "PlaceNew",
+            entity: {
+              state,
+              conditions: [{
+                conditionType: "Is",
+                matcher: {
+                  ...matcher,
+                  ...(entityDefinition?.perPlayer
+                    ? {
+                        player: {
+                          type: "contextPath",
+                          path: ["loopTarget"],
+                        },
+                      }
+                    : {}
+                  ),
+                },
+              }],
+            },
+            arguments: {
+              destination: {
+                conditions: [{
+                  conditionType: "Is",
+                  matcher: {
+                    ...placement.destination,
+                    player: {
+                      type: "contextPath",
+                      path: ["loopTarget"],
+                    },
+                  },
+                }],
+              },
+            },
+          },
+        } as MoveDefinition;
+      } else {
+        return {
+          moveType: "PlaceNew",
+          entity: {
+            state,
+            conditions: [{
+              conditionType: "Is",
+              matcher,
+            }],
+          },
+          arguments: {
+            destination: {
+              conditions: [{
+                conditionType: "Is",
+                matcher: placement.destination,
+              }],
+            },
+          },
+        } as MoveDefinition;
+      }
+    });
+    if (!rules.initialMoves) rules.initialMoves = [];
+    (rules.initialMoves as MoveDefinition[]).unshift(...initialPlacementMoves);
+    delete rules.initialPlacements;
+  }
+}
+
+const keyMappings: [string, string][] = [];
+
+const simpleReplacements: [string, unknown][] = [
+  [
+    "isCurrentPlayer",
+    {
+      conditionType: "Is",
+      matcher: {
+        player: {
+          type: "ctxPath",
+          path: ["currentPlayer"],
+        },
+      },
+    },
+  ],
+  [
+    "isEmpty",
+    {
+      conditionType: "Not",
+      conditions: [{ conditionType: "Contains" }],
+    },
+  ],
+  [
+    "ownerOfFirstResultEntity",
+    {
+      type: "contextPath",
+      path: ["results", 0, "matches", 0, 0, "entities", 0, "attributes", "player"],
+    },
+  ],
+];
+
+const transformationRules: TransformRule[] = [
+  {
+    test: (val) => Boolean(val && typeof val === "object"),
+    replace: (val) => {
+      const obj = val as Record<string, unknown>;
+      keyMappings.forEach(([oldKey, newKey]) => {
+        if (Object.prototype.hasOwnProperty.call(obj, oldKey)) {
+          obj[newKey] = obj[oldKey];
+          delete obj[oldKey];
+        }
+      });
+      return val;
+    },
+  },
+  {
+    test: (val) => typeof val === "string",
+    replace: (val) => {
+      for (let i = 0, len = simpleReplacements.length; i < len; i++) {
+        if (val === simpleReplacements[i][0]) {
+          return simpleReplacements[i][1];
+        }
+      }
+      return val;
+    },
+  },
+  {
+    test: (val) => Boolean(val && typeof val === "object" && (val as { conditions?: unknown }).conditions),
+    replace: (val) => {
+      const v = val as { conditions: unknown };
+      if (!Array.isArray(v.conditions)) {
+        v.conditions = [v.conditions];
+      }
+      return val;
+    },
+  },
+  {
+    test: (val) => Boolean(val && typeof val === "object" && (val as { conditions?: unknown }).conditions),
+    replace: (val) => {
+      const v = val as { conditions: Array<Record<string, unknown>> };
+      for (let i = 0, len = v.conditions.length; i < len; i++) {
+        if (!v.conditions[i].conditionType) {
+          v.conditions[i] = {
+            conditionType: "Is",
+            matcher: v.conditions[i],
+          };
+        }
+      }
+      return val;
+    },
+  },
+  {
+    test: (val) => Boolean(val && typeof val === "object" && typeof (val as { target?: unknown }).target === "string"),
+    replace: (val) => {
+      const v = val as { target: string };
+      return {
+        ...v,
+        target: {
+          conditions: [{
+            conditionType: "Is",
+            matcher: {
+              name: v.target,
+            },
+          }],
+        },
+      };
+    },
+  },
+];
+
+export default function expandGameRules (gameRules: GameFactoryInput): ExpandedGameRules {
+  const rules = transformJSON(gameRules, transformationRules) as GameFactoryInput;
+
+  if (!rules.sharedBoard) {
+    rules.sharedBoard = rules.entities as unknown as GameFactoryInput["sharedBoard"];
+  }
+
+  if (!rules.turn) {
+    rules.turn = {
+      minMoves: 1,
+      maxMoves: 1,
+    };
+  }
+
+  expandEntities(rules);
+  expandInitialPlacements(rules as unknown as Record<string, unknown>, rules.entities);
+
+  if (rules.phases) {
+    Object.entries(rules.phases).forEach((phaseRule) => {
+      expandInitialPlacements(phaseRule as unknown as Record<string, unknown>, rules.entities);
+    });
+  }
+
+  if (gameRules.numPlayers) {
+    gameRules.minPlayers = gameRules.maxPlayers = gameRules.numPlayers;
+  }
+
+  return rules as ExpandedGameRules;
+}

package/src/game-factory/game-factory.ts

@@ -0,0 +1,263 @@
+import { serialize } from "wackson";
+import type { GameFactoryInput, MoveDefinition, TurnConfig } from "../types/bagel-types.js";
+import moveFactory from "./move/move-factory.js";
+import Bank from "./bank/bank.js";
+import expandGameRules from "./expand-game-rules.js";
+import getScenarioResults from "../utils/get-scenario-results.js";
+import doMoves from "../utils/do-moves.js";
+import deserializeBgioArguments from "../utils/deserialize-bgio-arguments.js";
+import type { BgioResolveState } from "../utils/bgio-resolve-types.js";
+
+/** boardgame.io-style arguments (minimal typing; engine passes full objects). */
+export type BgioArguments = BgioResolveState;
+
+/** Object returned from `gameFactory` (boardgame.io game definition). */
+export type BoardGameEngineGame = Record<string, unknown> & { name: string };
+
+export default function gameFactory (
+  gameRules: GameFactoryInput,
+  gameName: string
+): BoardGameEngineGame {
+  const game: BoardGameEngineGame = { name: gameName };
+  const rules = expandGameRules(gameRules);
+
+  game.setup = (bgioArguments: BgioArguments) => {
+    const { ctx } = bgioArguments;
+    const initialState: Record<string, unknown> = {
+      _meta: {
+        passedPlayers: [],
+        previousPayloads: {},
+      },
+    };
+
+    const entityDefinitions = expandEntityDefinitions(rules.entities, ctx as { numPlayers: number }) as Record<string, unknown>[];
+    const bank = new Bank(entityDefinitions);
+    initialState.bank = bank;
+    initialState.sharedBoard = bank.getOne(
+      bgioArguments,
+      {
+        conditions: [{
+          conditionType: "Is",
+          matcher: { name: "sharedBoard" },
+        }],
+      },
+      {}
+    );
+
+    if (rules.personalBoard) {
+      initialState.personalBoards = (bgioArguments.ctx as { playOrder: string[] }).playOrder.map((playerID: string) =>
+        bank.getOne(
+          bgioArguments,
+          {
+            conditions: [{
+              conditionType: "Is",
+              matcher: {
+                name: "personalBoard",
+                player: playerID,
+              },
+            }],
+          },
+          {}
+        )
+      );
+    }
+
+    rules.initialMoves?.forEach((moveRule) => {
+      moveFactory(moveRule, game).moveInstance!.doMove(
+        { ...bgioArguments, G: initialState },
+        undefined,
+        {}
+      );
+    });
+    return JSON.parse(serialize(initialState));
+  };
+
+  if (rules.moves) {
+    game.moves = createMoves(rules.moves, game);
+  }
+
+  if (rules.turn) {
+    game.turn = createTurn(rules.turn, game);
+  }
+
+  if (rules.phases) {
+    game.phases = Object.entries(rules.phases).reduce<Record<string, unknown>>((acc, [name, phaseRule]) => ({
+      ...acc,
+      [name]: createPhase(phaseRule as Record<string, unknown>, game),
+    }), {});
+  }
+
+  if (rules.endIf) {
+    const endIfRules = rules.endIf;
+    game.endIf = (bgioArguments: BgioArguments) => {
+      const newBgioArguments = deserializeBgioArguments(bgioArguments);
+      return getScenarioResults(newBgioArguments, endIfRules);
+    };
+  }
+
+  if (!gameRules.DEBUG_DISABLE_SECRET_STATE) {
+    game.playerView = (bgioArguments: BgioArguments) => {
+      const { G, playerID } = deserializeBgioArguments(bgioArguments);
+      const tracker = (G as { bank: { tracker: Record<string, {
+        rule: { contentsHiddenFrom?: string; player?: string; hideLength?: boolean };
+        spaces?: unknown[];
+        entities?: unknown[];
+      }> } }).bank.tracker;
+      Object.values(tracker).forEach((entity) => {
+        if (
+          entity.rule.contentsHiddenFrom === "All" ||
+          (
+            entity.rule.contentsHiddenFrom === "Others" &&
+            (
+              playerID !== entity.rule.player ||
+              playerID === undefined
+            )
+          )
+        ) {
+          if (entity.spaces) {
+            entity.spaces = entity.rule.hideLength
+              ? []
+              : entity.spaces.map(() => (G as { bank: { createEntity: () => unknown } }).bank.createEntity());
+          }
+          if (entity.entities) {
+            entity.entities = entity.rule.hideLength
+              ? []
+              : entity.entities.map(() => (G as { bank: { createEntity: () => unknown } }).bank.createEntity());
+          }
+        }
+      });
+      return JSON.parse(serialize(G));
+    };
+  }
+
+  return game;
+}
+
+function expandEntityDefinitions (entities: unknown[], ctx: { numPlayers: number }) {
+  return entities.reduce<unknown[]>((acc, entity) => {
+    const entityCopy = { ...(entity as Record<string, unknown>) };
+
+    if (entityCopy.perPlayer) {
+      delete entityCopy.perPlayer;
+      if (entityCopy.variants) {
+        entityCopy.variants =
+          (new Array(ctx.numPlayers)).fill(undefined).reduce<unknown[]>((accu, _, i) => [
+            ...accu,
+            ...(entityCopy.variants as unknown[]).map((variant: unknown) => ({ ...(variant as object), player: `${i}` })),
+          ], []);
+      } else {
+        entityCopy.variants =
+          (new Array(ctx.numPlayers)).fill(undefined).map((_, i) => ({ player: `${i}` }));
+      }
+    }
+
+    if (entityCopy.variants) {
+      const variants = entityCopy.variants as unknown[];
+      delete entityCopy.variants;
+
+      return [
+        ...acc,
+        ...variants.map((variant) => ({
+          ...entityCopy,
+          ...(variant as object),
+        })),
+      ];
+    } else {
+      return [
+        ...acc,
+        entityCopy,
+      ];
+    }
+  }, []);
+}
+
+function createTurn (turnRule: TurnConfig | Record<string, unknown>, game: BoardGameEngineGame) {
+  const turn = { ...turnRule } as Record<string, unknown>;
+
+  turn.onBegin = (bgioArguments: BgioArguments) => {
+    const newBgioArguments = deserializeBgioArguments(bgioArguments);
+    const stageRule = (turnRule.stages as Record<string, { initialMoves?: MoveDefinition[] }> | undefined)?.[
+      (newBgioArguments.ctx as { activePlayers?: Record<string, string>; currentPlayer: string }).activePlayers?.[
+        (newBgioArguments.ctx as { currentPlayer: string }).currentPlayer
+      ] as string
+    ];
+
+    (newBgioArguments.G as { _meta: { passedPlayers: string[] } })._meta.passedPlayers = (newBgioArguments.G as { _meta: { passedPlayers: string[] } })._meta.passedPlayers
+      .filter((p) => p !== (newBgioArguments.ctx as { currentPlayer: string }).currentPlayer);
+
+    doMoves(newBgioArguments, turnRule.initialMoves as MoveDefinition[] | undefined, { game });
+    doMoves(newBgioArguments, stageRule?.initialMoves, { game });
+
+    return JSON.parse(serialize(newBgioArguments.G));
+  };
+
+  if (turnRule.stages) {
+    Object.entries(turnRule.stages as Record<string, { moves?: Record<string, MoveDefinition> }>).forEach(([stageName, stageRule]) => {
+      if (stageRule.moves) {
+        ((turn.stages as Record<string, { moves?: Record<string, unknown> }>)[stageName]).moves = createMoves(stageRule.moves, game);
+      }
+    });
+  }
+
+  const order = turnRule.order as {
+    playOrder?: string | ((args: { ctx: { playOrder: string[] }; G: { _meta: { isAfterFirstPhase?: boolean } } }) => string[]);
+    first?: () => number;
+    next?: (args: { ctx: { playOrderPos: number; numPlayers: number } }) => number;
+  } | undefined;
+  if (order?.playOrder === "RotateFirst") {
+    order.first = () => 0;
+    order.next = ({ ctx }) => (ctx.playOrderPos + 1) % ctx.numPlayers;
+    (turn.order as typeof order).playOrder = ({ ctx, G }) => {
+      return G._meta.isAfterFirstPhase
+        ? [...ctx.playOrder.slice(1), ctx.playOrder[0]]
+        : ctx.playOrder;
+    };
+  }
+
+  return turn;
+}
+
+function createPhase (phaseRule: Record<string, unknown>, game: BoardGameEngineGame) {
+  const phase = { ...phaseRule };
+  if (phaseRule.turn) {
+    phase.turn = createTurn(phaseRule.turn as Record<string, unknown>, game);
+  }
+  if (phaseRule.moves) {
+    phase.moves = createMoves(phaseRule.moves as Record<string, MoveDefinition>, game);
+  }
+
+  phase.onBegin = (bgioArguments: BgioArguments) => {
+    const newBgioArguments = deserializeBgioArguments(bgioArguments);
+    doMoves(newBgioArguments, phaseRule.initialMoves as MoveDefinition[] | undefined, { game });
+    (newBgioArguments.G as { _meta: Record<string, unknown> })._meta.currentPhaseHasBeenSetUp = true;
+    (newBgioArguments.G as { _meta: Record<string, unknown> })._meta.nextPhase = phaseRule.next;
+    return JSON.parse(serialize(newBgioArguments.G));
+  };
+
+  if (phaseRule.endIf) {
+    const phaseEndIf = phaseRule.endIf as unknown[];
+    phase.endIf = (bgioArguments: BgioArguments) => {
+      const newBgioArguments = deserializeBgioArguments(bgioArguments);
+      if ((newBgioArguments.G as { _meta: { currentPhaseHasBeenSetUp?: boolean } })._meta.currentPhaseHasBeenSetUp) {
+        const result = getScenarioResults(newBgioArguments, phaseEndIf);
+        if (result) {
+          return result;
+        }
+      }
+    };
+  }
+
+  phase.onEnd = ({ G }: { G: { _meta: Record<string, unknown> } }) => {
+    G._meta.currentPhaseHasBeenSetUp = false;
+    G._meta.isAfterFirstPhase = true;
+  };
+
+  return phase;
+}
+
+function createMoves (moves: Record<string, MoveDefinition>, game: BoardGameEngineGame) {
+  return Object.entries(moves).reduce<Record<string, unknown>>((acc, [name, moveDefinition]) => ({
+    ...acc,
+    [name]: moveFactory({ ...moveDefinition, name }, game),
+  }), {});
+}

package/src/game-factory/move/end-turn.ts

@@ -0,0 +1,7 @@
+import Move from "./move.js";
+
+export default class EndTurn extends Move {
+  do (bgioArguments: unknown) {
+    (bgioArguments as { events: { endTurn: () => void } }).events.endTurn();
+  }
+}

package/src/game-factory/move/for-each.ts

@@ -0,0 +1,20 @@
+import type { MoveDefinition } from "../../types/bagel-types.js";
+import Move from "./move.js";
+import { getMoveInstance } from "./move-factory.js";
+
+export default class ForEach extends Move {
+  do (bgioArguments: unknown, rule: unknown, resolvedPayload: unknown, context: Record<string, unknown>) {
+    const { targets } = (resolvedPayload as { arguments: { targets: unknown[] } }).arguments;
+    targets.forEach((target: unknown) => {
+      const loopContext = {
+        ...context,
+        loopTarget: target
+      }
+      getMoveInstance((rule as { move: MoveDefinition }).move)!.doMove(
+        bgioArguments,
+        undefined,
+        loopContext
+      )
+    })
+  }
+}