@civ-clone/core-strategy 0.1.0

package/.deepsource.toml

@@ -0,0 +1,21 @@
+version = 1
+
+test_patterns = ["test/**/*.test.ts"]
+
+exclude_patterns = ["**/*.js"]
+
+[[analyzers]]
+name = "javascript"
+enabled = true
+
+[analyzers.meta]
+dialect = "typescript"
+environment = [
+  "nodejs",
+  "mocha"
+]
+
+[[analyzers]]
+name = "test-coverage"
+enabled = true
+

package/.gitattributes

@@ -0,0 +1,2 @@
+**/*.js linguist-generated=true
+

package/.github/workflows/build-on-push.yml

@@ -0,0 +1,15 @@
+name: Build and test application on push to remote
+
+on: [push]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v1
+      - uses: actions/setup-node@v1
+        with:
+          node-version: 12
+      - run: npm install
+      - run: npm run prettier:check
+      - run: npm test

package/.prettierrc

@@ -0,0 +1,4 @@
+{
+  "semi": true,
+  "singleQuote": true
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Dom Hastings
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,123 @@
+# 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.
+
+The consumer `AIClient`, `SimpleAIStrategyClient`, is available at
+[civ-clone/simple-ai-strategy-client](https://github.com/civ-clone/simple-ai-strategy-client).
+
+Another aim for this set of classes is to be able to automate simple tasks (explore, improve terrain, go-to, etc.).
+
+Lastly, there's the possibility for primitive Barbarian behaviour, without having a "ghost" player (like Civ1).
+
+## Current state
+
+```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 {
+    // Check if your `Routine` can handle this type of action first, fail early as lots of routines will be even
+    // more expensive to check otherwise.
+    if (!(action instanceof MyHandleableAction)) {
+      return false;
+    }
+
+    // In here you can use any existing code, for example you could trigger existing `Action`s for `Unit`s...
+
+    // If you need to share data across many `Strategy`s or `Routine`s you can use the `StrategyNoteRegistry` (with
+    // an optional custom `generateKey` method to ensure you always use the expected key).
+    const existingNote = strategyNoteRegistryInstance.getByKey(
+      myCustomKeyGenerator(action.value())
+    );
+
+    if (!existingNote) {
+      return false;
+    }
+
+    const data = existingNote.value(),
+      newAction = new DoSomething(data.x(), data.y(), data.thing());
+
+    newAction.perform(action);
+
+    // When you have handled the action, ensure you return `true` to prevent any more actions from triggering.
+    return true;
+  }
+}
+
+// The core `generateKey` method exists in `StrategyNote`, but having a more specific function associated to your
+// `Strategy` can help ensure you are passing the expected entities and get consistent keys.
+import { generateKey } from '@civ-clone/core-strategy/StrategyNote';
+
+export const myCustomKeyGenerator = (item: SpecificItemClass) =>
+  generateKey(item, MyRoutine.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:
+import { High, Normal } from '@civ-clone/core-rule/Priorities';
+import {
+  TraitRegistry,
+  instance as traitRegistryInstance,
+} from '@civ-clone/core-civilization/TraitRegistry';
+import Expansionist from '@civ-clone/base-leader-trait-development/Development/Expansionist';
+import Player from '@civ-clone/core-player/Player';
+import Priority from '@civ-clone/core-strategy/Rules/Priority';
+import Routine from '@civ-clone/core-strategy/Strategy';
+import Trait from '@civ-clone/core-civilization/Trait';
+
+export const getRules = (
+  traitRegistry: TraitRegistry = traitRegistryInstance
+): Priority[] => [
+  new Priority(
+    new Criterion(
+      (player: Player, routine: Routine) => routine instanceof MyRoutine
+    ),
+    new Effect((player: Player) => {
+      const civilization = player.civilization(),
+        leader = civilization.leader();
+
+      if (
+        leader &&
+        traitRegistry.some(
+          (trait: Trait) =>
+            leader instanceof trait.leader() && trait instanceof Expansionist
+        )
+      ) {
+        // Could be any arbitrary `Priority` (from `core-rule`) to give more fine-grained control.
+        return new High();
+      }
+
+      return new Normal();
+    })
+  ),
+];
+
+// In the main entrypoint make sure you register the `Rule`s and the `Strategy`:
+import { instance as ruleRegistryInstance } from '@civ-clone/core-rule/RuleRegistry';
+import { instance as strategyRegistryInstance } from '@civ-clone/core-strategy/StrategyRegistry';
+
+ruleRegistryInstance.register(...getRules());
+strategyRegistryInstance.register(new MyStrategy());
+
+// `StrategyNote`s can be written from anywhere, for example when first making contact with another `Player` or when a
+// `Tile` is discovered, which can then be acted upon.
+```

package/Routine.d.ts

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

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

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

@@ -0,0 +1,39 @@
+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/Rules/Priority.d.ts

@@ -0,0 +1,6 @@
+import Player from '@civ-clone/core-player/Player';
+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> {}
+export default Priority;

package/Rules/Priority.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Priority = void 0;
+const Rule_1 = require("@civ-clone/core-rule/Rule");
+class Priority extends Rule_1.default {
+}
+exports.Priority = Priority;
+exports.default = Priority;
+//# sourceMappingURL=Priority.js.map

package/Rules/Priority.js.map

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

package/Rules/Priority.ts

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

package/Strategy.d.ts

@@ -0,0 +1,18 @@
+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 Routine from './Routine';
+export interface IStrategy {
+  attempt(action: PlayerAction): boolean;
+  priority(player: Player): Priority;
+}
+export declare class Strategy implements IStrategy {
+  #private;
+  constructor(...items: Routine[]);
+  /**
+   * Checks to see if the `action` can be handled, returns `true` if it is, `false` otherwise.
+   */
+  attempt(action: PlayerAction): boolean;
+  priority(player: Player): Priority;
+}
+export default Strategy;

