@civ-clone/core-strategy 0.1.0 → 0.1.2

package/README.md

@@ -1,10 +1,11 @@
 # core-strategy
 
-A framework for building modular AI. The idea being that `Strategy`s are built of many `Routine`s for specific
-`PlayerAction`s and it should be easy enough to register new `Strategy`s to handle newly added `PlayerAction`s.
+A framework for building modular AI. The idea being that `Strategy`s can handle one of many `PlayerAction`s and it
+should be easy enough to register new `Strategy`s to handle newly added `PlayerAction`s or specific custom `Unit`s and
+their actions (`Caravan`, `Diplomat`, etc).
 
-The consumer `AIClient`, `SimpleAIStrategyClient`, is available at
-[civ-clone/simple-ai-strategy-client](https://github.com/civ-clone/simple-ai-strategy-client).
+The consumer `AIClient`, `StrategyAIClient`, is available at
+[civ-clone/core-strategy-ai-client](https://github.com/civ-clone/core-strategy-ai-client).
 
 Another aim for this set of classes is to be able to automate simple tasks (explore, improve terrain, go-to, etc.).
 
@@ -12,27 +13,13 @@ Lastly, there's the possibility for primitive Barbarian behaviour, without havin
 
 ## Current state
 
+This is purely illustrative and might change quite substantially until I've got a reasonable working implementation.
+
 ```ts
 import Strategy from '@civ-clone/core-strategy/Strategy';
 
 // Export your base `Strategy`:
 export class MyStrategy extends Strategy {
-  constructor(
-    dependencyForRoutine: SpecificThing = defaultInstanceOfSpecificThing
-  ) {
-    super(
-      new MyRoutine(dependencyForRoutine),
-      new AnotherRoutine(dependencyForRoutine)
-    );
-  }
-}
-
-import PlayerAction from '@civ-clone/core-player/PlayerAction';
-import Routine from '@civ-clone/core-strategy/Strategy';
-import { instance as strategyNoteInstance } from '@civ-clone/core-strategy/StrategyNoteRegistry';
-
-// which is comprised of `Routine`s like the following:
-export class MyRoutine extends Routine {
   // Inject dependencies (e.g. `Registry`s) into the `constructor` as usual
 
   attempt(action: PlayerAction<SpecificItemClass>): boolean {
@@ -69,7 +56,7 @@ export class MyRoutine extends Routine {
 import { generateKey } from '@civ-clone/core-strategy/StrategyNote';
 
 export const myCustomKeyGenerator = (item: SpecificItemClass) =>
-  generateKey(item, MyRoutine.name);
+  generateKey(item, MyStrategy.name);
 
 // To control the priority of your `Routine`s you need to use `Priority` `Rule`s and you can even take the `Leader`s
 // `Trait`s into consideration if you wish:
@@ -89,7 +76,7 @@ export const getRules = (
 ): Priority[] => [
   new Priority(
     new Criterion(
-      (player: Player, routine: Routine) => routine instanceof MyRoutine
+      (player: Player, strategy: Strategy) => routine instanceof MyRoutine
     ),
     new Effect((player: Player) => {
       const civilization = player.civilization(),

package/Rules/Priority.d.ts

@@ -1,6 +1,9 @@
-import Player from '@civ-clone/core-player/Player';
+import PlayerAction from '@civ-clone/core-player/PlayerAction';
 import PriorityValue from '@civ-clone/core-rule/Priority';
-import Routine from '../Routine';
 import Rule from '@civ-clone/core-rule/Rule';
-export declare class Priority extends Rule<[Player, Routine], PriorityValue> {}
+import Strategy from '../Strategy';
+export declare class Priority extends Rule<
+  [PlayerAction, Strategy],
+  PriorityValue
+> {}
 export default Priority;

package/Rules/Priority.js.map

@@ -1 +1 @@
-{"version":3,"file":"Priority.js","sourceRoot":"","sources":["Priority.ts"],"names":[],"mappings":";;;AAGA,oDAA6C;AAE7C,MAAa,QAAS,SAAQ,cAAsC;CAAG;AAAvE,4BAAuE;AAEvE,kBAAe,QAAQ,CAAC"}
+{"version":3,"file":"Priority.js","sourceRoot":"","sources":["Priority.ts"],"names":[],"mappings":";;;AAEA,oDAA6C;AAG7C,MAAa,QAAS,SAAQ,cAA6C;CAAG;AAA9E,4BAA8E;AAE9E,kBAAe,QAAQ,CAAC"}

package/Rules/Priority.ts

@@ -1,8 +1,8 @@
-import Player from '@civ-clone/core-player/Player';
+import PlayerAction from '@civ-clone/core-player/PlayerAction';
 import PriorityValue from '@civ-clone/core-rule/Priority';
-import Routine from '../Routine';
 import Rule from '@civ-clone/core-rule/Rule';
+import Strategy from '../Strategy';
 
-export class Priority extends Rule<[Player, Routine], PriorityValue> {}
+export class Priority extends Rule<[PlayerAction, Strategy], PriorityValue> {}
 
 export default Priority;

package/Strategy.d.ts

@@ -1,18 +1,18 @@
-import Player from '@civ-clone/core-player/Player';
+import { RuleRegistry } from '@civ-clone/core-rule/RuleRegistry';
 import PlayerAction from '@civ-clone/core-player/PlayerAction';
 import Priority from '@civ-clone/core-rule/Priority';
-import Routine from './Routine';
 export interface IStrategy {
   attempt(action: PlayerAction): boolean;
-  priority(player: Player): Priority;
+  priority(action: PlayerAction): Priority;
 }
 export declare class Strategy implements IStrategy {
-  #private;
-  constructor(...items: Routine[]);
+  private _ruleRegistry;
+  constructor(ruleRegistry?: RuleRegistry);
   /**
    * Checks to see if the `action` can be handled, returns `true` if it is, `false` otherwise.
    */
   attempt(action: PlayerAction): boolean;
-  priority(player: Player): Priority;
+  priority(action: PlayerAction): Priority;
+  protected ruleRegistry(): RuleRegistry;
 }
 export default Strategy;

package/Strategy.js

@@ -1,32 +1,30 @@
 "use strict";
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _Strategy_routines;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Strategy = void 0;
+const RuleRegistry_1 = require("@civ-clone/core-rule/RuleRegistry");
 const Priority_1 = require("@civ-clone/core-rule/Priority");
+const Priority_2 = require("./Rules/Priority");
 class Strategy {
-    constructor(...items) {
-        _Strategy_routines.set(this, []);
-        items.forEach((item) => __classPrivateFieldGet(this, _Strategy_routines, "f").push(item));
+    constructor(ruleRegistry = RuleRegistry_1.instance) {
+        this._ruleRegistry = ruleRegistry;
     }
     /**
      * Checks to see if the `action` can be handled, returns `true` if it is, `false` otherwise.
      */
     attempt(action) {
-        return __classPrivateFieldGet(this, _Strategy_routines, "f")
-            .sort((a, b) => a.priority(action.player()).value() -
-            b.priority(action.player()).value())
-            .some((routine) => routine.attempt(action));
+        throw new Error('This must be overwritten in the implementor.');
     }
-    priority(player) {
-        return new Priority_1.default(Math.min(...__classPrivateFieldGet(this, _Strategy_routines, "f").map((routine) => routine.priority(player).value()), Infinity));
+    priority(action) {
+        return new Priority_1.default(
+        // This takes the highest priority (lowest value) from all the applicable `PriorityRule`s
+        Math.min(...this._ruleRegistry
+            .process(Priority_2.default, action, this)
+            .map((priority) => priority.value()), Infinity));
+    }
+    ruleRegistry() {
+        return this._ruleRegistry;
     }
 }
 exports.Strategy = Strategy;
-_Strategy_routines = new WeakMap();
 exports.default = Strategy;
 //# sourceMappingURL=Strategy.js.map

package/Strategy.js.map

@@ -1 +1 @@
-{"version":3,"file":"Strategy.js","sourceRoot":"","sources":["Strategy.ts"],"names":[],"mappings":";;;;;;;;;AAEA,4DAAqD;AAQrD,MAAa,QAAQ;IAGnB,YAAY,GAAG,KAAgB;QAF/B,6BAAuB,EAAE,EAAC;QAGxB,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,uBAAA,IAAI,0BAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;IACrD,CAAC;IAED;;OAEG;IACH,OAAO,CAAC,MAAoB;QAC1B,OAAO,uBAAA,IAAI,0BAAU;aAClB,IAAI,CACH,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CACP,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,KAAK,EAAE;YACnC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,KAAK,EAAE,CACtC;aACA,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC;IAChD,CAAC;IAED,QAAQ,CAAC,MAAc;QACrB,OAAO,IAAI,kBAAQ,CACjB,IAAI,CAAC,GAAG,CACN,GAAG,uBAAA,IAAI,0BAAU,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,CAAC,EACpE,QAAQ,CACT,CACF,CAAC;IACJ,CAAC;CACF;AA5BD,4BA4BC;;AAED,kBAAe,QAAQ,CAAC"}
+{"version":3,"file":"Strategy.js","sourceRoot":"","sources":["Strategy.ts"],"names":[],"mappings":";;;AAAA,oEAG2C;AAE3C,4DAAqD;AACrD,+CAA4C;AAO5C,MAAa,QAAQ;IAGnB,YAAY,eAA6B,uBAAoB;QAC3D,IAAI,CAAC,aAAa,GAAG,YAAY,CAAC;IACpC,CAAC;IAED;;OAEG;IACH,OAAO,CAAC,MAAoB;QAC1B,MAAM,IAAI,KAAK,CAAC,8CAA8C,CAAC,CAAC;IAClE,CAAC;IAED,QAAQ,CAAC,MAAoB;QAC3B,OAAO,IAAI,kBAAQ;QACjB,yFAAyF;QACzF,IAAI,CAAC,GAAG,CACN,GAAG,IAAI,CAAC,aAAa;aAClB,OAAO,CAAC,kBAAY,EAAE,MAAM,EAAE,IAAI,CAAC;aACnC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC,EACtC,QAAQ,CACT,CACF,CAAC;IACJ,CAAC;IAES,YAAY;QACpB,OAAO,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;CACF;AA7BD,4BA6BC;AAED,kBAAe,QAAQ,CAAC"}

package/Strategy.ts

@@ -1,41 +1,45 @@
-import Player from '@civ-clone/core-player/Player';
+import {
+  RuleRegistry,
+  instance as ruleRegistryInstance,
+} from '@civ-clone/core-rule/RuleRegistry';
 import PlayerAction from '@civ-clone/core-player/PlayerAction';
 import Priority from '@civ-clone/core-rule/Priority';
-import Routine from './Routine';
+import PriorityRule from './Rules/Priority';
 
 export interface IStrategy {
   attempt(action: PlayerAction): boolean;
-  priority(player: Player): Priority;
+  priority(action: PlayerAction): Priority;
 }
 
 export class Strategy implements IStrategy {
-  #routines: Routine[] = [];
+  private _ruleRegistry: RuleRegistry;
 
-  constructor(...items: Routine[]) {
-    items.forEach((item) => this.#routines.push(item));
+  constructor(ruleRegistry: RuleRegistry = ruleRegistryInstance) {
+    this._ruleRegistry = ruleRegistry;
   }
 
   /**
    * Checks to see if the `action` can be handled, returns `true` if it is, `false` otherwise.
    */
   attempt(action: PlayerAction): boolean {
-    return this.#routines
-      .sort(
-        (a, b) =>
-          a.priority(action.player()).value() -
-          b.priority(action.player()).value()
-      )
-      .some((routine) => routine.attempt(action));
+    throw new Error('This must be overwritten in the implementor.');
   }
 
-  priority(player: Player): Priority {
+  priority(action: PlayerAction): Priority {
     return new Priority(
+      // This takes the highest priority (lowest value) from all the applicable `PriorityRule`s
       Math.min(
-        ...this.#routines.map((routine) => routine.priority(player).value()),
+        ...this._ruleRegistry
+          .process(PriorityRule, action, this)
+          .map((priority) => priority.value()),
         Infinity
       )
     );
   }
+
+  protected ruleRegistry(): RuleRegistry {
+    return this._ruleRegistry;
+  }
 }
 
 export default Strategy;

package/StrategyNote.d.ts

@@ -1,17 +1,16 @@
-declare type IDataObject = {
-  id(): string;
-};
+import { IDataObject } from '@civ-clone/core-data-object/DataObject';
 export interface IStrategyNote<Value = any> {
   key(): string;
   value(): Value;
 }
 export declare class StrategyNote<Value = any> implements IStrategyNote<Value> {
-  #private;
+  private _key;
+  private _value;
   constructor(key: string, value: Value);
   key(): string;
   value(): Value;
 }
 export declare const generateKey: (
-  ...items: (IDataObject | string)[]
+  ...items: (Pick<IDataObject, 'id'> | string)[]
 ) => string;
 export default StrategyNote;

package/StrategyNote.js

@@ -1,37 +1,22 @@
 "use strict";
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _StrategyNote_key, _StrategyNote_value;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateKey = exports.StrategyNote = void 0;
 const DataObject_1 = require("@civ-clone/core-data-object/DataObject");
 class StrategyNote {
     constructor(key, value) {
-        _StrategyNote_key.set(this, void 0);
-        _StrategyNote_value.set(this, void 0);
-        __classPrivateFieldSet(this, _StrategyNote_key, key, "f");
-        __classPrivateFieldSet(this, _StrategyNote_value, value, "f");
+        this._key = key;
+        this._value = value;
     }
     key() {
-        return __classPrivateFieldGet(this, _StrategyNote_key, "f");
+        return this._key;
     }
     value() {
-        return __classPrivateFieldGet(this, _StrategyNote_value, "f");
+        return this._value;
     }
 }
 exports.StrategyNote = StrategyNote;
-_StrategyNote_key = new WeakMap(), _StrategyNote_value = new WeakMap();
 const generateKey = (...items) => items
-    .map((item) => item instanceof DataObject_1.default
+    .map((item) => item instanceof DataObject_1.DataObject
     ? item.id()
     : typeof item === 'string'
         ? item

package/StrategyNote.js.map

@@ -1 +1 @@
-{"version":3,"file":"StrategyNote.js","sourceRoot":"","sources":["StrategyNote.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,uEAAgE;AAWhE,MAAa,YAAY;IAIvB,YAAY,GAAW,EAAE,KAAY;QAHrC,oCAAa;QACb,sCAAc;QAGZ,uBAAA,IAAI,qBAAQ,GAAG,MAAA,CAAC;QAChB,uBAAA,IAAI,uBAAU,KAAK,MAAA,CAAC;IACtB,CAAC;IAEM,GAAG;QACR,OAAO,uBAAA,IAAI,yBAAK,CAAC;IACnB,CAAC;IAEM,KAAK;QACV,OAAO,uBAAA,IAAI,2BAAO,CAAC;IACrB,CAAC;CACF;AAhBD,oCAgBC;;AAEM,MAAM,WAAW,GAAmD,CACzE,GAAG,KAA+B,EAClC,EAAE,CACF,KAAK;KACF,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CACZ,IAAI,YAAY,oBAAU;IACxB,CAAC,CAAC,IAAI,CAAC,EAAE,EAAE;IACX,CAAC,CAAC,OAAO,IAAI,KAAK,QAAQ;QAC1B,CAAC,CAAC,IAAI;QACN,CAAC,CAAC,IAAI,CAAC,QAAQ,EAAE,CACpB;KACA,IAAI,CAAC,GAAG,CAAC,CAAC;AAXF,QAAA,WAAW,eAWT;AAEf,kBAAe,YAAY,CAAC"}
+{"version":3,"file":"StrategyNote.js","sourceRoot":"","sources":["StrategyNote.ts"],"names":[],"mappings":";;;AAAA,uEAGgD;AAOhD,MAAa,YAAY;IAIvB,YAAY,GAAW,EAAE,KAAY;QACnC,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC;QAChB,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;IACtB,CAAC;IAEM,GAAG;QACR,OAAO,IAAI,CAAC,IAAI,CAAC;IACnB,CAAC;IAEM,KAAK;QACV,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;CACF;AAhBD,oCAgBC;AAEM,MAAM,WAAW,GAEV,CAAC,GAAG,KAA2C,EAAE,EAAE,CAC/D,KAAK;KACF,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CACZ,IAAI,YAAY,uBAAU;IACxB,CAAC,CAAC,IAAI,CAAC,EAAE,EAAE;IACX,CAAC,CAAC,OAAO,IAAI,KAAK,QAAQ;QAC1B,CAAC,CAAC,IAAI;QACN,CAAC,CAAC,IAAI,CAAC,QAAQ,EAAE,CACpB;KACA,IAAI,CAAC,GAAG,CAAC,CAAC;AAXF,QAAA,WAAW,eAWT;AAEf,kBAAe,YAAY,CAAC"}

package/StrategyNote.ts

@@ -1,8 +1,7 @@
-import DataObject from '@civ-clone/core-data-object/DataObject';
-
-type IDataObject = {
-  id(): string;
-};
+import {
+  DataObject,
+  IDataObject,
+} from '@civ-clone/core-data-object/DataObject';
 
 export interface IStrategyNote<Value = any> {
   key(): string;
@@ -10,26 +9,26 @@ export interface IStrategyNote<Value = any> {
 }
 
 export class StrategyNote<Value = any> implements IStrategyNote<Value> {
-  #key: string;
-  #value: Value;
+  private _key: string;
+  private _value: Value;
 
   constructor(key: string, value: Value) {
-    this.#key = key;
-    this.#value = value;
+    this._key = key;
+    this._value = value;
   }
 
   public key(): string {
-    return this.#key;
+    return this._key;
   }
 
   public value(): Value {
-    return this.#value;
+    return this._value;
   }
 }
 
-export const generateKey: (...items: (IDataObject | string)[]) => string = (
-  ...items: (IDataObject | string)[]
-) =>
+export const generateKey: (
+  ...items: (Pick<IDataObject, 'id'> | string)[]
+) => string = (...items: (Pick<IDataObject, 'id'> | string)[]) =>
   items
     .map((item) =>
       item instanceof DataObject

package/StrategyNoteRegistry.d.ts

@@ -12,6 +12,7 @@ export declare class StrategyNoteRegistry
   extends EntityRegistry<StrategyNote>
   implements IStrategyNoteRegistry
 {
+  constructor();
   getByKey<Value = any>(key: string): StrategyNote<Value> | undefined;
   getOrCreateByKey<Value>(key: string, value: Value): StrategyNote<Value>;
   register(...entities: StrategyNote[]): void;

package/StrategyNoteRegistry.js

@@ -4,6 +4,9 @@ exports.instance = exports.StrategyNoteRegistry = void 0;
 const EntityRegistry_1 = require("@civ-clone/core-registry/EntityRegistry");
 const StrategyNote_1 = require("./StrategyNote");
 class StrategyNoteRegistry extends EntityRegistry_1.EntityRegistry {
+    constructor() {
+        super(StrategyNote_1.default);
+    }
     getByKey(key) {
         return this.getBy('key', key)[0];
     }

package/StrategyNoteRegistry.js.map

@@ -1 +1 @@
-{"version":3,"file":"StrategyNoteRegistry.js","sourceRoot":"","sources":["StrategyNoteRegistry.ts"],"names":[],"mappings":";;;AAAA,4EAGiD;AACjD,iDAA0C;AAQ1C,MAAa,oBACX,SAAQ,+BAA4B;IAGpC,QAAQ,CAAc,GAAW;QAC/B,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;IACnC,CAAC;IAED,gBAAgB,CAAQ,GAAW,EAAE,KAAY;QAC/C,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;QAEpC,IAAI,QAAQ,EAAE;YACZ,OAAO,QAAQ,CAAC;SACjB;QAED,MAAM,IAAI,GAAG,IAAI,sBAAY,CAAQ,GAAG,EAAE,KAAK,CAAC,CAAC;QAEjD,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;QAEpB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,QAAQ,CAAC,GAAG,QAAwB;QAClC,QAAQ,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,EAAE;YAC1B,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,EAAE;gBAC/B,MAAM,IAAI,SAAS,CACjB,oBAAoB,MAAM,CAAC,GAAG,EAAE,mBAAmB,CACpD,CAAC;aACH;YAED,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;QACzB,CAAC,CAAC,CAAC;IACL,CAAC;IAED,OAAO,CAAC,GAAG,QAAwB;QACjC,QAAQ,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,EAAE;YAC1B,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC;YAE7C,IAAI,QAAQ,EAAE;gBACZ,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;aAC3B;YAED,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;QACxB,CAAC,CAAC,CAAC;IACL,CAAC;CACF;AA7CD,oDA6CC;AAEY,QAAA,QAAQ,GAAyB,IAAI,oBAAoB,EAAE,CAAC;AAEzE,kBAAe,oBAAoB,CAAC"}
+{"version":3,"file":"StrategyNoteRegistry.js","sourceRoot":"","sources":["StrategyNoteRegistry.ts"],"names":[],"mappings":";;;AAAA,4EAGiD;AACjD,iDAA0C;AAQ1C,MAAa,oBACX,SAAQ,+BAA4B;IAGpC;QACE,KAAK,CAAC,sBAAY,CAAC,CAAC;IACtB,CAAC;IAED,QAAQ,CAAc,GAAW;QAC/B,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;IACnC,CAAC;IAED,gBAAgB,CAAQ,GAAW,EAAE,KAAY;QAC/C,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;QAEpC,IAAI,QAAQ,EAAE;YACZ,OAAO,QAAQ,CAAC;SACjB;QAED,MAAM,IAAI,GAAG,IAAI,sBAAY,CAAQ,GAAG,EAAE,KAAK,CAAC,CAAC;QAEjD,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;QAEpB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,QAAQ,CAAC,GAAG,QAAwB;QAClC,QAAQ,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,EAAE;YAC1B,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,EAAE;gBAC/B,MAAM,IAAI,SAAS,CACjB,oBAAoB,MAAM,CAAC,GAAG,EAAE,mBAAmB,CACpD,CAAC;aACH;YAED,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;QACzB,CAAC,CAAC,CAAC;IACL,CAAC;IAED,OAAO,CAAC,GAAG,QAAwB;QACjC,QAAQ,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,EAAE;YAC1B,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC;YAE7C,IAAI,QAAQ,EAAE;gBACZ,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;aAC3B;YAED,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;QACxB,CAAC,CAAC,CAAC;IACL,CAAC;CACF;AAjDD,oDAiDC;AAEY,QAAA,QAAQ,GAAyB,IAAI,oBAAoB,EAAE,CAAC;AAEzE,kBAAe,oBAAoB,CAAC"}

package/StrategyNoteRegistry.ts

@@ -14,6 +14,10 @@ export class StrategyNoteRegistry
   extends EntityRegistry<StrategyNote>
   implements IStrategyNoteRegistry
 {
+  constructor() {
+    super(StrategyNote);
+  }
+
   getByKey<Value = any>(key: string): StrategyNote<Value> | undefined {
     return this.getBy('key', key)[0];
   }

package/StrategyRegistry.d.ts

@@ -1,6 +1,6 @@
 import EntityRegistry from '@civ-clone/core-registry/EntityRegistry';
-import Strategy from './Strategy';
 import PlayerAction from '@civ-clone/core-player/PlayerAction';
+import Strategy from './Strategy';
 export declare class StrategyRegistry extends EntityRegistry<Strategy> {
   constructor();
   /**

package/StrategyRegistry.js

@@ -13,8 +13,7 @@ class StrategyRegistry extends EntityRegistry_1.default {
      */
     attempt(action) {
         return this.entries()
-            .sort((a, b) => a.priority(action.player()).value() -
-            b.priority(action.player()).value() ||
+            .sort((a, b) => a.priority(action).value() - b.priority(action).value() ||
             Math.floor(Math.random() * 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;AACrE,yCAAkC;AAGlC,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,MAAM,EAAE,CAAC,CAAC,KAAK,EAAE;YACjC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,KAAK,EAAE;YACrC,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;AAnBD,4CAmBC;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;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"}

package/StrategyRegistry.ts

@@ -1,6 +1,6 @@
 import EntityRegistry from '@civ-clone/core-registry/EntityRegistry';
-import Strategy from './Strategy';
 import PlayerAction from '@civ-clone/core-player/PlayerAction';
+import Strategy from './Strategy';
 
 export class StrategyRegistry extends EntityRegistry<Strategy> {
   constructor() {
@@ -15,8 +15,7 @@ export class StrategyRegistry extends EntityRegistry<Strategy> {
     return this.entries()
       .sort(
         (a, b) =>
-          a.priority(action.player()).value() -
-            b.priority(action.player()).value() ||
+          a.priority(action).value() - b.priority(action).value() ||
           Math.floor(Math.random() * 3 - 1)
       )
       .some((strategy) => strategy.attempt(action));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@civ-clone/core-strategy",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "repository": "git@github.com:civ-clone/core-strategy.git",
   "keywords": [
     "typescript",

package/tests/Strategy.test.ts

@@ -1,80 +1,142 @@
-import { High, Normal } from '@civ-clone/core-rule/Priorities';
-import { RoutineA, RoutineB, RoutineFalse, RoutineTrue } from './lib/Routines';
+import { High, Low, Normal } from '@civ-clone/core-rule/Priorities';
+import { StrategyA, StrategyB, StrategyFalse } from './lib/Strategies';
 import { expect, spy } 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 Priority from '@civ-clone/core-rule/Priority';
 import PriorityRule from '../Rules/Priority';
-import Routine from '../Routine';
 import RuleRegistry from '@civ-clone/core-rule/RuleRegistry';
 import Strategy from '../Strategy';
+import PlayerActionBase from '@civ-clone/core-player/PlayerAction';
+import StrategyRegistry from '../StrategyRegistry';
+import TraitRegistry from '@civ-clone/core-civilization/TraitRegistry';
+import Civilization from '@civ-clone/core-civilization/Civilization';
+import { TraitFull, TraitHalf, TraitNone } from './lib/Traits';
+import Leader from '@civ-clone/core-civilization/Leader';
+import Trait from '@civ-clone/core-civilization/Trait';
 
 describe('Strategy', () => {
-  const testPlayer = new Player();
+  const action = new PlayerActionBase(new Player(), null);
 
   it('should default to `Priority(Infinity)`', () =>
-    expect(new Strategy().priority(testPlayer).value()).eq(Infinity));
-
-  it('should stop calling `Routine`s after the first successful `attempt()`', async () => {
-    const routineA = new RoutineFalse(),
-      routineB = new RoutineTrue(),
-      routineC = new RoutineTrue(),
-      strategy = new Strategy(routineA, routineB, routineC),
-      spyA = spy.on(routineA, 'attempt'),
-      spyB = spy.on(routineB, 'attempt'),
-      spyC = spy.on(routineC, 'attempt');
-
-    expect(await strategy.attempt(new PlayerAction(testPlayer, null))).true;
-    expect(spyA).called();
-    expect(spyB).called();
-    expect(spyC).not.called();
-  });
+    expect(new Strategy().priority(action).value()).eq(Infinity));
 
-  it('should respect `Routine` `Priority`s', async () => {
+  it('should respect `Strategy` `Priority`s', async () => {
     const ruleRegistry = new RuleRegistry(),
-      routineA = new RoutineA(ruleRegistry),
-      routineB = new RoutineB(ruleRegistry),
-      strategy = new Strategy(routineA, routineB),
-      spyA = spy.on(routineA, 'attempt'),
-      spyB = spy.on(routineB, 'attempt');
+      strategyRegistry = new StrategyRegistry(),
+      strategyA = new StrategyA(ruleRegistry),
+      strategyB = new StrategyB(ruleRegistry),
+      spyA = spy.on(strategyA, 'attempt'),
+      spyB = spy.on(strategyB, 'attempt');
+
+    strategyRegistry.register(strategyA, strategyB);
 
     ruleRegistry.register(
       ...(
         [
-          [RoutineA, High],
-          [RoutineB, Normal],
-        ] as [typeof Routine, typeof Priority][]
+          [StrategyA, High],
+          [StrategyB, Normal],
+        ] as [typeof Strategy, typeof Priority][]
       ).map(
-        ([RoutineType, PriorityType]) =>
+        ([StrategyType, PriorityType]) =>
           new PriorityRule(
             new Criterion(
-              (player: Player, routine: Routine) =>
-                routine instanceof RoutineType
+              (action: PlayerActionBase, strategy: Strategy) =>
+                strategy instanceof StrategyType
             ),
             new Effect(() => new PriorityType())
           )
       )
     );
 
-    expect(await strategy.attempt(new PlayerAction(testPlayer, null))).true;
+    expect(await strategyRegistry.attempt(action)).true;
     expect(spyA).called();
     expect(spyB).not.called();
   });
 
-  it('should return false if there are no successfully executed `Routine`s', async () => {
-    const routineA = new RoutineFalse(),
-      routineB = new RoutineFalse(),
-      routineC = new RoutineFalse(),
-      strategy = new Strategy(routineA, routineB, routineC),
-      spyA = spy.on(routineA, 'attempt'),
-      spyB = spy.on(routineB, 'attempt'),
-      spyC = spy.on(routineC, 'attempt');
+  it('should return false if there are no successfully executed `Strategy`s', async () => {
+    const strategyA = new StrategyFalse(),
+      strategyB = new StrategyFalse(),
+      strategyC = new StrategyFalse(),
+      strategyRegistry = new StrategyRegistry(),
+      spyA = spy.on(strategyA, 'attempt'),
+      spyB = spy.on(strategyB, 'attempt'),
+      spyC = spy.on(strategyC, 'attempt');
 
-    expect(await strategy.attempt(new PlayerAction(testPlayer, null))).false;
+    strategyRegistry.register(strategyA, strategyB, strategyC);
+
+    expect(await strategyRegistry.attempt(action)).false;
     expect(spyA).called();
     expect(spyB).called();
     expect(spyC).called();
   });
+
+  it('should be possible to prioritise based on `Priority` `Rule`s', async () => {
+    const traitRegistry = new TraitRegistry(),
+      ruleRegistry = new RuleRegistry(),
+      civilization = new Civilization(),
+      traitNone = new TraitNone(Leader),
+      traitHalf = new TraitHalf(Leader),
+      traitFull = new TraitFull(Leader),
+      testPlayer = action.player(),
+      strategyA = new StrategyA(ruleRegistry),
+      strategyB = new StrategyB(ruleRegistry);
+
+    ruleRegistry.register(
+      ...(
+        [
+          [StrategyA, TraitFull, High],
+          [StrategyA, TraitHalf, Normal],
+          [StrategyA, TraitNone, Low],
+          [StrategyB, TraitFull, Low],
+          [StrategyB, TraitHalf, Normal],
+          [StrategyB, TraitNone, High],
+        ] as [typeof Strategy, typeof Trait, typeof Priority][]
+      ).map(
+        ([RoutineType, TraitType, PriorityType]) =>
+          new PriorityRule(
+            new Criterion(
+              (action: PlayerActionBase, strategy: Strategy) =>
+                strategy instanceof RoutineType
+            ),
+            new Criterion(
+              (action: PlayerActionBase) =>
+                action.player().civilization().leader() !== null
+            ),
+            new Criterion((action: PlayerActionBase) =>
+              traitRegistry
+                .getByLeader(
+                  action
+                    .player()
+                    .civilization()
+                    .leader()!
+                    .sourceClass() as typeof Leader
+                )
+                .some((trait) => trait instanceof TraitType)
+            ),
+            new Effect(() => new PriorityType())
+          )
+      )
+    );
+
+    testPlayer.setCivilization(civilization);
+    civilization.setLeader(new Leader());
+    traitRegistry.register(traitFull);
+
+    expect(strategyA.priority(action).value()).equal(new High().value());
+    expect(strategyB.priority(action).value()).equal(new Low().value());
+
+    traitRegistry.unregister(traitFull);
+    traitRegistry.register(traitHalf);
+
+    expect(strategyA.priority(action).value()).equal(new Normal().value());
+    expect(strategyB.priority(action).value()).equal(new Normal().value());
+
+    traitRegistry.unregister(traitHalf);
+    traitRegistry.register(traitNone);
+
+    expect(strategyA.priority(action).value()).equal(new Low().value());
+    expect(strategyB.priority(action).value()).equal(new High().value());
+  });
 });

package/tests/StrategyRegistry.test.ts

@@ -1,4 +1,4 @@
-import { RoutineFalse, RoutineTrue } from './lib/Routines';
+import { StrategyFalse, StrategyTrue } from './lib/Strategies';
 import { expect, spy, use } from 'chai';
 import Player from '@civ-clone/core-player/Player';
 import { PlayerAction } from './lib/PlayerActions';
@@ -12,8 +12,8 @@ describe('StrategyRegistry', () => {
   const testPlayer = new Player();
 
   it('should filter inactive `Strategy`s', async () => {
-    const strategyA = new Strategy(new RoutineTrue()),
-      strategyB = new Strategy(new RoutineTrue()),
+    const strategyA = new StrategyTrue(),
+      strategyB = new Strategy(),
       strategyRegistry = new StrategyRegistry(),
       spyA = spy.on(strategyA, 'attempt'),
       spyB = spy.on(strategyB, 'attempt');
@@ -27,8 +27,8 @@ describe('StrategyRegistry', () => {
   });
 
   it('should stop calling `Strategy`s after the first successful `attempt()`', async () => {
-    const strategyA = new Strategy(new RoutineTrue()),
-      strategyB = new Strategy(new RoutineFalse()),
+    const strategyA = new StrategyTrue(),
+      strategyB = new StrategyFalse(),
       strategyRegistry = new StrategyRegistry(),
       spyA = spy.on(strategyA, 'attempt'),
       spyB = spy.on(strategyB, 'attempt');
@@ -42,9 +42,8 @@ describe('StrategyRegistry', () => {
   });
 
   it('should respect `Strategy` `Priority`s', async () => {
-    const routine = new RoutineTrue(),
-      strategyA = new Strategy(routine),
-      strategyB = new Strategy(routine),
+    const strategyA = new StrategyTrue(),
+      strategyB = new StrategyTrue(),
       strategyRegistry = new StrategyRegistry(),
       spyA = spy.on(strategyA, 'attempt'),
       spyB = spy.on(strategyB, 'attempt');
@@ -58,9 +57,9 @@ describe('StrategyRegistry', () => {
   });
 
   it('should return false if there are no successfully executed `Strategy`s', async () => {
-    const strategyA = new Strategy(new RoutineFalse()),
-      strategyB = new Strategy(new RoutineFalse()),
-      strategyC = new Strategy(new RoutineFalse()),
+    const strategyA = new StrategyFalse(),
+      strategyB = new StrategyFalse(),
+      strategyC = new StrategyFalse(),
       strategyRegistry = new StrategyRegistry(),
       spyA = spy.on(strategyA, 'attempt'),
       spyB = spy.on(strategyB, 'attempt'),

package/tests/lib/Strategies.d.ts

@@ -0,0 +1,9 @@
+import Strategy from '../../Strategy';
+export declare class StrategyTrue extends Strategy {
+  attempt(): boolean;
+}
+export declare class StrategyFalse extends Strategy {
+  attempt(): boolean;
+}
+export declare class StrategyA extends StrategyTrue {}
+export declare class StrategyB extends StrategyTrue {}

package/tests/lib/Strategies.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StrategyB = exports.StrategyA = exports.StrategyFalse = exports.StrategyTrue = void 0;
+const Strategy_1 = require("../../Strategy");
+class StrategyTrue extends Strategy_1.default {
+    attempt() {
+        return true;
+    }
+}
+exports.StrategyTrue = StrategyTrue;
+class StrategyFalse extends Strategy_1.default {
+    attempt() {
+        return false;
+    }
+}
+exports.StrategyFalse = StrategyFalse;
+class StrategyA extends StrategyTrue {
+}
+exports.StrategyA = StrategyA;
+class StrategyB extends StrategyTrue {
+}
+exports.StrategyB = StrategyB;
+//# sourceMappingURL=Strategies.js.map

package/tests/lib/Strategies.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Strategies.js","sourceRoot":"","sources":["Strategies.ts"],"names":[],"mappings":";;;AAAA,6CAAsC;AAEtC,MAAa,YAAa,SAAQ,kBAAQ;IACjC,OAAO;QACZ,OAAO,IAAI,CAAC;IACd,CAAC;CACF;AAJD,oCAIC;AAED,MAAa,aAAc,SAAQ,kBAAQ;IAClC,OAAO;QACZ,OAAO,KAAK,CAAC;IACf,CAAC;CACF;AAJD,sCAIC;AAED,MAAa,SAAU,SAAQ,YAAY;CAAG;AAA9C,8BAA8C;AAE9C,MAAa,SAAU,SAAQ,YAAY;CAAG;AAA9C,8BAA8C"}

package/tests/lib/Strategies.ts

@@ -0,0 +1,17 @@
+import Strategy from '../../Strategy';
+
+export class StrategyTrue extends Strategy {
+  public attempt(): boolean {
+    return true;
+  }
+}
+
+export class StrategyFalse extends Strategy {
+  public attempt(): boolean {
+    return false;
+  }
+}
+
+export class StrategyA extends StrategyTrue {}
+
+export class StrategyB extends StrategyTrue {}

package/tsconfig.json

@@ -2,7 +2,7 @@
   "compilerOptions": {
     "declaration": true,
     "lib": [
-      "es2019"
+      "es2020"
     ],
     "module": "commonjs",
     "sourceMap": true,

package/Routine.d.ts

@@ -1,15 +0,0 @@
-import { RuleRegistry } from '@civ-clone/core-rule/RuleRegistry';
-import Player from '@civ-clone/core-player/Player';
-import PlayerAction from '@civ-clone/core-player/PlayerAction';
-import Priority from '@civ-clone/core-rule/Priority';
-export interface IRoutine {
-  attempt(action: PlayerAction): boolean;
-  priority(player: Player): Priority;
-}
-export declare class Routine implements IRoutine {
-  #private;
-  constructor(ruleRegistry?: RuleRegistry);
-  attempt(action: PlayerAction): boolean;
-  priority(player: Player): Priority;
-}
-export default Routine;

package/Routine.js

@@ -1,38 +0,0 @@
-"use strict";
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _Routine_ruleRegistry;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Routine = void 0;
-const RuleRegistry_1 = require("@civ-clone/core-rule/RuleRegistry");
-const Priority_1 = require("@civ-clone/core-rule/Priority");
-const Priority_2 = require("./Rules/Priority");
-class Routine {
-    constructor(ruleRegistry = RuleRegistry_1.instance) {
-        _Routine_ruleRegistry.set(this, void 0);
-        __classPrivateFieldSet(this, _Routine_ruleRegistry, ruleRegistry, "f");
-    }
-    attempt(action) {
-        throw new TypeError('`attempt` must be overridden.');
-    }
-    priority(player) {
-        return new Priority_1.default(
-        // This takes the highest priority (lowest value) from all the applicable `PriorityRule`s
-        Math.min(...__classPrivateFieldGet(this, _Routine_ruleRegistry, "f")
-            .process(Priority_2.default, player, this)
-            .map((priority) => priority.value()), Infinity));
-    }
-}
-exports.Routine = Routine;
-_Routine_ruleRegistry = new WeakMap();
-exports.default = Routine;
-//# sourceMappingURL=Routine.js.map

package/Routine.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Routine.js","sourceRoot":"","sources":["Routine.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,oEAG2C;AAG3C,4DAAqD;AACrD,+CAA4C;AAO5C,MAAa,OAAO;IAGlB,YAAY,eAA6B,uBAAoB;QAF7D,wCAA4B;QAG1B,uBAAA,IAAI,yBAAiB,YAAY,MAAA,CAAC;IACpC,CAAC;IAED,OAAO,CAAC,MAAoB;QAC1B,MAAM,IAAI,SAAS,CAAC,+BAA+B,CAAC,CAAC;IACvD,CAAC;IAED,QAAQ,CAAC,MAAc;QACrB,OAAO,IAAI,kBAAQ;QACjB,yFAAyF;QACzF,IAAI,CAAC,GAAG,CACN,GAAG,uBAAA,IAAI,6BAAc;aAClB,OAAO,CAAC,kBAAY,EAAE,MAAM,EAAE,IAAI,CAAC;aACnC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC,EACtC,QAAQ,CACT,CACF,CAAC;IACJ,CAAC;CACF;AAtBD,0BAsBC;;AAED,kBAAe,OAAO,CAAC"}

package/Routine.ts

@@ -1,39 +0,0 @@
-import {
-  RuleRegistry,
-  instance as ruleRegistryInstance,
-} from '@civ-clone/core-rule/RuleRegistry';
-import Player from '@civ-clone/core-player/Player';
-import PlayerAction from '@civ-clone/core-player/PlayerAction';
-import Priority from '@civ-clone/core-rule/Priority';
-import PriorityRule from './Rules/Priority';
-
-export interface IRoutine {
-  attempt(action: PlayerAction): boolean;
-  priority(player: Player): Priority;
-}
-
-export class Routine implements IRoutine {
-  #ruleRegistry: RuleRegistry;
-
-  constructor(ruleRegistry: RuleRegistry = ruleRegistryInstance) {
-    this.#ruleRegistry = ruleRegistry;
-  }
-
-  attempt(action: PlayerAction): boolean {
-    throw new TypeError('`attempt` must be overridden.');
-  }
-
-  priority(player: Player): Priority {
-    return new Priority(
-      // This takes the highest priority (lowest value) from all the applicable `PriorityRule`s
-      Math.min(
-        ...this.#ruleRegistry
-          .process(PriorityRule, player, this)
-          .map((priority) => priority.value()),
-        Infinity
-      )
-    );
-  }
-}
-
-export default Routine;

package/tests/Routine.test.ts

@@ -1,93 +0,0 @@
-import { High, Low, Normal } from '@civ-clone/core-rule/Priorities';
-import { RoutineA, RoutineB } from './lib/Routines';
-import { TraitFull, TraitHalf, TraitNone } from './lib/Traits';
-import Civilization from '@civ-clone/core-civilization/Civilization';
-import Criterion from '@civ-clone/core-rule/Criterion';
-import Effect from '@civ-clone/core-rule/Effect';
-import Leader from '@civ-clone/core-civilization/Leader';
-import Player from '@civ-clone/core-player/Player';
-import Priority from '@civ-clone/core-rule/Priority';
-import PriorityRule from '../Rules/Priority';
-import Routine from '../Routine';
-import RuleRegistry from '@civ-clone/core-rule/RuleRegistry';
-import Trait from '@civ-clone/core-civilization/Trait';
-import TraitRegistry from '@civ-clone/core-civilization/TraitRegistry';
-import { expect } from 'chai';
-
-describe('Routine', () => {
-  const testPlayer = new Player();
-
-  it('should default to `Normal` `Priority`', () => {
-    const routine = new Routine();
-
-    expect(routine.priority(testPlayer).value()).equal(Infinity);
-  });
-
-  it('should be possible to prioritise based on `Priority` `Rule`s', async () => {
-    const traitRegistry = new TraitRegistry(),
-      ruleRegistry = new RuleRegistry(),
-      civilization = new Civilization(),
-      traitNone = new TraitNone(Leader),
-      traitHalf = new TraitHalf(Leader),
-      traitFull = new TraitFull(Leader),
-      routine = new RoutineA(ruleRegistry),
-      inverseRoutine = new RoutineB(ruleRegistry);
-
-    ruleRegistry.register(
-      ...(
-        [
-          [RoutineA, TraitFull, High],
-          [RoutineA, TraitHalf, Normal],
-          [RoutineA, TraitNone, Low],
-          [RoutineB, TraitFull, Low],
-          [RoutineB, TraitHalf, Normal],
-          [RoutineB, TraitNone, High],
-        ] as [typeof Routine, typeof Trait, typeof Priority][]
-      ).map(
-        ([RoutineType, TraitType, PriorityType]) =>
-          new PriorityRule(
-            new Criterion(
-              (player: Player, routine: Routine) =>
-                routine instanceof RoutineType
-            ),
-            new Criterion(
-              (player: Player) => player.civilization().leader() !== null
-            ),
-            new Criterion((player: Player) =>
-              traitRegistry
-                .getByLeader(
-                  player.civilization().leader()!.sourceClass() as typeof Leader
-                )
-                .some((trait) => trait instanceof TraitType)
-            ),
-            new Effect(() => new PriorityType())
-          )
-      )
-    );
-
-    testPlayer.setCivilization(civilization);
-    civilization.setLeader(new Leader());
-    traitRegistry.register(traitFull);
-
-    expect(routine.priority(testPlayer).value()).equal(new High().value());
-    expect(inverseRoutine.priority(testPlayer).value()).equal(
-      new Low().value()
-    );
-
-    traitRegistry.unregister(traitFull);
-    traitRegistry.register(traitHalf);
-
-    expect(routine.priority(testPlayer).value()).equal(new Normal().value());
-    expect(inverseRoutine.priority(testPlayer).value()).equal(
-      new Normal().value()
-    );
-
-    traitRegistry.unregister(traitHalf);
-    traitRegistry.register(traitNone);
-
-    expect(routine.priority(testPlayer).value()).equal(new Low().value());
-    expect(inverseRoutine.priority(testPlayer).value()).equal(
-      new High().value()
-    );
-  });
-});

package/tests/lib/Routines.d.ts

@@ -1,9 +0,0 @@
-import Routine from '../../Routine';
-export declare class RoutineTrue extends Routine {
-  attempt(): boolean;
-}
-export declare class RoutineFalse extends Routine {
-  attempt(): boolean;
-}
-export declare class RoutineA extends RoutineTrue {}
-export declare class RoutineB extends RoutineTrue {}

package/tests/lib/Routines.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RoutineB = exports.RoutineA = exports.RoutineFalse = exports.RoutineTrue = void 0;
-const Routine_1 = require("../../Routine");
-class RoutineTrue extends Routine_1.default {
-    attempt() {
-        return true;
-    }
-}
-exports.RoutineTrue = RoutineTrue;
-class RoutineFalse extends Routine_1.default {
-    attempt() {
-        return false;
-    }
-}
-exports.RoutineFalse = RoutineFalse;
-class RoutineA extends RoutineTrue {
-}
-exports.RoutineA = RoutineA;
-class RoutineB extends RoutineTrue {
-}
-exports.RoutineB = RoutineB;
-//# sourceMappingURL=Routines.js.map

package/tests/lib/Routines.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Routines.js","sourceRoot":"","sources":["Routines.ts"],"names":[],"mappings":";;;AAAA,2CAAoC;AAEpC,MAAa,WAAY,SAAQ,iBAAO;IAC/B,OAAO;QACZ,OAAO,IAAI,CAAC;IACd,CAAC;CACF;AAJD,kCAIC;AAED,MAAa,YAAa,SAAQ,iBAAO;IAChC,OAAO;QACZ,OAAO,KAAK,CAAC;IACf,CAAC;CACF;AAJD,oCAIC;AAED,MAAa,QAAS,SAAQ,WAAW;CAAG;AAA5C,4BAA4C;AAE5C,MAAa,QAAS,SAAQ,WAAW;CAAG;AAA5C,4BAA4C"}

package/tests/lib/Routines.ts

@@ -1,17 +0,0 @@
-import Routine from '../../Routine';
-
-export class RoutineTrue extends Routine {
-  public attempt(): boolean {
-    return true;
-  }
-}
-
-export class RoutineFalse extends Routine {
-  public attempt(): boolean {
-    return false;
-  }
-}
-
-export class RoutineA extends RoutineTrue {}
-
-export class RoutineB extends RoutineTrue {}