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

package/README.md

@@ -32,5 +32,31 @@ registry, the engine or a number take it first and return the function.
 - `lib/playerAction`: `hasActiveUnits(unitRegistry)` / `activeUnits(unitRegistry, ActiveUnit)` and
   `hasInactiveUnits(unitRegistry)` / `inactiveUnits(unitRegistry, InactiveUnit)`, waiting units last.
 
+## Rule assemblers
+
+For a ruleset that wants the rules themselves, each takes the ruleset's id prefix, its registries and its options, and
+returns the rules with ids `<prefix>:unit/<type>/<name>`, the same names and order civ1-unit uses
+(`tests/fixtures/civ1-unit-rules.json` pins them):
+
+- `lib/lifecycleRules`: `lifecycleRules(prefix, deps, options)`, by rule type (`activate`, `canStow`, `created`,
+  `defeated`, `destroyed`, `expectedMovementCost`, `halted`, `impassable`, `lostAtSea`, `playerAction`, `stowed`,
+  `transferred`, `unsupported`, `validateMove`), so each list can be registered where the ruleset wants it.
+- `lib/movedRules`: `movedRules(prefix, deps, options)`, the `Moved` rules: cargo, collecting, taking off, a
+  `CoastBound` unit lost at sea, `AttackEndsTurn`, and a broken peace treaty.
+- `lib/detonatedRules`: `detonatedRules(prefix, deps, options)`, what a nuclear detonation does to the 9 squares.
+  `sparesUnits` spares a city's units (Civ1's SDI Defense); an optional `vetoes` stops a detonation altogether.
+- `lib/diplomatRules`: `diplomatRules(prefix, deps)`, the embassy, investigation and leader-meeting rules.
+- `lib/treatyPartner`: `treatyPartner(improvements, deps)`, a `partnerOf` for `impassable` and the treaty actions: the
+  partner working an improved tile.
+
+### For civ1-unit's adoption (R2b)
+
+- `lifecycle.transferred` holds only `transferred/emit`: civ1-unit must register its own `transferred/start-afresh`
+  rule (`START_AFRESH_RULE`) before it, as it does today.
+- `HALVE_CITIES_PRIORITY` and `halveCity` now live in `lib/detonatedRules` as well as civ1-unit's `lib/nuclear`; R2b
+  makes civ1-unit re-export the base ones, so there is one copy.
+- The defaults reproduce civ1-unit exactly: `shortStep` and `vetoes` are for other rulesets (Civ2's short step and SDI
+  Defense), and leaving them out changes nothing.
+
 A library: no `main`, so it registers nothing on its own. Import what you need, for example
 `@civ-clone/base-unit-lifecycle/lib/destroyed`.

package/lib/detonatedRules.d.ts

@@ -0,0 +1,56 @@
+import { CityGrowthRegistry } from '@civ-clone/core-city-growth/CityGrowthRegistry';
+import { CityRegistry } from '@civ-clone/core-city/CityRegistry';
+import { Engine } from '@civ-clone/core-engine/Engine';
+import { RuleRegistry } from '@civ-clone/core-rule/RuleRegistry';
+import { TileImprovementRegistry } from '@civ-clone/core-tile-improvement/TileImprovementRegistry';
+import { UnitRegistry } from '@civ-clone/core-unit/UnitRegistry';
+import City from '@civ-clone/core-city/City';
+import Detonated from '@civ-clone/base-unit-action-nuclear-attack/Rules/Detonated';
+import Tile from '@civ-clone/core-world/Tile';
+import TileImprovement from '@civ-clone/core-tile-improvement/TileImprovement';
+import Unit from '@civ-clone/core-unit/Unit';
+/**
+ * Where `unit/detonated/halve-cities` runs among the `Detonated` rules: after the `Normal` ones (the units destroyed)
+ * and before `Low` (the fallout), so a rule that takes its place runs there too.
+ */
+export declare const HALVE_CITIES_PRIORITY = 2500;
+/** `city` loses half its size, rounded down, to `unit`'s detonation, so a city is never destroyed by it. */
+export declare const halveCity: (
+  city: City,
+  unit: Unit,
+  cityGrowthRegistry?: CityGrowthRegistry
+) => void;
+export interface DetonatedDependencies {
+  cityGrowthRegistry?: CityGrowthRegistry;
+  cityRegistry?: CityRegistry;
+  engine?: Engine;
+  randomNumberGenerator?: () => number;
+  ruleRegistry?: RuleRegistry;
+  tileImprovementRegistry?: TileImprovementRegistry;
+  unitRegistry?: UnitRegistry;
+}
+export interface DetonatedOptions {
+  sparesUnits: (city: City) => boolean;
+  vetoes?: (unit: Unit, tile: Tile) => boolean;
+  Pollution: new (tile: Tile, ruleRegistry: RuleRegistry) => TileImprovement;
+  falloutChance: number;
+}
+/**
+ * A ruleset's `Detonated` rules, with ids `<prefix>:unit/detonated/<name>` as civ1-unit's are, over the square a
+ * nuclear weapon detonates over and the 8 around it: tell the client, destroy every unit (but those `sparesUnits`
+ * keeps), halve every city, and fall out on the land.
+ */
+export declare const detonatedRules: (
+  prefix: string,
+  {
+    cityGrowthRegistry,
+    cityRegistry,
+    engine,
+    randomNumberGenerator,
+    ruleRegistry,
+    tileImprovementRegistry,
+    unitRegistry,
+  }: DetonatedDependencies,
+  { sparesUnits, Pollution, falloutChance, vetoes }: DetonatedOptions
+) => Detonated[];
+export default detonatedRules;

