board-game-engine 0.0.2 → 0.0.3

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

@@ -0,0 +1,239 @@
+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/end-turn.js

@@ -0,0 +1,7 @@
+import Move from "./move.js";
+
+export default class EndTurn extends Move {
+  do(bgioArguments) {
+    bgioArguments.events.endTurn()
+  }
+}

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

@@ -0,0 +1,18 @@
+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/index.js

@@ -0,0 +1,7 @@
+import MoveEntity from './move-entity.js'
+
+const moveIndex = {
+  MoveEntity,
+}
+
+export default moveIndex

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

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

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

@@ -0,0 +1,89 @@
+import { serialize, deserialize } from 'wackson'
+import { INVALID_MOVE } from '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.type) {
+    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

@@ -0,0 +1,131 @@
+import { INVALID_MOVE } from '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

@@ -0,0 +1,10 @@
+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/pass.js

@@ -0,0 +1,7 @@
+import Move from "./move.js";
+
+export default class Pass extends Move {
+  do(bgioArguments) {
+    bgioArguments.events.endTurn()
+  }
+}

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

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

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

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

@@ -0,0 +1,13 @@
+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 } }) {
+    console.log('entity', entity)
+    console.log('state', state)
+    entity.state = {
+      ...entity.state,
+      [state.property]: state.value,
+    }
+  }
+}

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

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

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

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