package/Strategy.js

@@ -0,0 +1,32 @@
+"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 Priority_1 = require("@civ-clone/core-rule/Priority");
+class Strategy {
+    constructor(...items) {
+        _Strategy_routines.set(this, []);
+        items.forEach((item) => __classPrivateFieldGet(this, _Strategy_routines, "f").push(item));
+    }
+    /**
+     * 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));
+    }
+    priority(player) {
+        return new Priority_1.default(Math.min(...__classPrivateFieldGet(this, _Strategy_routines, "f").map((routine) => routine.priority(player).value()), Infinity));
+    }
+}
+exports.Strategy = Strategy;
+_Strategy_routines = new WeakMap();
+exports.default = Strategy;
+//# sourceMappingURL=Strategy.js.map

package/Strategy.js.map

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

package/Strategy.ts

@@ -0,0 +1,41 @@
+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 Routine from './Routine';
+
+export interface IStrategy {
+  attempt(action: PlayerAction): boolean;
+  priority(player: Player): Priority;
+}
+
+export class Strategy implements IStrategy {
+  #routines: Routine[] = [];
+
+  constructor(...items: Routine[]) {
+    items.forEach((item) => this.#routines.push(item));
+  }
+
+  /**
+   * 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));
+  }
+
+  priority(player: Player): Priority {
+    return new Priority(
+      Math.min(
+        ...this.#routines.map((routine) => routine.priority(player).value()),
+        Infinity
+      )
+    );
+  }
+}
+
+export default Strategy;

package/StrategyNote.d.ts

@@ -0,0 +1,17 @@
+declare type IDataObject = {
+  id(): string;
+};
+export interface IStrategyNote<Value = any> {
+  key(): string;
+  value(): Value;
+}
+export declare class StrategyNote<Value = any> implements IStrategyNote<Value> {
+  #private;
+  constructor(key: string, value: Value);
+  key(): string;
+  value(): Value;
+}
+export declare const generateKey: (
+  ...items: (IDataObject | string)[]
+) => string;
+export default StrategyNote;

package/StrategyNote.js

@@ -0,0 +1,42 @@
+"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");
+    }
+    key() {
+        return __classPrivateFieldGet(this, _StrategyNote_key, "f");
+    }
+    value() {
+        return __classPrivateFieldGet(this, _StrategyNote_value, "f");
+    }
+}
+exports.StrategyNote = StrategyNote;
+_StrategyNote_key = new WeakMap(), _StrategyNote_value = new WeakMap();
+const generateKey = (...items) => items
+    .map((item) => item instanceof DataObject_1.default
+    ? item.id()
+    : typeof item === 'string'
+        ? item
+        : item.toString())
+    .join('-');
+exports.generateKey = generateKey;
+exports.default = StrategyNote;
+//# sourceMappingURL=StrategyNote.js.map

package/StrategyNote.js.map

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

package/StrategyNote.ts

@@ -0,0 +1,43 @@
+import DataObject from '@civ-clone/core-data-object/DataObject';
+
+type IDataObject = {
+  id(): string;
+};
+
+export interface IStrategyNote<Value = any> {
+  key(): string;
+  value(): Value;
+}
+
+export class StrategyNote<Value = any> implements IStrategyNote<Value> {
+  #key: string;
+  #value: Value;
+
+  constructor(key: string, value: Value) {
+    this.#key = key;
+    this.#value = value;
+  }
+
+  public key(): string {
+    return this.#key;
+  }
+
+  public value(): Value {
+    return this.#value;
+  }
+}
+
+export const generateKey: (...items: (IDataObject | string)[]) => string = (
+  ...items: (IDataObject | string)[]
+) =>
+  items
+    .map((item) =>
+      item instanceof DataObject
+        ? item.id()
+        : typeof item === 'string'
+        ? item
+        : item.toString()
+    )
+    .join('-');
+
+export default StrategyNote;

package/StrategyNoteRegistry.d.ts

@@ -0,0 +1,21 @@
+import {
+  EntityRegistry,
+  IEntityRegistry,
+} from '@civ-clone/core-registry/EntityRegistry';
+import StrategyNote from './StrategyNote';
+export interface IStrategyNoteRegistry extends IEntityRegistry<StrategyNote> {
+  getByKey<Value = any>(key: string): StrategyNote<Value> | undefined;
+  getOrCreateByKey<Value>(key: string, value: Value): StrategyNote<Value>;
+  replace(...entities: StrategyNote[]): void;
+}
+export declare class StrategyNoteRegistry
+  extends EntityRegistry<StrategyNote>
+  implements IStrategyNoteRegistry
+{
+  getByKey<Value = any>(key: string): StrategyNote<Value> | undefined;
+  getOrCreateByKey<Value>(key: string, value: Value): StrategyNote<Value>;
+  register(...entities: StrategyNote[]): void;
+  replace(...entities: StrategyNote[]): void;
+}
+export declare const instance: StrategyNoteRegistry;
+export default StrategyNoteRegistry;

package/StrategyNoteRegistry.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 {
+    getByKey(key) {
+        return this.getBy('key', key)[0];
+    }
+    getOrCreateByKey(key, value) {
+        const existing = this.getByKey(key);
+        if (existing) {
+            return existing;
+        }
+        const note = new StrategyNote_1.default(key, value);
+        this.register(note);
+        return note;
+    }
+    register(...entities) {
+        entities.forEach((entity) => {
+            if (this.getByKey(entity.key())) {
+                throw new TypeError(`Entity with key '${entity.key()}' already exists.`);
+            }
+            super.register(entity);
+        });
+    }
+    replace(...entities) {
+        entities.forEach((entity) => {
+            const existing = this.getByKey(entity.key());
+            if (existing) {
+                this.unregister(existing);
+            }
+            this.register(entity);
+        });
+    }
+}
+exports.StrategyNoteRegistry = StrategyNoteRegistry;
+exports.instance = new StrategyNoteRegistry();
+exports.default = StrategyNoteRegistry;
+//# sourceMappingURL=StrategyNoteRegistry.js.map

package/StrategyNoteRegistry.js.map

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

package/StrategyNoteRegistry.ts

@@ -0,0 +1,62 @@
+import {
+  EntityRegistry,
+  IEntityRegistry,
+} from '@civ-clone/core-registry/EntityRegistry';
+import StrategyNote from './StrategyNote';
+
+export interface IStrategyNoteRegistry extends IEntityRegistry<StrategyNote> {
+  getByKey<Value = any>(key: string): StrategyNote<Value> | undefined;
+  getOrCreateByKey<Value>(key: string, value: Value): StrategyNote<Value>;
+  replace(...entities: StrategyNote[]): void;
+}
+
+export class StrategyNoteRegistry
+  extends EntityRegistry<StrategyNote>
+  implements IStrategyNoteRegistry
+{
+  getByKey<Value = any>(key: string): StrategyNote<Value> | undefined {
+    return this.getBy('key', key)[0];
+  }
+
+  getOrCreateByKey<Value>(key: string, value: Value): StrategyNote<Value> {
+    const existing = this.getByKey(key);
+
+    if (existing) {
+      return existing;
+    }
+
+    const note = new StrategyNote<Value>(key, value);
+
+    this.register(note);
+
+    return note;
+  }
+
+  register(...entities: StrategyNote[]): void {
+    entities.forEach((entity) => {
+      if (this.getByKey(entity.key())) {
+        throw new TypeError(
+          `Entity with key '${entity.key()}' already exists.`
+        );
+      }
+
+      super.register(entity);
+    });
+  }
+
+  replace(...entities: StrategyNote[]): void {
+    entities.forEach((entity) => {
+      const existing = this.getByKey(entity.key());
+
+      if (existing) {
+        this.unregister(existing);
+      }
+
+      this.register(entity);
+    });
+  }
+}
+
+export const instance: StrategyNoteRegistry = new StrategyNoteRegistry();
+
+export default StrategyNoteRegistry;

package/StrategyRegistry.d.ts

@@ -0,0 +1,13 @@
+import EntityRegistry from '@civ-clone/core-registry/EntityRegistry';
+import Strategy from './Strategy';
+import PlayerAction from '@civ-clone/core-player/PlayerAction';
+export declare class StrategyRegistry extends EntityRegistry<Strategy> {
+  constructor();
+  /**
+   * Iterates all `Strategy`s ordered first by `Priority`, then by a random number so that alternative strategies are
+   * tried.
+   */
+  attempt(action: PlayerAction): boolean;
+}
+export declare const instance: StrategyRegistry;
+export default StrategyRegistry;

