board-game-engine 2.0.0 → 2.0.1

package/src/game-factory/move/move-factory.js

@@ -1,89 +0,0 @@
-import { serialize, deserialize } from 'wackson'
-import { INVALID_MOVE } from '@mnbroatch/boardgame.io/dist/cjs/core.js';
-import { registry } from '../../registry.js'
-import deserializeBgioArguments from '../../utils/deserialize-bgio-arguments.js'
-import MoveEntity from "./move-entity.js";
-import RemoveEntity from "./remove-entity.js";
-import PlaceNew from "./place-new.js";
-import TakeFrom from "./take-from.js";
-import SetState from "./set-state.js";
-import SetActivePlayers from "./set-active-players.js";
-import EndTurn from "./end-turn.js";
-import PassTurn from "./pass-turn.js";
-import ForEach from "./for-each.js";
-import Pass from "./pass.js";
-import Shuffle from "./shuffle.js";
-
-export default function moveFactory(moveRule, game) {
-  const moveInstance = getMoveInstance(moveRule)
-
-  // accepts serialized G and payload, returns serialized
-  const compatibleMove = function (
-    bgioArguments,
-    serializablePayload
-  ) {
-    const newBgioArguments = deserializeBgioArguments(bgioArguments)
-    const { G } = newBgioArguments
-    const payload = revivePayload(serializablePayload, G)
-    const context = { moveInstance, game }
-    const moveConditionResults = moveInstance.doMove(newBgioArguments, payload, context)
-
-    context.moveConditionResults = [moveConditionResults]
-
-    if (moveConditionResults !== INVALID_MOVE && moveRule.then) {
-      for (let automaticMoveRule of moveRule.then) {
-        const result = getMoveInstance(automaticMoveRule).doMove(
-          newBgioArguments,
-          {},
-          {...context} // spread here so prevArguments doesn't change for sibling
-        )
-        context.moveConditionResults.push(result)
-      }
-    }
-
-    return JSON.parse(serialize(G))
-  }
-  compatibleMove.moveInstance = moveInstance
-  return compatibleMove
-}
-
-function revivePayload (serializablePayload, G) {
-  if (serializablePayload) {
-    const payload = deserialize(JSON.stringify(serializablePayload), registry)
-    payload.arguments =
-      Object.entries(payload.arguments).reduce((acc, [key, argOrEntityId]) => ({
-        ...acc,
-        [key]: typeof argOrEntityId === 'number' ? G.bank.locate(argOrEntityId) : argOrEntityId
-      }), {})
-    return payload
-  } else {
-    return serializablePayload
-  }
-}
-
-export function getMoveInstance (moveRule) {
-  switch (moveRule.moveType) {
-    case 'MoveEntity':
-      return new MoveEntity(moveRule);
-    case 'PlaceNew':
-      return new PlaceNew(moveRule);
-    case 'RemoveEntity':
-      return new RemoveEntity(moveRule);
-    case 'TakeFrom':
-      return new TakeFrom(moveRule);
-    case 'SetState':
-      return new SetState(moveRule);
-    case 'ForEach':
-      return new ForEach(moveRule);
-    case 'Pass':
-      return new Pass(moveRule);
-    case 'Shuffle':
-      return new Shuffle(moveRule);
-    case 'SetActivePlayers':
-      return new SetActivePlayers(moveRule);
-    case 'EndTurn':
-      return new EndTurn(moveRule);
-    case 'PassTurn':
-      return new PassTurn(moveRule);
-  }
-}

package/src/game-factory/move/move.js

