@civ-clone/base-unit-lifecycle 0.1.0 → 0.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@civ-clone/base-unit-lifecycle",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Building blocks for a ruleset's unit lifecycle rules: what happens when a unit is created, activated, moved, stowed aboard a transport, halted, defeated, destroyed, lost at sea or left unsupported, and which of a player's units can take orders. The ruleset keeps its own rules, ids and order, and builds their criteria and effects from these.",
   "repository": "git@github.com:civ-clone/base-unit-lifecycle.git",
   "keywords": [
@@ -29,17 +29,35 @@
   },
   "dependencies": {
     "@civ-clone/base-unit-action-embark": "^0.1.0",
+    "@civ-clone/base-unit-action-establish-embassy": "^0.1.0",
+    "@civ-clone/base-unit-action-goto": "^0.1.9",
+    "@civ-clone/base-unit-action-investigate-city": "^0.1.0",
+    "@civ-clone/base-unit-action-meet-with-leader": "^0.1.0",
+    "@civ-clone/base-unit-action-nuclear-attack": "^0.1.0",
     "@civ-clone/base-unit-action-rules": "^0.1.5",
     "@civ-clone/base-unit-action-sleep": "^0.1.0",
+    "@civ-clone/base-unit-trait-attack-ends-turn": "^0.1.0",
     "@civ-clone/base-unit-trait-carries": "^0.1.0",
+    "@civ-clone/base-unit-trait-coast-bound": "^0.1.0",
+    "@civ-clone/base-unit-trait-non-combatant": "^0.1.0",
+    "@civ-clone/base-unit-type-air": "^0.1.0",
+    "@civ-clone/base-unit-type-land": "^0.1.0",
+    "@civ-clone/base-unit-type-naval-transport": "^0.1.3",
     "@civ-clone/core-city": "^0.1.19",
+    "@civ-clone/core-city-growth": "^0.1.6",
+    "@civ-clone/core-diplomacy": "^0.1.8",
     "@civ-clone/core-engine": "^0.1.0",
     "@civ-clone/core-player": "^0.1.0",
+    "@civ-clone/core-random": "^0.1.2",
     "@civ-clone/core-rule": "^0.1.9",
     "@civ-clone/core-terrain": "^0.1.0",
+    "@civ-clone/core-tile-improvement": "^0.1.6",
+    "@civ-clone/core-turn-based-game": "^0.1.10",
     "@civ-clone/core-unit": "^0.1.31",
     "@civ-clone/core-unit-improvement": "^0.1.0",
     "@civ-clone/core-unit-transport": "^0.1.8",
-    "@civ-clone/core-world": "^0.1.0"
+    "@civ-clone/core-world": "^0.1.0",
+    "@civ-clone/core-world-path": "^0.1.3",
+    "@civ-clone/library-diplomacy": "^0.1.4"
   }
 }

package/tests/fixtures/civ1-unit-rules.json