package/StrategyRegistry.js

@@ -0,0 +1,25 @@
+"use strict";
+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");
+class StrategyRegistry extends EntityRegistry_1.default {
+    constructor() {
+        super(Strategy_1.default);
+    }
+    /**
+     * Iterates all `Strategy`s ordered first by `Priority`, then by a random number so that alternative strategies are
+     * tried.
+     */
+    attempt(action) {
+        return this.entries()
+            .sort((a, b) => a.priority(action.player()).value() -
+            b.priority(action.player()).value() ||
+            Math.floor(Math.random() * 3 - 1))
+            .some((strategy) => strategy.attempt(action));
+    }
+}
+exports.StrategyRegistry = StrategyRegistry;
+exports.instance = new StrategyRegistry();
+exports.default = StrategyRegistry;
+//# sourceMappingURL=StrategyRegistry.js.map

package/StrategyRegistry.js.map

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

package/StrategyRegistry.ts

@@ -0,0 +1,28 @@
+import EntityRegistry from '@civ-clone/core-registry/EntityRegistry';
+import Strategy from './Strategy';
+import PlayerAction from '@civ-clone/core-player/PlayerAction';
+
+export class StrategyRegistry extends EntityRegistry<Strategy> {
+  constructor() {
+    super(Strategy);
+  }
+
+  /**
+   * Iterates all `Strategy`s ordered first by `Priority`, then by a random number so that alternative strategies are
+   * tried.
+   */
+  attempt(action: PlayerAction): boolean {
+    return this.entries()
+      .sort(
+        (a, b) =>
+          a.priority(action.player()).value() -
+            b.priority(action.player()).value() ||
+          Math.floor(Math.random() * 3 - 1)
+      )
+      .some((strategy) => strategy.attempt(action));
+  }
+}
+
+export const instance = new StrategyRegistry();
+
+export default StrategyRegistry;

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@civ-clone/core-strategy",
+  "version": "0.1.0",
+  "repository": "git@github.com:civ-clone/core-strategy.git",
+  "keywords": [
+    "typescript",
+    "civilization"
+  ],
+  "author": "dom111 <dom111@users.noreply.github.com>",
+  "license": "MIT",
+  "private": false,
+  "scripts": {
+    "build": "npm run ts:compile && npm run prettier:format",
+    "prettier:check": "prettier --config .prettierrc '**/*.ts'",
+    "prettier:format": "prettier --config .prettierrc '**/*.ts' --write",
+    "test": "ts-mocha ./tests/*.test.ts",
+    "test:coverage": "c8 ts-mocha ./tests/*.test.ts",
+    "ts:compile": "tsc --build tsconfig.json"
+  },
+  "devDependencies": {
+    "@types/chai": "^4.0",
+    "@types/chai-spies": "^1.0",
+    "@types/mocha": "^9.0",
+    "@types/node": "^14.0",
+    "c8": "^7.0",
+    "chai": "^4.0",
+    "chai-spies": "^1.0",
+    "mocha": "^9.0",
+    "prettier": "^2.0",
+    "ts-mocha": "^9.0",
+    "typescript": "^4.0"
+  },
+  "dependencies": {
+    "@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-registry": "^0.1.0",
+    "@civ-clone/core-rule": "^0.1.1"
+  }
+}

