board-game-engine 2.0.0 → 2.1.0

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

@@ -0,0 +1,18 @@
+import Move from "./move.js";
+
+export default class MoveEntity extends Move {
+  do (bgioArguments: unknown, rule: { position?: unknown }, resolvedPayload: unknown) {
+    const { entity, destination } = (resolvedPayload as { arguments: { entity: unknown; destination: unknown } }).arguments;
+    // todo: move all such things to always be multiple
+    const g = bgioArguments as { G: { bank: { findParent: (e: unknown) => { remove: (x: unknown) => void } | undefined } } };
+    if (Array.isArray(entity)) {
+      entity.forEach((e: unknown) => {
+        g.G.bank.findParent(e)?.remove(e);
+        (destination as { placeEntity: (e: unknown, p?: unknown) => void }).placeEntity(e, rule.position);
+      });
+    } else {
+      g.G.bank.findParent(entity)?.remove(entity);
+      (destination as { placeEntity: (e: unknown, p?: unknown) => void }).placeEntity(entity, rule.position);
+    }
+  }
+}

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

@@ -0,0 +1,107 @@
+import { serialize, deserialize } from 'wackson'
+import { INVALID_MOVE } from '@mnbroatch/boardgame.io/dist/cjs/core.js';
+import { registry } from '../../registry.js'
+import deserializeBgioArguments from '../../utils/deserialize-bgio-arguments.js'
+import MoveEntity from "./move-entity.js";
+import RemoveEntity from "./remove-entity.js";
+import PlaceNew from "./place-new.js";
+import TakeFrom from "./take-from.js";
+import SetState from "./set-state.js";
+import SetActivePlayers from "./set-active-players.js";
+import EndTurn from "./end-turn.js";
+import PassTurn from "./pass-turn.js";
+import ForEach from "./for-each.js";
+import Pass from "./pass.js";
+import Shuffle from "./shuffle.js";
+import type { MoveDefinition } from "../../types/bagel-types.js";
+import type { BgioResolveState } from "../../utils/bgio-resolve-types.js";
+import type Move from "./move.js";
+
+type MoveFactoryContext = {
+  moveInstance: Move;
+  game: unknown;
+  moveConditionResults?: unknown[];
+};
+
+export default function moveFactory (moveRule: MoveDefinition, game: unknown) {
+  const moveInstance = getMoveInstance(moveRule);
+  if (!moveInstance) {
+    throw new Error("moveFactory: unknown moveType");
+  }
+
+  // accepts serialized G and payload, returns serialized
+  const compatibleMove = function (
+    bgioArguments: unknown,
+    serializablePayload: unknown
+  ) {
+    const newBgioArguments = deserializeBgioArguments(bgioArguments as BgioResolveState);
+    const { G } = newBgioArguments;
+    const payload = revivePayload(serializablePayload, G as { bank: { locate: (id: number) => unknown } });
+    const context: MoveFactoryContext = { moveInstance, game };
+    const moveConditionResults = moveInstance.doMove(newBgioArguments, payload, context);
+
+    context.moveConditionResults = [moveConditionResults];
+
+    if (moveConditionResults !== INVALID_MOVE && moveRule.then) {
+      for (const automaticMoveRule of moveRule.then) {
+        const auto = getMoveInstance(automaticMoveRule);
+        if (!auto) continue;
+        const result = auto.doMove(
+          newBgioArguments,
+          {},
+          { ...context } // spread here so prevArguments doesn't change for sibling
+        );
+        context.moveConditionResults!.push(result);
+      }
+    }
+
+    return JSON.parse(serialize(G));
+  };
+  compatibleMove.moveInstance = moveInstance;
+  return compatibleMove;
+}
+
+function revivePayload (
+  serializablePayload: unknown,
+  G: { bank: { locate: (id: number) => unknown } }
+): { arguments?: Record<string, unknown> } | undefined {
+  if (!serializablePayload) {
+    return undefined;
+  }
+  const payload = deserialize(JSON.stringify(serializablePayload), registry) as {
+    arguments: Record<string, unknown>;
+  };
+  payload.arguments =
+    Object.entries(payload.arguments).reduce<Record<string, unknown>>((acc, [key, argOrEntityId]) => ({
+      ...acc,
+      [key]: typeof argOrEntityId === "number" ? G.bank.locate(argOrEntityId as number) : argOrEntityId
+    }), {});
+  return payload;
+}
+
+export function getMoveInstance (moveRule: MoveDefinition) {
+  switch (moveRule.moveType) {
+    case 'MoveEntity':
+      return new MoveEntity(moveRule);
+    case 'PlaceNew':
+      return new PlaceNew(moveRule);
+    case 'RemoveEntity':
+      return new RemoveEntity(moveRule);
+    case 'TakeFrom':
+      return new TakeFrom(moveRule);
+    case 'SetState':
+      return new SetState(moveRule);
+    case 'ForEach':
+      return new ForEach(moveRule);
+    case 'Pass':
+      return new Pass(moveRule);
+    case 'Shuffle':
+      return new Shuffle(moveRule);
+    case 'SetActivePlayers':
+      return new SetActivePlayers(moveRule);
+    case 'EndTurn':
+      return new EndTurn(moveRule);
+    case 'PassTurn':
+      return new PassTurn(moveRule);
+  }
+}

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

