board-game-engine 2.1.0 → 2.1.1

package/src/game-factory/condition/{contains-condition.ts → contains-condition.js}

@@ -1,18 +1,17 @@
 import _matches from "lodash/matches.js";
-import type { Condition as ConditionRule } from "../../types/bagel-types.js";
 import Condition from "../condition/condition.js";
 import checkConditions from "../../utils/check-conditions.js";
 
 export default class ContainsCondition extends Condition {
-  checkCondition (bgioArguments: unknown, rule: unknown, payload: Record<string, unknown>, context: Record<string, unknown>) {
-    const target = payload.target as { entities?: unknown[]; spaces?: unknown[] } | undefined;
+  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: unknown) => checkConditions(
+      const matches = candidates?.filter(entity => checkConditions(
         bgioArguments,
-        (rule as { conditions?: ConditionRule[] }).conditions,
+        rule,
         { target: entity },
         context
       ).conditionsAreMet) ?? []

package/src/game-factory/condition/{contains-same-condition.ts → contains-same-condition.js}

@@ -3,24 +3,21 @@ import conditionFactory from "./condition-factory.js";
 import Condition from "./condition.js";
 
 export default class ContainsSame extends Condition {
-  checkCondition (bgioArguments: unknown, rule: unknown, conditionPayload: Record<string, unknown>, _newContext: Record<string, unknown>) {
-    const { targets } = conditionPayload as { targets: { entities?: unknown[]; rule?: unknown }[] };
+  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: unknown) => {
-      const e = entity as { rule?: unknown };
+    const conditionIsMet = first.entities.some(entity => {
       const condition = conditionFactory({
         conditionType: "Contains",
         conditions: [{
           conditionType: 'Is',
-          matcher: pick(e.rule as object, (rule as { properties: unknown }).properties as never)
+          matcher: pick(entity.rule, rule.properties)
         }]
-      });
-      if (!condition) return false;
-      return restEntities.every((ent: unknown) => {
+      })
+      return restEntities.every(ent => {
         return condition.isMet(bgioArguments, { target: ent })
       })
     })

package/src/game-factory/condition/{evaluate-condition.ts → evaluate-condition.js}

@@ -1,17 +1,16 @@
 import _matches from "lodash/matches.js";
 import Condition from "../condition/condition.js";
 import resolveExpression from "../../utils/resolve-expression.js";
-import type { BgioResolveState } from "../../utils/bgio-resolve-types.js";
 
 export default class Evaluate extends Condition {
-  checkCondition (bgioArguments: unknown, rule: unknown, payload: Record<string, unknown>, context: Record<string, unknown>) {
+  checkCondition(bgioArguments, rule, payload, context) {
     const newContext = { ...context }
     if (payload?.target) {
       newContext.target = payload.target
     }
     const result = resolveExpression(
-      bgioArguments as BgioResolveState,
-      rule as { expression: string; arguments?: unknown },
+      bgioArguments,
+      rule,
       newContext
     )
     return { result, conditionIsMet: !!result }

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

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

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

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

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

@@ -0,0 +1,9 @@
+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/{no-possible-moves-condition.ts → no-possible-moves-condition.js}

@@ -1,14 +1,13 @@
 import Condition from "./condition.js";
 import areThereValidMoves from "../../utils/any-valid-moves.js";
 import getCurrentMoves from "../../utils/get-current-moves.js";
-import type { GetCurrentMovesClient, GetCurrentMovesState } from "../../utils/get-current-moves.js";
 
 export default class NoPossibleMoves extends Condition {
-  checkCondition (bgioArguments: unknown, _unused: unknown, _payload: unknown, context: Record<string, unknown>) {
+  checkCondition(bgioArguments, _, __, context) {
     return {
       conditionIsMet: !areThereValidMoves(
         bgioArguments,
-        getCurrentMoves(bgioArguments as GetCurrentMovesState, context as unknown as GetCurrentMovesClient),
+        getCurrentMoves(bgioArguments, context),
       )
     }
   }

package/src/game-factory/condition/{not-condition.ts → not-condition.js}

@@ -1,12 +1,11 @@
-import type { Condition as ConditionRule } from "../../types/bagel-types.js";
 import Condition from "./condition.js";
 import checkConditions from "../../utils/check-conditions.js";
 
 export default class NotCondition extends Condition {
-  checkCondition (bgioArguments: unknown, rule: unknown, payload: Record<string, unknown>, context: Record<string, unknown>) {
+  checkCondition(bgioArguments, rule, payload, context) {
     const result = checkConditions(
       bgioArguments,
-      (rule as { conditions?: ConditionRule[] }).conditions,
+      rule,
       payload,
       context
     )

package/src/game-factory/condition/{or-condition.ts → or-condition.js}

@@ -1,12 +1,11 @@
-import type { Condition as ConditionRule } from "../../types/bagel-types.js";
 import Condition from "./condition.js";
 import findMetCondition from "../../utils/find-met-condition.js";
 
 export default class Or extends Condition {
-  checkCondition (bgioArguments: unknown, rule: unknown, payload: Record<string, unknown>, context: Record<string, unknown>) {
+  checkCondition(bgioArguments, rule, payload, context) {
     const result = findMetCondition(
       bgioArguments,
-      (rule as { conditions?: ConditionRule[] }).conditions,
+      rule,
       payload,
       context
     )

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

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

package/src/game-factory/condition/{some-condition.ts → some-condition.js}

@@ -1,18 +1,16 @@
-import type { Condition as ConditionRule } from "../../types/bagel-types.js";
 import Condition from "./condition.js";
 import checkConditions from "../../utils/check-conditions.js";
 
 export default class SomeCondition extends Condition {
-  checkCondition (bgioArguments: unknown, rule: unknown, conditionPayload: Record<string, unknown>, context: Record<string, unknown>) {
-    const targets = conditionPayload.target as unknown[];
-    const result = targets.find((target: unknown) => {
+  checkCondition(bgioArguments, rule, { target: targets }, context) {
+    const result = targets.find((target) => {
       const loopContext = {
         ...context,
         loopTarget: target
       }
       return checkConditions(
         bgioArguments,
-        (rule as { conditions?: ConditionRule[] }).conditions,
+        rule,
         undefined,
         loopContext
       ).conditionsAreMet

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

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

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

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