package/lib/detonatedRules.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detonatedRules = exports.halveCity = exports.HALVE_CITIES_PRIORITY = void 0;
+const CityGrowthRegistry_1 = require("@civ-clone/core-city-growth/CityGrowthRegistry");
+const CityRegistry_1 = require("@civ-clone/core-city/CityRegistry");
+const Engine_1 = require("@civ-clone/core-engine/Engine");
+const RuleRegistry_1 = require("@civ-clone/core-rule/RuleRegistry");
+const TileImprovementRegistry_1 = require("@civ-clone/core-tile-improvement/TileImprovementRegistry");
+const UnitRegistry_1 = require("@civ-clone/core-unit/UnitRegistry");
+const Destroyed_1 = require("@civ-clone/core-unit/Rules/Destroyed");
+const Detonated_1 = require("@civ-clone/base-unit-action-nuclear-attack/Rules/Detonated");
+const Effect_1 = require("@civ-clone/core-rule/Effect");
+const High_1 = require("@civ-clone/core-rule/Priorities/High");
+const Low_1 = require("@civ-clone/core-rule/Priorities/Low");
+const Priority_1 = require("@civ-clone/core-rule/Priority");
+const core_random_1 = require("@civ-clone/core-random");
+/**
+ * Where `unit/detonated/halve-cities` runs among the `Detonated` rules: after the `Normal` ones (the units destroyed)
+ * and before `Low` (the fallout), so a rule that takes its place runs there too.
+ */
+exports.HALVE_CITIES_PRIORITY = 2500;
+/** `city` loses half its size, rounded down, to `unit`'s detonation, so a city is never destroyed by it. */
+const halveCity = (city, unit, cityGrowthRegistry = CityGrowthRegistry_1.instance) => {
+    const cityGrowth = cityGrowthRegistry.getByCity(city), loss = Math.floor(cityGrowth.size() / 2);
+    for (let i = 0; i < loss; i++) {
+        cityGrowth.shrink(unit);
+    }
+};
+exports.halveCity = halveCity;
+/**
+ * A ruleset's `Detonated` rules, with ids `<prefix>:unit/detonated/<name>` as civ1-unit's are, over the square a
+ * nuclear weapon detonates over and the 8 around it: tell the client, destroy every unit (but those `sparesUnits`
+ * keeps), halve every city, and fall out on the land.
+ */
+const detonatedRules = (prefix, { cityGrowthRegistry = CityGrowthRegistry_1.instance, cityRegistry = CityRegistry_1.instance, engine = Engine_1.instance, randomNumberGenerator = core_random_1.instance, ruleRegistry = RuleRegistry_1.instance, tileImprovementRegistry = TileImprovementRegistry_1.instance, unitRegistry = UnitRegistry_1.instance, }, { sparesUnits, Pollution, falloutChance, vetoes }) => {
+    const id = (name) => `${prefix}:unit/detonated/${name}`, area = (tile) => [tile, ...tile.getNeighbours()], 
+    // `vetoes` is asked once per detonation, by `emit` (which runs first, `High`), and the answer is kept for the
+    //  three rules after it, so destroying the units can't change it halfway. Without `vetoes`, nothing is kept or asked.
+    vetoed = new WeakMap(), stopped = (unit, tile) => { var _a; return vetoes !== undefined && ((_a = vetoed.get(unit)) !== null && _a !== void 0 ? _a : vetoes(unit, tile)); };
+    return [
+        new Detonated_1.default(
+        // Before anything changes, so a client can see what's there to be hit.
+        id('emit'), new High_1.default(), new Effect_1.default((unit, tile) => {
+            if (vetoes !== undefined) {
+                vetoed.set(unit, vetoes(unit, tile));
+            }
+            engine.emit('unit:nuclear-detonation', unit, tile);
+        })),
+        new Detonated_1.default(id('destroy-units'), new Effect_1.default((unit, tile) => stopped(unit, tile)
+            ? undefined
+            : area(tile).forEach((areaTile) => {
+                const city = cityRegistry.getByTile(areaTile);
+                if (city !== null && sparesUnits(city)) {
+                    engine.emit('city:sdi-protected', city, unit);
+                    return;
+                }
+                unitRegistry
+                    .getByTile(areaTile)
+                    .forEach((areaUnit) => {
+                    // Cargo is destroyed with its transport, earlier in this loop, if the transport is lost at sea.
+                    if (areaUnit.destroyed()) {
+                        return;
+                    }
+                    ruleRegistry.process(Destroyed_1.default, areaUnit, unit.player());
+                });
+            }))),
+        new Detonated_1.default(id('halve-cities'), new Priority_1.default(exports.HALVE_CITIES_PRIORITY), new Effect_1.default((unit, tile) => stopped(unit, tile)
+            ? undefined
+            : area(tile).forEach((areaTile) => {
+                const city = cityRegistry.getByTile(areaTile);
+                if (city === null) {
+                    return;
+                }
+                (0, exports.halveCity)(city, unit, cityGrowthRegistry);
+            }))),
+        new Detonated_1.default(id('fallout'), new Low_1.default(), new Effect_1.default((unit, tile) => stopped(unit, tile)
+            ? undefined
+            : area(tile)
+                .filter((areaTile) => areaTile.isLand() &&
+                cityRegistry.getByTile(areaTile) === null &&
+                !tileImprovementRegistry
+                    .getByTile(areaTile)
+                    .some((improvement) => improvement instanceof Pollution))
+                .forEach((areaTile) => {
+                if (randomNumberGenerator() >= falloutChance) {
+                    return;
+                }
+                // Building it processes `Built`, which puts it on the tile.
+                new Pollution(areaTile, ruleRegistry);
+            }))),
+    ];
+};
+exports.detonatedRules = detonatedRules;
+exports.default = exports.detonatedRules;
+//# sourceMappingURL=detonatedRules.js.map

