board-game-engine 1.0.5 → 2.0.1

package/src/game-factory/condition/would-condition.js

@@ -1,94 +0,0 @@
-import Condition from "./condition.js";
-import checkConditions from "../../utils/check-conditions.js";
-import simulateMove from "../../utils/simulate-move.js";
-
-// relying on target order is not perfect;
-// I think we'll want to switch to named arguments
-const argNameMap = {
-  PlaceNew: ['destination'],
-  RemoveEntity: ['entity'],
-  MoveEntity: ['entity', 'destination'],
-  TakeFrom: ['source', 'destination'],
-  SetState: ['entity', 'state'],
-}
-
-export default class WouldCondition extends Condition {
-  checkCondition(bgioArguments, rule, { target, targets = [target] }, context) {
-    const payload = {
-      arguments: targets.reduce((acc, target, i) => ({
-        ...acc,
-        [argNameMap[context.moveInstance.rule.moveType][i]]: target
-      }), {})
-    }
-
-    const simulatedG = simulateMove(
-      bgioArguments,
-      payload,
-      context
-    )
-
-    let simulatedConditionsPayload = {}
-    if (target) {
-      simulatedConditionsPayload = {
-        target: simulatedG.bank.locate(target.entityId)
-      }
-    } else if (targets) {
-      simulatedConditionsPayload = {
-        targets: targets.map(t => simulatedG.bank.locate(t.entityId))
-      }
-    }
-
-    const conditionResults = checkConditions(
-      {
-        ...bgioArguments,
-        G: simulatedG
-      },
-      rule,
-      simulatedConditionsPayload,
-      context
-    )
-
-    const conditionIsMet = conditionResults.conditionsAreMet
-
-    // optimization: don't bother restoring on failure
-    const results = conditionIsMet
-      ? restoreReferences(
-        conditionResults.results,
-        entityId => bgioArguments.G.bank.locate(entityId)
-      )
-      : conditionResults.results
-
-    return {
-      results,
-      conditionIsMet
-    }
-  }
-}
-
-// references to simulated object are useless
-function restoreReferences(obj, getOriginalEntity, seen = new WeakSet()) {
-  if (typeof obj !== 'object' || obj === null) {
-    return obj;
-  }
-  
-  if (seen.has(obj)) {
-    return obj;
-  }
-  seen.add(obj);
-  
-  if (obj.entityId !== undefined) {
-    return getOriginalEntity(obj.entityId);
-  }
-  
-  if (Array.isArray(obj)) {
-    return obj.map(item => restoreReferences(item, getOriginalEntity, seen));
-  } else {
-    const restored = {};
-    for (const key in obj) {
-      if (obj.hasOwnProperty(key)) {
-        restored[key] = restoreReferences(obj[key], getOriginalEntity, seen);
-      }
-    }
-    return restored;
-  }
-}

package/src/game-factory/entity.js

@@ -1,29 +0,0 @@
-export default class Entity {
-  constructor (options, rule, id) {
-    if (!options?.fromBank) {
-      throw new Error(`Do not create entities directly. Go through the Bank. rule: ${JSON.stringify(rule)}`)
-    }
-    this.rule = rule
-    this.entityId = id
-    this.state = {}
-    if (this.rule.stateGroups) {
-      Object.entries(this.rule.stateGroups)
-        .forEach(([stateGroupName, stateGroupValues]) => {
-          const stateGroupValueName = options?.initialStateGroups?.[stateGroupName]
-            ?? Object.keys(stateGroupValues)[0]
-          Object.assign(this.state, stateGroupValues[stateGroupValueName])
-        })
-    }
-    if (this.rule.state) {
-      Object.assign(this.state, this.rule.state)
-    }
-  }
-
-  get attributes () {
-    return {
-      ...this.rule,
-      ...this,
-      ...this.state
-    }
-  }
-}

package/src/game-factory/expand-game-rules.js