@@ -0,0 +1,147 @@
+import { INVALID_MOVE } from "@mnbroatch/boardgame.io/dist/cjs/core.js";
+import type { Condition, MoveDefinition } from "../../types/bagel-types.js";
+import checkConditions from "../../utils/check-conditions.js";
+import resolveProperties from "../../utils/resolve-properties.js";
+import type { BgioResolveState } from "../../utils/bgio-resolve-types.js";
+
+export default class Move {
+  rule: MoveDefinition;
+
+  constructor (rule: MoveDefinition) {
+    this.rule = this.transformRule(rule as Parameters<Move["transformRule"]>[0]) as MoveDefinition;
+  }
+
+  checkValidity (bgioArguments: unknown, payload: { arguments: Record<string, unknown> }, context: Record<string, unknown>) {
+    const moveArguments =
+      "arguments" in this.rule && this.rule.arguments
+        ? this.rule.arguments
+        : {};
+    const argRuleEntries = Object.entries(moveArguments) as [string, { conditions?: Condition[] }][];
+
+    if (
+      !argRuleEntries.every(([argName]) => {
+        const arg = payload.arguments[argName];
+        return arg !== undefined && (!Array.isArray(arg) || arg.length);
+      })
+    ) {
+      return false;
+    }
+
+    const argumentResults: Record<string, { results: unknown[]; conditionsAreMet: boolean }> = {};
+
+    for (let i = 0, len = argRuleEntries.length; i < len; i++) {
+      const [argName, argRule] = argRuleEntries[i];
+      const payloadArg = payload.arguments[argName];
+      const args = Array.isArray(payloadArg)
+        ? payloadArg
+        : [payloadArg];
+
+      const argResults: unknown[] = [];
+      for (let j = 0, lenj = args.length; j < lenj; j++) {
+        const arg = args[j];
+        const result = checkConditions(
+          bgioArguments as BgioResolveState,
+          argRule.conditions,
+          { target: arg },
+          { ...context, moveArguments: payload.arguments }
+        );
+        argResults.push(result);
+        if (!result.conditionsAreMet) {
+          break;
+        }
+      }
+
+      const last = argResults[argResults.length - 1] as { conditionsAreMet: boolean } | undefined;
+      const argConditionsAreMet = last?.conditionsAreMet ?? false;
+      argumentResults[argName] = {
+        results: argResults,
+        conditionsAreMet: argConditionsAreMet,
+      };
+      if (!argConditionsAreMet) {
+        break;
+      }
+    }
+
+    const moveResults = checkConditions(
+      bgioArguments as BgioResolveState,
+      (this.rule as { conditions?: Condition[] }).conditions,
+      {},
+      { ...context, moveArguments: payload.arguments }
+    );
+
+    return {
+      argumentResults,
+      moveResults,
+      conditionsAreMet: moveResults.conditionsAreMet
+        && Object.values(argumentResults).every((a) => a.conditionsAreMet),
+    };
+  }
+
+  isValid (bgioArguments: unknown, payload: { arguments: Record<string, unknown> }, context: Record<string, unknown>) {
+    const conditionResults = this.checkValidity(
+      bgioArguments,
+      payload,
+      context
+    );
+    if (conditionResults === false) return false;
+    return conditionResults.conditionsAreMet;
+  }
+
+  doMove (
+    bgioArguments: unknown,
+    payload: { arguments?: Record<string, unknown> } | undefined,
+    context: Record<string, unknown>,
+    { skipCheck = false } = {}
+  ) {
+    const rule = resolveProperties(
+      bgioArguments as BgioResolveState,
+      this.rule,
+      context
+    ) as { name?: string; arguments?: Record<string, unknown> };
+    const resolvedPayload = {
+      ...payload,
+      arguments: Object.entries(rule.arguments ?? {})
+        .reduce<Record<string, unknown>>((acc, [argName, arg]) => ({
+          ...acc,
+          [argName]: payload?.arguments?.[argName] ?? arg,
+        }), {}),
+    };
+
+    if (rule.name) {
+      (bgioArguments as { G: { _meta: { previousPayloads: Record<string, unknown> } } }).G._meta.previousPayloads[rule.name] = resolvedPayload;
+    }
+
+    let conditionResults: ReturnType<Move["checkValidity"]> | undefined;
+    if (!skipCheck) {
+      conditionResults = this.checkValidity(bgioArguments, resolvedPayload as { arguments: Record<string, unknown> }, context);
+    }
+
+    if (!skipCheck && conditionResults !== false && !conditionResults!.conditionsAreMet) {
+      return INVALID_MOVE;
+    } else {
+      this.do(bgioArguments, rule, resolvedPayload, context);
+      if (context) {
+        context.previousArguments = resolvedPayload.arguments;
+      }
+    }
+
+    return { conditionResults };
+  }
+
+  do (_bgioArguments: unknown, _rule: unknown, _resolvedPayload: unknown, _context: unknown) {
+    throw new Error("Move#do must be implemented by subclass");
+  }
+
+  transformRule (rule: { arguments?: Record<string, { playerChoice?: boolean; resolveAsEntity?: boolean }> }) {
+    const args = rule.arguments;
+    if (args) {
+      for (const key in args) {
+        const arg = args[key];
+        if (arg && !arg.playerChoice) {
+          arg.resolveAsEntity = true;
+        }
+      }
+    }
+    return rule;
+  }
+}

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

