@civ-clone/base-unit-lifecycle 0.0.0-stage → 0.1.1

package/lib/destroyed.ts

@@ -0,0 +1,106 @@
+import Engine from '@civ-clone/core-engine/Engine';
+import { ITransport } from '@civ-clone/core-unit-transport/Transport';
+import Player from '@civ-clone/core-player/Player';
+import Stowed from '@civ-clone/base-unit-action-embark/Busy/Stowed';
+import TransportManifest from '@civ-clone/core-unit-transport/TransportManifest';
+import TransportRegistry from '@civ-clone/core-unit-transport/TransportRegistry';
+import Unit from '@civ-clone/core-unit/Unit';
+import UnitImprovementRegistry from '@civ-clone/core-unit-improvement/UnitImprovementRegistry';
+import UnitLossRegistry from '@civ-clone/core-unit/UnitLossRegistry';
+import { Water } from '@civ-clone/core-terrain/Types';
+
+// What a ruleset's `Destroyed` rules ask and do when `unit` is destroyed. `player` destroyed it, or is `null` when no
+//  one did (disbanding, founding or joining a city, a spent unit...).
+
+// Emits `unit:destroyed` with the unit and the player who destroyed it.
+export const emitDestroyed =
+  (engine: Engine) =>
+  (unit: Unit, player: Player | null): void => {
+    engine.emit('unit:destroyed', unit, player);
+  };
+
+// Another player destroyed the unit.
+export const destroyedByAnother = (
+  unit: Unit,
+  player: Player | null
+): boolean => player !== null && player !== unit.player();
+
+// The unit isn't marked destroyed yet: a rule that should act once per unit asks it before `deactivate` runs.
+export const notYetDestroyed = (unit: Unit): boolean => !unit.destroyed();
+
+// Records the unit's type as a loss of its player's in `unitLossRegistry`.
+export const countLoss =
+  (unitLossRegistry: UnitLossRegistry) =>
+  (unit: Unit): void => {
+    unitLossRegistry.record(unit.player(), unit.sourceClass() as typeof Unit);
+  };
+
+// Makes the unit inactive and marks it destroyed.
+export const deactivate = (unit: Unit): void => {
+  unit.setActive(false);
+  unit.setDestroyed();
+};
+
+// Removes the unit's improvements (veteran status, fortification...).
+export const removeImprovements =
+  (unitImprovementRegistry: UnitImprovementRegistry) =>
+  (unit: Unit): void =>
+    unitImprovementRegistry
+      .getByUnit(unit)
+      .forEach((unitImprovement) =>
+        unitImprovementRegistry.unregister(unitImprovement)
+      );
+
+// Takes a unit off its transport. Nothing clears `Stowed` on its own (its criterion is `() => false`), so a unit taken
+//  off a transport, destroyed or not, would otherwise stay stowed aboard nothing.
+export const leaveTransport =
+  (transportRegistry: TransportRegistry) =>
+  (manifest: TransportManifest): void => {
+    const cargo = manifest.unit();
+
+    transportRegistry.unregister(manifest);
+
+    if (cargo.busy() instanceof Stowed) {
+      cargo.setBusy();
+    }
+  };
+
+// The unit is a transport with something aboard.
+export const carriesCargo =
+  (transportRegistry: TransportRegistry) =>
+  (unit: Unit): boolean =>
+    transportRegistry.getByTransport(unit as unknown as ITransport).length > 0;
+
+// Takes everything off the transport (`leaveTransport`). At sea (on `Water`) the cargo goes down with it, destroyed by
+//  `player`; in a city it stays in the city.
+export const loseCargo = (transportRegistry: TransportRegistry) => {
+  const leave = leaveTransport(transportRegistry);
+
+  return (unit: Unit, player: Player | null): void =>
+    transportRegistry
+      .getByTransport(unit as unknown as ITransport)
+      // A copy: unregistering changes the list.
+      .slice()
+      .forEach((manifest: TransportManifest): void => {
+        const cargo = manifest.unit();
+
+        leave(manifest);
+
+        if (unit.tile().terrain() instanceof Water && !cargo.destroyed()) {
+          cargo.destroy(player);
+        }
+      });
+};
+
+// The unit is aboard a transport.
+export const isAboard =
+  (transportRegistry: TransportRegistry) =>
+  (unit: Unit): boolean =>
+    transportRegistry.hasUnit(unit);
+
+// Takes the unit off the transport it's aboard (`leaveTransport`).
+export const leaveOwnTransport = (transportRegistry: TransportRegistry) => {
+  const leave = leaveTransport(transportRegistry);
+
+  return (unit: Unit): void => leave(transportRegistry.getByUnit(unit));
+};

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/halted.d.ts

@@ -0,0 +1,6 @@
+import Engine from '@civ-clone/core-engine/Engine';
+import Tile from '@civ-clone/core-world/Tile';
+import Unit from '@civ-clone/core-unit/Unit';
+export declare const emitHalted: (
+  engine: Engine
+) => (unit: Unit, target: Tile) => void;

package/lib/halted.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitHalted = void 0;
+// Emits `unit:halted` with the unit and its destination: a GoTo stopped next to it, for the player to choose what to
+//  do there.
+const emitHalted = (engine) => (unit, target) => {
+    engine.emit('unit:halted', unit, target);
+};
+exports.emitHalted = emitHalted;
+//# sourceMappingURL=halted.js.map

package/lib/halted.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"halted.js","sourceRoot":"","sources":["halted.ts"],"names":[],"mappings":";;;AAIA,qHAAqH;AACrH,aAAa;AACN,MAAM,UAAU,GACrB,CAAC,MAAc,EAAE,EAAE,CACnB,CAAC,IAAU,EAAE,MAAY,EAAQ,EAAE;IACjC,MAAM,CAAC,IAAI,CAAC,aAAa,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;AAC3C,CAAC,CAAC;AAJS,QAAA,UAAU,cAInB"}

package/lib/halted.ts

@@ -0,0 +1,11 @@
+import Engine from '@civ-clone/core-engine/Engine';
+import Tile from '@civ-clone/core-world/Tile';
+import Unit from '@civ-clone/core-unit/Unit';
+
+// Emits `unit:halted` with the unit and its destination: a GoTo stopped next to it, for the player to choose what to
+//  do there.
+export const emitHalted =
+  (engine: Engine) =>
+  (unit: Unit, target: Tile): void => {
+    engine.emit('unit:halted', unit, target);
+  };

package/lib/impassable.d.ts

@@ -0,0 +1,8 @@
+import { PartnerOf } from '@civ-clone/base-unit-action-rules/lib/criteria/partners';
+import Tile from '@civ-clone/core-world/Tile';
+import Unit from '@civ-clone/core-unit/Unit';
+export declare const fromLand: (unit: Unit, to: Tile, from: Tile) => boolean;
+export declare const toPartnersLand: (
+  partnerOf: PartnerOf
+) => (unit: Unit, to: Tile) => boolean;
+export declare const impassable: () => boolean;