package/lib/detonatedRules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"detonatedRules.js","sourceRoot":"","sources":["detonatedRules.ts"],"names":[],"mappings":"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"}

package/lib/detonatedRules.ts

@@ -0,0 +1,196 @@
+import {
+  CityGrowthRegistry,
+  instance as cityGrowthRegistryInstance,
+} from '@civ-clone/core-city-growth/CityGrowthRegistry';
+import {
+  CityRegistry,
+  instance as cityRegistryInstance,
+} from '@civ-clone/core-city/CityRegistry';
+import {
+  Engine,
+  instance as engineInstance,
+} from '@civ-clone/core-engine/Engine';
+import {
+  RuleRegistry,
+  instance as ruleRegistryInstance,
+} from '@civ-clone/core-rule/RuleRegistry';
+import {
+  TileImprovementRegistry,
+  instance as tileImprovementRegistryInstance,
+} from '@civ-clone/core-tile-improvement/TileImprovementRegistry';
+import {
+  UnitRegistry,
+  instance as unitRegistryInstance,
+} from '@civ-clone/core-unit/UnitRegistry';
+import City from '@civ-clone/core-city/City';
+import Destroyed from '@civ-clone/core-unit/Rules/Destroyed';
+import Detonated from '@civ-clone/base-unit-action-nuclear-attack/Rules/Detonated';
+import Effect from '@civ-clone/core-rule/Effect';
+import High from '@civ-clone/core-rule/Priorities/High';
+import Low from '@civ-clone/core-rule/Priorities/Low';
+import Priority from '@civ-clone/core-rule/Priority';
+import Tile from '@civ-clone/core-world/Tile';
+import TileImprovement from '@civ-clone/core-tile-improvement/TileImprovement';
+import Unit from '@civ-clone/core-unit/Unit';
+import { instance as rngInstance } from '@civ-clone/core-random';
+
+/**
+ * Where `unit/detonated/halve-cities` runs among the `Detonated` rules: after the `Normal` ones (the units destroyed)
+ * and before `Low` (the fallout), so a rule that takes its place runs there too.
+ */
+export const HALVE_CITIES_PRIORITY = 2500;
+
+/** `city` loses half its size, rounded down, to `unit`'s detonation, so a city is never destroyed by it. */
+export const halveCity = (
+  city: City,
+  unit: Unit,
+  cityGrowthRegistry: CityGrowthRegistry = cityGrowthRegistryInstance
+): void => {
+  const cityGrowth = cityGrowthRegistry.getByCity(city),
+    loss = Math.floor(cityGrowth.size() / 2);
+
+  for (let i = 0; i < loss; i++) {
+    cityGrowth.shrink(unit);
+  }
+};
+
+export interface DetonatedDependencies {
+  cityGrowthRegistry?: CityGrowthRegistry;
+  cityRegistry?: CityRegistry;
+  engine?: Engine;
+  randomNumberGenerator?: () => number;
+  ruleRegistry?: RuleRegistry;
+  tileImprovementRegistry?: TileImprovementRegistry;
+  unitRegistry?: UnitRegistry;
+}
+
+export interface DetonatedOptions {
+  // Whether the units in `city` are spared (Civ1's SDI Defense: the city is still halved and the land falls out).
+  sparesUnits: (city: City) => boolean;
+  // Whether nothing happens at all over `tile` (Civ2's SDI Defense stops the whole attack). Without it, every
+  //  detonation goes off. Asked once per rule, by the destroy, halve and fallout rules; the client is told either way.
+  vetoes?: (unit: Unit, tile: Tile) => boolean;
+  // The fallout a detonation leaves on land.
+  Pollution: new (tile: Tile, ruleRegistry: RuleRegistry) => TileImprovement;
+  // The chance each land square in the area without a city or fallout gets some.
+  falloutChance: number;
+}
+
+/**
+ * A ruleset's `Detonated` rules, with ids `<prefix>:unit/detonated/<name>` as civ1-unit's are, over the square a
+ * nuclear weapon detonates over and the 8 around it: tell the client, destroy every unit (but those `sparesUnits`
+ * keeps), halve every city, and fall out on the land.
+ */
+export const detonatedRules = (
+  prefix: string,
+  {
+    cityGrowthRegistry = cityGrowthRegistryInstance,
+    cityRegistry = cityRegistryInstance,
+    engine = engineInstance,
+    randomNumberGenerator = rngInstance,
+    ruleRegistry = ruleRegistryInstance,
+    tileImprovementRegistry = tileImprovementRegistryInstance,
+    unitRegistry = unitRegistryInstance,
+  }: DetonatedDependencies,
+  { sparesUnits, Pollution, falloutChance, vetoes }: DetonatedOptions
+): Detonated[] => {
+  const id = (name: string): string => `${prefix}:unit/detonated/${name}`,
+    area = (tile: Tile): Tile[] => [tile, ...tile.getNeighbours()],
+    // `vetoes` is asked once per detonation, by `emit` (which runs first, `High`), and the answer is kept for the
+    //  three rules after it, so destroying the units can't change it halfway. Without `vetoes`, nothing is kept or asked.
+    vetoed = new WeakMap<Unit, boolean>(),
+    stopped = (unit: Unit, tile: Tile): boolean =>
+      vetoes !== undefined && (vetoed.get(unit) ?? vetoes(unit, tile));
+
+  return [
+    new Detonated(
+      // Before anything changes, so a client can see what's there to be hit.
+      id('emit'),
+      new High(),
+      new Effect((unit: Unit, tile: Tile): void => {
+        if (vetoes !== undefined) {
+          vetoed.set(unit, vetoes(unit, tile));
+        }
+
+        engine.emit('unit:nuclear-detonation', unit, tile);
+      })
+    ),
+
+    new Detonated(
+      id('destroy-units'),
+      new Effect((unit: Unit, tile: Tile): void =>
+        stopped(unit, tile)
+          ? undefined
+          : area(tile).forEach((areaTile: Tile): void => {
+              const city = cityRegistry.getByTile(areaTile);
+
+              if (city !== null && sparesUnits(city)) {
+                engine.emit('city:sdi-protected', city, unit);
+
+                return;
+              }
+
+              unitRegistry
+                .getByTile(areaTile)
+                .forEach((areaUnit: Unit): void => {
+                  // Cargo is destroyed with its transport, earlier in this loop, if the transport is lost at sea.
+                  if (areaUnit.destroyed()) {
+                    return;
+                  }
+
+                  ruleRegistry.process(Destroyed, areaUnit, unit.player());
+                });
+            })
+      )
+    ),
+
+    new Detonated(
+      id('halve-cities'),
+      new Priority(HALVE_CITIES_PRIORITY),
+      new Effect((unit: Unit, tile: Tile): void =>
+        stopped(unit, tile)
+          ? undefined
+          : area(tile).forEach((areaTile: Tile): void => {
+              const city = cityRegistry.getByTile(areaTile);
+
+              if (city === null) {
+                return;
+              }
+
+              halveCity(city, unit, cityGrowthRegistry);
+            })
+      )
+    ),
+
+    new Detonated(
+      id('fallout'),
+      new Low(),
+      new Effect((unit: Unit, tile: Tile): void =>
+        stopped(unit, tile)
+          ? undefined
+          : area(tile)
+              .filter(
+                (areaTile: Tile): boolean =>
+                  areaTile.isLand() &&
+                  cityRegistry.getByTile(areaTile) === null &&
+                  !tileImprovementRegistry
+                    .getByTile(areaTile)
+                    .some(
+                      (improvement: TileImprovement): boolean =>
+                        improvement instanceof Pollution
+                    )
+              )
+              .forEach((areaTile: Tile): void => {
+                if (randomNumberGenerator() >= falloutChance) {
+                  return;
+                }
+
+                // Building it processes `Built`, which puts it on the tile.
+                new Pollution(areaTile, ruleRegistry);
+              })
+      )
+    ),
+  ];
+};
+
+export default detonatedRules;

