board-game-engine 2.0.0 → 2.0.1

package/src/client/client.js

@@ -1,224 +0,0 @@
-import { Client as BoardgameIOClient } from '@mnbroatch/boardgame.io/client'
-import { Debug } from '@mnbroatch/boardgame.io/debug';
-import { SocketIO } from '@mnbroatch/boardgame.io/multiplayer'
-import { serialize, deserialize } from 'wackson';
-import gameFactory from '../game-factory/game-factory.js'
-import { registry } from '../registry.js';
-import simulateMove from '../utils/simulate-move.js';
-import getCurrentMoves from '../utils/get-current-moves.js';
-import resolveProperties from '../utils/resolve-properties.js';
-import checkConditions from '../utils/check-conditions.js';
-import preparePayload from '../utils/prepare-payload.js';
-import getSteps from '../utils/get-steps.js';
-import createPayload from '../utils/create-payload.js';
-
-export class Client {
-  constructor (options) {
-    this.options = options
-    this.game = options.boardgameIOGame
-      || gameFactory(JSON.parse(options.gameRules), options.gameName)
-
-    if (!options.boardgameIOGame) {
-      this.moveBuilder = { targets: [], stepIndex: 0, eliminatedMoves: [] }
-      this.optimisticWinner = null
-    }
-  }
-
-  connect () {
-    const {
-      server,
-      numPlayers,
-      debug = {
-        collapseOnLoad: true,
-        impl: Debug,
-      },
-      matchID,
-      playerID,
-      credentials,
-      multiplayer = SocketIO({ server, socketOpts: { transports: ['websocket', 'polling'] } }),
-    } = this.options
-
-    try {
-      const clientOptions = !credentials
-        ? { game: this.game, numPlayers, debug }
-        : {
-            game: this.game,
-            multiplayer,
-            matchID,
-            playerID,
-            credentials,
-            numPlayers,
-            debug,
-          }
-
-      this.client = BoardgameIOClient(clientOptions)
-      this.client.subscribe(() => this.update())
-      this.client.start()
-      return this
-    } catch (error) {
-      console.error('Failed to join game:', error?.message ?? error)
-      if (error?.stack) console.error(error.stack)
-    }
-  }
-
-  update () {
-    this.options.onClientUpdate?.()
-  }
-
-  getState () {
-    const bgioState = this.client?.getState()
-    if (!bgioState) return {}
-
-    const state = this.options.boardgameIOGame
-      ? bgioState
-      : {
-        ...bgioState,
-        G: deserialize(JSON.stringify(bgioState.G), registry),
-      }
-
-    const gameover = this.optimisticWinner ?? state?.ctx?.gameover
-
-    const currentMoves = gameover
-      ? []
-      : getCurrentMoves(state, this.client)
-
-    if (this.options.boardgameIOGame) {
-      return {
-        state,
-        gameover,
-        moves: this.client.moves,
-        currentMoves
-      }
-    }
-
-    const _wrappedMoves = Object.entries(currentMoves)
-      .reduce((acc, [moveName, rawMove]) => {
-          const move = (payload) => {
-            this.client.moves[moveName](preparePayload(payload))
-          }
-          move.moveInstance = rawMove.moveInstance
-          return { ...acc, [moveName]: move }
-        }, {})
-
-    const { allClickable, _possibleMoveMeta } = getPossibleMoves(state, _wrappedMoves, this.moveBuilder)
-
-    return { state, gameover, allClickable, _wrappedMoves, _possibleMoveMeta }
-  }
-
-  doStep (_target) {
-    if (this.options.boardgameIOGame) return
-
-    const { state, _wrappedMoves, _possibleMoveMeta } = this.getState()
-
-    const target = _target.abstract
-      ? _target
-      : state.G.bank.locate(_target.entityId)
-
-    const newEliminated = Object.entries(_possibleMoveMeta)
-      .filter(([_, meta]) => !hasTarget(meta.clickableForMove, target))
-      .map(([name]) => name)
-      .concat(this.moveBuilder.eliminatedMoves);
-
-    if (newEliminated.length === Object.keys(_wrappedMoves).length) {
-      console.error('invalid move with target:', target?.rule);
-      return;
-    }
-
-    const remainingMoveEntries = Object.entries(_possibleMoveMeta)
-      .filter(([name]) => !newEliminated.includes(name))
-
-    if (isMoveCompleted(state, _wrappedMoves, remainingMoveEntries, this.moveBuilder.stepIndex)) {
-      const [moveName] = remainingMoveEntries[0]
-      const move = _wrappedMoves[moveName]
-      const payload = createPayload(
-        state,
-        move.moveInstance.rule,
-        [...this.moveBuilder.targets, target],
-        { moveInstance: move.moveInstance }
-      );
-
-      this.optimisticWinner = getWinnerAfterMove(state, this.game, move.moveInstance, payload);
-      move(payload);
-      this.moveBuilder = { targets: [], stepIndex: 0, eliminatedMoves: [] };
-    } else {
-      this.moveBuilder = {
-        eliminatedMoves: newEliminated,
-        stepIndex: this.moveBuilder.stepIndex + 1,
-        targets: [...this.moveBuilder.targets, target]
-      }
-    }
-
-    this.update()
-  }
-
-  reset () {
-    if (this.options.boardgameIOGame) return
-    this.moveBuilder = { targets: [], stepIndex: 0, eliminatedMoves: [] };
-    this.optimisticWinner = null
-    this.update()
-  }
-
-  undoStep () {
-    if (this.options.boardgameIOGame) return
-    if (this.moveBuilder.targets.length) {
-      this.moveBuilder = {
-        targets: this.moveBuilder.targets.slice(0, -1),
-        stepIndex: Math.max(0, this.moveBuilder.stepIndex - 1),
-        eliminatedMoves: []
-      }
-    }
-    this.update()
-  }
-}
-
-function hasTarget(clickableSet, target) {
-  if (!target.abstract) return clickableSet.has(target);
-  return [...clickableSet].some(item => item.abstract && item.value === target.value);
-}
-
-function getPossibleMoves(bgioState, moves, moveBuilder) {
-  const { eliminatedMoves, stepIndex } = moveBuilder;
-  const _possibleMoveMeta = {};
-  const allClickable = new Set();
-
-  Object.entries(moves)
-    .filter(([moveName]) => !eliminatedMoves.includes(moveName))
-    .forEach(([moveName, move]) => {
-      const moveRule = resolveProperties(bgioState, { ...move.moveInstance.rule, moveName })
-
-      const context = {
-        moveInstance: move.moveInstance,
-        moveArguments: moveRule.arguments
-      }
-
-      const targets = moveBuilder.targets.map(t =>
-        t.abstract ? t : bgioState.G.bank.locate(t.entityId)
-      )
-
-      const payload = createPayload(bgioState, moveRule, targets, context);
-
-      context.moveArguments = { ...context.moveArguments, ...payload.arguments }
-
-      const moveIsAllowed = checkConditions(bgioState, moveRule, {}, context).conditionsAreMet;
-      const moveSteps = getSteps(bgioState, moveRule);
-
-      const clickableForMove = new Set(
-        (moveIsAllowed && moveSteps?.[stepIndex]?.getClickable(context)) || []
-      );
-
-      _possibleMoveMeta[moveName] = { clickableForMove };
-      clickableForMove.forEach(entity => allClickable.add(entity));
-    });
-
-  return { _possibleMoveMeta, allClickable };
-}
-
-function isMoveCompleted(state, moves, remainingMoveEntries, stepIndex) {
-  return remainingMoveEntries.length === 1 &&
-    getSteps(state, moves[remainingMoveEntries[0][0]].moveInstance.rule).length === stepIndex + 1;
-}
-
-function getWinnerAfterMove (state, game, moveInstance, movePayload) {
-  const simulatedG = simulateMove(state, preparePayload(movePayload), { moveInstance })
-  return game.endIf?.({ ...state, G: JSON.parse(serialize(simulatedG)) })
-}

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

