board-game-engine 2.0.1 → 2.1.1

package/src/game-factory/condition/has-line-condition.ts

@@ -1,15 +0,0 @@
-import Condition from "./condition.js";
-import gridContainsSequence from "../../utils/grid-contains-sequence.js";
-import type { GridLike, SequenceChunk } from "../../utils/grid-contains-sequence.js";
-
-export default class HasLineCondition extends Condition {
-  checkCondition (bgioArguments: unknown, rule: unknown, payload: Record<string, unknown>, context: Record<string, unknown>) {
-    const { matches } = gridContainsSequence(
-      bgioArguments,
-      payload.target as GridLike,
-      (rule as { sequence: SequenceChunk[] }).sequence,
-      context
-    ) as { matches: unknown[] };
-    return { matches, conditionIsMet: !!matches.length };
-  }
-}

package/src/game-factory/condition/in-line-condition.ts

@@ -1,25 +0,0 @@
-import Condition from "./condition.js";
-import gridContainsSequence from "../../utils/grid-contains-sequence.js";
-import type { GridLike, SequenceChunk } from "../../utils/grid-contains-sequence.js";
-
-
-export default class InLineCondition extends Condition {
-  checkCondition (bgioArguments: unknown, rule: unknown, payload: Record<string, unknown>, context: Record<string, unknown>) {
-    const { G } = bgioArguments as { G: { bank: { findParent: (t: unknown) => unknown } } };
-    const { target } = payload;
-    const parent = G.bank.findParent(payload.target);
-    
-    const { matches: allMatches } = gridContainsSequence(
-      bgioArguments,
-      parent as GridLike,
-      (rule as { sequence: SequenceChunk[] }).sequence,
-      context
-    ) as { matches: unknown[][] };
-    
-    const matches = allMatches.filter((sequence: unknown[]) =>
-      sequence.some((space: unknown) => space === target)
-    );
-
-    return { matches, conditionIsMet: !!matches.length };
-  }
-}

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

@@ -1,24 +0,0 @@
-import Condition from "./condition.js";
-import entityMatches from '../../utils/entity-matches.js'
-import type { BgioResolveState } from "../../utils/bgio-resolve-types.js";
-
-export default class Is extends Condition {
-  checkCondition (bgioArguments: unknown, rule: unknown, { target }: Record<string, unknown>, context: Record<string, unknown>) {
-    if ((this.rule as { entity?: unknown }).entity && target !== (rule as { entity?: unknown }).entity) {
-      return {
-        target,
-        conditionIsMet: false,
-      }
-    }
-
-    return {
-      target,
-      conditionIsMet: entityMatches(
-        bgioArguments as BgioResolveState,
-        (rule as { matcher: Record<string, unknown> }).matcher,
-        target as { rule: Record<string, unknown>; state?: Record<string, unknown> },
-        context
-      )
-    }
-  }
-}

package/src/game-factory/condition/is-full-condition.ts

@@ -1,10 +0,0 @@
-import Condition from "./condition.js";
-
-export default class IsFull extends Condition {
-  checkCondition (_bgioArguments: unknown, _rule: unknown, payload: Record<string, unknown>, _context: Record<string, unknown>) {
-    const t = payload.target as { spaces: { entities?: unknown[] }[] };
-    return {
-      conditionIsMet: t.spaces.every((space: { entities?: unknown[] }) => space?.entities?.length)
-    };
-  }
-}

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

@@ -1,13 +0,0 @@
-import Condition from "./condition.js";
-
-export default class Position extends Condition {
-  checkCondition (bgioArguments: unknown, rule: unknown, conditionPayload: Record<string, unknown>, _newContext: Record<string, unknown>) {
-    const target = conditionPayload.target;
-    const parent = (bgioArguments as { G: { bank: { findParent: (t: unknown) => { entities: unknown[] } } } }).G.bank.findParent(target);
-    let conditionIsMet = false;
-    if ((rule as { position?: string }).position === "First") {
-      conditionIsMet = parent.entities.indexOf(target) === 0;
-    }
-    return { conditionIsMet };
-  }
-}

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

@@ -1,104 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,263 +0,0 @@
-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;
-}