package/lib/diplomatRules.d.ts

@@ -0,0 +1,27 @@
+import { Engine } from '@civ-clone/core-engine/Engine';
+import { InteractionRegistry } from '@civ-clone/core-diplomacy/InteractionRegistry';
+import { RuleRegistry } from '@civ-clone/core-rule/RuleRegistry';
+import { Turn } from '@civ-clone/core-turn-based-game/Turn';
+import CityInvestigated from '@civ-clone/base-unit-action-investigate-city/Rules/CityInvestigated';
+import EmbassyEstablished from '@civ-clone/base-unit-action-establish-embassy/Rules/EmbassyEstablished';
+import LeaderMet from '@civ-clone/base-unit-action-meet-with-leader/Rules/LeaderMet';
+export interface DiplomatDependencies {
+  engine?: Engine;
+  interactionRegistry?: InteractionRegistry;
+  ruleRegistry?: RuleRegistry;
+  turn?: Turn;
+}
+/**
+ * A ruleset's rules for the diplomatic missions that need no numbers of its own, with ids `<prefix>:unit/<event>/<name>`
+ * as civ1-unit's are: an embassy is a one-way record for the Diplomat's player; an investigation is the client's to
+ * show; meeting a leader ends the Diplomat's turn and opens talks, which are the client's.
+ */
+export declare const diplomatRules: (
+  prefix: string,
+  { engine, interactionRegistry, ruleRegistry, turn }: DiplomatDependencies
+) => {
+  embassyEstablished: EmbassyEstablished[];
+  cityInvestigated: CityInvestigated[];
+  leaderMet: LeaderMet[];
+};
+export default diplomatRules;

