board-game-engine 0.0.2 → 0.0.3

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({ type: '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 { Client } from './client/client'
+export { default as gameFactory } from './game-factory/game-factory'

package/src/registry.js

@@ -0,0 +1,17 @@
+import Board from "./game-factory/board.js";
+import SpaceGroup from "./game-factory/space-group/space-group.js";
+import Space from "./game-factory/space/space.js";
+import Grid from "./game-factory/space-group/grid.js";
+import Bank from "./game-factory/bank/bank.js";
+import BankSlot from "./game-factory/bank/bank-slot.js";
+import Entity from "./game-factory/entity.js";
+
+export const registry = {
+  Board,
+  SpaceGroup,
+  Space,
+  Grid,
+  Bank,
+  BankSlot,
+  Entity,
+};

package/src/utils/any-valid-moves.js

@@ -0,0 +1,157 @@
+import isPlainObject from "lodash/isPlainObject.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') {
+    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]);
+    }
+  }
+  
+  // 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) {
+  const argNames = Object.keys(ruleArguments);
+  const graph = {};
+  const inDegree = {};
+  
+  // Initialize
+  argNames.forEach(name => {
+    graph[name] = [];
+    inDegree[name] = 0;
+  });
+  
+  // 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 => {
+      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 = [];
+  
+  while (queue.length > 0) {
+    const current = queue.shift();
+    sorted.push(current);
+    
+    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;
+}
+
+// Recursively try to build a valid argument combination
+function findValidCombination(
+  bgioArguments, 
+  moveInstance,
+  ruleArguments,
+  orderedArgNames,
+  context,
+  index = 0,
+  currentArgs = {}
+) {
+  // Base case: all arguments resolved
+  if (index === orderedArgNames.length) {
+    const resolvedPayload = { arguments: currentArgs };
+    return moveInstance.isValid(bgioArguments, resolvedPayload, context);
+  }
+  
+  const argName = orderedArgNames[index];
+  const arg = ruleArguments[argName];
+  
+  // Update context with current arguments for dependency resolution
+  const updatedContext = {
+    ...context,
+    moveArguments: currentArgs
+  };
+  
+  // Get all possible values for this argument if not resolved
+  // If it is unresolved, it means it was a playerChoice
+  const matches = isPlainObject(arg)
+    ? resolveEntity(
+      bgioArguments,
+      { ...arg, matchMultiple: true },
+      updatedContext,
+      argName 
+    )
+    : arg;
+  
+  const matchArray = Array.isArray(matches) ? matches : (matches !== undefined ? [matches] : []);
+  
+  // If no valid values for this argument, this branch fails
+  if (matchArray.length === 0) {
+    return false;
+  }
+  
+  // Try each possible value (short-circuits on first success)
+  return matchArray.some(value => {
+    return findValidCombination(
+      bgioArguments,
+      moveInstance,
+      ruleArguments,
+      orderedArgNames,
+      context,
+      index + 1,
+      { ...currentArgs, [argName]: value }
+    );
+  });
+}
+
+export default function areThereValidMoves(bgioArguments, moves) {
+  return Object.values(moves).some(move => {
+    const { moveInstance } = move;
+    const context = { moveInstance };
+    const rule = resolveProperties(
+      bgioArguments,
+      moveInstance.rule,
+      context
+    );
+
+    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);
+    }
+    
+    // Get dependency-ordered argument names
+    const orderedArgNames = getArgumentOrder(ruleArguments);
+    
+    // Recursively search for any valid combination (short-circuits on first valid)
+    return findValidCombination(
+      bgioArguments,
+      moveInstance,
+      ruleArguments,
+      orderedArgNames,
+      context
+    );
+  });
+}

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,28 @@
+// 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.type]
+    .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.js

