board-game-engine 0.0.2 → 0.0.3

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

package/src/utils/prepare-payload.js

@@ -0,0 +1,16 @@
+import { serialize } from "wackson";
+
+// todo: remember why reducing to id was preferred?
+export default function preparePayload (payload) {
+  if (payload?.arguments) {
+    const payloadCopy = { ...payload }
+    payloadCopy.arguments =
+      Object.entries(payloadCopy.arguments).reduce((acc, [key, argument]) => ({
+        ...acc,
+        [key]: argument.abstract ? argument : argument.entityId
+      }), {})
+    return JSON.parse(serialize(payloadCopy, { deduplicateInstances: false }))
+  } else {
+    return payload
+  }
+}

package/src/utils/resolve-entity.js

@@ -0,0 +1,9 @@
+import isPlainObject from "lodash/isPlainObject.js";
+
+const abstractTargetNames = ['state']
+
+export default function resolveEntity (bgioArguments, target, context, targetName) {
+  return !abstractTargetNames.includes(targetName) && isPlainObject(target)
+    ? bgioArguments.G.bank.find(bgioArguments, target, context)
+    : target
+}

package/src/utils/resolve-expression.js

@@ -0,0 +1,10 @@
+import { Parser } from 'expr-eval'
+import resolveProperties from "../utils/resolve-properties.js";
+
+const parser = new Parser();
+parser.functions.sum = array => array.reduce((acc, val) => acc + val, 0)
+
+export default function resolveExpression (bgioArguments, rule, context) {
+  const args = resolveProperties(bgioArguments, rule.arguments, context)
+  return parser.evaluate(rule.expression, args)
+}

package/src/utils/resolve-properties.js

@@ -0,0 +1,157 @@
+import isPlainObject from "lodash/isPlainObject.js";
+import pick from "lodash/pick.js";
+import get from "./get.js";
+import resolveExpression from "./resolve-expression.js";
+import resolveEntity from "./resolve-entity.js";
+
+// some keys only contain things that will be the root of a later resolution
+const resolutionTerminators = [
+  'conditions',
+  'move',
+  'then',
+  'mapping',
+]
+
+export default function resolveProperties (bgioArguments, obj, context, key) {
+  if (!isPlainObject(obj) && !Array.isArray(obj)) {
+    return obj
+  }
+
+  let resolvedProperties = Array.isArray(obj)
+    ? [...obj]
+    : { ...obj }
+
+  Object.entries(obj).forEach(([key, value]) => {
+    if (!resolutionTerminators.includes(key)) {
+      resolvedProperties[key] = resolveProperties(bgioArguments, value, context, key)
+    }
+  })
+
+  const resolved = resolveProperty(bgioArguments, resolvedProperties, context)
+
+  const resolveAsEntity = resolved?.resolveAsEntity
+    || key === 'target'
+    || key === 'targets'
+
+  return resolveAsEntity
+    ? resolveEntity(
+        bgioArguments,
+        resolved,
+        context,
+        key
+      )
+    : resolved
+}
+
+function resolveProperty (bgioArguments, value, context) {
+  if (value?.type === 'expression') {
+    return resolveExpression(
+      bgioArguments,
+      {
+        ...value,
+        arguments: resolveProperties(bgioArguments, value.arguments, context, 'arguments')
+      },
+      context
+    )
+  } else if (value?.type === 'count') {
+    return bgioArguments.G.bank.findAll(
+      bgioArguments,
+      value,
+      context
+    ).length
+  } else if (value?.type === 'contextPath') {
+    return get(context, value.path)
+  } else if (value?.type === 'ctxPath') {
+    return get(bgioArguments.ctx, value.path)
+  } else if (value?.type === 'gamePath') {
+    return get(bgioArguments.G, value.path)
+  } else if (value?.type === 'RelativePath') {
+    const target = resolveProperties(bgioArguments, value.target, context, 'target')
+    return get(target.attributes, value.path) ?? null
+  } else if (value?.type === 'Parent') {
+    const originalTarget = value.target
+      ? resolveProperties(bgioArguments, value.target, context, 'target')
+      : context.originalTarget
+    return bgioArguments.G.bank.findParent(originalTarget) ?? null
+  } else if (value?.type === 'map') {
+    return getMappedTargets(
+      bgioArguments,
+      value.targets,
+      value.mapping,
+      context
+    ).map(mappedTarget => mappedTarget.value)
+  } else if (value?.type === 'mapMax') {
+    const mappedTargets = getMappedTargets(
+      bgioArguments,
+      value.targets,
+      value.mapping,
+      context
+    )
+    let maxValue
+    const maxTargets = []
+    for (let i = 0, len = mappedTargets.length; i < len; i++) {
+      const { target, value: val } = mappedTargets[i]
+      if (maxValue === undefined || val > maxValue) {
+        maxValue = val
+        maxTargets.length = 0
+        maxTargets.push(target)
+      } else if (val === maxValue) {
+        maxTargets.push(target)
+      }
+    }
+    return maxTargets
+  } else if (value?.type === 'Pick') {
+    const target = resolveProperties(bgioArguments, value.target, context, 'target')
+    if (target !== undefined) {
+      console.log('target', target)
+      console.log('target.attributes', target.attributes)
+      const x = pick(
+        resolveProperties(
+          bgioArguments,
+          target.attributes,
+          context,
+          'attributes'
+        ),
+        value.properties
+      )
+      console.log('x', x)
+      return x
+    } else {
+      console.log('8888target', target)
+    }
+  } else if (value?.type === 'Coordinates') {
+    const originalTarget = value.target
+      ? resolveProperties(bgioArguments, value.target, context, 'target')
+      : context.originalTarget
+      const parent = bgioArguments.G.bank.findParent(originalTarget)
+      return parent.getCoordinates(originalTarget.rule.index)
+  } else if (value?.type === 'relativeCoordinates') {
+    const originalTarget = value.target
+      ? resolveProperties(bgioArguments, value.target, context, 'target')
+      : context.originalTarget
+    const parent = bgioArguments.G.bank.findParent(originalTarget)
+    const oldCoordinates =
+      parent.getCoordinates(originalTarget.rule.index)
+    const newCoordinates =
+      parent.getRelativeCoordinates(
+      oldCoordinates,
+      resolveProperties(bgioArguments, value.location, context, 'location')
+    )
+    return (newCoordinates && parent.spaces[parent.getIndex(newCoordinates)]) ?? null
+  } else {
+    return value
+  }
+}
+
+function getMappedTargets (bgioArguments, targetsRule, mapping, context) {
+  targetsRule.resolveAsEntity = true
+  return resolveProperties(bgioArguments, targetsRule, context)?.map(target => ({
+    target,
+    value: resolveProperties(
+      bgioArguments,
+      mapping,
+      { ...context, loopTarget: target },
+    )
+  })) ?? []
+}
+

