board-game-engine 2.0.1 → 2.1.1

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

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

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

@@ -0,0 +1,29 @@
+import Entity from "../entity.js";
+
+export default class SpaceGroup extends Entity {
+  constructor (options, ...rest) {
+    super(options, ...rest)
+    this.spaces = this.makeSpaces(options.bank);
+  }
+
+  makeSpaces (bank) {
+    return Array(this.getSpacesCount()).fill()
+      .map((_, i) => bank.createEntity({ entityType: 'Space', index: i }))
+  }
+
+  getEmptySpaces() {
+    return this.spaces.filter(space => space.isEmpty())
+  }
+
+  getSpace(index) {
+    return this.spaces[index]
+  }
+
+  getEntities(index) {
+    return this.getSpace(index).entities;
+  }
+
+  placeEntity(index, entity) {
+    this.getSpace(index).placeEntity(entity);
+  }
+}

package/src/index.js

@@ -0,0 +1,2 @@
+export { default as gameFactory } from './game-factory/game-factory'
+export { Client } from './client/client'

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

@@ -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: unknown, refs = new Set<string>()): Set<string> {
-  if (!obj || typeof obj !== "object") {
+function findMoveArgumentReferences(obj, refs = new Set()) {
+  if (!obj || typeof obj !== 'object') {
     return refs;
   }
-
-  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]));
+  
+  // 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]);
     }
   }
-
-  for (const value of Object.values(obj as object)) {
+  
+  // Recurse into object properties and array elements
+  for (const value of Object.values(obj)) {
     findMoveArgumentReferences(value, refs);
   }
-
+  
   return refs;
 }
 
 // Build a dependency graph and return topologically sorted argument names
-function getArgumentOrder (ruleArguments: Record<string, unknown>) {
+function getArgumentOrder(ruleArguments) {
   const argNames = Object.keys(ruleArguments);
-  const graph: Record<string, string[]> = {};
-  const inDegree: Record<string, number> = {};
-
-  argNames.forEach((name) => {
+  const graph = {};
+  const inDegree = {};
+  
+  // Initialize
+  argNames.forEach(name => {
     graph[name] = [];
     inDegree[name] = 0;
   });
-
-  argNames.forEach((argName) => {
+  
+  // Build dependency edges (if arg B references arg A, A -> B)
+  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]++;
       }
     });
   });
-
-  const queue = argNames.filter((name) => inDegree[name] === 0);
-  const sorted: string[] = [];
-
+  
+  // Topological sort (Kahn's algorithm)
+  const queue = argNames.filter(name => inDegree[name] === 0);
+  const sorted = [];
+  
   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: BgioResolveState,
-  moveInstance: MoveEntry["moveInstance"],
-  ruleArguments: Record<string, unknown>,
-  orderedArgNames: string[],
-  context: Record<string, unknown>,
+function findValidCombination(
+  bgioArguments, 
+  moveInstance,
+  ruleArguments,
+  orderedArgNames,
+  context,
   index = 0,
-  currentArgs: Record<string, unknown> = {}
-): boolean {
+  currentArgs = {}
+) {
   // 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 as Record<string, unknown>), matchMultiple: true },
+      { ...arg, matchMultiple: true },
       updatedContext,
       argName 
     )
@@ -112,7 +112,7 @@ function findValidCombination (
   }
   
   // Try each possible value (short-circuits on first success)