@@ -1,131 +0,0 @@
-import { INVALID_MOVE } from '@mnbroatch/boardgame.io/dist/cjs/core.js';
-import checkConditions from "../../utils/check-conditions.js";
-import resolveProperties from "../../utils/resolve-properties.js";
-
-export default class Move {
-  constructor (rule) {
-    this.rule = this.transformRule(rule)
-  }
-
-  checkValidity (bgioArguments, payload, context) {
-    const argRuleEntries = Object.entries(this.rule.arguments ?? {})
-
-    if (
-      !argRuleEntries.every(([argName]) => {
-        const arg = payload.arguments[argName]
-        return arg !== undefined && (!Array.isArray(arg) || arg.length)
-      })
-    ) {
-      // not the best return value but we don't want to do expensive checks
-      // when we know the operation is doomed. At least for now.
-      return false
-    }
-
-    const argumentResults = {}
-
-    for (let i = 0, len = argRuleEntries.length; i < len; i++) {
-      const [argName, argRule] = argRuleEntries[i]
-      const payloadArg = payload.arguments[argName]
-      const args = Array.isArray(payloadArg)
-        ? payloadArg
-        : [payloadArg]
-
-      const argResults = []
-      for (let j = 0, len = args.length; j < len; j++) {
-        const arg = args[j]
-        const result = checkConditions(
-          bgioArguments,
-          argRule,
-          { target: arg },
-          { ...context, moveArguments: payload.arguments }
-        )
-        argResults.push(result)
-        if (!result.conditionsAreMet) {
-          break
-        }
-      }
-
-      const argConditionsAreMet = argResults.at(-1).conditionsAreMet
-      argumentResults[argName] = {
-        results: argResults,
-        conditionsAreMet: argConditionsAreMet
-      }
-      if (!argConditionsAreMet) {
-        break
-      }
-    }
-
-    const moveResults = checkConditions(
-      bgioArguments,
-      { conditions: this.rule.conditions },
-      undefined,
-      { ...context, moveArguments: payload.arguments }
-    )
-
-    return {
-      argumentResults,
-      moveResults,
-      conditionsAreMet: moveResults.conditionsAreMet
-        && Object.values(argumentResults).every(a => a.conditionsAreMet)
-    }
-  }
-
-  isValid (bgioArguments, payload, context) {
-    const conditionResults = this.checkValidity(
-      bgioArguments,
-      payload,
-      context
-    )
-    return conditionResults.conditionsAreMet
-  }
-
-  doMove (bgioArguments, payload, context, { skipCheck = false } = {}) {
-    const rule = resolveProperties(
-      bgioArguments,
-      this.rule,
-      context
-    )
-    const resolvedPayload = {
-      ...payload,
-      arguments: Object.entries(rule.arguments ?? {})
-        .reduce((acc, [argName, arg]) => {
-          return {
-            ...acc,
-            [argName]: payload?.arguments?.[argName] ?? arg
-          };
-        }, {})
-    };
-
-    // does not store automatic moves, do we need that?
-    if (rule.name) {
-      bgioArguments.G._meta.previousPayloads[rule.name] = resolvedPayload
-    }
-
-    let conditionResults
-    if (!skipCheck) {
-      conditionResults = this.checkValidity(bgioArguments, resolvedPayload, context)
-    }
-
-    if (!skipCheck && !conditionResults.conditionsAreMet) {
-      return INVALID_MOVE
-    } else {
-      this.do(bgioArguments, rule, resolvedPayload, context)
-      if (context) {
-        context.previousArguments = resolvedPayload.arguments
-      }
-    }
-
-    return { conditionResults }
-  }
-
-  transformRule (rule) {
-    const args = rule.arguments
-    for (let key in args) {
-      const arg = args[key]
-      if (!arg.playerChoice) {
-        arg.resolveAsEntity = true
-      }
-    }
-    return rule
-  }
-}

package/src/game-factory/move/pass-turn.js

@@ -1,10 +0,0 @@
-import Move from "./move.js";
-
-export default class PassTurn extends Move {
-  do(bgioArguments) {
-    if (bgioArguments.G._meta.passedPlayers.length < bgioArguments.ctx.numPlayers) {
-      bgioArguments.G._meta.passedPlayers.push(bgioArguments.ctx.currentPlayer)
-      bgioArguments.events.pass()
-    }
-  }
-}

package/src/game-factory/move/place-new.js