package/tests/Routine.test.ts

@@ -0,0 +1,93 @@
+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/Strategy.test.ts

@@ -0,0 +1,80 @@
+import { High, Normal } from '@civ-clone/core-rule/Priorities';
+import { RoutineA, RoutineB, RoutineFalse, RoutineTrue } from './lib/Routines';
+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';
+
+describe('Strategy', () => {
+  const testPlayer = new Player();
+
+  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();
+  });
+
+  it('should respect `Routine` `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');
+
+    ruleRegistry.register(
+      ...(
+        [
+          [RoutineA, High],
+          [RoutineB, Normal],
+        ] as [typeof Routine, typeof Priority][]
+      ).map(
+        ([RoutineType, PriorityType]) =>
+          new PriorityRule(
+            new Criterion(
+              (player: Player, routine: Routine) =>
+                routine instanceof RoutineType
+            ),
+            new Effect(() => new PriorityType())
+          )
+      )
+    );
+
+    expect(await strategy.attempt(new PlayerAction(testPlayer, null))).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');
+
+    expect(await strategy.attempt(new PlayerAction(testPlayer, null))).false;
+    expect(spyA).called();
+    expect(spyB).called();
+    expect(spyC).called();
+  });
+});

package/tests/StrategyRegistry.test.ts

@@ -0,0 +1,77 @@
+import { RoutineFalse, RoutineTrue } from './lib/Routines';
+import { expect, spy, use } from 'chai';
+import Player from '@civ-clone/core-player/Player';
+import { PlayerAction } from './lib/PlayerActions';
+import Strategy from '../Strategy';
+import StrategyRegistry from '../StrategyRegistry';
+import * as spies from 'chai-spies';
+
+use(spies);
+
+describe('StrategyRegistry', () => {
+  const testPlayer = new Player();
+
+  it('should filter inactive `Strategy`s', async () => {
+    const strategyA = new Strategy(new RoutineTrue()),
+      strategyB = new Strategy(new RoutineTrue()),
+      strategyRegistry = new StrategyRegistry(),
+      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;
+  });
+
+  it('should stop calling `Strategy`s after the first successful `attempt()`', async () => {
+    const strategyA = new Strategy(new RoutineTrue()),
+      strategyB = new Strategy(new RoutineFalse()),
+      strategyRegistry = new StrategyRegistry(),
+      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;
+  });
+
+  it('should respect `Strategy` `Priority`s', async () => {
+    const routine = new RoutineTrue(),
+      strategyA = new Strategy(routine),
+      strategyB = new Strategy(routine),
+      strategyRegistry = new StrategyRegistry(),
+      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;
+  });
+
+  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()),
+      strategyRegistry = new StrategyRegistry(),
+      spyA = spy.on(strategyA, 'attempt'),
+      spyB = spy.on(strategyB, 'attempt'),
+      spyC = spy.on(strategyC, 'attempt');
+
+    strategyRegistry.register(strategyA, strategyB, strategyC);
+
+    expect(await strategyRegistry.attempt(new PlayerAction(testPlayer, null)))
+      .false;
+    expect(spyA).called;
+    expect(spyB).called;
+    expect(spyC).called;
+  });
+});

