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

package/README.md

@@ -20,7 +20,7 @@ registry, the engine or a number take it first and return the function.
 - `lib/halted`: `emitHalted(engine)` (`unit:halted`), a GoTo stopped next to its destination.
 - `lib/unsupported`: `emitUnsupported(engine)` (`unit:unsupported`).
 - `lib/defeated`: `emitAndDestroy(engine, ruleRegistry)` (`unit:defeated`, then `Destroyed`), and for a defeated
-  defender's stack, `defended`, `notInCity(cityRegistry)`, `hasStack(unitRegistry)` and
+  defender's stack, `defended`, `notInCity(cityRegistry)`, `notSpared(sparesStack)`, `hasStack(unitRegistry)` and
   `destroyStack(unitRegistry, ruleRegistry)`.
 - `lib/destroyed`: `emitDestroyed(engine)` (`unit:destroyed`); `destroyedByAnother`, `notYetDestroyed` and
   `countLoss(unitLossRegistry)` for a loss report; `deactivate`; `removeImprovements(unitImprovementRegistry)`;
@@ -32,5 +32,33 @@ 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`, `vetoes` and `sparesStack` are for other rulesets (Civ2's
+  short step, SDI Defense, and the squares besides a city where a stack outlives its defender), and leaving them out
+  changes nothing: `lifecycleRules`' `destroy-stack` rule only gains its `notSpared` criterion when `sparesStack` is
+  given.
+
 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/defeated.d.ts

@@ -2,6 +2,7 @@ import Action from '@civ-clone/core-unit/Action';
 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 Tile from '@civ-clone/core-world/Tile';
 import Unit from '@civ-clone/core-unit/Unit';
 import UnitRegistry from '@civ-clone/core-unit/UnitRegistry';
 export declare const emitAndDestroy: (
@@ -16,6 +17,10 @@ export declare const defended: (
 export declare const notInCity: (
   cityRegistry: CityRegistry
 ) => (unit: Unit) => boolean;
+export type SparesStack = (tile: Tile, defender: Unit) => boolean;
+export declare const notSpared: (
+  sparesStack: SparesStack
+) => (unit: Unit) => boolean;
 export declare const hasStack: (
   unitRegistry: UnitRegistry
 ) => (unit: Unit) => boolean;

package/lib/defeated.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.destroyStack = exports.hasStack = exports.notInCity = exports.defended = exports.emitAndDestroy = void 0;
+exports.destroyStack = exports.hasStack = exports.notSpared = exports.notInCity = exports.defended = exports.emitAndDestroy = void 0;
 const Destroyed_1 = require("@civ-clone/core-unit/Rules/Destroyed");
 // What a ruleset's `Defeated` rules ask and do when `unit` loses a fight to `by`. `action`, when given, is the attack:
 //  `action.unit()` attacked.
@@ -17,6 +17,9 @@ exports.defended = defended;
 // The defeated unit is not in a city.
 const notInCity = (cityRegistry) => (unit) => cityRegistry.getByTile(unit.tile()) === null;
 exports.notInCity = notInCity;
+// The square the defeated unit lost on doesn't keep its stack.
+const notSpared = (sparesStack) => (unit) => !sparesStack(unit.tile(), unit);
+exports.notSpared = notSpared;
 // Other units of the defeated unit's player share its tile.
 const hasStack = (unitRegistry) => (unit) => unitRegistry
     .getByTile(unit.tile())

package/lib/defeated.js.map

@@ -1 +1 @@
-{"version":3,"file":"defeated.js","sourceRoot":"","sources":["defeated.ts"],"names":[],"mappings":";;;AAEA,oEAA6D;AAM7D,uHAAuH;AACvH,6BAA6B;AAE7B,oHAAoH;AACpH,wBAAwB;AACjB,MAAM,cAAc,GACzB,CAAC,MAAc,EAAE,YAA0B,EAAE,EAAE,CAC/C,CAAC,IAAU,EAAE,EAAQ,EAAE,MAAe,EAAQ,EAAE;IAC9C,MAAM,CAAC,IAAI,CAAC,eAAe,EAAE,IAAI,EAAE,EAAE,EAAE,MAAM,CAAC,CAAC;IAE/C,YAAY,CAAC,OAAO,CAAC,mBAAS,EAAE,IAAI,EAAE,EAAE,CAAC,MAAM,EAAE,CAAC,CAAC;AACrD,CAAC,CAAC;AANS,QAAA,cAAc,kBAMvB;AAEJ,uFAAuF;AAChF,MAAM,QAAQ,GAAG,CAAC,IAAU,EAAE,EAAQ,EAAE,MAAe,EAAW,EAAE,CACzE,CAAC,MAAM,IAAI,MAAM,CAAC,IAAI,EAAE,KAAK,IAAI,CAAC;AADvB,QAAA,QAAQ,YACe;AAEpC,sCAAsC;AAC/B,MAAM,SAAS,GACpB,CAAC,YAA0B,EAAE,EAAE,CAC/B,CAAC,IAAU,EAAW,EAAE,CACtB,YAAY,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI,CAAC;AAHpC,QAAA,SAAS,aAG2B;AAEjD,4DAA4D;AACrD,MAAM,QAAQ,GACnB,CAAC,YAA0B,EAAE,EAAE,CAC/B,CAAC,IAAU,EAAW,EAAE,CACtB,YAAY;KACT,SAAS,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;KACtB,MAAM,CACL,CAAC,QAAc,EAAE,EAAE,CACjB,QAAQ,KAAK,IAAI,IAAI,QAAQ,CAAC,MAAM,EAAE,KAAK,IAAI,CAAC,MAAM,EAAE,CAC3D,CAAC,MAAM,GAAG,CAAC,CAAC;AARN,QAAA,QAAQ,YAQF;AAEnB,sHAAsH;AAC/G,MAAM,YAAY,GACvB,CAAC,YAA0B,EAAE,YAA0B,EAAE,EAAE,CAC3D,CAAC,IAAU,EAAE,EAAQ,EAAQ,EAAE,CAC7B,YAAY;KACT,SAAS,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;KACtB,MAAM,CACL,CAAC,QAAc,EAAW,EAAE,CAC1B,QAAQ,KAAK,IAAI,IAAI,QAAQ,CAAC,MAAM,EAAE,KAAK,IAAI,CAAC,MAAM,EAAE,CAC3D;KACA,OAAO,CAAC,CAAC,QAAc,EAAQ,EAAE;IAChC,YAAY,CAAC,OAAO,CAAC,mBAAS,EAAE,QAAQ,EAAE,EAAE,CAAC,MAAM,EAAE,CAAC,CAAC;AACzD,CAAC,CAAC,CAAC;AAXI,QAAA,YAAY,gBAWhB"}
+{"version":3,"file":"defeated.js","sourceRoot":"","sources":["defeated.ts"],"names":[],"mappings":";;;AAEA,oEAA6D;AAO7D,uHAAuH;AACvH,6BAA6B;AAE7B,oHAAoH;AACpH,wBAAwB;AACjB,MAAM,cAAc,GACzB,CAAC,MAAc,EAAE,YAA0B,EAAE,EAAE,CAC/C,CAAC,IAAU,EAAE,EAAQ,EAAE,MAAe,EAAQ,EAAE;IAC9C,MAAM,CAAC,IAAI,CAAC,eAAe,EAAE,IAAI,EAAE,EAAE,EAAE,MAAM,CAAC,CAAC;IAE/C,YAAY,CAAC,OAAO,CAAC,mBAAS,EAAE,IAAI,EAAE,EAAE,CAAC,MAAM,EAAE,CAAC,CAAC;AACrD,CAAC,CAAC;AANS,QAAA,cAAc,kBAMvB;AAEJ,uFAAuF;AAChF,MAAM,QAAQ,GAAG,CAAC,IAAU,EAAE,EAAQ,EAAE,MAAe,EAAW,EAAE,CACzE,CAAC,MAAM,IAAI,MAAM,CAAC,IAAI,EAAE,KAAK,IAAI,CAAC;AADvB,QAAA,QAAQ,YACe;AAEpC,sCAAsC;AAC/B,MAAM,SAAS,GACpB,CAAC,YAA0B,EAAE,EAAE,CAC/B,CAAC,IAAU,EAAW,EAAE,CACtB,YAAY,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI,CAAC;AAHpC,QAAA,SAAS,aAG2B;AAMjD,+DAA+D;AACxD,MAAM,SAAS,GACpB,CAAC,WAAwB,EAAE,EAAE,CAC7B,CAAC,IAAU,EAAW,EAAE,CACtB,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,IAAI,CAAC,CAAC;AAHvB,QAAA,SAAS,aAGc;AAEpC,4DAA4D;AACrD,MAAM,QAAQ,GACnB,CAAC,YAA0B,EAAE,EAAE,CAC/B,CAAC,IAAU,EAAW,EAAE,CACtB,YAAY;KACT,SAAS,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;KACtB,MAAM,CACL,CAAC,QAAc,EAAE,EAAE,CACjB,QAAQ,KAAK,IAAI,IAAI,QAAQ,CAAC,MAAM,EAAE,KAAK,IAAI,CAAC,MAAM,EAAE,CAC3D,CAAC,MAAM,GAAG,CAAC,CAAC;AARN,QAAA,QAAQ,YAQF;AAEnB,sHAAsH;AAC/G,MAAM,YAAY,GACvB,CAAC,YAA0B,EAAE,YAA0B,EAAE,EAAE,CAC3D,CAAC,IAAU,EAAE,EAAQ,EAAQ,EAAE,CAC7B,YAAY;KACT,SAAS,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;KACtB,MAAM,CACL,CAAC,QAAc,EAAW,EAAE,CAC1B,QAAQ,KAAK,IAAI,IAAI,QAAQ,CAAC,MAAM,EAAE,KAAK,IAAI,CAAC,MAAM,EAAE,CAC3D;KACA,OAAO,CAAC,CAAC,QAAc,EAAQ,EAAE;IAChC,YAAY,CAAC,OAAO,CAAC,mBAAS,EAAE,QAAQ,EAAE,EAAE,CAAC,MAAM,EAAE,CAAC,CAAC;AACzD,CAAC,CAAC,CAAC;AAXI,QAAA,YAAY,gBAWhB"}

package/lib/defeated.ts

@@ -3,6 +3,7 @@ import CityRegistry from '@civ-clone/core-city/CityRegistry';
 import Destroyed from '@civ-clone/core-unit/Rules/Destroyed';
 import Engine from '@civ-clone/core-engine/Engine';
 import RuleRegistry from '@civ-clone/core-rule/RuleRegistry';
+import Tile from '@civ-clone/core-world/Tile';
 import Unit from '@civ-clone/core-unit/Unit';
 import UnitRegistry from '@civ-clone/core-unit/UnitRegistry';
 
@@ -29,6 +30,16 @@ export const notInCity =
   (unit: Unit): boolean =>
     cityRegistry.getByTile(unit.tile()) === null;
 
+// Whether the square `defender` lost on keeps the units sharing it: a ruleset's own places (a fortress, say) where only
+//  the defender is lost.
+export type SparesStack = (tile: Tile, defender: Unit) => boolean;
+
+// The square the defeated unit lost on doesn't keep its stack.
+export const notSpared =
+  (sparesStack: SparesStack) =>
+  (unit: Unit): boolean =>
+    !sparesStack(unit.tile(), unit);
+
 // Other units of the defeated unit's player share its tile.
 export const hasStack =
   (unitRegistry: UnitRegistry) =>

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;