package/lib/diplomatRules.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diplomatRules = void 0;
+const Engine_1 = require("@civ-clone/core-engine/Engine");
+const InteractionRegistry_1 = require("@civ-clone/core-diplomacy/InteractionRegistry");
+const RuleRegistry_1 = require("@civ-clone/core-rule/RuleRegistry");
+const Turn_1 = require("@civ-clone/core-turn-based-game/Turn");
+const CityInvestigated_1 = require("@civ-clone/base-unit-action-investigate-city/Rules/CityInvestigated");
+const Effect_1 = require("@civ-clone/core-rule/Effect");
+const Embassy_1 = require("@civ-clone/base-unit-action-establish-embassy/Embassy");
+const EmbassyEstablished_1 = require("@civ-clone/base-unit-action-establish-embassy/Rules/EmbassyEstablished");
+const LeaderMet_1 = require("@civ-clone/base-unit-action-meet-with-leader/Rules/LeaderMet");
+/**
+ * A ruleset's rules for the diplomatic missions that need no numbers of its own, with ids `<prefix>:unit/<event>/<name>`
+ * as civ1-unit's are: an embassy is a one-way record for the Diplomat's player; an investigation is the client's to
+ * show; meeting a leader ends the Diplomat's turn and opens talks, which are the client's.
+ */
+const diplomatRules = (prefix, { engine = Engine_1.instance, interactionRegistry = InteractionRegistry_1.instance, ruleRegistry = RuleRegistry_1.instance, turn = Turn_1.instance, }) => ({
+    embassyEstablished: [
+        new EmbassyEstablished_1.default(`${prefix}:unit/embassy-established/register`, new Effect_1.default((unit, city) => {
+            interactionRegistry.register(new Embassy_1.default(unit.player(), city.player(), ruleRegistry, turn));
+            engine.emit('player:embassy-established', unit.player(), city.player());
+            return true;
+        })),
+    ],
+    cityInvestigated: [
+        new CityInvestigated_1.default(`${prefix}:unit/city-investigated/emit`, new Effect_1.default((unit, city) => {
+            engine.emit('city:investigated', city, unit.player());
+            return true;
+        })),
+    ],
+    leaderMet: [
+        new LeaderMet_1.default(`${prefix}:unit/leader-met/meet`, new Effect_1.default((unit, player) => {
+            unit.moves().set(0);
+            engine.emit('player:meet-with-leader', unit.player(), player);
+        })),
+    ],
+});
+exports.diplomatRules = diplomatRules;
+exports.default = exports.diplomatRules;
+//# sourceMappingURL=diplomatRules.js.map

