board-game-engine 2.0.0 → 2.1.0

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

@@ -0,0 +1,81 @@
+import resolveProperties from "../../utils/resolve-properties.js";
+import type { BgioResolveState } from "../../utils/bgio-resolve-types.js";
+
+class BankSlot {
+  bank: { createEntity: (rule: Record<string, unknown>) => unknown };
+  rule: Record<string, unknown> & { count?: number | string; name?: string };
+  pool: unknown[];
+  remaining: number;
+
+  constructor (rule: Record<string, unknown> & { count?: number | string; name?: string }, bank: BankSlot["bank"]) {
+    this.bank = bank;
+    this.rule = rule;
+    this.pool = [];
+    this.remaining = +((rule.count as number | string) || 1);
+  }
+
+  getOne (bgioArguments: BgioResolveState, options: { state?: unknown }, context: Record<string, unknown>) {
+    return this.getMultiple(bgioArguments, 1, options, context)[0];
+  }
+
+  getMultiple (
+    bgioArguments: BgioResolveState,
+    count: number = Infinity,
+    options: { state?: unknown } = {},
+    context: Record<string, unknown> = {}
+  ) {
+    const toReturn: unknown[] = [];
+
+    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}`);
+    }
+
+    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 as { state: Record<string, unknown> }).state = {
+          ...(entity as { state: Record<string, unknown> }).state,
+          ...newState as Record<string, unknown>,
+        };
+      });
+    }
+
+    return toReturn;
+  }
+
+  returnToBank (entity: { rule: { state?: unknown }; state?: unknown }) {
+    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.ts

@@ -0,0 +1,125 @@
+import find from "lodash/find.js";
+import filter from "lodash/filter.js";
+import checkConditions from "../../utils/check-conditions.js";
+import type { RuleWithConditions } from "../../types/rule-with-conditions.js";
+import { registry } from "../../registry.js";
+import BankSlot from "./bank-slot.js";
+import type { BgioResolveState } from "../../utils/bgio-resolve-types.js";
+
+class Bank {
+  currentEntityId: number;
+  tracker: Record<number, unknown>;
+  slots: InstanceType<typeof BankSlot>[];
+
+  constructor (entityRules: Record<string, unknown>[]) {
+    this.currentEntityId = 0;
+    this.tracker = {};
+    this.slots = entityRules.map((rule) => new BankSlot(rule, this));
+  }
+
+  createEntity (definition: Record<string, unknown> = {}, options?: Record<string, unknown>) {
+    const Ctor = registry[(definition.entityType || "Entity") as keyof typeof registry] as new (
+      a: unknown,
+      b: Record<string, unknown>,
+      c: number
+    ) => unknown;
+    const entity = new Ctor(
+      {
+        bank: this,
+        fromBank: true,
+        ...options,
+      },
+      definition,
+      this.currentEntityId++
+    );
+    this.track(entity as { entityId: number });
+    return entity;
+  }
+
+  track (entity: { entityId: number }) {
+    this.tracker[entity.entityId] = entity;
+  }
+
+  locate (entityId: unknown) {
+    return this.tracker[entityId as number];
+  }
+
+  findAll (bgioArguments: BgioResolveState, rule: RuleWithConditions, context: Record<string, unknown>) {
+    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.conditions,
+        { target: entity },
+        context
+      ).conditionsAreMet
+    );
+  }
+
+  findOne (bgioArguments: BgioResolveState, rule: RuleWithConditions, context: Record<string, unknown>) {
+    return this.findAll(bgioArguments, rule, context)[0];
+  }
+
+  find (bgioArguments: BgioResolveState, rule: RuleWithConditions & { matchMultiple?: boolean }, context: Record<string, unknown>) {
+    return rule.matchMultiple
+      ? this.findAll(bgioArguments, rule, context)
+      : this.findOne(bgioArguments, rule, context);
+  }
+
+  findParent (entity: unknown) {
+    return find(this.tracker, (ent) =>
+      (ent as { entities?: unknown[] }).entities?.includes(entity)
+        || (ent as { spaces?: unknown[] }).spaces?.includes(entity)
+    );
+  }
+
+  getOne (bgioArguments: BgioResolveState, rule: RuleWithConditions & { state?: unknown }, context: Record<string, unknown>) {
+    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: BgioResolveState, rule: RuleWithConditions & { state?: unknown }, count: number, context: Record<string, unknown>) {
+    const slots = this.getSlots(bgioArguments, rule, context);
+    if (!slots.length) {
+      console.error(`No matching slots for ${JSON.stringify(rule)}`);
+    }
+    return slots.reduce<unknown[]>((acc, slot) => [
+      ...acc,
+      ...slot.getMultiple(bgioArguments, count, { state: rule.state }),
+    ], []);
+  }
+
+  getSlot (bgioArguments: BgioResolveState, rule: RuleWithConditions, context: Record<string, unknown>) {
+    return this.slots.find((slot) => checkConditions(
+      bgioArguments,
+      rule.conditions,
+      { target: slot },
+      context
+    ).conditionsAreMet
+    );
+  }
+
+  getSlots (bgioArguments: BgioResolveState, rule: RuleWithConditions, context: Record<string, unknown>) {
+    return this.slots.filter((slot) => checkConditions(
+      bgioArguments,
+      rule.conditions,
+      { target: slot },
+      context
+    ).conditionsAreMet
+    );
+  }
+
+  returnToBank (bgioArguments: BgioResolveState, entity: { entityId: number; rule: Record<string, unknown> }) {
+    (this.findParent(entity) as { remove: (e: unknown) => void }).remove(entity);
+    this.getSlot(bgioArguments, entity.rule as RuleWithConditions, {})!.returnToBank(entity);
+    delete this.tracker[entity.entityId];
+  }
+}
+
+export default Bank;

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

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

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

@@ -0,0 +1,59 @@
+import type { Condition as ConditionRule } from "../../types/bagel-types.js";
+import type ConditionBase from "./condition.js";
+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: ConditionRule): ConditionBase | undefined {
+  if (typeof rule !== "object" || rule === null || !("conditionType" in rule)) {
+    return undefined;
+  }
+  const r = rule as { conditionType: string; [k: string]: unknown };
+  if (r.conditionType === "Is") {
+    return new Is(r);
+  } else if (r.conditionType === "Not") {
+    return new Not(r);
+  } else if (r.conditionType === "Or") {
+    return new Or(r);
+  } else if (r.conditionType === "Some") {
+    return new Some(r);
+  } else if (r.conditionType === "Contains") {
+    return new ContainsCondition(r);
+  } else if (r.conditionType === "ContainsSame") {
+    return new ContainsSameCondition(r);
+  } else if (r.conditionType === "Every") {
+    return new Every(r);
+  } else if (r.conditionType === "InLine") {
+    return new InLine(r);
+  } else if (r.conditionType === "HasLine") {
+    return new HasLine(r);
+  } else if (r.conditionType === "IsFull") {
+    return new IsFull(r);
+  } else if (r.conditionType === "Would") {
+    return new Would(r);
+  } else if (r.conditionType === "NoPossibleMoves") {
+    return new NoPossibleMoves(r);
+  } else if (r.conditionType === "Evaluate") {
+    return new Evaluate(r);
+  } else if (r.conditionType === "Position") {
+    return new Position(r);
+  // } else if (rule.conditionType === "bingo") {
+    // return new BingoCondition(rule);
+  // } else if (rule.conditionType === "relativeMove") {
+  //   return new RelativeMoveCondition(rule);
+  }
+  return undefined;
+}

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

@@ -0,0 +1,50 @@
+import resolveProperties from "../../utils/resolve-properties.js";
+import type { BgioResolveState } from "../../utils/bgio-resolve-types.js";
+
+export default abstract class Condition {
+  rule: unknown;
+
+  constructor (rule: unknown) {
+    this.rule = rule;
+  }
+
+  check (bgioArguments: unknown, payload: Record<string, unknown>, context: Record<string, unknown>) {
+    const conditionPayload = { ...payload };
+    const newContext = { ...context };
+
+    if (conditionPayload.target) {
+      newContext.originalTarget = conditionPayload.target;
+    }
+
+    const rule = resolveProperties(
+      bgioArguments as BgioResolveState,
+      this.rule,
+      newContext
+    );
+
+    if ((rule as { target?: unknown }).target !== undefined) {
+      conditionPayload.target = (rule as { target: unknown }).target;
+    }
+
+    if ((this.rule as { target?: unknown }).target !== undefined && !conditionPayload.target) {
+      return { conditionIsMet: false };
+    }
+
+    return this.checkCondition(bgioArguments, rule, conditionPayload, newContext);
+  }
+
+  abstract checkCondition (
+    bgioArguments: unknown,
+    rule: unknown,
+    conditionPayload: Record<string, unknown>,
+    newContext: Record<string, unknown>
+  ): { conditionIsMet: boolean; [k: string]: unknown };
+
+  isMet (...args: unknown[]) {
+    return (this.check as (a: unknown, b: Record<string, unknown>, c: Record<string, unknown>) => { conditionIsMet: boolean })(
+      args[0],
+      (args[1] as Record<string, unknown>) ?? {},
+      (args[2] as Record<string, unknown>) ?? {}
+    ).conditionIsMet;
+  }
+}

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

@@ -1,17 +1,18 @@
 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, rule, payload, context) {
-    const { target } = payload
+  checkCondition (bgioArguments: unknown, rule: unknown, payload: Record<string, unknown>, context: Record<string, unknown>) {
+    const target = payload.target as { entities?: unknown[]; spaces?: unknown[] } | undefined;
     if (!target) {
       return { matches: [], conditionIsMet: false }
     } else {
       const candidates = target.entities ?? target.spaces
-      const matches = candidates?.filter(entity => checkConditions(
+      const matches = candidates?.filter((entity: unknown) => checkConditions(
         bgioArguments,
-        rule,
+        (rule as { conditions?: ConditionRule[] }).conditions,
         { target: entity },
         context
       ).conditionsAreMet) ?? []

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

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

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

@@ -1,16 +1,17 @@
 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, rule, payload, context) {
+  checkCondition (bgioArguments: unknown, rule: unknown, payload: Record<string, unknown>, context: Record<string, unknown>) {
     const newContext = { ...context }
     if (payload?.target) {
       newContext.target = payload.target
     }
     const result = resolveExpression(
-      bgioArguments,
-      rule,
+      bgioArguments as BgioResolveState,
+      rule as { expression: string; arguments?: unknown },
       newContext
     )
     return { result, conditionIsMet: !!result }

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

@@ -0,0 +1,27 @@
+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 EveryCondition extends Condition {
+  checkCondition (bgioArguments: unknown, rule: unknown, conditionPayload: Record<string, unknown>, context: Record<string, unknown>) {
+    const targets = conditionPayload.target as unknown[];
+    const results = targets.map((target: unknown) => {
+      const loopContext = {
+        ...context,
+        loopTarget: target
+      }
+
+      return checkConditions(
+        bgioArguments,
+        (rule as { conditions?: ConditionRule[] }).conditions,
+        undefined,
+        loopContext
+      )
+    })
+
+    return {
+      conditionIsMet: results.every((r: { conditionsAreMet: boolean }) => r.conditionsAreMet),
+      results
+    }
+  }
+}

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

@@ -0,0 +1,15 @@
+import Condition from "./condition.js";
+import gridContainsSequence from "../../utils/grid-contains-sequence.js";
+import type { GridLike, SequenceChunk } from "../../utils/grid-contains-sequence.js";
+
+export default class HasLineCondition extends Condition {
+  checkCondition (bgioArguments: unknown, rule: unknown, payload: Record<string, unknown>, context: Record<string, unknown>) {
+    const { matches } = gridContainsSequence(
+      bgioArguments,
+      payload.target as GridLike,
+      (rule as { sequence: SequenceChunk[] }).sequence,
+      context
+    ) as { matches: unknown[] };
+    return { matches, conditionIsMet: !!matches.length };
+  }
+}

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

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

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

@@ -0,0 +1,24 @@
+import Condition from "./condition.js";
+import entityMatches from '../../utils/entity-matches.js'
+import type { BgioResolveState } from "../../utils/bgio-resolve-types.js";
+
+export default class Is extends Condition {
+  checkCondition (bgioArguments: unknown, rule: unknown, { target }: Record<string, unknown>, context: Record<string, unknown>) {
+    if ((this.rule as { entity?: unknown }).entity && target !== (rule as { entity?: unknown }).entity) {
+      return {
+        target,
+        conditionIsMet: false,
+      }
+    }
+
+    return {
+      target,
+      conditionIsMet: entityMatches(
+        bgioArguments as BgioResolveState,
+        (rule as { matcher: Record<string, unknown> }).matcher,
+        target as { rule: Record<string, unknown>; state?: Record<string, unknown> },
+        context
+      )
+    }
+  }
+}

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

@@ -0,0 +1,10 @@
+import Condition from "./condition.js";
+
+export default class IsFull extends Condition {
+  checkCondition (_bgioArguments: unknown, _rule: unknown, payload: Record<string, unknown>, _context: Record<string, unknown>) {
+    const t = payload.target as { spaces: { entities?: unknown[] }[] };
+    return {
+      conditionIsMet: t.spaces.every((space: { entities?: unknown[] }) => space?.entities?.length)
+    };
+  }
+}

package/src/game-factory/condition/{no-possible-moves-condition.js → no-possible-moves-condition.ts}

@@ -1,13 +1,14 @@
 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, _, __, context) {
+  checkCondition (bgioArguments: unknown, _unused: unknown, _payload: unknown, context: Record<string, unknown>) {
     return {
       conditionIsMet: !areThereValidMoves(
         bgioArguments,
-        getCurrentMoves(bgioArguments, context),
+        getCurrentMoves(bgioArguments as GetCurrentMovesState, context as unknown as GetCurrentMovesClient),
       )
     }
   }

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

@@ -1,11 +1,12 @@
+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, rule, payload, context) {
+  checkCondition (bgioArguments: unknown, rule: unknown, payload: Record<string, unknown>, context: Record<string, unknown>) {
     const result = checkConditions(
       bgioArguments,
-      rule,
+      (rule as { conditions?: ConditionRule[] }).conditions,
       payload,
       context
     )

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

@@ -1,11 +1,12 @@
+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, rule, payload, context) {
+  checkCondition (bgioArguments: unknown, rule: unknown, payload: Record<string, unknown>, context: Record<string, unknown>) {
     const result = findMetCondition(
       bgioArguments,
-      rule,
+      (rule as { conditions?: ConditionRule[] }).conditions,
       payload,
       context
     )

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

@@ -0,0 +1,13 @@
+import Condition from "./condition.js";
+
+export default class Position extends Condition {
+  checkCondition (bgioArguments: unknown, rule: unknown, conditionPayload: Record<string, unknown>, _newContext: Record<string, unknown>) {
+    const target = conditionPayload.target;
+    const parent = (bgioArguments as { G: { bank: { findParent: (t: unknown) => { entities: unknown[] } } } }).G.bank.findParent(target);
+    let conditionIsMet = false;
+    if ((rule as { position?: string }).position === "First") {
+      conditionIsMet = parent.entities.indexOf(target) === 0;
+    }
+    return { conditionIsMet };
+  }
+}

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

@@ -1,16 +1,18 @@
+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, rule, { target: targets }, context) {
-    const result = targets.find((target) => {
+  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) => {
       const loopContext = {
         ...context,
         loopTarget: target
       }
       return checkConditions(
         bgioArguments,
-        rule,
+        (rule as { conditions?: ConditionRule[] }).conditions,
         undefined,
         loopContext
       ).conditionsAreMet