@@ -0,0 +1,15 @@
+import Move from "./move.js";
+
+export default class PassTurn extends Move {
+  do (bgioArguments: unknown) {
+    const a = bgioArguments as {
+      G: { _meta: { passedPlayers: unknown[] } };
+      ctx: { numPlayers: number; currentPlayer: string };
+      events: { pass: () => void };
+    };
+    if (a.G._meta.passedPlayers.length < a.ctx.numPlayers) {
+      a.G._meta.passedPlayers.push(a.ctx.currentPlayer);
+      a.events.pass();
+    }
+  }
+}

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

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

package/src/game-factory/move/place-new.ts

@@ -0,0 +1,42 @@
+import type { MovePlaceNew } from "../../types/bagel-types.js";
+import type { BgioResolveState } from "../../utils/bgio-resolve-types.js";
+import { bankOf } from "../../utils/bgio-resolve-types.js";
+import Move from "./move.js";
+
+type PlaceNewRule = MovePlaceNew & { count?: number; position?: unknown };
+
+export default class PlaceNew extends Move {
+  do (bgioArguments: unknown, rule: unknown, resolvedPayload: unknown, context: Record<string, unknown>) {
+    const { destination } = (resolvedPayload as { arguments: { destination: unknown } }).arguments;
+    const bgio = bgioArguments as BgioResolveState;
+    const r = rule as PlaceNewRule;
+    const bank = bankOf(bgio);
+    const entities = r.matchMultiple
+      ? bank.getMultiple(
+          bgio,
+          {
+            ...r.entity,
+            conditions: [
+              ...(r.entity?.conditions || []),
+              ...(r.conditions || []),
+            ]
+          },
+          r.count ?? 1,
+          context
+        )
+      : [bank.getOne(
+          bgio,
+          {
+            ...r.entity,
+            conditions: [
+              ...(r.entity?.conditions || []),
+              ...(r.conditions || []),
+            ]
+          },
+          context
+        )]
+    entities.forEach((entity: unknown) => {
+      (destination as { placeEntity: (e: unknown, p?: unknown) => void }).placeEntity(entity, r.position as unknown);
+    });
+  }
+}

