Work in progress - rewriting AI mechanism.

README.md

@@ -1,7 +1,8 @@
 # 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`, `StrategyAIClient`, is available at
 [civ-clone/core-strategy-ai-client](https://github.com/civ-clone/core-strategy-ai-client).
@@ -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(),

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;

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;

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[]);
+  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;

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[] = [];
+  #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;

StrategyNote.d.ts

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

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;
@@ -27,9 +26,9 @@ export class StrategyNote<Value = any> implements IStrategyNote<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

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;