@@ -1,69 +0,0 @@
-import resolveProperties from '../../utils/resolve-properties.js'
-
-// lazily create entities as needed, and also function as an index of entities created
-class BankSlot {
-  constructor (rule, bank) {
-    this.bank = bank
-    this.rule = rule
-    this.pool = []
-    this.remaining = +rule.count || 1
-  }
-
-  getOne (bgioArguments, options, context) {
-    return this.getMultiple(bgioArguments, 1, options, context)[0]
-  }
-
-  getMultiple (bgioArguments, count = Infinity, options = {}, context) {
-    const toReturn = []
-    
-    if (this.remaining === Infinity && count === Infinity) {
-      throw new Error(`Cannot get infinite pieces from slot with infinite remaining: ${this.rule.name}`)
-    }
-    
-    if (count !== Infinity && count > this.remaining) {
-      throw new Error(`Requested ${count} pieces but only ${this.remaining} available in slot: ${this.rule.name}`)
-    }
-    
-    // Determine actual count to fetch
-    const actualCount = count === Infinity ? this.remaining : count
-    
-    if (this.remaining !== Infinity) {
-      this.remaining -= actualCount
-    }
-    
-    const fromPool = Math.min(actualCount, this.pool.length)
-    toReturn.push(...this.pool.splice(0, fromPool))
-    
-    const remainder = actualCount - fromPool
-    if (remainder > 0) {
-      toReturn.push(
-        ...Array.from(new Array(remainder)).map(() =>
-          this.bank.createEntity(this.rule)
-        )
-      )
-    }
-    
-    if (options.state) {
-      const newState = resolveProperties(bgioArguments, options.state, context)
-      toReturn.forEach(entity => {
-        entity.state = { ...entity.state, ...newState }
-      })
-    }
-    
-    return toReturn
-  }
-
-  returnToBank (entity) {
-    if (entity.rule.state) {
-      entity.state = entity.rule.state
-    } else {
-      delete entity.state
-    }
-    if (this.remaining !== undefined) {
-      this.remaining += 1
-    }
-    this.pool.push(entity)
-  }
-}
-
-export default BankSlot

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