package/src/game-factory/move/remove-entity.ts

@@ -0,0 +1,11 @@
+import type { BgioResolveState } from "../../utils/bgio-resolve-types.js";
+import { bankOf } from "../../utils/bgio-resolve-types.js";
+import Move from "./move.js";
+
+export default class RemoveEntity extends Move {
+  do (bgioArguments: unknown, _rule: unknown, resolvedPayload: unknown) {
+    const { entity } = (resolvedPayload as { arguments: { entity: unknown } }).arguments;
+    const bgio = bgioArguments as BgioResolveState;
+    bankOf(bgio).returnToBank(bgio, entity as { entityId: number; rule: Record<string, unknown> });
+  }
+}

package/src/game-factory/move/set-active-players.ts

@@ -0,0 +1,26 @@
+import type { MoveDefinition } from "../../types/bagel-types.js";
+import type { BgioResolveState } from "../../utils/bgio-resolve-types.js";
+import Move from "./move.js";
+import doMoves from '../../utils/do-moves.js'
+
+export default class SetActivePlayers extends Move {
+  do (bgioArguments: unknown, rule: Record<string, unknown>, _unused: unknown, context: Record<string, unknown>) {
+    const b = bgioArguments as { events: { setActivePlayers: (o: unknown) => void }; ctx: { phase: string } };
+    b.events.setActivePlayers((rule as { options: unknown }).options);
+
+    // this is going to need to be expanded to handle more complex things
+    // than "move current player to new stage"
+    const phaseName = b.ctx.phase;
+    const stageName = (rule.options as { currentPlayer?: { stage?: string } }).currentPlayer?.stage;
+    const phaseOrRoot = (context.game as { phases?: Record<string, unknown> }).phases?.[phaseName] ?? context.game;
+    const stage = (phaseOrRoot as { turn?: { stages?: Record<string, unknown> } })?.turn?.stages?.[stageName as string];
+    doMoves(
+      bgioArguments as BgioResolveState,
+      (stage as { initialMoves?: MoveDefinition[] } | undefined)?.initialMoves,
+      {
+        ...context,
+        stageName,
+      } as unknown as Parameters<typeof doMoves>[2]
+    )
+  }
+}

package/src/game-factory/move/set-state.ts

@@ -0,0 +1,14 @@
+import Move from "./move.js";
+
+// todo: invariant conditions like "is one of the allowed values"
+export default class SetState extends Move {
+  do (_unused: unknown, _rule: unknown, resolvedPayload: unknown) {
+    const { entity, state } = (resolvedPayload as {
+      arguments: { entity: { state?: Record<string, unknown> }; state: { property: string; value: unknown } };
+    }).arguments;
+    entity.state = {
+      ...entity.state,
+      [state.property]: state.value,
+    };
+  }
+}

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

@@ -0,0 +1,9 @@
+import Move from "./move.js";
+
+export default class Shuffle extends Move {
+  do (bgioArguments: unknown, _rule: unknown, resolvedPayload: unknown) {
+    const { target } = (resolvedPayload as { arguments: { target: { entities: unknown[] } } }).arguments;
+    const b = bgioArguments as { random: { Shuffle: <T>(xs: T[]) => T[] } };
+    target.entities = b.random.Shuffle(target.entities);
+  }
+}

package/src/game-factory/move/take-from.ts

@@ -0,0 +1,12 @@
+import Move from "./move.js";
+
+export default class TakeFrom extends Move {
+  do (_bgioArguments: unknown, rule: { arguments: { source: { position?: unknown } } }, resolvedPayload: unknown) {
+    const { source, destination } = (resolvedPayload as { arguments: { source: unknown; destination: unknown } }).arguments;
+    (destination as { placeEntity: (e: unknown) => void }).placeEntity(
+      (source as { takeOne: (p: unknown) => unknown }).takeOne(
+        (rule as { arguments: { source: { position?: unknown } } }).arguments.source.position
+      )
+    );
+  }
+}

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