@@ -1,271 +0,0 @@
-import cloneDeep from "lodash/cloneDeep.js";
-import find from "lodash/find.js";
-import transformJSON from "../utils/json-transformer.js";
-
-// for later when we implement deep replacement
-// { type: 'IsEmpty' } = { type: 'not', conditions: [{ type: 'Contains' }], 
-// { matcher: {...blah} } => conditions.push({type: "Is", matcher: {...blah} })
-
-    // put somewhere
-    // const invariantConditionMappings = [
-    //   {
-    //     rule: {
-    //       type: 'BankHasEnough',
-    //       entity: rule.entity
-    //     }
-    //   },
-    // ]
-
-
-// Things we always want, don't need to configure, and
-// want to treat as first-class citizens
-const invariantEntities = [
-  {
-    entityType: "Space",
-    count: "Infinity",
-  },
-  {
-    entityType: "Board",
-    name: 'sharedBoard'
-  },
-  {
-    name: "playerMarker",
-    perPlayer: true,
-    count: "Infinity"
-  }
-]
-
-function expandEntities (rules) {
-  rules.entities = [
-    ...invariantEntities,
-    ...(rules.entities || [])
-  ]
-}
-
-function expandInitialPlacements (rules, entities) {
-  if (rules.sharedBoard) {
-    const sharedBoardPlacements = rules.sharedBoard.map(matcher => ({ entity: matcher, destination: { name: 'sharedBoard' } }))
-    if (!rules.initialPlacements) rules.initialPlacements = []
-    rules.initialPlacements.unshift(...sharedBoardPlacements)
-  }
-
-  if (rules.personalBoard) {
-    entities.push({
-      entityType: "Board",
-      name: 'personalBoard',
-      perPlayer: true
-    })
-    const personalBoardPlacements = rules.personalBoard.map(matcher => ({
-      entity: matcher,
-      destination: {
-        name: 'personalBoard'
-      }
-    }))
-    if (!rules.initialPlacements) rules.initialPlacements = []
-    rules.initialPlacements.unshift(...personalBoardPlacements)
-  }
-
-  if (rules.initialPlacements) {
-    const initialPlacementMoves = rules.initialPlacements.map(placement =>  {
-
-      // probably going to need to separate this even in the shorthand. maybe
-      // combine, then search entity rule and extract state variables instead?
-      const { state, ...matcher } = placement.entity
-      const entityDefinition = find(entities, matcher)
-      
-      if (placement.destination.name === 'personalBoard') {
-        return {
-          moveType: 'ForEach',
-          arguments: {
-            targets: {
-              type: 'ctxPath',
-              path: ['playOrder']
-            }
-          },
-          move: {
-            moveType: 'PlaceNew',
-            entity: {
-              state,
-              conditions: [{
-                conditionType: 'Is',
-                matcher: {
-                  ...matcher,
-                  ...(entityDefinition.perPlayer
-                      ? {
-                          player: {
-                            type: 'contextPath',
-                            path: ['loopTarget']
-                          }
-                        }
-                      : {}
-                  )
-                },
-              }]
-            },
-            arguments: {
-              destination: {
-                conditions: [{
-                  conditionType: 'Is',
-                  matcher: {
-                    ...placement.destination,
-                    player: {
-                      type: 'contextPath',
-                      path: ['loopTarget']
-                    }
-                  }
-                }]
-              },
-            }
-          }
-        }
-      } else {
-        return {
-          moveType: 'PlaceNew',
-          entity: {
-            state,
-            conditions: [{
-              conditionType: 'Is',
-              matcher,
-            }]
-          },
-          arguments: {
-            destination: {
-              conditions: [{
-                conditionType: 'Is',
-                matcher: placement.destination
-              }]
-            },
-          }
-        }
-      }
-    })
-    if (!rules.initialMoves) rules.initialMoves = []
-    rules.initialMoves.unshift(...initialPlacementMoves)
-    delete rules.initialPlacements
-  }
-}
-
-const keyMappings = []
-
-const simpleReplacements = [
-  [
-    'isCurrentPlayer', 
-    {
-      conditionType: 'Is',
-      matcher: {
-        player: {
-          type: 'ctxPath',
-          path: ['currentPlayer']
-        }
-      }
-    }
-  ],
-  [
-    'isEmpty',
-    {
-      conditionType: 'Not',
-      conditions: [{conditionType: 'Contains'}]
-    }
-  ],
-  [
-    'ownerOfFirstResultEntity', // might have to more tightly couple this to HasLine condition
-    {
-      "type": "contextPath",
-      "path": ["results", 0, "matches", 0, 0, "entities", 0, "attributes", "player"]
-    }
-  ]
-]
-
-const transformationRules = [
-  {
-    test: val => val && typeof val === 'object',
-    replace: (val) => {
-      keyMappings.forEach(([oldKey, newKey]) => {
-        if (val.hasOwnProperty(oldKey)) {
-          val[newKey] = val[oldKey]
-          delete val[oldKey]
-        }
-      })
-      return val
-    }
-  },
-  {
-    test: val => typeof val === 'string',
-    replace: (val) => {
-      for (let i = 0, len = simpleReplacements.length; i < len; i++) {
-        if (val === simpleReplacements[i][0]) {
-          return simpleReplacements[i][1]
-        }
-      }
-      return val
-    }
-  },
-  {
-    test: val => val?.conditions,
-    replace: (val) => {
-      if (!Array.isArray(val.conditions)) {
-        val.conditions = [val.conditions]
-      }
-      return val
-    }
-  },
-  {
-    test: val => val?.conditions,
-    replace: (val) => {
-      // make "Is" the default condition
-      for (let i = 0, len = val.conditions.length; i < len; i++) {
-        if (!val.conditions[i].conditionType) {
-          val.conditions[i] = {
-            conditionType: 'Is',
-            matcher: val.conditions[i]
-          }
-        }
-      }
-      return val
-    }
-  },
-  {
-    test: val => typeof val?.target === 'string',
-    replace: val => ({
-      ...val,
-      target: {
-        conditions: [{
-          conditionType: 'Is',
-          matcher: {
-            name: val.target
-          }
-        }]
-      }
-    })
-  }
-]
-
-export default function expandGameRules (gameRules) {
-  const rules = transformJSON(gameRules, transformationRules)
-
-  if (!rules.sharedBoard) {
-    rules.sharedBoard = rules.entities
-  }
-
-  if (!rules.turn) {
-    rules.turn = {
-      minMoves: 1,
-      maxMoves: 1
-    }
-  }
-
-  expandEntities(rules)
-  expandInitialPlacements(rules, rules.entities)
-
-  if (rules.phases) {
-    Object.entries(rules.phases).forEach((phaseRule) => {
-      expandInitialPlacements(phaseRule, rules.entities)
-    })
-  }
-
-  if (gameRules.numPlayers) {
-    gameRules.minPlayers = gameRules.maxPlayers = gameRules.numPlayers
-  }
-
-  return rules
-}

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