@@ -1,114 +0,0 @@
-import find from 'lodash/find.js'
-import filter from 'lodash/filter.js'
-import checkConditions from '../../utils/check-conditions.js'
-import { registry } from '../../registry.js'
-import BankSlot from './bank-slot.js'
-
-class Bank {
-  constructor (entityRules) {
-    this.currentEntityId = 0
-    this.tracker = {}
-    this.slots = entityRules.map(rule => new BankSlot(rule, this))
-  }
-
-  createEntity (definition = {}, options) {
-    const entity = new (registry[definition.entityType || 'Entity'])(
-      {
-        bank: this,
-        fromBank: true,
-        ...options
-      },
-      definition,
-      this.currentEntityId++
-    )
-    this.track(entity)
-    return entity
-  }
-
-  track (entity) {
-    this.tracker[entity.entityId] = entity
-  }
- 
-  locate (entityId) {
-    return this.tracker[entityId]
-  }
-
-  findAll (bgioArguments, rule, context) {
-    if (!rule.conditions) {
-      throw new Error (`Cannot find entity with no conditions. Rule: ${JSON.stringify(rule)}`)
-    }
-    return filter(
-      Object.values(this.tracker),
-      entity => checkConditions(
-        bgioArguments,
-        rule,
-        { target: entity },
-        context
-      ).conditionsAreMet
-    )
-  }
-
-  findOne (bgioArguments, rule, context) {
-    return this.findAll(bgioArguments, rule, context)[0]
-  }
-
-  find (bgioArguments, rule, context) {
-    return rule.matchMultiple
-      ? this.findAll(bgioArguments, rule, context)
-      : this.findOne(bgioArguments, rule, context)
-  }
-
-  findParent (entity) {
-    return find(this.tracker, ent =>
-      ent.entities?.includes(entity)
-        || ent.spaces?.includes(entity)
-    )
-  }
- 
-  getOne (bgioArguments, rule, context) {
-    const slot = this.getSlot(bgioArguments, rule, context)
-    if (!slot) {
-      console.error(`No matching slot for ${JSON.stringify(rule)}`)
-    }
-    return slot.getOne(bgioArguments, { state: rule.state }, context)
-  }
-
-  getMultiple (bgioArguments, rule, count, context) {
-    const slots = this.getSlots(bgioArguments, rule, context)
-    if (!slots.length) {
-      console.error(`No matching slots for ${JSON.stringify(rule)}`)
-    }
-    return slots.reduce((acc, slot) => [
-      ...acc,
-      ...slot.getMultiple(bgioArguments, count, { state: rule.state })
-    ], [])
-  }
-
-  getSlot (bgioArguments, rule, context) {
-    return this.slots.find(slot => checkConditions(
-        bgioArguments,
-        rule,
-        { target: slot },
-        context
-      ).conditionsAreMet
-    )
-  }
-
-  getSlots (bgioArguments, rule, context) {
-    return this.slots.filter(slot => checkConditions(
-        bgioArguments,
-        rule,
-        { target: slot },
-        context
-      ).conditionsAreMet
-    )
-  }
-
-  returnToBank (bgioArguments, entity) {
-    this.findParent(entity).remove(entity)
-    this.getSlot(bgioArguments, entity.rule).returnToBank(entity)
-    delete this.tracker[entity.entityId]
-  }
-}
-
-export default Bank

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