package/lib/diplomatRules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"diplomatRules.js","sourceRoot":"","sources":["diplomatRules.ts"],"names":[],"mappings":";;;AAAA,0DAGuC;AACvC,uFAGuD;AACvD,oEAG2C;AAC3C,+DAG8C;AAE9C,0GAAmG;AACnG,wDAAiD;AACjD,mFAA4E;AAC5E,+GAAwG;AACxG,4FAAqF;AAWrF;;;;GAIG;AACI,MAAM,aAAa,GAAG,CAC3B,MAAc,EACd,EACE,MAAM,GAAG,iBAAc,EACvB,mBAAmB,GAAG,8BAA2B,EACjD,YAAY,GAAG,uBAAoB,EACnC,IAAI,GAAG,eAAY,GACE,EACvB,EAAE,CAAC,CAAC;IACJ,kBAAkB,EAAE;QAClB,IAAI,4BAAkB,CACpB,GAAG,MAAM,oCAAoC,EAC7C,IAAI,gBAAM,CAAC,CAAC,IAAU,EAAE,IAAU,EAAW,EAAE;YAC7C,mBAAmB,CAAC,QAAQ,CAC1B,IAAI,iBAAO,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,IAAI,CAAC,MAAM,EAAE,EAAE,YAAY,EAAE,IAAI,CAAU,CACvE,CAAC;YAEF,MAAM,CAAC,IAAI,CAAC,4BAA4B,EAAE,IAAI,CAAC,MAAM,EAAE,EAAE,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;YAExE,OAAO,IAAI,CAAC;QACd,CAAC,CAAC,CACH;KACF;IACD,gBAAgB,EAAE;QAChB,IAAI,0BAAgB,CAClB,GAAG,MAAM,8BAA8B,EACvC,IAAI,gBAAM,CAAC,CAAC,IAAU,EAAE,IAAU,EAAW,EAAE;YAC7C,MAAM,CAAC,IAAI,CAAC,mBAAmB,EAAE,IAAI,EAAE,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;YAEtD,OAAO,IAAI,CAAC;QACd,CAAC,CAAC,CACH;KACF;IACD,SAAS,EAAE;QACT,IAAI,mBAAS,CACX,GAAG,MAAM,uBAAuB,EAChC,IAAI,gBAAM,CAAC,CAAC,IAAU,EAAE,MAAc,EAAQ,EAAE;YAC9C,IAAI,CAAC,KAAK,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;YAEpB,MAAM,CAAC,IAAI,CAAC,yBAAyB,EAAE,IAAI,CAAC,MAAM,EAAE,EAAE,MAAM,CAAC,CAAC;QAChE,CAAC,CAAC,CACH;KACF;CACF,CAAC,CAAC;AA3CU,QAAA,aAAa,iBA2CvB;AAEH,kBAAe,qBAAa,CAAC"}

