board-game-engine 1.0.5 → 2.0.1

package/src/game-factory/condition/{evaluate-condition.js → evaluate-condition.ts}

@@ -1,16 +1,17 @@
 import _matches from "lodash/matches.js";
 import Condition from "../condition/condition.js";
 import resolveExpression from "../../utils/resolve-expression.js";
+import type { BgioResolveState } from "../../utils/bgio-resolve-types.js";
 
 export default class Evaluate extends Condition {
-  checkCondition(bgioArguments, rule, payload, context) {
+  checkCondition (bgioArguments: unknown, rule: unknown, payload: Record<string, unknown>, context: Record<string, unknown>) {
     const newContext = { ...context }
     if (payload?.target) {
       newContext.target = payload.target
     }
     const result = resolveExpression(
-      bgioArguments,
-      rule,
+      bgioArguments as BgioResolveState,
+      rule as { expression: string; arguments?: unknown },
       newContext
     )
     return { result, conditionIsMet: !!result }

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

@@ -0,0 +1,27 @@
+import type { Condition as ConditionRule } from "../../types/bagel-types.js";
+import Condition from "./condition.js";
+import checkConditions from "../../utils/check-conditions.js";
+
+export default class EveryCondition extends Condition {
+  checkCondition (bgioArguments: unknown, rule: unknown, conditionPayload: Record<string, unknown>, context: Record<string, unknown>) {
+    const targets = conditionPayload.target as unknown[];
+    const results = targets.map((target: unknown) => {
+      const loopContext = {
+        ...context,
+        loopTarget: target
+      }
+
+      return checkConditions(
+        bgioArguments,
+        (rule as { conditions?: ConditionRule[] }).conditions,
+        undefined,
+        loopContext
+      )
+    })
+
+    return {
+      conditionIsMet: results.every((r: { conditionsAreMet: boolean }) => r.conditionsAreMet),
+      results
+    }
+  }
+}

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

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

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

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

@@ -0,0 +1,10 @@
+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/{no-possible-moves-condition.js → no-possible-moves-condition.ts}

@@ -1,13 +1,14 @@
 import Condition from "./condition.js";
 import areThereValidMoves from "../../utils/any-valid-moves.js";
 import getCurrentMoves from "../../utils/get-current-moves.js";
+import type { GetCurrentMovesClient, GetCurrentMovesState } from "../../utils/get-current-moves.js";
 
 export default class NoPossibleMoves extends Condition {
-  checkCondition(bgioArguments, _, __, context) {
+  checkCondition (bgioArguments: unknown, _unused: unknown, _payload: unknown, context: Record<string, unknown>) {
     return {
       conditionIsMet: !areThereValidMoves(
         bgioArguments,
-        getCurrentMoves(bgioArguments, context),
+        getCurrentMoves(bgioArguments as GetCurrentMovesState, context as unknown as GetCurrentMovesClient),
       )
     }
   }

package/src/game-factory/condition/{not-condition.js → not-condition.ts}

@@ -1,11 +1,12 @@
+import type { Condition as ConditionRule } from "../../types/bagel-types.js";
 import Condition from "./condition.js";
 import checkConditions from "../../utils/check-conditions.js";
 
 export default class NotCondition extends Condition {
-  checkCondition(bgioArguments, rule, payload, context) {
+  checkCondition (bgioArguments: unknown, rule: unknown, payload: Record<string, unknown>, context: Record<string, unknown>) {
     const result = checkConditions(
       bgioArguments,
-      rule,
+      (rule as { conditions?: ConditionRule[] }).conditions,
       payload,
       context
     )

package/src/game-factory/condition/{or-condition.js → or-condition.ts}

@@ -1,11 +1,12 @@
+import type { Condition as ConditionRule } from "../../types/bagel-types.js";
 import Condition from "./condition.js";
 import findMetCondition from "../../utils/find-met-condition.js";
 
 export default class Or extends Condition {
-  checkCondition(bgioArguments, rule, payload, context) {
+  checkCondition (bgioArguments: unknown, rule: unknown, payload: Record<string, unknown>, context: Record<string, unknown>) {
     const result = findMetCondition(
       bgioArguments,
-      rule,
+      (rule as { conditions?: ConditionRule[] }).conditions,
       payload,
       context
     )

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

@@ -0,0 +1,13 @@
+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/{some-condition.js → some-condition.ts}

@@ -1,16 +1,18 @@
+import type { Condition as ConditionRule } from "../../types/bagel-types.js";
 import Condition from "./condition.js";
 import checkConditions from "../../utils/check-conditions.js";
 
 export default class SomeCondition extends Condition {
-  checkCondition(bgioArguments, rule, { target: targets }, context) {
-    const result = targets.find((target) => {
+  checkCondition (bgioArguments: unknown, rule: unknown, conditionPayload: Record<string, unknown>, context: Record<string, unknown>) {
+    const targets = conditionPayload.target as unknown[];
+    const result = targets.find((target: unknown) => {
       const loopContext = {
         ...context,
         loopTarget: target
       }
       return checkConditions(
         bgioArguments,
-        rule,
+        (rule as { conditions?: ConditionRule[] }).conditions,
         undefined,
         loopContext
       ).conditionsAreMet

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;
+}