@@ -1,33 +0,0 @@
-import Move from "./move.js";
-
-export default class PlaceNew extends Move {
-  do(bgioArguments, rule, { arguments: { destination } }, context) {
-    const entities = rule.matchMultiple
-      ? bgioArguments.G.bank.getMultiple(
-          bgioArguments,
-          {
-            ...rule.entity,
-            conditions: [
-              ...(rule.entity?.conditions || []),
-              ...(rule.conditions || []),
-            ]
-          },
-          rule.count,
-          context
-        )
-      : [bgioArguments.G.bank.getOne(
-          bgioArguments,
-          {
-            ...rule.entity,
-            conditions: [
-              ...(rule.entity?.conditions || []),
-              ...(rule.conditions || []),
-            ]
-          },
-          context
-        )]
-    entities.forEach((entity) => {
-      destination.placeEntity(entity, rule.position)
-    })
-  }
-}

package/src/game-factory/move/remove-entity.js

@@ -1,7 +0,0 @@
-import Move from "./move.js";
-
-export default class RemoveEntity extends Move {
-  do(bgioArguments, rule, { arguments: { entity } }) {
-    bgioArguments.G.bank.returnToBank(bgioArguments, entity)
-  }
-}

package/src/game-factory/move/set-active-players.js

@@ -1,23 +0,0 @@
-import Move from "./move.js";
-import doMoves from '../../utils/do-moves.js'
-
-export default class SetActivePlayers extends Move {
-  do(bgioArguments, rule, _, context) {
-    bgioArguments.events.setActivePlayers(rule.options)
-
-    // this is going to need to be expanded to handle more complex things
-    // than "move current player to new stage"
-    const phaseName = bgioArguments.ctx.phase
-    const stageName = rule.options.currentPlayer?.stage
-    const phaseOrRoot = context.game.phases?.[phaseName] ?? context.game
-    const stage = phaseOrRoot?.turn?.stages?.[stageName]
-    doMoves(
-      bgioArguments,
-      stage?.initialMoves,
-      {
-        ...context,
-        stageName,
-      }
-    )
-  }
-}

package/src/game-factory/move/set-state.js

@@ -1,11 +0,0 @@
-import Move from "./move.js";
-
-// todo: invariant conditions like "is one of the allowed values"
-export default class SetState extends Move {
-  do(_, __, { arguments: { entity, state } }) {
-    entity.state = {
-      ...entity.state,
-      [state.property]: state.value,
-    }
-  }
-}

package/src/game-factory/move/shuffle.js

@@ -1,7 +0,0 @@
-import Move from "./move.js";
-
-export default class Shuffle extends Move {
-  do(bgioArguments, _, { arguments: { target } }) {
-    target.entities = bgioArguments.random.Shuffle(target.entities)
-  }
-}

package/src/game-factory/move/take-from.js

@@ -1,7 +0,0 @@
-import Move from "./move.js";
-
-export default class TakeFrom extends Move {
-  do(bgioArguments, rule, { arguments: { source, destination } }) {
-    destination.placeEntity(source.takeOne(rule.arguments.source.position))
-  }
-}

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

@@ -1,30 +0,0 @@
-import Entity from "../entity.js";
-
-export default class Space extends Entity {
-  constructor (...args) {
-    super(...args)
-    this.entities = []
-  }
-
-  placeEntity (entity, position = 'Last') {
-    if (position === 'Last') {
-      this.entities.push(entity);
-    } else if (position === 'First') {
-      this.entities.unshift(entity);
-    }
-  }
-
-  remove (entity) {
-    this.entities.splice(this.entities.indexOf(entity), 1);
-  }
-
-  takeOne (position = 'First') {
-    if (position === 'First') {
-      return this.entities.splice(0, 1)[0];
-    }
-  }
-
-  isEmpty() {
-    return this.entities.length === 0;
-  }
-}

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

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

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

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

package/src/utils/check-conditions.js

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

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

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

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

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

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

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

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

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

@@ -1,25 +0,0 @@
-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/json-transformer.js

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

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