package/lib/diplomatRules.ts

@@ -0,0 +1,83 @@
+import {
+  Engine,
+  instance as engineInstance,
+} from '@civ-clone/core-engine/Engine';
+import {
+  InteractionRegistry,
+  instance as interactionRegistryInstance,
+} from '@civ-clone/core-diplomacy/InteractionRegistry';
+import {
+  RuleRegistry,
+  instance as ruleRegistryInstance,
+} from '@civ-clone/core-rule/RuleRegistry';
+import {
+  Turn,
+  instance as turnInstance,
+} from '@civ-clone/core-turn-based-game/Turn';
+import City from '@civ-clone/core-city/City';
+import CityInvestigated from '@civ-clone/base-unit-action-investigate-city/Rules/CityInvestigated';
+import Effect from '@civ-clone/core-rule/Effect';
+import Embassy from '@civ-clone/base-unit-action-establish-embassy/Embassy';
+import EmbassyEstablished from '@civ-clone/base-unit-action-establish-embassy/Rules/EmbassyEstablished';
+import LeaderMet from '@civ-clone/base-unit-action-meet-with-leader/Rules/LeaderMet';
+import Player from '@civ-clone/core-player/Player';
+import Unit from '@civ-clone/core-unit/Unit';
+
+export interface DiplomatDependencies {
+  engine?: Engine;
+  interactionRegistry?: InteractionRegistry;
+  ruleRegistry?: RuleRegistry;
+  turn?: Turn;
+}
+
+/**
+ * A ruleset's rules for the diplomatic missions that need no numbers of its own, with ids `<prefix>:unit/<event>/<name>`
+ * as civ1-unit's are: an embassy is a one-way record for the Diplomat's player; an investigation is the client's to
+ * show; meeting a leader ends the Diplomat's turn and opens talks, which are the client's.
+ */
+export const diplomatRules = (
+  prefix: string,
+  {
+    engine = engineInstance,
+    interactionRegistry = interactionRegistryInstance,
+    ruleRegistry = ruleRegistryInstance,
+    turn = turnInstance,
+  }: DiplomatDependencies
+) => ({
+  embassyEstablished: [
+    new EmbassyEstablished(
+      `${prefix}:unit/embassy-established/register`,
+      new Effect((unit: Unit, city: City): boolean => {
+        interactionRegistry.register(
+          new Embassy(unit.player(), city.player(), ruleRegistry, turn) as never
+        );
+
+        engine.emit('player:embassy-established', unit.player(), city.player());
+
+        return true;
+      })
+    ),
+  ],
+  cityInvestigated: [
+    new CityInvestigated(
+      `${prefix}:unit/city-investigated/emit`,
+      new Effect((unit: Unit, city: City): boolean => {
+        engine.emit('city:investigated', city, unit.player());
+
+        return true;
+      })
+    ),
+  ],
+  leaderMet: [
+    new LeaderMet(
+      `${prefix}:unit/leader-met/meet`,
+      new Effect((unit: Unit, player: Player): void => {
+        unit.moves().set(0);
+
+        engine.emit('player:meet-with-leader', unit.player(), player);
+      })
+    ),
+  ],
+});
+
+export default diplomatRules;

package/lib/lifecycleRules.d.ts

