board-game-engine 1.0.5 → 2.0.1

package/src/utils/{any-valid-moves.js → any-valid-moves.ts}

@@ -1,83 +1,83 @@
 import isPlainObject from "lodash/isPlainObject.js";
+import type { BgioResolveState } from "./bgio-resolve-types.js";
 import resolveProperties from "./resolve-properties.js";
 import resolveEntity from "./resolve-entity.js";
 
 // Recursively find all contextPath references to moveArguments
-function findMoveArgumentReferences(obj, refs = new Set()) {
-  if (!obj || typeof obj !== 'object') {
+function findMoveArgumentReferences (obj: unknown, refs = new Set<string>()): Set<string> {
+  if (!obj || typeof obj !== "object") {
     return refs;
   }
-  
-  // Check if this is a contextPath reference to moveArguments
-  if (obj.type === 'contextPath' && Array.isArray(obj.path)) {
-    if (obj.path[0] === 'moveArguments' && obj.path[1]) {
-      refs.add(obj.path[1]);
+
+  const o = obj as { type?: string; path?: unknown[] };
+  if (o.type === "contextPath" && Array.isArray(o.path)) {
+    if (o.path[0] === "moveArguments" && o.path[1]) {
+      refs.add(String(o.path[1]));
     }
   }
-  
-  // Recurse into object properties and array elements
-  for (const value of Object.values(obj)) {
+
+  for (const value of Object.values(obj as object)) {
     findMoveArgumentReferences(value, refs);
   }
-  
+
   return refs;
 }
 
 // Build a dependency graph and return topologically sorted argument names
-function getArgumentOrder(ruleArguments) {
+function getArgumentOrder (ruleArguments: Record<string, unknown>) {
   const argNames = Object.keys(ruleArguments);
-  const graph = {};
-  const inDegree = {};
-  
-  // Initialize
-  argNames.forEach(name => {
+  const graph: Record<string, string[]> = {};
+  const inDegree: Record<string, number> = {};
+
+  argNames.forEach((name) => {
     graph[name] = [];
     inDegree[name] = 0;
   });
-  
-  // Build dependency edges (if arg B references arg A, A -> B)
-  argNames.forEach(argName => {
+
+  argNames.forEach((argName) => {
     const arg = ruleArguments[argName];
     const referencedArgs = findMoveArgumentReferences(arg);
-    
-    referencedArgs.forEach(refArg => {
+
+    referencedArgs.forEach((refArg) => {
       if (argNames.includes(refArg) && refArg !== argName) {
         graph[refArg].push(argName);
         inDegree[argName]++;
       }
     });
   });
-  
-  // Topological sort (Kahn's algorithm)
-  const queue = argNames.filter(name => inDegree[name] === 0);
-  const sorted = [];
-  
+
+  const queue = argNames.filter((name) => inDegree[name] === 0);
+  const sorted: string[] = [];
+
   while (queue.length > 0) {
-    const current = queue.shift();
+    const current = queue.shift()!;
     sorted.push(current);
-    
-    graph[current].forEach(neighbor => {
+
+    graph[current].forEach((neighbor) => {
       inDegree[neighbor]--;
       if (inDegree[neighbor] === 0) {
         queue.push(neighbor);
       }
     });
   }
-  
-  // If not all nodes processed, there's a cycle - fall back to original order
+
   return sorted.length === argNames.length ? sorted : argNames;
 }
 
+type MoveEntry = {
+  moveInstance: { isValid: (a: unknown, p: unknown, c: unknown) => boolean; rule: unknown };
+};
+
 // Recursively try to build a valid argument combination
-function findValidCombination(
-  bgioArguments, 
-  moveInstance,
-  ruleArguments,
-  orderedArgNames,
-  context,
+function findValidCombination (
+  bgioArguments: BgioResolveState,
+  moveInstance: MoveEntry["moveInstance"],
+  ruleArguments: Record<string, unknown>,
+  orderedArgNames: string[],
+  context: Record<string, unknown>,
   index = 0,
-  currentArgs = {}
-) {
+  currentArgs: Record<string, unknown> = {}
+): boolean {
   // Base case: all arguments resolved
   if (index === orderedArgNames.length) {
     const resolvedPayload = { arguments: currentArgs };
@@ -98,7 +98,7 @@ function findValidCombination(
   const matches = isPlainObject(arg)
     ? resolveEntity(
       bgioArguments,
-      { ...arg, matchMultiple: true },
+      { ...(arg as Record<string, unknown>), matchMultiple: true },
       updatedContext,
       argName 
     )
@@ -112,7 +112,7 @@ function findValidCombination(
   }
   
   // Try each possible value (short-circuits on first success)
-  return matchArray.some(value => {
+  return matchArray.some((value: unknown) => {
     return findValidCombination(
       bgioArguments,
       moveInstance,
@@ -125,21 +125,26 @@ function findValidCombination(
   });
 }
 
-export default function areThereValidMoves(bgioArguments, moves) {
-  return Object.values(moves).some(move => {
-    const { moveInstance } = move;
+export default function areThereValidMoves (
+  bgioArguments: unknown,
+  moves: Record<string, unknown>
+) {
+  const bgio = bgioArguments as BgioResolveState;
+  return Object.values(moves).some((move) => {
+    const moveInstance = (move as MoveEntry | undefined)?.moveInstance;
+    if (!moveInstance) return false;
     const context = { moveInstance };
     const rule = resolveProperties(
-      bgioArguments,
+      bgio,
       moveInstance.rule,
       context
-    );
+    ) as { arguments?: Record<string, unknown> };
 
     const ruleArguments = rule.arguments ?? {};
     
     // If no arguments required, just check if move is valid
     if (Object.keys(ruleArguments).length === 0) {
-      return moveInstance.isValid(bgioArguments, { arguments: {} }, context);
+      return moveInstance.isValid(bgio, { arguments: {} }, context);
     }
     
     // Get dependency-ordered argument names
@@ -147,7 +152,7 @@ export default function areThereValidMoves(bgioArguments, moves) {
     
     // Recursively search for any valid combination (short-circuits on first valid)
     return findValidCombination(
-      bgioArguments,
+      bgio,
       moveInstance,
       ruleArguments,
       orderedArgNames,

package/src/utils/bgio-resolve-types.ts

@@ -0,0 +1,27 @@
+import type { RuleWithConditions } from "../types/rule-with-conditions.js";
+
+/** boardgame.io match args + engine `G` after setup (deserialized, many fields). */
+export type BgioResolveState = {
+  ctx: Record<string, unknown>;
+  G: Record<string, unknown>;
+  playerID?: string;
+} & Record<string, unknown>;
+
+/** Bank API on `G` used by resolution and moves (subset of {@link Bank} methods). */
+export type BankApi = {
+  find: (a: unknown, t: unknown, c: unknown) => unknown;
+  findAll: (a: unknown, t: unknown, c: unknown) => unknown[];
+  findParent: (t: unknown) => unknown;
+  getOne: (a: BgioResolveState, rule: RuleWithConditions & { state?: unknown }, c: Record<string, unknown>) => unknown;
+  getMultiple: (
+    a: BgioResolveState,
+    rule: RuleWithConditions & { state?: unknown },
+    count: number,
+    c: Record<string, unknown>
+  ) => unknown[];
+  returnToBank: (a: BgioResolveState, entity: { entityId: number; rule: Record<string, unknown> }) => void;
+};
+
+export function bankOf (bg: BgioResolveState): BankApi {
+  return (bg.G as { bank: BankApi }).bank;
+}

package/src/utils/check-conditions.ts

@@ -0,0 +1,28 @@
+import conditionFactory from "../game-factory/condition/condition-factory.js";
+import type { Condition as ConditionRule } from "../types/bagel-types.js";
+
+export default function checkConditions (
+  bgioArguments: unknown,
+  conditions: ConditionRule[] = [],
+  payload: Record<string, unknown> = {},
+  context: Record<string, unknown> = {}
+) {
+  const results: unknown[] = [];
+  let failedAt: unknown;
+  for (const conditionRule of conditions) {
+    const result = conditionFactory(conditionRule as ConditionRule)!
+      .check(bgioArguments, payload, context);
+    if (!(result as { conditionIsMet: boolean }).conditionIsMet) {
+      failedAt = conditionRule;
+      break;
+    } else {
+      results.push(result);
+    }
+  }
+
+  return {
+    results,
+    failedAt,
+    conditionsAreMet: results.length === conditions.length,
+  };
+}

package/src/utils/create-payload.ts

@@ -0,0 +1,19 @@
+import getSteps from "./get-steps.js";
+
+export default function createPayload (
+  bgioState: Parameters<typeof getSteps>[0],
+  moveRule: Parameters<typeof getSteps>[1],
+  targets: unknown[],
+  _context: Record<string, unknown>
+) {
+  const argNames = getSteps(
+    bgioState,
+    moveRule
+  ).map((s) => s.argName);
+  return {
+    arguments: targets.reduce<Record<string, unknown>>((acc, target, i) => ({
+      ...acc,
+      [argNames[i]]: target,
+    }), {}),
+  };
+}

package/src/utils/deserialize-bgio-arguments.ts

@@ -0,0 +1,10 @@
+import { deserialize } from "wackson";
+import { registry } from "../registry.js";
+import type { BgioResolveState } from "./bgio-resolve-types.js";
+
+export default function deserializeBgioArguments (bgioArguments: BgioResolveState): BgioResolveState {
+  return {
+    ...bgioArguments,
+    G: deserialize(JSON.stringify(bgioArguments.G), registry) as Record<string, unknown>,
+  };
+}

package/src/utils/do-moves.ts

@@ -0,0 +1,22 @@
+import type { MoveDefinition } from "../types/bagel-types.js";
+import moveFactory from "../game-factory/move/move-factory.js";
+
+export default function doMoves (
+  bgioArguments: { G: unknown; [k: string]: unknown },
+  moves: MoveDefinition[] = [],
+  context: { game: Record<string, unknown> } & Record<string, unknown>
+) {
+  if (!moves?.length) {
+    return bgioArguments.G;
+  }
+
+  moves.forEach((moveRule) => {
+    moveFactory(moveRule, context.game).moveInstance!.doMove(
+      bgioArguments,
+      undefined,
+      context
+    );
+  });
+
+  return bgioArguments.G;
+}

package/src/utils/entity-matches.ts

@@ -0,0 +1,30 @@
+import matches from "lodash/matches.js";
+import resolveProperties from "./resolve-properties.js";
+import type { BgioResolveState } from "./bgio-resolve-types.js";
+
+function resolveMatcher (
+  bgioArguments: BgioResolveState,
+  matcher: Record<string, unknown>,
+  context: Record<string, unknown>
+) {
+  const resolvedMatcher = { ...matcher };
+  delete resolvedMatcher.state;
+  delete resolvedMatcher.stateGroups;
+  return resolveProperties(bgioArguments, resolvedMatcher, context);
+}
+
+function getEntityMatcher (entity: { rule: Record<string, unknown>; state?: Record<string, unknown> }) {
+  return {
+    ...entity.rule,
+    ...entity.state,
+  };
+}
+
+export default function entityMatches (
+  bgioArguments: BgioResolveState,
+  matcher: Record<string, unknown>,
+  entity: { rule: Record<string, unknown>; state?: Record<string, unknown> },
+  context: Record<string, unknown>
+): boolean {
+  return matches(resolveMatcher(bgioArguments, matcher, context))(getEntityMatcher(entity));
+}

package/src/utils/expr-eval.d.ts

@@ -0,0 +1,6 @@
+declare module "expr-eval" {
+  export class Parser {
+    functions: Record<string, (...args: unknown[]) => unknown>;
+    evaluate (expression: string, variables?: Record<string, unknown>): number;
+  }
+}

package/src/utils/find-met-condition.ts

@@ -0,0 +1,23 @@
+import conditionFactory from "../game-factory/condition/condition-factory.js";
+import type { Condition as ConditionRule } from "../types/bagel-types.js";
+
+export default function findMetCondition (
+  bgioArguments: unknown,
+  conditions: ConditionRule[] = [],
+  payload: Record<string, unknown>,
+  context: Record<string, unknown>,
+) {
+  let success: { conditionRule: unknown; [k: string]: unknown } | undefined;
+  for (const conditionRule of conditions) {
+    const result = conditionFactory(conditionRule as ConditionRule)!
+      .check(bgioArguments, payload, context);
+    if ((result as { conditionIsMet: boolean }).conditionIsMet) {
+      success = {
+        ...result as object,
+        conditionRule,
+      };
+      break;
+    }
+  }
+  return success;
+}

package/src/utils/get-current-moves.ts

@@ -0,0 +1,39 @@
+/**
+ * Minimal shape of the boardgame.io client (or stand-in) used to resolve the active move set.
+ */
+export interface GetCurrentMovesClient {
+  game: {
+    phases?: Record<string, unknown>;
+    moves?: Record<string, unknown>;
+    turn?: { stages?: Record<string, unknown> };
+  };
+  playerID?: string;
+  stageName?: string;
+}
+
+/** `state` shape expected by {@link getCurrentMoves} (boardgame.io match state). */
+export interface GetCurrentMovesState {
+  ctx: {
+    phase?: string;
+    activePlayers?: Record<string, string>;
+    currentPlayer?: string;
+  };
+}
+
+// get the most specific set of moves for current stage/phase
+// this will probably all break for complex stages with multiple active players
+export default function getCurrentMoves (
+  state: GetCurrentMovesState,
+  client: GetCurrentMovesClient
+): Record<string, unknown> {
+  const { game, playerID, stageName } = client;
+  const phaseName = state.ctx.phase;
+
+  const stageNameToUse = stageName ?? state.ctx.activePlayers?.[playerID ?? state.ctx.currentPlayer ?? ""];
+  const phaseOrRoot =
+    (game as { phases?: Record<string, unknown> }).phases?.[phaseName as string] ?? game;
+  const stageOrPhaseOrRoot =
+    (phaseOrRoot as { turn?: { stages?: Record<string, unknown> } }).turn?.stages?.[stageNameToUse as string] ?? phaseOrRoot;
+
+  return (stageOrPhaseOrRoot as { moves?: Record<string, unknown> }).moves ?? {};
+}

package/src/utils/get-scenario-results.ts

@@ -0,0 +1,30 @@
+import checkConditions from "./check-conditions.js";
+import resolveProperties from "./resolve-properties.js";
+import type { BgioResolveState } from "./bgio-resolve-types.js";
+import type { Condition } from "../types/bagel-types.js";
+export default function getScenarioResults (
+  bgioArguments: BgioResolveState,
+  scenarios: unknown[]
+) {
+  let match: { scenario: { result?: unknown; [k: string]: unknown }; conditionResults: { results: unknown[] } } | undefined;
+  for (const scenario of scenarios) {
+    const conditionResults = checkConditions(
+      bgioArguments,
+      (scenario as { conditions?: Condition[] }).conditions
+    );
+    if (conditionResults.conditionsAreMet) {
+      match = { scenario: scenario as { result?: unknown }, conditionResults };
+      break;
+    }
+  }
+
+  if (match?.scenario?.result) {
+    return resolveProperties(
+      bgioArguments,
+      match.scenario.result,
+      { results: match.conditionResults.results }
+    );
+  } else {
+    return match;
+  }
+}

package/src/utils/get-steps.ts

@@ -0,0 +1,38 @@
+import { bankOf, type BgioResolveState } from "./bgio-resolve-types.js";
+
+// controls order of what players need to click first
+const argNamesMap: Record<string, string[]> = {
+  PlaceNew: ["destination"],
+  RemoveEntity: ["entity"],
+  MoveEntity: ["entity", "destination"],
+  TakeFrom: ["source", "destination"],
+  SetState: ["entity", "state"],
+};
+
+// this might not be where special handling for setstate wants to live
+export default function getSteps (
+  bgioState: BgioResolveState,
+  moveRule: {
+    moveType: string;
+    arguments: Record<string, { playerChoice?: boolean; possibleValues?: unknown[]; [k: string]: unknown }>;
+  }
+) {
+  const names = argNamesMap[moveRule.moveType];
+  if (!names) return [];
+  return names
+    .filter((argName) => moveRule.arguments[argName]?.playerChoice)
+    .map((argName) => ({
+      argName,
+      getClickable: argName === "state"
+        ? () => (moveRule.arguments[argName].possibleValues as unknown[]).map((value) => ({
+            abstract: true,
+            ...moveRule.arguments[argName],
+            value,
+          }))
+        : (context: Record<string, unknown>) => bankOf(bgioState).findAll(
+            bgioState,
+            moveRule.arguments[argName],
+            context
+          ),
+    }));
+}

package/src/utils/get.ts

@@ -0,0 +1,28 @@
+type PathStep = string | number | { flatten: boolean; map?: (string | number)[] };
+
+export default function get (obj: unknown, pathArray: PathStep[]): unknown {
+  let current: unknown = obj;
+
+  for (const step of pathArray) {
+    if (current === undefined) {
+      return current;
+    }
+
+    if (step && typeof step === "object" && "flatten" in step && step.flatten) {
+      if (!Array.isArray(current)) {
+        return undefined;
+      }
+
+      let flat = current.flat() as unknown[];
+
+      if (step.map) {
+        flat = flat.map((item) => get(item, step.map!));
+      }
+      current = flat;
+    } else {
+      current = (current as Record<string | number, unknown>)[step as string | number];
+    }
+  }
+
+  return current;
+}