package/tests/lib/PlayerActions.d.ts

@@ -0,0 +1,2 @@
+import PlayerActionBase from '@civ-clone/core-player/PlayerAction';
+export declare class PlayerAction<T = null> extends PlayerActionBase<T> {}

package/tests/lib/PlayerActions.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlayerAction = void 0;
+const PlayerAction_1 = require("@civ-clone/core-player/PlayerAction");
+class PlayerAction extends PlayerAction_1.default {
+}
+exports.PlayerAction = PlayerAction;
+//# sourceMappingURL=PlayerActions.js.map

package/tests/lib/PlayerActions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PlayerActions.js","sourceRoot":"","sources":["PlayerActions.ts"],"names":[],"mappings":";;;AAAA,sEAAmE;AAEnE,MAAa,YAAuB,SAAQ,sBAAmB;CAAG;AAAlE,oCAAkE"}

package/tests/lib/PlayerActions.ts

@@ -0,0 +1,3 @@
+import PlayerActionBase from '@civ-clone/core-player/PlayerAction';
+
+export class PlayerAction<T = null> extends PlayerActionBase<T> {}

package/tests/lib/Routines.d.ts

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

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

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

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

package/tests/lib/Traits.d.ts

@@ -0,0 +1,12 @@
+import Leader from '@civ-clone/core-civilization/Leader';
+import Trait from '@civ-clone/core-civilization/Trait';
+export declare class TraitType extends Trait {}
+export declare class TraitFull extends TraitType {
+  constructor(leader: typeof Leader);
+}
+export declare class TraitHalf extends TraitType {
+  constructor(leader: typeof Leader);
+}
+export declare class TraitNone extends TraitType {
+  constructor(leader: typeof Leader);
+}