@@ -0,0 +1,89 @@
+{
+  "Rules/Unit/activate": [
+    ["civ1-unit:unit/activate/has-moves", "Activate", 2000, 1],
+    ["civ1-unit:unit/activate/clear-busy", "Activate", 2000, 1],
+    ["civ1-unit:unit/activate/remove-improvement/Fortified", "Activate", 2000, 1]
+  ],
+  "Rules/Unit/canStow": [
+    ["civ1-unit:unit/can-stow/Land", "CanStow", 2000, 1],
+    ["civ1-unit:unit/can-stow/Air", "CanStow", 2000, 1]
+  ],
+  "Rules/Unit/created": [
+    ["civ1-unit:unit/created/register", "Created", 2000, 0],
+    ["civ1-unit:unit/created/apply-visibility", "Created", 2000, 0],
+    ["civ1-unit:unit/created/set-moves", "Created", 2000, 0],
+    ["civ1-unit:unit/created/emit", "Created", 2000, 0]
+  ],
+  "Rules/Unit/defeated": [
+    ["civ1-unit:unit/defeated/emit-and-destroy", "Defeated", 2000, 0],
+    ["civ1-unit:unit/defeated/destroy-stack", "Defeated", 2000, 3]
+  ],
+  "Rules/Unit/destroyed": [
+    ["civ1-unit:unit/destroyed/emit", "Destroyed", 2000, 0],
+    ["civ1-unit:unit/destroyed/count-loss", "Destroyed", 2000, 2],
+    ["civ1-unit:unit/destroyed/deactivate", "Destroyed", 2000, 0],
+    ["civ1-unit:unit/destroyed/remove-improvements", "Destroyed", 2000, 0],
+    ["civ1-unit:unit/destroyed/lose-cargo", "Destroyed", 2000, 1],
+    ["civ1-unit:unit/destroyed/leave-transport", "Destroyed", 2000, 1]
+  ],
+  "Rules/Unit/expectedMovementCost": [
+    ["civ1-unit:unit/expected-movement-cost/shortfall", "ExpectedMovementCost", 2000, 1]
+  ],
+  "Rules/Unit/halted": [
+    ["civ1-unit:unit/halted/emit", "Halted", 2000, 0]
+  ],
+  "Rules/Unit/impassable": [
+    ["civ1-unit:unit/impassable/treaty-partners-land", "Impassable", 2000, 2]
+  ],
+  "Rules/Unit/lostAtSea": [
+    ["civ1-unit:unit/lost-at-sea/emit", "LostAtSea", 2000, 0],
+    ["civ1-unit:unit/lost-at-sea/count-loss", "LostAtSea", 2000, 0],
+    ["civ1-unit:unit/lost-at-sea/destroy", "LostAtSea", 2000, 0]
+  ],
+  "Rules/Player/action": [
+    ["civ1-unit:player/action/active-units", "Action", 2000, 1],
+    ["civ1-unit:player/action/inactive-units", "Action", 2000, 1]
+  ],
+  "Rules/Unit/stowed": [
+    ["civ1-unit:unit/stowed/sleep", "Stowed", 2000, 0]
+  ],
+  "Rules/Unit/transferred": [
+    ["civ1-unit:unit/transferred/start-afresh", "Transferred", 2000, 0],
+    ["civ1-unit:unit/transferred/emit", "Transferred", 2000, 0]
+  ],
+  "Rules/Unit/unsupported": [
+    ["civ1-unit:unit/unsupported/emit", "Unsupported", 2000, 0]
+  ],
+  "Rules/Unit/validateMove": [
+    ["civ1-unit:unit/validate-move/enough-moves", "ValidateMove", 2000, 1],
+    ["civ1-unit:unit/validate-move/not-enough-moves", "ValidateMove", 2000, 1]
+  ],
+  "Rules/Unit/moved": [
+    ["civ1-unit:unit/moved/emit", "Moved", 2000, 0],
+    ["civ1-unit:unit/moved/apply-visibility", "Moved", 2000, 0],
+    ["civ1-unit:unit/moved/end-moves-when-exhausted", "Moved", 2000, 1],
+    ["civ1-unit:unit/moved/move-cargo", "Moved", 2000, 3],
+    ["civ1-unit:unit/moved/collect-aircraft", "Moved", 2000, 4],
+    ["civ1-unit:unit/moved/collect-sleeping", "Moved", 2000, 4],
+    ["civ1-unit:unit/moved/disembark", "Moved", 2000, 1],
+    ["civ1-unit:unit/moved/take-off", "Moved", 2000, 4],
+    ["civ1-unit:unit/moved/trireme-lost-at-sea", "Moved", 2000, 4],
+    ["civ1-unit:unit/moved/bomber/end-turn-after-attack", "Moved", 1000, 2],
+    ["civ1-unit:unit/moved/break-peace-treaty", "Moved", 2000, 1]
+  ],
+  "Rules/Unit/detonated": [
+    ["civ1-unit:unit/detonated/emit", "Detonated", 1000, 0],
+    ["civ1-unit:unit/detonated/destroy-units", "Detonated", 2000, 0],
+    ["civ1-unit:unit/detonated/halve-cities", "Detonated", 2500, 0],
+    ["civ1-unit:unit/detonated/fallout", "Detonated", 3000, 0]
+  ],
+  "Rules/Unit/diplomat": [
+    ["civ1-unit:unit/embassy-established/register", "EmbassyEstablished", 2000, 0],
+    ["civ1-unit:unit/city-investigated/emit", "CityInvestigated", 2000, 0],
+    ["civ1-unit:unit/leader-met/meet", "LeaderMet", 2000, 0],
+    ["civ1-unit:unit/technology-stolen/steal", "TechnologyStolen", 2000, 0],
+    ["civ1-unit:unit/city-sabotaged/sabotage", "CitySabotaged", 2000, 0],
+    ["civ1-unit:unit/revolt-incited/capture", "RevoltIncited", 2000, 0],
+    ["civ1-unit:unit/unit-bribed/transfer", "UnitBribed", 2000, 0]
+  ]
+}

package/tests/lifecycle.test.ts

@@ -39,6 +39,7 @@ import {
   emitAndDestroy,
   hasStack,
   notInCity,
+  notSpared,
 } from '../lib/defeated';
 import { fromLand, impassable, toPartnersLand } from '../lib/impassable';
 import {
@@ -396,6 +397,25 @@ describe('defeated', (): void => {
       [friend, winner],
     ]);
   });