@@ -0,0 +1,36 @@
+import Entity from "../entity.js";
+
+export default class Space extends Entity {
+  entities: unknown[];
+
+  constructor (
+    options: ConstructorParameters<typeof Entity>[0],
+    rule: Record<string, unknown>,
+    id: number
+  ) {
+    super(options, rule, id);
+    this.entities = [];
+  }
+
+  placeEntity (entity: unknown, position: "Last" | "First" = "Last") {
+    if (position === "Last") {
+      this.entities.push(entity);
+    } else if (position === "First") {
+      this.entities.unshift(entity);
+    }
+  }
+
+  remove (entity: unknown) {
+    this.entities.splice(this.entities.indexOf(entity), 1);
+  }
+
+  takeOne (position: "First" = "First") {
+    if (position === "First") {
+      return this.entities.splice(0, 1)[0];
+    }
+  }
+
+  isEmpty () {
+    return this.entities.length === 0;
+  }
+}

package/src/game-factory/space-group/grid.ts

@@ -0,0 +1,48 @@
+import chunk from "lodash/chunk.js";
+import SpaceGroup from "./space-group.js";
+
+export default class Grid extends SpaceGroup {
+  declare rule: Record<string, unknown> & { width: number; height: number };
+
+  getSpacesCount () {
+    return (this.rule.width as number) * (this.rule.height as number);
+  }
+
+  getRows () {
+    return chunk(this.spaces, this.rule.width as number);
+  }
+
+  getCoordinates (index: number) {
+    const { width } = this.rule;
+    return [
+      index % width,
+      Math.floor(index / width),
+    ];
+  }
+
+  getIndex ([x, y]: [number, number]) {
+    const { width } = this.rule;
+    return y * width + x;
+  }
+
+  override getSpace (arg: number | [number, number]) {
+    if (Array.isArray(arg)) {
+      return this.spaces[this.getIndex(arg)];
+    }
+    return this.spaces[arg];
+  }
+
+  getRelativeCoordinates ([oldX, oldY]: [number, number], [relativeX, relativeY]: [number, number]) {
+    const newCoordinates: [number, number] = [oldX + relativeX, oldY + relativeY];
+    return this.areCoordinatesValid(newCoordinates)
+      ? newCoordinates
+      : null;
+  }
+
+  areCoordinatesValid ([x, y]: [number, number]) {
+    return x >= 0
+      && y >= 0
+      && x < (this.rule.width as number)
+      && y < (this.rule.height as number);
+  }
+}

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

@@ -0,0 +1,44 @@
+import Entity from "../entity.js";
+
+type BankLike = { createEntity: (def: Record<string, unknown>) => unknown };
+
+export default class SpaceGroup extends Entity {
+  spaces: unknown[];
+
+  constructor (
+    options: ConstructorParameters<typeof Entity>[0] & { bank: BankLike },
+    rule: Record<string, unknown>,
+    id: number
+  ) {
+    super(options, rule, id);
+    this.spaces = this.makeSpaces(options.bank);
+  }
+
+  makeSpaces (bank: BankLike) {
+    return Array(this.getSpacesCount()).fill(undefined)
+      .map((_, i) => bank.createEntity({ entityType: "Space", index: i }));
+  }
+
+  getEmptySpaces () {
+    return (this.spaces as { isEmpty: () => boolean }[]).filter((space) => space.isEmpty());
+  }
+
+  getSpace (arg: number | [number, number]) {
+    if (Array.isArray(arg)) {
+      throw new Error("Numeric index only for SpaceGroup#getSpace");
+    }
+    return this.spaces[arg];
+  }
+
+  getEntities (index: number) {
+    return (this.getSpace(index) as { entities: unknown[] }).entities;
+  }
+
+  placeEntity (index: number, entity: unknown) {
+    (this.getSpace(index) as { placeEntity: (e: unknown) => void }).placeEntity(entity);
+  }
+
+  getSpacesCount (): number {
+    throw new Error("SpaceGroup#getSpacesCount must be implemented by subclass");
+  }
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+export { default as gameFactory } from "./game-factory/game-factory.js";
+export { Client } from "./client/client.js";
+export type { ClientOptions } from "./client/client.js";
+export type { BoardGameEngineGame, BgioArguments } from "./game-factory/game-factory.js";
+export type * from "./types/index.js";