board-game-engine 0.0.2 → 0.0.3

package/dist/board-game-engine.min.js.LICENSE.txt

@@ -0,0 +1,14 @@
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */

package/package.json

@@ -1,18 +1,19 @@
 {
   "name": "board-game-engine",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "wip board game engine",
   "main": "dist/board-game-engine.js",
   "scripts": {
     "test": "jest --coverage --verbose false",
     "lint": "eslint .",
+    "postinstall": "node ./patch-bgio.cjs",
     "build": "webpack",
     "prepublish": "npm run build"
   },
   "author": "Matthew Broatch",
   "license": "ISC",
   "devDependencies": {
-    "@babel/preset-env": "^7.16.7",
+    "@babel/preset-env": "^7.16.8",
     "@babel/preset-typescript": "^7.27.1",
     "babel-jest": "^27.4.4",
     "babel-loader": "",
@@ -23,10 +24,12 @@
     "eslint-plugin-import": "^2.3.0",
     "jest": "^27.4.3",
     "standard": "^16.0.4",
-    "webpack": "^5.65.0",
+    "webpack": "^5.66.0",
     "webpack-cli": "^4.9.1"
   },
   "dependencies": {
+    "boardgame.io": "^0.50.2",
+    "expr-eval": "^2.0.2",
     "wackson": "^1.1.0"
   },
   "repository": {

package/patch-bgio.cjs

@@ -0,0 +1,23 @@
+// scalpel to make guts.js work
+const fs = require('fs');
+const path = require('path');
+
+const serverFile = path.join(
+  __dirname,
+  'node_modules',
+  'boardgame.io',
+  'dist/cjs/server.js'
+);
+
+fs.appendFileSync(
+  serverFile,
+  `
+exports.configureRouter = configureRouter
+exports.createServerRunConfig = createServerRunConfig
+exports.configureApp = configureApp
+exports.getPortFromServer = getPortFromServer
+exports.getPortFromServer = getPortFromServer
+exports.Master = Master
+exports.TransportAPI = TransportAPI
+`
+);

package/src/client/client.js

@@ -0,0 +1,287 @@
+import { Client as BoardgameIOClient } from 'boardgame.io/client'
+import { Debug } from 'boardgame.io/debug';
+import { SocketIO } from '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 default class Client {
+  constructor (options) {
+    this.options = options
+    this.moveBuilder = {
+      targets: [],
+      stepIndex: 0,
+      eliminatedMoves: []
+    }
+    this.optimisticWinner = null
+    this.allClickable = new Set()
+    this.game = gameFactory(JSON.parse(options.gameRules), options.gameName)
+  }
+
+  connect () {
+    const {
+      server,
+      numPlayers,
+      onClientUpdate,
+      debug = {
+        collapseOnLoad: true,
+        impl: Debug,
+      },
+      gameId,
+      gameRules,
+      boardgamePlayerID,
+      clientToken,
+      singlePlayer = !clientToken,
+    } = this.options
+
+    try {
+      const clientOptions = singlePlayer
+        ? { game: this.game, numPlayers, debug }
+        : {
+            game: this.game,
+            multiplayer: singlePlayer ? undefined : SocketIO({
+              server,
+              socketOpts: {
+                transports: ['websocket', 'polling']
+              }
+            }),
+            matchID: gameId,
+            playerID: boardgamePlayerID,
+            credentials: clientToken,
+            debug,
+          }
+
+      this.client = BoardgameIOClient(clientOptions)
+
+      if (onClientUpdate) {
+        this.client.subscribe(onClientUpdate)
+      }
+
+      this.client.start()
+
+      return this
+    } catch (error) {
+      console.error('Failed to join game:', error)
+    }
+  }
+
+  getState () {
+    let state
+    let moves
+    let gameover
+    const clientState = this.client?.getState()
+    if (clientState) {
+      state = {
+        ...clientState,
+        G: deserialize(JSON.stringify(clientState.G), registry),
+        originalG: clientState.G,
+      }
+
+      gameover = state?.ctx?.gameover
+
+      // Fix: use arrow function so `this` refers to the Client instance
+      moves = !gameover
+        ? Object.entries(getCurrentMoves(state, this.client)).reduce((acc, [moveName, rawMove]) => {
+            const move = (payload) => {
+              this.client.moves[moveName](preparePayload(payload))
+            }
+            move.moveInstance = rawMove.moveInstance
+            return {
+              ...acc,
+              [moveName]: move
+            }
+          }, {})
+        : []
+    }
+
+    return {
+      state,
+      gameover,
+      moves
+    }
+  }
+
+  doStep (target, isSpectator) {
+    const { state, moves } = this.getState()
+    const { possibleMoveMeta, allClickable } = getPossibleMoves(
+      state,
+      moves,
+      this.moveBuilder,
+      isSpectator
+    )
+    this.allClickable = allClickable
+
+    // Filter out moves that don't accept this target
+    const newEliminated = Object.entries(possibleMoveMeta)
+      .filter(([_, meta]) => !meta.finishedOnLastStep && !meta.clickableForMove.has(target))
+      .map(([name]) => name)
+      .concat(this.moveBuilder.eliminatedMoves);
+
+    if (newEliminated.length === Object.keys(moves).length) {
+      console.error('invalid move with target:', target?.rule);
+      return;
+    }
+
+    this.moveBuilder = {
+      eliminatedMoves: newEliminated,
+      stepIndex: this.moveBuilder.stepIndex + 1,
+      targets: [...this.moveBuilder.targets, target]
+    }
+
+    // Fix: filter possibleMoveMeta to only include moves not in newEliminated,
+    // so findCompletedMove sees the post-elimination state rather than the stale pre-elimination state
+    const filteredMoveMeta = Object.fromEntries(
+      Object.entries(possibleMoveMeta).filter(([name]) => !newEliminated.includes(name))
+    );
+
+    const completed = findCompletedMove(state, filteredMoveMeta, this.moveBuilder, moves);
+    
+    if (completed) {
+      // without this, an extra post-game turn would flash
+      this.optimisticWinner = getWinnerAfterMove(
+        state,
+        this.game,
+        completed.move.moveInstance,
+        completed.payload
+      );
+      
+      completed.move(completed.payload);
+      
+      this.moveBuilder = ({ targets: [], stepIndex: 0, eliminatedMoves: [] });
+    }
+
+    this.options.onClientUpdate?.()
+  }
+
+  reset () {
+    this.moveBuilder = ({ targets: [], stepIndex: 0, eliminatedMoves: [] });
+    this.optimisticWinner = null
+    this.options.onClientUpdate?.()
+  }
+
+  undoStep () {
+    if (this.moveBuilder.targets.length) {
+      this.moveBuilder = {
+        targets: this.moveBuilder.targets.slice(0, -1),
+        stepIndex: Math.max(0, this.moveBuilder.stepIndex - 1),
+        eliminatedMoves: []
+      }
+    }
+    this.options.onClientUpdate?.()
+  }
+}
+
+function getPossibleMoves(bgioState, moves, moveBuilder, isSpectator) {
+  if (isSpectator) {
+    return { possibleMoveMeta: {}, allClickable: new Set() };
+  }
+
+  const { eliminatedMoves, stepIndex } = moveBuilder;
+  
+  const possibleMoveMeta = {};
+  const allClickable = new Set();
+
+  const availableMoves = Object.entries(moves)
+    .filter(([moveName]) => !eliminatedMoves.includes(moveName));
+
+  availableMoves.forEach(([moveName, move]) => {
+    const moveRule = resolveProperties(
+      bgioState,
+      { ...move.moveInstance.rule, moveName }
+    )
+
+    const context = {
+      moveInstance: move.moveInstance,
+      moveArguments: moveRule.arguments
+    }
+    
+    const payload = createPayload(
+      bgioState,
+      moveRule,
+      moveBuilder.targets,
+      context
+    );
+    
+    context.moveArguments = {
+      ...context.moveArguments,
+      ...payload.arguments,
+    }
+
+    const moveIsAllowed = checkConditions(
+      bgioState,
+      moveRule,
+      {},
+      context
+    ).conditionsAreMet;
+
+    const moveSteps = getSteps(
+      bgioState,
+      moveRule
+    );
+
+    const lastStep = moveSteps?.[stepIndex - 1];
+    const currentStep = moveSteps?.[stepIndex];
+    const finishedOnLastStep = moveSteps && !!lastStep && !currentStep;
+    
+    const clickableForMove = new Set(
+      (moveIsAllowed && currentStep?.getClickable(context)) || []
+    );
+
+    possibleMoveMeta[moveName] = { finishedOnLastStep, clickableForMove };
+    
+    clickableForMove.forEach((entity) => {
+      allClickable.add(entity);
+    });
+  });
+
+  return { possibleMoveMeta, allClickable };
+}
+
+// Fix: renamed first parameter from `bgioArguments` to `bgioState` to match its actual usage
+function findCompletedMove(bgioState, possibleMoveMeta, moveBuilder, moves) {
+  const possibleMoveNames = Object.keys(possibleMoveMeta);
+  
+  // Only one possible move left
+  if (possibleMoveNames.length !== 1) return null;
+  
+  const moveName = possibleMoveNames[0];
+  const meta = possibleMoveMeta[moveName];
+  
+  // And it's finished
+  if (!meta.finishedOnLastStep) return null;
+  
+  const move = moves[moveName];
+  const moveRule = move.moveInstance.rule;
+  
+  const payload = createPayload(
+    bgioState,
+    moveRule,
+    moveBuilder.targets,
+    { moveInstance: move.moveInstance }
+  );
+
+  return { moveName, move, payload };
+}
+
+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

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

@@ -0,0 +1,114 @@
+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.type || '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/board.js

@@ -0,0 +1,3 @@
+import Space from './space/space.js'
+
+export default class Board extends Space {}

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

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

@@ -0,0 +1,39 @@
+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/contains-condition.js

@@ -0,0 +1,21 @@
+import _matches from "lodash/matches.js";
+import Condition from "../condition/condition.js";
+import checkConditions from "../../utils/check-conditions.js";
+
+export default class ContainsCondition extends Condition {
+  checkCondition(bgioArguments, rule, payload, context) {
+    const { target } = payload
+    if (!target) {
+      return { matches: [], conditionIsMet: false }
+    } else {
+      const candidates = target.entities ?? target.spaces
+      const matches = candidates?.filter(entity => checkConditions(
+        bgioArguments,
+        rule,
+        { target: entity },
+        context
+      ).conditionsAreMet) ?? []
+      return { matches, conditionIsMet: !!matches.length }
+    }
+  }
+}

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

@@ -0,0 +1,27 @@
+import pick from "lodash/pick.js";
+import conditionFactory from "./condition-factory.js";
+import Condition from "./condition.js";
+
+export default class ContainsSame extends Condition {
+  checkCondition (bgioArguments, rule, { targets }) {
+    if (targets.length === 1 && targets[0].entities?.length) {
+      return { conditionIsMet: true }
+    }
+
+    const [ first, ...restEntities ] = targets;
+    const conditionIsMet = first.entities.some(entity => {
+      const condition = conditionFactory({
+        conditionType: "Contains",
+        conditions: [{
+          conditionType: 'Is',
+          matcher: pick(entity.rule, rule.properties)
+        }]
+      })
+      return restEntities.every(ent => {
+        return condition.isMet(bgioArguments, { target: ent })
+      })
+    })
+
+    return { conditionIsMet }
+  }
+}