+  it('asks the ruleset whether the square spares the stack, with the square and the defender', (): void => {
+    const tile = {},
+      fort = {},
+      unit = standIn({ tile: () => tile }),
+      fortified = standIn({ tile: () => fort }),
+      asked: any[][] = [],
+      sparesStack = (square: any, defender: Unit): boolean => {
+        asked.push([square, defender]);
+
+        return square === fort;
+      };
+
+    expect(notSpared(sparesStack as any)(unit)).to.true;
+    expect(notSpared(sparesStack as any)(fortified)).to.false;
+    expect(asked).to.eql([
+      [tile, unit],
+      [fort, fortified],
+    ]);
+  });
 });
 
 describe('destroyed', (): void => {

package/tests/movedRules.test.ts

@@ -0,0 +1,256 @@
+import { Peace, Vendetta } from '@civ-clone/library-diplomacy/Declarations';
+import Air from '@civ-clone/base-unit-type-air/Air';
+import InteractionRegistry from '@civ-clone/core-diplomacy/InteractionRegistry';
+import Land from '@civ-clone/base-unit-type-land/Land';
+import Moved from '@civ-clone/core-unit/Rules/Moved';
+import NavalTransport from '@civ-clone/base-unit-type-naval-transport/NavalTransport';
+import Player from '@civ-clone/core-player/Player';
+import RuleRegistry from '@civ-clone/core-rule/RuleRegistry';
+import Sleeping from '@civ-clone/base-unit-action-sleep/Rules/Sleeping';
+import Stowed from '@civ-clone/base-unit-action-embark/Busy/Stowed';
+import { expect } from 'chai';
+import movedRules from '../lib/movedRules';
+
+// The bodies of `movedRules`, with stand-in units, actions and registries: each rule processed through a registry, as
+//  `Moved` is in a game (every rule's criteria checked before any effect runs).
+
+class Move {
+  fromTile: unknown;
+  toTile: unknown;
+  forUnits: unknown[] = [];
+
+  constructor(fromTile: unknown, toTile: unknown) {
+    this.fromTile = fromTile;
+    this.toTile = toTile;
+  }
+
+  from() {
+    return this.fromTile;
+  }
+
+  to() {
+    return this.toTile;
+  }
+
+  forUnit(unit: unknown) {
+    this.forUnits.push(unit);
+
+    return this;
+  }
+}
+class Disembark extends Move {}
+class Attack {}
+class SneakMove extends Move {
+  _enemy: Player;
+
+  constructor(enemy: Player) {
+    super(null, null);
+
+    this._enemy = enemy;
+  }
+
+  enemy() {
+    return this._enemy;
+  }
+}
+class SneakAttack extends Attack {
+  _enemy: Player;
+
+  constructor(enemy: Player) {
+    super();
+
+    this._enemy = enemy;
+  }
+
+  enemy() {
+    return this._enemy;
+  }
+}
+
+const me = new Player(new RuleRegistry()),
+  them = new Player(new RuleRegistry());
+
+type Stub = Record<string, unknown>;
+
+const stub = (Type: Function, props: Stub): any =>
+  Object.assign(Object.create(Type.prototype), {
+    player: () => me,
+    busy: () => null,
+    setBusy() {},
+    hasTrait: () => false,
+    moves: () => ({ value: () => 1, set() {} }),
+    setActive() {},
+    applyVisibility() {},
+    action() {},
+    ...props,
+  });
+
+const setUp = ({
+  cityOwner = null as Player | null,
+  unitsOn = [] as unknown[],
+  aboard = new Map<unknown, unknown>(),
+  interactionRegistry = new InteractionRegistry(),
+} = {}) => {
+  const ruleRegistry = new RuleRegistry(),
+    unregistered: unknown[] = [];
+
+  ruleRegistry.register(
+    ...movedRules(
+      'game',
+      {
+        cityRegistry: {
+          getByTile: () => (cityOwner ? { player: () => cityOwner } : null),
+        } as never,
+        engine: { emit() {} } as never,
+        interactionRegistry,
+        randomNumberGenerator: () => 1,
+        ruleRegistry,
+        transportRegistry: {
+          hasUnit: (unit: unknown) => aboard.has(unit),
+          getByUnit: (unit: unknown) => ({
+            transport: () => aboard.get(unit),
+          }),
+          unregister: (manifest: unknown) => unregistered.push(manifest),
+        } as never,
+        unitRegistry: { getByTile: () => unitsOn } as never,
+      },
+      {
+        Move: Move as never,
+        Disembark: Disembark as never,
+        attacks: [Attack, SneakAttack] as never[],
+        noVendetta: [SneakMove] as never[],
+        coastBoundLoss: 0.5,
+      }
+    )
+  );
+
+  return {
+    moved: (unit: unknown, action: unknown) =>
+      ruleRegistry.process(Moved, unit as never, action as never),
+    unregistered,
+    interactionRegistry,
+  };
+};
+
+// A transport with `cargo` aboard, recording what it unloads and stows.
+const transport = (cargo: unknown[], tile: unknown = 'sea') => {
+  const unloaded: unknown[] = [],
+    stowed: unknown[] = [];
+
+  return {
+    unloaded,
+    stowed,
+    ship: stub(NavalTransport, {
+      tile: () => tile,
+      hasCargo: () => cargo.length > 0,
+      cargo: () => cargo,
+      unload: (unit: unknown) => unloaded.push(unit),
+      hasCapacity: () => true,
+      canStow: () => true,
+      stow: (unit: unknown) => stowed.push(unit),
+    }),
+  };
+};
+
+describe('movedRules', (): void => {
+  it('takes only sentried cargo and aircraft out of its own port, and all of it at sea', (): void => {
+    const awake = stub(Land, {}),
+      sentried = stub(Land, { busy: () => new Stowed() }),
+      asleep = stub(Land, { busy: () => new Sleeping() }),
+      aircraft = stub(Air, {}),
+      cargo = [awake, sentried, asleep, aircraft],
+      inPort = transport(cargo),
+      atSea = transport(cargo);
+
+    const leaving = new Move('port', 'sea');
+
+    setUp({ cityOwner: me }).moved(inPort.ship, leaving);
+    expect(inPort.unloaded).to.deep.equal([awake]);
+    expect(leaving.forUnits).to.deep.equal([sentried, asleep, aircraft]);
+
+    const sailing = new Move('sea', 'sea');
+
+    setUp().moved(atSea.ship, sailing);
+    expect(atSea.unloaded).to.deep.equal([]);
+    expect(sailing.forUnits).to.deep.equal(cargo);
+  });
+
+  it('collects its aircraft outside its cities, and its sleeping units in them', (): void => {
+    const aircraft = stub(Air, {}),
+      sleeper = stub(Land, { busy: () => new Sleeping() }),
+      awake = stub(Land, {}),
+      foreign = stub(Air, { player: () => them });
+
+    const atSea = transport([], 'here');
+
+    setUp({ unitsOn: [aircraft, sleeper, awake, foreign] }).moved(
+      atSea.ship,
+      new Move('there', 'here')
+    );
+    expect(atSea.stowed).to.deep.equal([aircraft]);
+
+    const inPort = transport([], 'here');
+
+    setUp({ cityOwner: me, unitsOn: [aircraft, sleeper, awake] }).moved(
+      inPort.ship,
+      new Move('there', 'here')
+    );
+    expect(inPort.stowed).to.deep.equal([sleeper]);
+  });
+
+  it('unloads a disembarking unit and forgets its manifest, and a unit that moves off its transport', (): void => {
+    const unloaded: unknown[] = [],
+      ship = {
+        unload: (unit: unknown) => unloaded.push(unit),
+        tile: () => 'sea',
+      },
+      leaving = stub(Land, { tile: () => 'shore' }),
+      takingOff = stub(Air, { tile: () => 'sky', busy: () => new Stowed() }),
+      aboard = new Map<unknown, unknown>([
+        [leaving, ship],
+        [takingOff, ship],
+      ]),
+      { moved, unregistered } = setUp({ aboard });
+
+    moved(leaving, new Disembark('sea', 'shore'));
+    expect(unloaded).to.deep.equal([leaving]);
+    expect(unregistered).to.length(1);
+
+    let busy: unknown = 'stowed';
+
+    takingOff.setBusy = (value?: unknown) => (busy = value ?? null);
+    moved(takingOff, new Move('sea', 'sky'));
+    expect(unloaded).to.deep.equal([leaving, takingOff]);
+    expect(busy).to.null;
+  });
+
+  it('ends a treaty broken by a sneak attack, with a grudge, and one broken by a sneak move, without', (): void => {
+    const attacker = stub(Land, {}),
+      attacked = setUp(),
+      walked = setUp();
+
+    attacked.interactionRegistry.register(
+      new Peace(me, them, new RuleRegistry())
+    );
+    walked.interactionRegistry.register(
+      new Peace(me, them, new RuleRegistry())
+    );
+
+    attacked.moved(attacker, new SneakAttack(them));
+    walked.moved(attacker, new SneakMove(them));
+
+    const active = (registry: InteractionRegistry, Type: Function) =>
+      registry
+        .entries()
+        .filter(
+          (interaction) =>
+            interaction instanceof Type &&
+            (interaction as unknown as { active(): boolean }).active()
+        ).length;
+
+    expect(active(attacked.interactionRegistry, Peace)).to.equal(0);
+    expect(active(attacked.interactionRegistry, Vendetta)).to.equal(1);
+    expect(active(walked.interactionRegistry, Peace)).to.equal(0);
+    expect(active(walked.interactionRegistry, Vendetta)).to.equal(0);
+  });
+});