@civ-clone/core-strategy 0.1.2 → 0.1.4

package/StrategyRegistry.d.ts

@@ -2,7 +2,8 @@ import EntityRegistry from '@civ-clone/core-registry/EntityRegistry';
 import PlayerAction from '@civ-clone/core-player/PlayerAction';
 import Strategy from './Strategy';
 export declare class StrategyRegistry extends EntityRegistry<Strategy> {
-  constructor();
+  private _randomNumberGenerator;
+  constructor(randomNumberGenerator?: () => number);
   /**
    * Iterates all `Strategy`s ordered first by `Priority`, then by a random number so that alternative strategies are
    * tried.

package/StrategyRegistry.js

@@ -3,9 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.instance = exports.StrategyRegistry = void 0;
 const EntityRegistry_1 = require("@civ-clone/core-registry/EntityRegistry");
 const Strategy_1 = require("./Strategy");
+const core_random_1 = require("@civ-clone/core-random");
 class StrategyRegistry extends EntityRegistry_1.default {
-    constructor() {
+    constructor(randomNumberGenerator = core_random_1.instance) {
         super(Strategy_1.default);
+        this._randomNumberGenerator = randomNumberGenerator;
     }
     /**
      * Iterates all `Strategy`s ordered first by `Priority`, then by a random number so that alternative strategies are
@@ -14,7 +16,7 @@ class StrategyRegistry extends EntityRegistry_1.default {
     attempt(action) {
         return this.entries()
             .sort((a, b) => a.priority(action).value() - b.priority(action).value() ||
-            Math.floor(Math.random() * 3 - 1))
+            Math.floor(this._randomNumberGenerator() * 3 - 1))
             .some((strategy) => strategy.attempt(action));
     }
 }

package/StrategyRegistry.js.map

@@ -1 +1 @@
-{"version":3,"file":"StrategyRegistry.js","sourceRoot":"","sources":["StrategyRegistry.ts"],"names":[],"mappings":";;;AAAA,4EAAqE;AAErE,yCAAkC;AAElC,MAAa,gBAAiB,SAAQ,wBAAwB;IAC5D;QACE,KAAK,CAAC,kBAAQ,CAAC,CAAC;IAClB,CAAC;IAED;;;OAGG;IACH,OAAO,CAAC,MAAoB;QAC1B,OAAO,IAAI,CAAC,OAAO,EAAE;aAClB,IAAI,CACH,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CACP,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE;YACvD,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC,CACpC;aACA,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC;IAClD,CAAC;CACF;AAlBD,4CAkBC;AAEY,QAAA,QAAQ,GAAG,IAAI,gBAAgB,EAAE,CAAC;AAE/C,kBAAe,gBAAgB,CAAC"}
+{"version":3,"file":"StrategyRegistry.js","sourceRoot":"","sources":["StrategyRegistry.ts"],"names":[],"mappings":";;;AAAA,4EAAqE;AAErE,yCAAkC;AAClC,wDAAiE;AAEjE,MAAa,gBAAiB,SAAQ,wBAAwB;IAG5D,YAAY,wBAAsC,sBAAW;QAC3D,KAAK,CAAC,kBAAQ,CAAC,CAAC;QAEhB,IAAI,CAAC,sBAAsB,GAAG,qBAAqB,CAAC;IACtD,CAAC;IAED;;;OAGG;IACH,OAAO,CAAC,MAAoB;QAC1B,OAAO,IAAI,CAAC,OAAO,EAAE;aAClB,IAAI,CACH,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CACP,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE;YACvD,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,sBAAsB,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC,CACpD;aACA,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC;IAClD,CAAC;CACF;AAtBD,4CAsBC;AAEY,QAAA,QAAQ,GAAG,IAAI,gBAAgB,EAAE,CAAC;AAE/C,kBAAe,gBAAgB,CAAC"}

package/StrategyRegistry.ts

@@ -1,10 +1,15 @@
 import EntityRegistry from '@civ-clone/core-registry/EntityRegistry';
 import PlayerAction from '@civ-clone/core-player/PlayerAction';
 import Strategy from './Strategy';
+import { instance as rngInstance } from '@civ-clone/core-random';
 
 export class StrategyRegistry extends EntityRegistry<Strategy> {
-  constructor() {
+  private _randomNumberGenerator: () => number;
+
+  constructor(randomNumberGenerator: () => number = rngInstance) {
     super(Strategy);
+
+    this._randomNumberGenerator = randomNumberGenerator;
   }
 
   /**
@@ -16,7 +21,7 @@ export class StrategyRegistry extends EntityRegistry<Strategy> {
       .sort(
         (a, b) =>
           a.priority(action).value() - b.priority(action).value() ||
-          Math.floor(Math.random() * 3 - 1)
+          Math.floor(this._randomNumberGenerator() * 3 - 1)
       )
       .some((strategy) => strategy.attempt(action));
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@civ-clone/core-strategy",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "repository": "git@github.com:civ-clone/core-strategy.git",
   "keywords": [
     "typescript",
@@ -34,6 +34,7 @@
     "@civ-clone/core-civilization": "^0.1.0",
     "@civ-clone/core-data-object": "^0.1.0",
     "@civ-clone/core-player": "^0.1.2",
+    "@civ-clone/core-random": "^0.1.0",
     "@civ-clone/core-registry": "^0.1.0",
     "@civ-clone/core-rule": "^0.1.1"
   }

package/tests/StrategyRegistry.test.ts

@@ -1,7 +1,12 @@
 import { StrategyFalse, StrategyTrue } from './lib/Strategies';
 import { expect, spy, use } from 'chai';
+import Criterion from '@civ-clone/core-rule/Criterion';
+import Effect from '@civ-clone/core-rule/Effect';
 import Player from '@civ-clone/core-player/Player';
 import { PlayerAction } from './lib/PlayerActions';
+import PriorityRule from '../Rules/Priority';
+import PriorityValue from '@civ-clone/core-rule/Priority';
+import RuleRegistry from '@civ-clone/core-rule/RuleRegistry';
 import Strategy from '../Strategy';
 import StrategyRegistry from '../StrategyRegistry';
 import * as spies from 'chai-spies';
@@ -11,49 +16,63 @@ use(spies);
 describe('StrategyRegistry', () => {
   const testPlayer = new Player();
 
-  it('should filter inactive `Strategy`s', async () => {
-    const strategyA = new StrategyTrue(),
-      strategyB = new Strategy(),
-      strategyRegistry = new StrategyRegistry(),
-      spyA = spy.on(strategyA, 'attempt'),
-      spyB = spy.on(strategyB, 'attempt');
-
-    strategyRegistry.register(strategyA, strategyB);
+  it('should stop calling `Strategy`s after the first successful `attempt()`', async () => {
+    // `A` is given the higher priority so that it definitely runs first.
+    // Equal priorities are ordered by a random draw, which would make "the
+    // second one was not reached" true only some of the time.
+    const ruleRegistry = new RuleRegistry(),
+      strategyA = new StrategyTrue(ruleRegistry),
+      strategyB = new StrategyTrue(ruleRegistry),
+      strategyRegistry = new StrategyRegistry();
 
-    expect(await strategyRegistry.attempt(new PlayerAction(testPlayer, null)))
-      .true;
-    expect(spyA).not.called;
-    expect(spyB).called;
-  });
+    ruleRegistry.register(
+      new PriorityRule(
+        new Criterion(
+          (action: PlayerAction, strategy: Strategy): boolean =>
+            strategy === strategyA
+        ),
+        new Effect((): PriorityValue => new PriorityValue(1))
+      )
+    );
 
-  it('should stop calling `Strategy`s after the first successful `attempt()`', async () => {
-    const strategyA = new StrategyTrue(),
-      strategyB = new StrategyFalse(),
-      strategyRegistry = new StrategyRegistry(),
-      spyA = spy.on(strategyA, 'attempt'),
+    const spyA = spy.on(strategyA, 'attempt'),
       spyB = spy.on(strategyB, 'attempt');
 
     strategyRegistry.register(strategyA, strategyB);
 
-    expect(await strategyRegistry.attempt(new PlayerAction(testPlayer, null)))
-      .true;
-    expect(spyA).called;
-    expect(spyB).not.called;
+    expect(strategyRegistry.attempt(new PlayerAction(testPlayer, null))).true;
+    expect(spyA).to.have.been.called();
+    expect(spyB).to.not.have.been.called();
   });
 
   it('should respect `Strategy` `Priority`s', async () => {
-    const strategyA = new StrategyTrue(),
-      strategyB = new StrategyTrue(),
-      strategyRegistry = new StrategyRegistry(),
-      spyA = spy.on(strategyA, 'attempt'),
+    const ruleRegistry = new RuleRegistry(),
+      strategyA = new StrategyTrue(ruleRegistry),
+      strategyB = new StrategyTrue(ruleRegistry),
+      strategyRegistry = new StrategyRegistry();
+
+    // Without this the two are tied and the order is a coin flip. Giving `B`
+    // the lower value — which is the higher priority — is the whole point of
+    // the test, and it is what makes the assertion below meaningful rather
+    // than true three times in four.
+    ruleRegistry.register(
+      new PriorityRule(
+        new Criterion(
+          (action: PlayerAction, strategy: Strategy): boolean =>
+            strategy === strategyB
+        ),
+        new Effect((): PriorityValue => new PriorityValue(1))
+      )
+    );
+
+    const spyA = spy.on(strategyA, 'attempt'),
       spyB = spy.on(strategyB, 'attempt');
 
     strategyRegistry.register(strategyA, strategyB);
 
-    expect(await strategyRegistry.attempt(new PlayerAction(testPlayer, null)))
-      .true;
-    expect(spyA).not.called;
-    expect(spyB).called;
+    expect(strategyRegistry.attempt(new PlayerAction(testPlayer, null))).true;
+    expect(spyB).to.have.been.called();
+    expect(spyA).to.not.have.been.called();
   });
 
   it('should return false if there are no successfully executed `Strategy`s', async () => {
@@ -67,10 +86,9 @@ describe('StrategyRegistry', () => {
 
     strategyRegistry.register(strategyA, strategyB, strategyC);
 
-    expect(await strategyRegistry.attempt(new PlayerAction(testPlayer, null)))
-      .false;
-    expect(spyA).called;
-    expect(spyB).called;
-    expect(spyC).called;
+    expect(strategyRegistry.attempt(new PlayerAction(testPlayer, null))).false;
+    expect(spyA).to.have.been.called();
+    expect(spyB).to.have.been.called();
+    expect(spyC).to.have.been.called();
   });
 });