@@ -1,52 +0,0 @@
-import Is from "./is-condition.js";
-import Not from "./not-condition.js";
-import Or from "./or-condition.js";
-import Some from "./some-condition.js";
-import Every from "./every-condition.js";
-import ContainsCondition from "./contains-condition.js";
-import ContainsSameCondition from "./contains-same-condition.js";
-import InLine from "./in-line-condition.js";
-import HasLine from "./has-line-condition.js";
-import IsFull from "./is-full-condition.js";
-import Would from "./would-condition.js";
-import NoPossibleMoves from "./no-possible-moves-condition.js";
-import Evaluate from "./evaluate-condition.js";
-import Position from "./position-condition.js";
-// import BingoCondition from "./bingo-condition.js";
-// import RelativeMoveCondition from "./relative-move-condition.js";
-
-export default function conditionFactory(rule) {
-  if (rule.conditionType === "Is") {
-    return new Is(rule);
-  } else if (rule.conditionType === "Not") {
-    return new Not(rule);
-  } else if (rule.conditionType === "Or") {
-    return new Or(rule);
-  } else if (rule.conditionType === "Some") {
-    return new Some(rule);
-  } else if (rule.conditionType === "Contains") {
-    return new ContainsCondition(rule);
-  } else if (rule.conditionType === "ContainsSame") {
-    return new ContainsSameCondition(rule);
-  } else if (rule.conditionType === "Every") {
-    return new Every(rule);
-  } else if (rule.conditionType === "InLine") {
-    return new InLine(rule);
-  } else if (rule.conditionType === "HasLine") {
-    return new HasLine(rule);
-  } else if (rule.conditionType === "IsFull") {
-    return new IsFull(rule);
-  } else if (rule.conditionType === "Would") {
-    return new Would(rule);
-  } else if (rule.conditionType === "NoPossibleMoves") {
-    return new NoPossibleMoves(rule);
-  } else if (rule.conditionType === "Evaluate") {
-    return new Evaluate(rule);
-  } else if (rule.conditionType === "Position") {
-    return new Position(rule);
-  // } else if (rule.conditionType === "bingo") {
-    // return new BingoCondition(rule);
-  // } else if (rule.conditionType === "relativeMove") {
-  //   return new RelativeMoveCondition(rule);
-  }
-}

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