@@ -1,239 +0,0 @@
-import { serialize } from "wackson";
-import moveFactory from "./move/move-factory.js";
-import Bank from "./bank/bank.js";
-import expandGameRules from "./expand-game-rules.js";
-import getScenarioResults from '../utils/get-scenario-results.js'
-import doMoves from '../utils/do-moves.js'
-import deserializeBgioArguments from '../utils/deserialize-bgio-arguments.js'
-
-export default function gameFactory (gameRules, gameName) {
-  const game = { name: gameName }
-  const rules = expandGameRules(gameRules)
-
-  game.setup = (bgioArguments) => {
-    const { ctx } = bgioArguments
-    const initialState = {
-      _meta: {
-        passedPlayers: [],
-        previousPayloads: {},
-      }
-    };
-
-    const entityDefinitions = expandEntityDefinitions(rules.entities, ctx)
-    initialState.bank = new Bank(entityDefinitions)
-    initialState.sharedBoard = initialState.bank.getOne(
-      bgioArguments,
-      {
-        conditions: [{
-          conditionType: 'Is',
-          matcher: { name: "sharedBoard" }
-        }]
-      }
-    )
-
-    if (rules.personalBoard) {
-      initialState.personalBoards = bgioArguments.ctx.playOrder.map((playerID) => 
-        initialState.bank.getOne(
-          bgioArguments,
-          {
-            conditions: [{
-              conditionType: 'Is',
-              matcher: {
-                name: "personalBoard",
-                player: playerID,
-              }
-            }]
-          }
-        )
-      )
-    }
-
-    rules.initialMoves?.forEach((moveRule) => {
-      moveFactory(moveRule, game).moveInstance.doMove(
-        { ...bgioArguments, G: initialState }
-      );
-    })
-    return JSON.parse(serialize(initialState));
-  }
-
-  if (rules.moves) {
-    game.moves = createMoves(rules.moves, game)
-  }
-
-  if (rules.turn) {
-    game.turn = createTurn(rules.turn, game)
-  }
-
-  if (rules.phases) {
-    game.phases = Object.entries(rules.phases).reduce((acc, [name, phaseRule]) => ({
-      ...acc,
-      [name]: createPhase(phaseRule, game)
-    }), {})
-  }
-
-  if (rules.endIf) {
-    game.endIf = (bgioArguments) => {
-      const newBgioArguments = deserializeBgioArguments(bgioArguments)
-      return getScenarioResults(newBgioArguments, rules.endIf)
-    }
-  }
-
-  if (!gameRules.DEBUG_DISABLE_SECRET_STATE) {
-    game.playerView = (bgioArguments) => {
-      const { G, playerID } = deserializeBgioArguments(bgioArguments)
-      Object.values(G.bank.tracker).forEach(((entity) => {
-        if (
-          entity.rule.contentsHiddenFrom === 'All' 
-           || (
-              entity.rule.contentsHiddenFrom === 'Others'
-                && (
-                  playerID !== entity.rule.player
-                  || playerID == undefined
-                )
-            )
-        ) {
-          // may want to hide entities inside spaces instead?
-          if (entity.spaces) {
-            entity.spaces = entity.rule.hideLength
-              ? []
-              : entity.spaces.map(() => G.bank.createEntity())
-          }
-          if (entity.entities) {
-            entity.entities = entity.rule.hideLength
-              ? []
-              : entity.entities.map(() => G.bank.createEntity())
-          }
-        }
-      }))
-      return JSON.parse(serialize(G))
-    }
-  }
-
-  return game
-}
-
-// create a new entity for each variant
-function expandEntityDefinitions (entities, ctx) {
-  return entities.reduce((acc, entity) => {
-    const entityCopy = { ...entity }
-
-    // perPlayer flag multiplies number of variants
-    if (entityCopy.perPlayer) {
-      delete entityCopy.perPlayer
-      if (entityCopy.variants) {
-        entityCopy.variants =
-          (new Array(ctx.numPlayers)).fill().reduce((accu, _, i) => [
-            ...accu,
-            ...entityCopy.variants.map(variant => ({ ...variant, player: `${i}` }))
-          ], [])
-      } else {
-        entityCopy.variants =
-          (new Array(ctx.numPlayers)).fill().map((_, i) => ({ player: `${i}` }))
-      }
-    }
-
-    // variants becomes new entitites
-    if (entityCopy.variants) {
-      const variants = entityCopy.variants
-      delete entityCopy.variants
-
-      return [
-        ...acc,
-        ...variants.map(variant => ({
-          ...entityCopy,
-          ...variant,
-        }))
-      ]
-    } else {
-      return [
-        ...acc,
-        entityCopy
-      ]
-    }
-  }, [])
-}
-
-function createTurn (turnRule, game) {
-  const turn = { ...turnRule }
-
-  turn.onBegin = (bgioArguments) => {
-    const newBgioArguments = deserializeBgioArguments(bgioArguments)
-    const stageRule = turnRule.stages?.[
-      newBgioArguments.ctx.activePlayers?.[newBgioArguments.ctx.currentPlayer]
-    ]
-
-    // not 100% sure about this logic / timing, but it seems to work so far in terms
-    // of letting a player pass and still take a turn later if a move becomes available
-    newBgioArguments.G._meta.passedPlayers = newBgioArguments.G._meta.passedPlayers
-      .filter(p => p !== newBgioArguments.ctx.currentPlayer)
-
-    doMoves(newBgioArguments, turnRule.initialMoves, { game })
-    doMoves(newBgioArguments, stageRule?.initialMoves, { game })
-
-    return JSON.parse(serialize(newBgioArguments.G));
-  }
-
-  if (turnRule.stages) {
-    Object.entries(turnRule.stages).forEach(([stageName, stageRule]) => {
-      if (stageRule.moves) {
-        turn.stages[stageName].moves = createMoves(stageRule.moves, game)
-      }
-    })
-  }
-
-  if (turnRule.order?.playOrder === 'RotateFirst') {
-    turnRule.order.first = () => 0
-    turnRule.order.next = ({ ctx }) => (ctx.playOrderPos + 1) % ctx.numPlayers
-    turn.order.playOrder = ({ ctx, G }) => {
-      return G._meta.isAfterFirstPhase
-        ? [...ctx.playOrder.slice(1), ctx.playOrder[0]]
-        : ctx.playOrder
-    }
-  }
-
-  return turn
-}
-
-function createPhase (phaseRule, game) {
-  const phase = {...phaseRule}
-  if (phaseRule.turn) {
-    phase.turn = createTurn(phaseRule.turn, game)
-  }
-  if (phaseRule.moves) {
-    phase.moves = createMoves(phaseRule.moves, game)
-  }
-
-  phase.onBegin = (bgioArguments) => {
-    const newBgioArguments = deserializeBgioArguments(bgioArguments)
-    doMoves(newBgioArguments, phaseRule.initialMoves, { game })
-    newBgioArguments.G._meta.currentPhaseHasBeenSetUp = true
-    newBgioArguments.G._meta.nextPhase = phaseRule.next
-    return JSON.parse(serialize(newBgioArguments.G));
-  }
-
-  if (phaseRule.endIf) {
-    phase.endIf = (bgioArguments) => {
-      const newBgioArguments = deserializeBgioArguments(bgioArguments)
-      if (newBgioArguments.G._meta.currentPhaseHasBeenSetUp) {
-        const result = getScenarioResults(newBgioArguments, phaseRule.endIf)
-        if (result) {
-          return result
-        }
-      }
-    }
-  }
-
-  phase.onEnd = ({ G }) => {
-    G._meta.currentPhaseHasBeenSetUp = false
-    G._meta.isAfterFirstPhase = true
-  }
-
-  return phase
-}
-
-function createMoves (moves, game) {
-  return Object.entries(moves).reduce((acc, [name, moveDefinition]) => ({
-    ...acc,
-    [name]: moveFactory({ ...moveDefinition, name }, game)
-  }), {})
-}

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

@@ -1,18 +0,0 @@
-import Move from "./move.js";
-import { getMoveInstance } from "./move-factory.js";
-
-export default class ForEach extends Move {
-  do(bgioArguments, rule, { arguments: { targets } }, context) {
-    targets.forEach((target) => {
-      const loopContext = {
-        ...context,
-        loopTarget: target
-      }
-      getMoveInstance(rule.move).doMove(
-        bgioArguments,
-        undefined,
-        loopContext
-      )
-    })
-  }
-}

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

@@ -1,16 +0,0 @@
-import Move from "./move.js";
-
-export default class MoveEntity extends Move {
-  do(bgioArguments, rule, { arguments: { entity, destination } }) {
-    // todo: move all such things to always be multiple
-    if (Array.isArray(entity)) {
-      entity.forEach((e) => {
-        bgioArguments.G.bank.findParent(e)?.remove(e)
-        destination.placeEntity(e, rule.position)
-      })
-    } else {
-      bgioArguments.G.bank.findParent(entity)?.remove(entity)
-      destination.placeEntity(entity, rule.position)
-    }
-  }
-}