package/src/utils/simulate-move.js

@@ -0,0 +1,25 @@
+import { serialize, deserialize } from 'wackson'
+import { registry } from '../registry.js'
+
+export default function simulateMove (bgioArguments, payload, context) {
+  const simulatedG = deserialize(serialize(bgioArguments.G), registry)
+  const newBgioArguments = {
+    ...bgioArguments,
+    G: simulatedG,
+  }
+  const simulatedPayload = { ...payload, arguments: {} }
+  Object.entries(payload.arguments).forEach(([argName, arg]) => {
+    simulatedPayload.arguments[argName] = arg.abstract
+      ? arg
+      : simulatedG.bank.locate(typeof arg === 'number' ? arg : arg.entityId)
+  })
+
+  context.moveInstance.doMove(
+    newBgioArguments,
+    simulatedPayload,
+    context,
+    { skipCheck: true }
+  )
+
+  return simulatedG
+}

package/webpack.config.js

@@ -1,6 +1,9 @@
 const common = {
   mode: 'production',
-  entry: './src/index.ts',
+  entry: './src/index.js',
+  optimization: {
+    concatenateModules: false,
+  },
   output: {
     filename: 'board-game-engine.min.js',
     library: {

package/src/action/action-factory.js

@@ -1,13 +0,0 @@
-import MovePieceAction from "./move-piece-action.js";
-import SwapAction from "./swap-action.js";
-import SelectPieceAction from "./select-piece-action.js";
-
-export default function actionFactory(actionPayload, game) {
-  if (actionPayload.type === "movePiece") {
-    return new MovePieceAction(actionPayload, game);
-  } else if (actionPayload.type === "swap") {
-    return new SwapAction(actionPayload, game);
-  } else if (actionPayload.type === "selectPiece") {
-    return new SelectPieceAction(actionPayload, game);
-  }
-}

package/src/action/action.js

@@ -1,34 +0,0 @@
-import conditionFactory from '../condition/condition-factory.js'
-
-export default class Action {
-  constructor (rules, game) {
-    this.game = game
-    this.rules = rules
-    this.id = `${Math.random()}`
-
-    const invariantConditionRules = [
-      { type: 'actionTypeMatches', actionRule: this.rules },
-      { type: 'pieceMatches', actionRule: this.rules },
-      { type: 'isValidPlayer' }
-    ]
-
-    this.conditions = [
-      ...invariantConditionRules,
-      ...(this.rules.conditions || [])
-    ].map((conditionRule) => conditionFactory(conditionRule, game))
-  }
-
-  assertIsValid (actionPayload) {
-    const unmetConditions = this.conditions.filter(
-      (condition) => !condition.isMet(actionPayload)
-    )
-    if (unmetConditions.length) {
-      console.log('==================')
-      console.log('unmetConditions', unmetConditions)
-      console.log('actionPayload', actionPayload)
-      throw new Error('conditions not met ^')
-    }
-  }
-
-  do () {}
-}

package/src/action/move-piece-action.js

@@ -1,11 +0,0 @@
-import Action from "./action.js";
-import resolveBoard from "../utils/resolve-board.ts";
-import resolvePiece from "../utils/resolve-piece.ts";
-
-export default class MovePieceAction extends Action {
-  do(actionPayload) {
-    const piece = resolvePiece(actionPayload.piece, this.game);
-    const board = resolveBoard(actionPayload.board, this.game)
-    board.placePiece(actionPayload.target, piece);
-  }
-}

package/src/action/select-piece-action.js

@@ -1,23 +0,0 @@
-import Action from "./action.js";
-
-export default class SelectPieceAction extends Action {
-  constructor(actionPayload, game) {
-    super(actionPayload, game);
-  }
-  do(actionPayload) {
-    let piece;
-    if (actionPayload.piece?.id) {
-      piece = this.game.getPiece({
-        id: actionPayload.piece?.id,
-      });
-    } else if (actionPayload.from === "player") {
-      piece = this.game.players
-        .find((player) => player.id === actionPayload.playerId)
-        .pieces.find((piece) => piece.name === actionPayload.piece.name)
-        .getOne();
-    }
-    this.game.context.selectedPiece = piece;
-
-    // do the "then"
-  }
-}

package/src/action/swap-action.js

@@ -1,14 +0,0 @@
-import Action from "./action.js";
-
-export default class SwapAction extends Action {
-  do(actionPayload) {
-    let piece;
-    if (actionPayload.from === "player") {
-      piece = this.game.players
-        .find((player) => player.id === actionPayload.playerId)
-        .pieces.find((piece) => piece.name === actionPayload.piece.name)
-        .getOne();
-    }
-    this.game.get(actionPayload.board).placePiece(actionPayload.target, piece);
-  }
-}

package/src/board/board-factory.js

@@ -1,12 +0,0 @@
-import Grid from "./grid.js";
-import Stack from "./stack.js";
-
-export default function boardFactory(boardRule, options) {
-  if (boardRule.type === "grid") {
-    return new Grid(boardRule, options);
-  } else if (boardRule.type === "stack") {
-    return new Stack(boardRule, options);
-  } else {
-    console.log("missing board type:", boardRule);
-  }
-}

package/src/board/board-group.js

@@ -1,9 +0,0 @@
-import Board from "./board.js";
-
-export default class BoardGroup extends Board {
-  constructor(boardRule, options) {
-    this.sections = boardRule.sections.map(() =>
-      Board.factory(boardRule, options),
-    );
-  }
-}

package/src/board/board.js

@@ -1,11 +0,0 @@
-export default class Board {
-  constructor (boardRule, options = {}) {
-    this.rule = boardRule
-    this.id = `${Math.random()}`
-    if (this.player) {
-      this.player = options.player
-    }
-  }
-
-  placePiece (target, piece) {}
-}

package/src/board/grid.js

@@ -1,52 +0,0 @@
-import get from "lodash/get.js";
-import Board from "./board.js";
-import Space from "../space/space.ts";
-
-export default class Grid extends Board {
-  constructor(boardRule, options) {
-    super(boardRule, options);
-    this.grid = makeGrid(boardRule);
-  }
-
-  getEmptySpaces() {
-    const emptySpaces = [];
-    for (const row of this.grid) {
-      for (const space of row) {
-        if (space.isEmpty()) {
-          emptySpaces.push(space);
-        }
-      }
-    }
-    return emptySpaces;
-  }
-
-  getSpace(target) {
-    return get(this.grid, target);
-  }
-
-  getPieces(target) {
-    return this.getSpace(target).pieces;
-  }
-
-  placePiece(target, piece) {
-    this.getSpace(target).placePiece(piece);
-  }
-}
-
-function makeGrid(boardRule) {
-  const x = boardRule.width;
-  const y = boardRule.height;
-  if (!x || !y) {
-    throw new Error("No size provided for grid");
-  }
-
-  const grid = [];
-  for (let i = 0; i < y; i++) {
-    const row = [];
-    for (let j = 0; j < x; j++) {
-      row.push(new Space([i, j]));
-    }
-    grid.push(row);
-  }
-  return grid;
-}

package/src/board/stack.js

@@ -1,16 +0,0 @@
-import Board from "./board.js";
-
-export default class Stack extends Board {
-  constructor(boardRule, options) {
-    super(boardRule, options);
-    this.stack = [];
-  }
-
-  placePiece(target, piece) {
-    if (target) {
-      // insert by index?
-    } else {
-      this.stack.push(piece);
-    }
-  }
-}

package/src/condition/action-type-matches-condition.js

@@ -1,7 +0,0 @@
-import Condition from "../condition/condition.js";
-
-export default class ActionTypeMatchesCondition extends Condition {
-  isMet(actionPayload) {
-    return actionPayload.actionRule?.type === this.rules.actionType;
-  }
-}

package/src/condition/bingo-condition.js

@@ -1,50 +0,0 @@
-import Condition from "../condition/condition.js";
-import resolveBoard from "../utils/resolve-board.ts";
-
-export default class BingoCondition extends Condition {
-  isMet() {
-    const grid = resolveBoard(this.rules.boardPath, this.game).grid;
-
-    // TODO: handle rectangles in addition to squares
-    const size = grid.length;
-
-    // Check rows
-    for (let i = 0; i < size; i++) {
-      if (this.checkLine(grid[i])) {
-        return true;
-      }
-    }
-
-    // Check columns
-    for (let i = 0; i < size; i++) {
-      const column = [];
-      for (let j = 0; j < size; j++) {
-        column.push(grid[j][i]);
-      }
-      if (this.checkLine(column)) {
-        return true;
-      }
-    }
-
-    // Check diagonals
-    const diagonal1 = [];
-    const diagonal2 = [];
-    for (let i = 0; i < size; i++) {
-      diagonal1.push(grid[i][i]);
-      diagonal2.push(grid[i][size - 1 - i]);
-    }
-    if (this.checkLine(diagonal1) || this.checkLine(diagonal2)) {
-      return true;
-    }
-
-    return false;
-  }
-
-  checkLine(line) {
-    return line.every((space) =>
-      space.pieces.some((piece) => {
-        return piece.doesRuleMatch(this.rules.piece);
-      }),
-    );
-  }
-}

package/src/condition/blackout-condition.js

@@ -1,9 +0,0 @@
-import Condition from "../condition/condition.js";
-import resolveBoard from "../utils/resolve-board.ts";
-
-export default class BlackoutCondition extends Condition {
-  isMet() {
-    const grid = resolveBoard(this.rules.boardPath, this.game).grid;
-    return grid.every((row) => row.every((space) => !space.isEmpty()));
-  }
-}

package/src/condition/condition-factory.js

@@ -1,31 +0,0 @@
-import DoesNotContainCondition from "./does-not-contain-condition.js";
-import ContainsCondition from "./contains-condition.js";
-import BingoCondition from "./bingo-condition.js";
-import BlackoutCondition from "./blackout-condition.js";
-import SomeCondition from "./some-condition.js";
-import RelativeMoveCondition from "./relative-move-condition.js";
-import ActionTypeMatchesCondition from "./action-type-matches-condition.js";
-import IsValidPlayerCondition from "./is-valid-player-condition.js";
-import PieceMatchesCondition from "./piece-matches-condition.js";
-
-export default function conditionFactory(conditionRule, game) {
-  if (conditionRule.type === "contains") {
-    return new ContainsCondition(conditionRule, game);
-  } else if (conditionRule.type === "doesNotContain") {
-    return new DoesNotContainCondition(conditionRule, game);
-  } else if (conditionRule.type === "bingo") {
-    return new BingoCondition(conditionRule, game);
-  } else if (conditionRule.type === "blackout") {
-    return new BlackoutCondition(conditionRule, game);
-  } else if (conditionRule.type === "some") {
-    return new SomeCondition(conditionRule, game);
-  } else if (conditionRule.type === "relativeMove") {
-    return new RelativeMoveCondition(conditionRule, game);
-  } else if (conditionRule.type === "actionTypeMatches") {
-    return new ActionTypeMatchesCondition(conditionRule, game);
-  } else if (conditionRule.type === "isValidPlayer") {
-    return new IsValidPlayerCondition(conditionRule, game);
-  } else if (conditionRule.type === "pieceMatches") {
-    return new PieceMatchesCondition(conditionRule, game);
-  }
-}

package/src/condition/condition.js

@@ -1,9 +0,0 @@
-export default class Condition {
-  constructor (rules, game) {
-    this.id = `${Math.random()}`
-    this.rules = rules;
-    this.game = game;
-  }
-
-  isMet(actionPayload) {}
-}

package/src/condition/contains-condition.js

@@ -1,14 +0,0 @@
-import matches from "lodash/matches.js";
-import Condition from "../condition/condition.js";
-
-export default class ContainsCondition extends Condition {
-  isMet(actionPayload) {
-    const board = this.game.get(actionPayload.board);
-    const pieces = board.getPieces(actionPayload.target);
-    return !!pieces.filter(filterPieces).length;
-  }
-
-  filterPieces(piece) {
-    return this.rules.piece === "any" || matches(this.rules.piece)(piece);
-  }
-}

package/src/condition/does-not-contain-condition.js

@@ -1,15 +0,0 @@
-import matches from "lodash/matches.js";
-import Condition from "../condition/condition.js";
-import resolveBoard from "../utils/resolve-board.ts";
-
-export default class DoesNotContainCondition extends Condition {
-  isMet(actionPayload) {
-    const board = resolveBoard(actionPayload.board, this.game);
-    const pieces = board.getPieces(actionPayload.target);
-    return !pieces.filter(this.filterPieces.bind(this)).length;
-  }
-
-  filterPieces(piece) {
-    return this.rules.piece === "any" || matches(piece, this.rules.piece || {});
-  }
-}

package/src/condition/is-valid-player-condition.js

@@ -1,7 +0,0 @@
-import Condition from "../condition/condition.js";
-
-export default class IsValidPlayerCondition extends Condition {
-  isMet(actionPayload) {
-    return this.game.players[this.game.currentRound.currentPlayerIndex].id === actionPayload.playerId;
-  }
-}

package/src/condition/piece-matches-condition.js

@@ -1,23 +0,0 @@
-import matches from "lodash/matches.js";
-import Condition from "../condition/condition.js";
-import resolvePiece from "../utils/resolve-piece.ts";
-
-export default class PieceMatchesCondition extends Condition {
-  isMet(actionPayload) {
-    const piece = resolvePiece(actionPayload.piece, this.game);
-
-    if (this.rules.actionRule?.piece && !piece) {
-      console.error("no piece found");
-      return false;
-    }
-
-    if (this.rules.actionRule?.piece) {
-      const matcher = {
-        ...this.rules.actionRule.piece,
-      };
-      return matches(matcher)(piece.rule);
-    }
-
-    return true;
-  }
-}

package/src/condition/relative-move-condition.js

@@ -1,16 +0,0 @@
-import matches from "lodash/matches.js";
-import Condition from "../condition/condition.js";
-
-export default class RelativeMoveCondition extends Condition {
-  isMet(actionPayload) {
-    const board = this.game.get(actionPayload.board);
-    const pieces = board.getPieces(actionPayload.target);
-    return !pieces.filter(this.filterPieces.bind(this)).length;
-  }
-
-  filterPieces(piece) {
-    return (
-      this.rules.piece === "any" || matches(piece, (this.rules.piece = {}))
-    );
-  }
-}

package/src/condition/some-condition.js

@@ -1,7 +0,0 @@
-import Condition from "../condition/condition.js";
-
-export default class SomeCondition extends Condition {
-  isMet() {
-    return this.rules.conditions.some((c) => new Condition(c).isMet());
-  }
-}