@@ -1,39 +0,0 @@
-import resolveProperties from "../../utils/resolve-properties.js";
-
-export default class Condition {
-  constructor (rule) {
-    this.rule = rule
-  }
-  
-  check (bgioArguments, payload, context) {
-    const conditionPayload = { ...payload }
-    const newContext = { ...context }
-
-    if (conditionPayload.target) {
-      newContext.originalTarget = conditionPayload.target
-    }
-
-    const rule = resolveProperties(
-      bgioArguments,
-      this.rule,
-      newContext
-    )
-
-    // We don't simply defer to payload target because of parent and relativePath
-    // target types, for instance, which retarget to another entity
-    if (rule.target !== undefined) {
-      conditionPayload.target = rule.target
-    }
-
-    // Nonexistent entities never fulfill conditions (including "Not" conditions!)
-    if (this.rule.target !== undefined && !conditionPayload.target) {
-      return { conditionIsMet: false }
-    }
-    
-    return this.checkCondition(bgioArguments, rule, conditionPayload, newContext)
-  }
-
-  isMet(...args) {
-    return this.check(...args).conditionIsMet
-  }
-}

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

@@ -1,25 +0,0 @@
-import Condition from "./condition.js";
-import checkConditions from "../../utils/check-conditions.js";
-
-export default class EveryCondition extends Condition {
-  checkCondition(bgioArguments, rule, { target: targets }, context) {
-    const results = targets.map((target) => {
-      const loopContext = {
-        ...context,
-        loopTarget: target
-      }
-
-      return checkConditions(
-        bgioArguments,
-        rule,
-        undefined,
-        loopContext
-      )
-    })
-
-    return {
-      conditionIsMet: results.every(r => r.conditionsAreMet),
-      results
-    }
-  }
-}

package/src/game-factory/condition/has-line-condition.js

@@ -1,14 +0,0 @@
-import Condition from "./condition.js";
-import gridContainsSequence from "../../utils/grid-contains-sequence.js";
-
-export default class HasLineCondition extends Condition {
-  checkCondition(bgioArguments, rule, payload, context) {
-    const { matches } = gridContainsSequence(
-      bgioArguments,
-      payload.target,
-      rule.sequence,
-      context
-    );
-    return { matches, conditionIsMet: !!matches.length };
-  }
-}

package/src/game-factory/condition/in-line-condition.js

@@ -1,19 +0,0 @@
-import Condition from "./condition.js";
-import gridContainsSequence from "../../utils/grid-contains-sequence.js";
-
-
-export default class InLineCondition extends Condition {
-  checkCondition(bgioArguments, rule, payload, context) {
-    const { G } = bgioArguments;
-    const { target } = payload;
-    const parent = G.bank.findParent(payload.target);
-    
-    const { matches: allMatches } = gridContainsSequence(bgioArguments, parent, rule.sequence, context);
-    
-    const matches = allMatches.filter(sequence => 
-      sequence.some(space => space === target)
-    );
-
-    return { matches, conditionIsMet: !!matches.length };
-  }
-}

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

@@ -1,23 +0,0 @@
-import Condition from "./condition.js";
-import entityMatches from '../../utils/entity-matches.js'
-
-export default class Is extends Condition {
-  checkCondition(bgioArguments, rule, { target }, context) {
-    if (this.rule.entity && target !== rule.entity) {
-      return {
-        target,
-        conditionIsMet: false,
-      }
-    }
-
-    return {
-      target,
-      conditionIsMet: entityMatches(
-        bgioArguments,
-        rule.matcher,
-        target,
-        context
-      )
-    }
-  }
-}

package/src/game-factory/condition/is-full-condition.js

@@ -1,9 +0,0 @@
-import Condition from "./condition.js";
-
-export default class IsFull extends Condition {
-  checkCondition(bgioArguments, rule, payload, context) {
-    return {
-      conditionIsMet: payload.target.spaces.every(space => space?.entities.length)
-    };
-  }
-}

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

@@ -1,12 +0,0 @@
-import Condition from "./condition.js";
-
-export default class Position extends Condition {
-  checkCondition(bgioArguments, rule, { target }) {
-    const parent = bgioArguments.G.bank.findParent(target)
-    let conditionIsMet
-    if (rule.position === 'First') {
-      conditionIsMet = parent.entities.indexOf(target) === 0
-    }
-    return { conditionIsMet }
-  }
-}