@@ -0,0 +1,118 @@
+import { CityRegistry } from '@civ-clone/core-city/CityRegistry';
+import { Engine } from '@civ-clone/core-engine/Engine';
+import { RuleRegistry } from '@civ-clone/core-rule/RuleRegistry';
+import { TransportRegistry } from '@civ-clone/core-unit-transport/TransportRegistry';
+import { UnitImprovementRegistry } from '@civ-clone/core-unit-improvement/UnitImprovementRegistry';
+import { UnitLossRegistry } from '@civ-clone/core-unit/UnitLossRegistry';
+import { UnitPlayerActionType } from './playerAction';
+import { UnitRegistry } from '@civ-clone/core-unit/UnitRegistry';
+import Action from '@civ-clone/core-player/Rules/Action';
+import Activate from '@civ-clone/core-unit/Rules/Activate';
+import CanStow from '@civ-clone/core-unit-transport/Rules/CanStow';
+import Created from '@civ-clone/core-unit/Rules/Created';
+import Defeated from '@civ-clone/core-unit/Rules/Defeated';
+import Destroyed from '@civ-clone/core-unit/Rules/Destroyed';
+import ExpectedMovementCost from '@civ-clone/core-world-path/Rules/ExpectedMovementCost';
+import Halted from '@civ-clone/base-unit-action-goto/Rules/Halted';
+import Impassable from '@civ-clone/core-world-path/Rules/Impassable';
+import LostAtSea from '@civ-clone/core-unit-transport/Rules/LostAtSea';
+import Player from '@civ-clone/core-player/Player';
+import PlayerAction from '@civ-clone/core-player/PlayerAction';
+import Stowed from '@civ-clone/core-unit-transport/Rules/Stowed';
+import Tile from '@civ-clone/core-world/Tile';
+import Transferred from '@civ-clone/core-unit/Rules/Transferred';
+import Unit from '@civ-clone/core-unit/Unit';
+import UnitImprovement from '@civ-clone/core-unit-improvement/UnitImprovement';
+import Unsupported from '@civ-clone/core-unit/Rules/Unsupported';
+import ValidateMove from '@civ-clone/core-unit/Rules/ValidateMove';
+export interface LifecycleDependencies {
+  cityRegistry?: CityRegistry;
+  engine?: Engine;
+  randomNumberGenerator?: () => number;
+  ruleRegistry?: RuleRegistry;
+  transportRegistry?: TransportRegistry;
+  unitImprovementRegistry?: UnitImprovementRegistry;
+  unitLossRegistry?: UnitLossRegistry;
+  unitRegistry?: UnitRegistry;
+}
+export interface LifecycleBaseOptions {
+  ActiveUnit: UnitPlayerActionType<PlayerAction>;
+  InactiveUnit: UnitPlayerActionType<PlayerAction>;
+  removedOnActivate: (typeof UnitImprovement)[];
+  stowable: (typeof Unit)[];
+  partnerOf?: (unit: Unit, tile: Tile) => Player | null;
+}
+/**
+ * How a unit short of a step's moves fares: Civ1's `shortfallFactor` (`spendShort`), or a ruleset's own `shortStep`,
+ *  which then needs no factor.
+ */
+export type LifecycleOptions = LifecycleBaseOptions &
+  (
+    | {
+        shortfallFactor: number;
+        shortStep?: undefined;
+      }
+    | {
+        shortfallFactor?: number;
+        shortStep: ShortStep;
+      }
+  );
+/**
+ * A ruleset's own short step: whether `unit`, with `remaining` of its `movement` moves, gets onto a square costing
+ *  `cost` (one draw of `randomNumberGenerator` at most), and what such a step is worth on average to route planning.
+ *  The unit's moves are spent either way.
+ */
+export interface ShortStep {
+  succeeds: (
+    unit: Unit,
+    remaining: number,
+    movement: number,
+    cost: number,
+    randomNumberGenerator: () => number
+  ) => boolean;
+  expectedCost: (movement: number, cost: number) => number;
+}
+/**
+ * A ruleset's unit lifecycle rules, by the rule type they are, in the order each type's rules run. Their ids are
+ * `<prefix>:unit/<type>/<name>` (`<prefix>:player/action/<name>` for the player actions), as civ1-unit's are, so a
+ * ruleset registers each list where it wants it and keeps the ids another package may name.
+ */
+export declare const lifecycleRules: (
+  prefix: string,
+  {
+    cityRegistry,
+    engine,
+    randomNumberGenerator,
+    ruleRegistry,
+    transportRegistry,
+    unitImprovementRegistry,
+    unitLossRegistry,
+    unitRegistry,
+  }: LifecycleDependencies,
+  {
+    ActiveUnit,
+    InactiveUnit,
+    removedOnActivate,
+    stowable,
+    partnerOf,
+    shortfallFactor,
+    shortStep,
+  }: LifecycleOptions
+) => {
+  activate: Activate[];
+  canStow: CanStow[];
+  created: Created[];
+  defeated: Defeated[];
+  destroyed: Destroyed[];
+  expectedMovementCost: ExpectedMovementCost[];
+  halted: Halted[];
+  impassable: Impassable[];
+  lostAtSea: LostAtSea[];
+  playerAction: Action[];
+  stowed: Stowed[];
+  transferred: Transferred[];
+  unsupported: Unsupported[];
+  validateMove: ValidateMove[];
+};
+export type LifecycleRules = ReturnType<typeof lifecycleRules>;
+export default lifecycleRules;