package/tests/lib/Traits.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TraitNone = exports.TraitHalf = exports.TraitFull = exports.TraitType = void 0;
+const Trait_1 = require("@civ-clone/core-civilization/Trait");
+class TraitType extends Trait_1.default {
+}
+exports.TraitType = TraitType;
+class TraitFull extends TraitType {
+    constructor(leader) {
+        super(leader, 1);
+    }
+}
+exports.TraitFull = TraitFull;
+class TraitHalf extends TraitType {
+    constructor(leader) {
+        super(leader, 0.5);
+    }
+}
+exports.TraitHalf = TraitHalf;
+class TraitNone extends TraitType {
+    constructor(leader) {
+        super(leader, 0);
+    }
+}
+exports.TraitNone = TraitNone;
+//# sourceMappingURL=Traits.js.map

package/tests/lib/Traits.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Traits.js","sourceRoot":"","sources":["Traits.ts"],"names":[],"mappings":";;;AACA,8DAAuD;AAEvD,MAAa,SAAU,SAAQ,eAAK;CAAG;AAAvC,8BAAuC;AAEvC,MAAa,SAAU,SAAQ,SAAS;IACtC,YAAY,MAAqB;QAC/B,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;IACnB,CAAC;CACF;AAJD,8BAIC;AAED,MAAa,SAAU,SAAQ,SAAS;IACtC,YAAY,MAAqB;QAC/B,KAAK,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACrB,CAAC;CACF;AAJD,8BAIC;AAED,MAAa,SAAU,SAAQ,SAAS;IACtC,YAAY,MAAqB;QAC/B,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;IACnB,CAAC;CACF;AAJD,8BAIC"}

package/tests/lib/Traits.ts

@@ -0,0 +1,22 @@
+import Leader from '@civ-clone/core-civilization/Leader';
+import Trait from '@civ-clone/core-civilization/Trait';
+
+export class TraitType extends Trait {}
+
+export class TraitFull extends TraitType {
+  constructor(leader: typeof Leader) {
+    super(leader, 1);
+  }
+}
+
+export class TraitHalf extends TraitType {
+  constructor(leader: typeof Leader) {
+    super(leader, 0.5);
+  }
+}
+
+export class TraitNone extends TraitType {
+  constructor(leader: typeof Leader) {
+    super(leader, 0);
+  }
+}

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "declaration": true,
+    "lib": [
+      "es2019"
+    ],
+    "module": "commonjs",
+    "sourceMap": true,
+    "strict": true,
+    "target": "ES2018"
+  },
+  "exclude": [
+    "node_modules",
+    "tests/*.test.ts"
+  ]
+}