@@ -0,0 +1,226 @@
+// claude ai did most of this
+import _matches from "lodash/matches.js";
+import checkConditions from "./check-conditions.js";
+
+// We'll check reverse directions along each line
+const directions = [
+  [1, 0],   // horizontal
+  [0, 1],   // vertical
+  [1, 1],   // diagonal down-right
+  [-1, 1],  // diagonal down-left
+];
+
+const sequenceCache = new WeakMap();
+
+function getSequenceKey(sequencePattern, context) {
+  const contextKey = {
+    moveInstance: context.moveInstance?.id,
+    moveArguments: context.moveArguments,
+    // Add other context properties that conditions might use
+  };
+  return JSON.stringify({ pattern: sequencePattern, context: contextKey });
+}
+
+// todo: use stable hash library that we're using for game rules hash
+function getGridStateKey(grid) {
+  const spaces = grid.entities || [];
+  
+  return spaces.map(space => {
+    const entities = space.entities || [];
+    if (entities.length === 0) return 'empty';
+    
+    return entities.map(entity => {
+      const sortedKeys = Object.keys(entity).sort();
+      const stateObj = {};
+      sortedKeys.forEach(key => {
+        stateObj[key] = entity[key];
+      });
+      return JSON.stringify(stateObj);
+    }).sort().join('|');
+  }).join(',');
+}
+
+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;
+  let startIndex = 0;
+  
+  while (startIndex <= length - minSequenceLength) {
+    const matchedSpaces = tryMatchSequence(
+      bgioArguments, 
+      lineSpaces, 
+      startIndex, 
+      sequencePattern,
+      context,
+      reverse
+    );
+    
+    if (matchedSpaces) {
+      matches.push(matchedSpaces);
+      startIndex++; // Move one space forward to find overlapping matches
+    } else {
+      startIndex++;
+    }
+  }
+  
+  return matches;
+}
+
+function getLineStartingPoints(grid, dx, dy) {
+  const { width, height } = grid.attributes;
+  const starts = [];
+  
+  if (dx === 1 && dy === 0) {
+    // Horizontal: start at leftmost column
+    for (let y = 0; y < height; y++) starts.push([0, y]);
+  } else if (dx === 0 && dy === 1) {
+    // Vertical: start at top row
+    for (let x = 0; x < width; x++) starts.push([x, 0]);
+  } else if (dx === 1 && dy === 1) {
+    // Diagonal down-right: start from top row and left column
+    for (let x = 0; x < width; x++) starts.push([x, 0]);
+    for (let y = 1; y < height; y++) starts.push([0, y]);
+  } else if (dx === -1 && dy === 1) {
+    // Diagonal down-left: start from top row and right column
+    for (let x = 0; x < width; x++) starts.push([x, 0]);
+    for (let y = 1; y < height; y++) starts.push([width - 1, y]);
+  }
+  
+  return starts;
+}
+
+function getLineSpaces(grid, startX, startY, dx, dy) {
+  const spaces = [];
+  let [x, y] = [startX, startY];
+  
+  while (grid.areCoordinatesValid([x, y])) {
+    spaces.push(grid.getSpace([x, y]));
+    x += dx;
+    y += dy;
+  }
+  return spaces;
+}
+
+function tryMatchSequence(bgioArguments, lineSpaces, startIndex, sequencePattern, context, reverse = false) {
+  let spaceIndex = startIndex;
+  const matchedSpaces = [];
+  const length = lineSpaces.length;
+  
+  for (const chunk of sequencePattern) {
+    const { count, minCount, maxCount, conditions } = chunk;
+    
+    let min, max;
+    if (count !== undefined) {
+      min = max = count;
+    } else if (minCount !== undefined || maxCount !== undefined) {
+      min = minCount || 0;
+      max = maxCount || Infinity;
+    } else {
+      min = max = 1;
+    }
+    
+    let matchedCount = 0;
+    const chunkMatches = [];
+    
+    // Greedy: try to match as many as possible up to max
+    while (matchedCount < max && spaceIndex < length) {
+      // Access space directly or in reverse without creating new array
+      const space = reverse 
+        ? lineSpaces[length - 1 - spaceIndex]
+        : lineSpaces[spaceIndex];
+      
+      // Pass all previously matched spaces in this chunk
+      if (checkSpaceConditions(bgioArguments, space, conditions, chunkMatches, context)) {
+        chunkMatches.push(space);
+        matchedCount++;
+        spaceIndex++;
+      } else {
+        break;
+      }
+    }
+    
+    // Check if we met the minimum requirement
+    if (matchedCount < min) {
+      return null;
+    }
+    
+    matchedSpaces.push(...chunkMatches);
+  }
+  
+  return matchedSpaces.length > 0 ? matchedSpaces : null;
+}
+
+function checkSpaceConditions(bgioArguments, space, conditions, chunkMatches = [], context) {
+  // Early exit if no conditions
+  if (!conditions || conditions.length === 0) {
+    return true;
+  }
+  
+  return checkConditions(
+    bgioArguments,
+    { conditions },
+    {
+      target: space,
+      targets: [space, ...chunkMatches] // for ContainsSame, other group conditions
+    },
+    context
+  ).conditionsAreMet
+}
+
+export default function gridContainsSequence(bgioArguments, grid, sequencePattern, context) {
+  const cacheKey = getSequenceKey(sequencePattern, context);
+  let gridCache = sequenceCache.get(grid);
+  
+  if (!gridCache) {
+    gridCache = new Map();
+    sequenceCache.set(grid, gridCache);
+  }
+  
+  const gridStateKey = getGridStateKey(grid);
+  const cacheEntry = gridCache.get(cacheKey);
+  
+  if (cacheEntry && cacheEntry.stateKey === gridStateKey) {
+    return cacheEntry.result;
+  }
+  
+  const matches = [];
+  
+  const minSequenceLength = sequencePattern.reduce((sum, chunk) => 
+    sum + (chunk.minCount || chunk.count || 1), 0
+  );
+  
+  // For each direction, scan each row/column/diagonal once
+  for (const [dx, dy] of directions) {
+    const lines = getLineStartingPoints(grid, dx, dy);
+    
+    for (const [startX, startY] of lines) {
+      const lineSpaces = getLineSpaces(grid, startX, startY, dx, dy);
+      
+      if (lineSpaces.length < minSequenceLength) {
+        continue;
+      }
+      
+      // todo: this forward/backward logic seems jank. why split them up?
+
+      const forwardMatches = findSequencesInLine(bgioArguments, lineSpaces, sequencePattern, minSequenceLength, context);
+      matches.push(...forwardMatches);
+      
+      // Only reverse if needed (avoid creating new arrays unnecessarily)
+      if (forwardMatches.length === 0 || sequencePattern.length > 1) {
+        const reverseMatches = findSequencesInLine(bgioArguments, lineSpaces, sequencePattern, minSequenceLength, context, true);
+        matches.push(...reverseMatches);
+      }
+    }
+  }
+  
+  const result = { matches, conditionIsMet: !!matches.length };
+  
+  gridCache.set(cacheKey, {
+    stateKey: gridStateKey,
+    result
+  });
+  
+  return result;
+}