-  return matchArray.some((value: unknown) => {
+  return matchArray.some(value => {
     return findValidCombination(
       bgioArguments,
       moveInstance,
@@ -125,26 +125,21 @@ function findValidCombination (
   });
 }
 
-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;
+export default function areThereValidMoves(bgioArguments, moves) {
+  return Object.values(moves).some(move => {
+    const { moveInstance } = move;
     const context = { moveInstance };
     const rule = resolveProperties(
-      bgio,
+      bgioArguments,
       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(bgio, { arguments: {} }, context);
+      return moveInstance.isValid(bgioArguments, { arguments: {} }, context);
     }
     
     // Get dependency-ordered argument names
@@ -152,7 +147,7 @@ export default function areThereValidMoves (
     
     // Recursively search for any valid combination (short-circuits on first valid)
     return findValidCombination(
-      bgio,
+      bgioArguments,
       moveInstance,
       ruleArguments,
       orderedArgNames,

package/src/utils/check-conditions.js

@@ -0,0 +1,28 @@
+import conditionFactory from '../game-factory/condition/condition-factory.js';
+
+export default function checkConditions (
+  bgioArguments,
+  rule,
+  payload,
+  context
+) {
+  const { conditions = [] } = rule
+  const results = [];
+  let failedAt
+  for (const conditionRule of conditions) {
+    const result = conditionFactory(conditionRule)
+      .check(bgioArguments, payload, context);
+    if (!result.conditionIsMet) {
+      failedAt = conditionRule
+      break
+    } else {
+      results.push(result);
+    }
+  }
+
+  return {
+    results,
+    failedAt,
+    conditionsAreMet: results.length === conditions.length
+  };
+}

package/src/utils/create-payload.js

@@ -0,0 +1,16 @@
+import getSteps from './get-steps.js';
+
+export default function createPayload (bgioState, moveRule, targets, context) {
+  const argNames = getSteps(
+    bgioState,
+    moveRule,
+    context
+  ).map(s => s.argName)
+  return {
+    arguments: targets.reduce((acc, target, i) => ({
+      ...acc,
+      [argNames[i]]: target
+    }), {})
+  }
+}
+

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

@@ -0,0 +1,8 @@
+import { deserialize } from "wackson";
+import { registry } from "../registry.js";
+export default function deserializeBgioArguments (bgioArguments) {
+  return {
+    ...bgioArguments,
+    G: deserialize(JSON.stringify(bgioArguments.G), registry)
+  }
+}

package/src/utils/do-moves.js

@@ -0,0 +1,18 @@
+import moveFactory from "../game-factory/move/move-factory.js";
+
+export default function doMoves (bgioArguments, moves = [], context) {
+  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.js

@@ -0,0 +1,20 @@
+import matches from 'lodash/matches.js'
+import resolveProperties from '../utils/resolve-properties.js'
+
+function resolveMatcher (bgioArguments, matcher, context) {
+  const resolvedMatcher = { ...matcher }
+  delete resolvedMatcher.state
+  delete resolvedMatcher.stateGroups
+  return resolveProperties(bgioArguments, resolvedMatcher, context)
+}
+
+function getEntityMatcher (entity) {
+  return {
+    ...entity.rule,
+    ...entity.state
+  }
+}
+
+export default function entityMatches (bgioArguments, matcher, entity, context) {
+  return matches(resolveMatcher(bgioArguments, matcher, context))(getEntityMatcher(entity))
+}

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

@@ -0,0 +1,22 @@
+import conditionFactory from '../game-factory/condition/condition-factory.js';
+
+export default function findMetCondition (
+  bgioArguments,
+  { conditions = [] },
+  payload,
+  context,
+) {
+  let success
+  for (const conditionRule of conditions) {
+    const result = conditionFactory(conditionRule)
+      .check(bgioArguments, payload, context);
+    if (result.conditionIsMet) {
+      success = {
+        ...result,
+        conditionRule
+      }
+      break
+    }
+  }
+  return success
+}

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

@@ -0,0 +1,12 @@
+// 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, { game, playerID, stageName }) {
+  const phaseName = state.ctx.phase
+
+  // currentPlayer used for single player editor mode
+  const stageNameToUse = stageName ?? state.ctx.activePlayers?.[playerID ?? state.ctx.currentPlayer]
+  const phaseOrRoot = game.phases?.[phaseName] ?? game
+  const stageOrPhaseOrRoot = phaseOrRoot.turn?.stages?.[stageNameToUse] ?? phaseOrRoot
+
+  return stageOrPhaseOrRoot.moves ?? {}
+}

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

@@ -0,0 +1,23 @@
+import checkConditions from "./check-conditions.js";
+import resolveProperties from './resolve-properties.js'
+
+export default function getScenarioResults(bgioArguments, scenarios, context) {
+  let match
+  for (const scenario of scenarios) {
+    const conditionResults = checkConditions(bgioArguments, scenario)
+    if (conditionResults.conditionsAreMet) {
+      match = { scenario, conditionResults }
+      break
+    }
+  }
+
+  if (match?.scenario?.result) {
+    return resolveProperties(
+      bgioArguments,
+      match.scenario.result,
+      { results: match.conditionResults.results }
+    )
+  } else {
+    return match
+  }
+}

package/src/utils/get-steps.js

@@ -0,0 +1,29 @@
+// controls order of what players need to click first
+const argNamesMap = {
+  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, moveRule) {
+  return argNamesMap[moveRule.moveType]
+    .filter(argName => moveRule.arguments[argName].playerChoice)
+    .map(argName => ({
+      argName,
+      getClickable: argName === 'state'
+        ? () => moveRule.arguments[argName].possibleValues.map((value) => ({
+            abstract: true,
+            ...moveRule.arguments[argName],
+            value
+          }))
+        : (context) => bgioState.G.bank.findAll(
+            bgioState,
+            moveRule.arguments[argName],
+            context
+          )
+
+    }))
+}

package/src/utils/get.js

@@ -0,0 +1,25 @@
+export default function get (obj, pathArray) {
+  let current = obj;
+  
+  for (const step of pathArray) {
+    if (current === undefined) {
+      return current
+    }
+    
+    if (step?.flatten) {
+      if (!Array.isArray(current)) {
+        return undefined;
+      }
+      
+      current = current.flat();
+      
+      if (step.map) {
+        current = current.map(item => get(item, step.map));
+      }
+    } else {
+      current = current[step];
+    }
+  }
+  
+  return current;
+}

package/src/utils/{grid-contains-sequence.ts → grid-contains-sequence.js}

@@ -1,37 +1,20 @@
 // claude ai did most of this
 import _matches from "lodash/matches.js";
-import type { Condition } from "../types/bagel-types.js";
 import checkConditions from "./check-conditions.js";
 
-export type SequenceChunk = {
-  count?: number;
-  minCount?: number;
-  maxCount?: number;
-  conditions?: Condition[];
-};
-
-type GridEntity = { entities?: unknown[]; [k: string]: unknown };
-type GridSpace = { entities?: GridEntity[]; [k: string]: unknown };
-export type GridLike = {
-  attributes: { width: number; height: number };
-  entities?: GridSpace[];
-  areCoordinatesValid: (c: number[]) => boolean;
-  getSpace: (c: number[]) => unknown;
-};
-
 // We'll check reverse directions along each line
-const directions: [number, number][] = [
+const directions = [
   [1, 0],   // horizontal
   [0, 1],   // vertical
   [1, 1],   // diagonal down-right
   [-1, 1],  // diagonal down-left
 ];
 
-const sequenceCache = new WeakMap<object, Map<string, { stateKey: string; result: unknown }>>();
+const sequenceCache = new WeakMap();
 
-function getSequenceKey (sequencePattern: unknown, context: Record<string, unknown>) {
+function getSequenceKey(sequencePattern, context) {
   const contextKey = {
-    moveInstance: (context.moveInstance as { id?: unknown } | undefined)?.id,
+    moveInstance: context.moveInstance?.id,
     moveArguments: context.moveArguments,
     // Add other context properties that conditions might use
   };
@@ -39,17 +22,17 @@ function getSequenceKey (sequencePattern: unknown, context: Record<string, unkno
 }
 
 // todo: use stable hash library that we're using for game rules hash
-function getGridStateKey (grid: GridLike) {
+function getGridStateKey(grid) {
   const spaces = grid.entities || [];
-
-  return spaces.map((space) => {
+  
+  return spaces.map(space => {
     const entities = space.entities || [];
-    if (entities.length === 0) return "empty";
-
-    return entities.map((entity) => {
+    if (entities.length === 0) return 'empty';
+    
+    return entities.map(entity => {
       const sortedKeys = Object.keys(entity).sort();
-      const stateObj: Record<string, unknown> = {};
-      sortedKeys.forEach((key) => {
+      const stateObj = {};
+      sortedKeys.forEach(key => {
         stateObj[key] = entity[key];
       });
       return JSON.stringify(stateObj);
@@ -57,15 +40,8 @@ function getGridStateKey (grid: GridLike) {
   }).join(',');
 }
 
-function findSequencesInLine (
-  bgioArguments: unknown,
-  lineSpaces: unknown[],
-  sequencePattern: SequenceChunk[],
-  minSequenceLength: number,
-  context: Record<string, unknown>,
-  reverse = false
-) {
-  const matches: unknown[][] = [];
+function findSequencesInLine(bgioArguments, lineSpaces, sequencePattern, minSequenceLength, context, reverse = false) {
+  const matches = [];
   
   // Use original array or iterate in reverse without creating new array
   const length = lineSpaces.length;
@@ -92,9 +68,9 @@ function findSequencesInLine (
   return matches;
 }
 
-function getLineStartingPoints (grid: GridLike, dx: number, dy: number) {
+function getLineStartingPoints(grid, dx, dy) {
   const { width, height } = grid.attributes;
-  const starts: [number, number][] = [];
+  const starts = [];
   
   if (dx === 1 && dy === 0) {
     // Horizontal: start at leftmost column
@@ -115,8 +91,8 @@ function getLineStartingPoints (grid: GridLike, dx: number, dy: number) {
   return starts;
 }
 
-function getLineSpaces (grid: GridLike, startX: number, startY: number, dx: number, dy: number) {
-  const spaces: unknown[] = [];
+function getLineSpaces(grid, startX, startY, dx, dy) {
+  const spaces = [];
   let [x, y] = [startX, startY];
   
   while (grid.areCoordinatesValid([x, y])) {
@@ -127,16 +103,9 @@ function getLineSpaces (grid: GridLike, startX: number, startY: number, dx: numb
   return spaces;
 }
 
-function tryMatchSequence (
-  bgioArguments: unknown,
-  lineSpaces: unknown[],
-  startIndex: number,
-  sequencePattern: SequenceChunk[],
-  context: Record<string, unknown>,
-  reverse = false
-) {
+function tryMatchSequence(bgioArguments, lineSpaces, startIndex, sequencePattern, context, reverse = false) {
   let spaceIndex = startIndex;
-  const matchedSpaces: unknown[] = [];
+  const matchedSpaces = [];
   const length = lineSpaces.length;
   
   for (const chunk of sequencePattern) {
@@ -153,7 +122,7 @@ function tryMatchSequence (
     }
     
     let matchedCount = 0;
-    const chunkMatches: unknown[] = [];
+    const chunkMatches = [];
     
     // Greedy: try to match as many as possible up to max
     while (matchedCount < max && spaceIndex < length) {
@@ -183,16 +152,15 @@ function tryMatchSequence (
   return matchedSpaces.length > 0 ? matchedSpaces : null;
 }
 
-function checkSpaceConditions (
-  bgioArguments: unknown,
-  space: unknown,
-  conditions: Condition[] | undefined,
-  chunkMatches: unknown[] = [],
-  context?: Record<string, unknown>
-) {
+function checkSpaceConditions(bgioArguments, space, conditions, chunkMatches = [], context) {
+  // Early exit if no conditions
+  if (!conditions || conditions.length === 0) {
+    return true;
+  }
+  
   return checkConditions(
     bgioArguments,
-    conditions,
+    { conditions },
     {
       target: space,
       targets: [space, ...chunkMatches] // for ContainsSame, other group conditions
@@ -201,12 +169,7 @@ function checkSpaceConditions (
   ).conditionsAreMet
 }
 
-export default function gridContainsSequence (
-  bgioArguments: unknown,
-  grid: GridLike,
-  sequencePattern: SequenceChunk[],
-  context: Record<string, unknown>
-) {
+export default function gridContainsSequence(bgioArguments, grid, sequencePattern, context) {
   const cacheKey = getSequenceKey(sequencePattern, context);
   let gridCache = sequenceCache.get(grid);
   
@@ -222,11 +185,10 @@ export default function gridContainsSequence (
     return cacheEntry.result;
   }
   
-  const matches: unknown[][] = [];
-
-  const minSequenceLength = sequencePattern.reduce(
-    (sum: number, chunk: SequenceChunk) => sum + (chunk.minCount || chunk.count || 1),
-    0
+  const matches = [];
+  
+  const minSequenceLength = sequencePattern.reduce((sum, chunk) => 
+    sum + (chunk.minCount || chunk.count || 1), 0
   );
   
   // For each direction, scan each row/column/diagonal once

package/src/utils/json-transformer.js

@@ -0,0 +1,12 @@
+// recurse and replace. circular references not allowed
+export default function transformJSON(data, rules) {
+  return JSON.parse(JSON.stringify(data), (key, value) => {
+    let result = value;
+    for (const rule of rules) {
+      if (rule.test(result)) {
+        result = rule.replace(result);
+      }
+    }
+    return result;
+  });
+}