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

package/lib/movedRules.ts

@@ -0,0 +1,300 @@
+import {
+  CityRegistry,
+  instance as cityRegistryInstance,
+} from '@civ-clone/core-city/CityRegistry';
+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 {
+  TransportRegistry,
+  instance as transportRegistryInstance,
+} from '@civ-clone/core-unit-transport/TransportRegistry';
+import {
+  UnitRegistry,
+  instance as unitRegistryInstance,
+} from '@civ-clone/core-unit/UnitRegistry';
+import { Peace, Vendetta } from '@civ-clone/library-diplomacy/Declarations';
+import Action from '@civ-clone/core-unit/Action';
+import Air from '@civ-clone/base-unit-type-air/Air';
+import AttackEndsTurn from '@civ-clone/base-unit-trait-attack-ends-turn/AttackEndsTurn';
+import CoastBound from '@civ-clone/base-unit-trait-coast-bound/CoastBound';
+import Criterion from '@civ-clone/core-rule/Criterion';
+import Effect from '@civ-clone/core-rule/Effect';
+import High from '@civ-clone/core-rule/Priorities/High';
+import { ITransport } from '@civ-clone/core-unit-transport/Transport';
+import LostAtSea from '@civ-clone/core-unit-transport/Rules/LostAtSea';
+import Moved from '@civ-clone/core-unit/Rules/Moved';
+import NavalTransport from '@civ-clone/base-unit-type-naval-transport/NavalTransport';
+import Never from '@civ-clone/core-diplomacy/Expiries/Never';
+import Player from '@civ-clone/core-player/Player';
+import Sleeping from '@civ-clone/base-unit-action-sleep/Rules/Sleeping';
+import Stowed from '@civ-clone/base-unit-action-embark/Busy/Stowed';
+import Tile from '@civ-clone/core-world/Tile';
+import Unit from '@civ-clone/core-unit/Unit';
+import { hasVendetta } from '@civ-clone/library-diplomacy/lib/holds';
+import { instance as rngInstance } from '@civ-clone/core-random';
+
+type ActionType = abstract new (...args: any[]) => Action;
+
+export interface MovedDependencies {
+  cityRegistry?: CityRegistry;
+  engine?: Engine;
+  interactionRegistry?: InteractionRegistry;
+  randomNumberGenerator?: () => number;
+  ruleRegistry?: RuleRegistry;
+  transportRegistry?: TransportRegistry;
+  unitRegistry?: UnitRegistry;
+}
+
+export interface MovedOptions {
+  // The ruleset's own action classes: a plain move, leaving a transport, and the attacks.
+  Move: ActionType;
+  Disembark: ActionType;
+  attacks: ActionType[];
+  // Actions with an enemy that end a peace treaty without a grudge (walking onto, or pillaging, the partner's land).
+  noVendetta: ActionType[];
+  // The chance a `CoastBound` unit that ends its move out of sight of land is lost.
+  coastBoundLoss: number;
+}
+
+/**
+ * A ruleset's `Moved` rules, in order, with ids `<prefix>:unit/moved/<name>` as civ1-unit's are: telling the client,
+ * vision, ending a unit's moves, transports carrying and collecting their cargo, leaving a transport, a `CoastBound`
+ * unit lost at sea, an `AttackEndsTurn` unit's turn ending, and a broken peace treaty.
+ */
+export const movedRules = (
+  prefix: string,
+  {
+    cityRegistry = cityRegistryInstance,
+    engine = engineInstance,
+    interactionRegistry = interactionRegistryInstance,
+    randomNumberGenerator = rngInstance,
+    ruleRegistry = ruleRegistryInstance,
+    transportRegistry = transportRegistryInstance,
+    unitRegistry = unitRegistryInstance,
+  }: MovedDependencies,
+  { Move, Disembark, attacks, noVendetta, coastBoundLoss }: MovedOptions
+): Moved[] => {
+  const id = (name: string): string => `${prefix}:unit/moved/${name}`,
+    // Stows each of `units` aboard `transport`, as `Embark` and `LandAircraft` do, until it is full.
+    collect = (transport: NavalTransport, units: Unit[]): void =>
+      units.forEach((unit: Unit): void => {
+        if (!transport.hasCapacity() || !transport.canStow(unit)) {
+          return;
+        }
+
+        transport.stow(unit, unit.tile());
+
+        unit.setBusy(new Stowed());
+      }),
+    // The transport's own units on the tile it has just moved onto, that aren't already aboard something.
+    unitsToCollect = (transport: Unit, tile: Tile = transport.tile()): Unit[] =>
+      unitRegistry
+        .getByTile(tile)
+        .filter(
+          (unit: Unit): boolean =>
+            unit !== transport &&
+            unit.player() === transport.player() &&
+            !transportRegistry.hasUnit(unit)
+        ),
+    // A transport's own move that took it onto a new tile (not one it was carried along on, and not an attack).
+    transportMoved = [
+      new Criterion((unit: Unit): boolean => unit instanceof NavalTransport),
+      new Criterion(
+        (unit: Unit, action: Action): boolean => action instanceof Move
+      ),
+      new Criterion(
+        (unit: Unit, action: Action): boolean => action.to() === unit.tile()
+      ),
+    ],
+    isOwnCity = (unit: Unit): boolean =>
+      cityRegistry.getByTile(unit.tile())?.player() === unit.player();
+
+  return [
+    new Moved(
+      id('emit'),
+      new Effect((unit: Unit, action: Action): void => {
+        engine.emit('unit:moved', unit, action);
+      })
+    ),
+    new Moved(
+      id('apply-visibility'),
+      new Effect((unit: Unit): void => unit.applyVisibility())
+    ),
+    new Moved(
+      id('end-moves-when-exhausted'),
+      new Criterion((unit: Unit): boolean => unit.moves().value() < 0.3),
+      new Effect((unit: Unit): void => {
+        unit.moves().set(0);
+        unit.setActive(false);
+      })
+    ),
+    new Moved(
+      // A transport leaving one of its player's cities takes only the units sentried aboard (`Stowed` or `Sleeping`);
+      //  at sea, all of its cargo goes with it, and so does an aircraft aboard, awake or not.
+      id('move-cargo'),
+      new Criterion((unit: Unit): boolean => unit instanceof NavalTransport),
+      new Criterion(
+        (unit: Unit, action: Action): boolean => action instanceof Move
+      ),
+      new Criterion((unit: Unit): boolean =>
+        (unit as NavalTransport).hasCargo()
+      ),
+      new Effect((unit: Unit, action: Action): void => {
+        const transport = unit as NavalTransport,
+          leftPort =
+            cityRegistry.getByTile(action.from())?.player() === unit.player();
+
+        transport.cargo().forEach((cargo: Unit): void => {
+          if (
+            leftPort &&
+            !(cargo instanceof Air) &&
+            !(cargo.busy() instanceof Stowed) &&
+            !(cargo.busy() instanceof Sleeping)
+          ) {
+            transport.unload(cargo);
+
+            return;
+          }
+
+          cargo.action(action.forUnit(cargo));
+        });
+      })
+    ),
+    // These two come after `move-cargo`, so a unit collected here isn't also sent along the move just made.
+    new Moved(
+      // A carrier that moves onto its player's aircraft outside a city picks them up.
+      id('collect-aircraft'),
+      ...transportMoved,
+      new Criterion((unit: Unit): boolean => !isOwnCity(unit)),
+      new Effect((unit: Unit): void =>
+        collect(
+          unit as NavalTransport,
+          unitsToCollect(unit).filter(
+            (tileUnit: Unit): boolean => tileUnit instanceof Air
+          )
+        )
+      )
+    ),
+    new Moved(
+      // A transport that moves into one of its player's cities picks up the units sleeping there.
+      id('collect-sleeping'),
+      ...transportMoved,
+      new Criterion((unit: Unit): boolean => isOwnCity(unit)),
+      new Effect((unit: Unit): void =>
+        collect(
+          unit as NavalTransport,
+          unitsToCollect(unit).filter(
+            (tileUnit: Unit): boolean => tileUnit.busy() instanceof Sleeping
+          )
+        )
+      )
+    ),
+    new Moved(
+      id('disembark'),
+      new Criterion(
+        (unit: Unit, action: Action): boolean => action instanceof Disembark
+      ),
+      new Effect((unit: Unit): void => {
+        const manifest = transportRegistry.getByUnit(unit);
+
+        manifest.transport().unload(unit);
+
+        transportRegistry.unregister(manifest);
+      })
+    ),
+    new Moved(
+      // A unit that leaves its transport's tile with a plain move (an aircraft taking off, a unit walking off a ship in
+      //  a city) is no longer aboard. A `Disembark` is a move too, which `disembark` unloads.
+      id('take-off'),
+      new Criterion(
+        (unit: Unit, action: Action): boolean => action instanceof Move
+      ),
+      new Criterion(
+        (unit: Unit, action: Action): boolean => !(action instanceof Disembark)
+      ),
+      new Criterion((unit: Unit): boolean => transportRegistry.hasUnit(unit)),
+      new Criterion(
+        (unit: Unit): boolean =>
+          transportRegistry.getByUnit(unit).transport().tile() !== unit.tile()
+      ),
+      new Effect((unit: Unit): void => {
+        transportRegistry.getByUnit(unit).transport().unload(unit);
+
+        if (unit.busy() instanceof Stowed) {
+          unit.setBusy();
+        }
+      })
+    ),
+    new Moved(
+      id('trireme-lost-at-sea'),
+      new Criterion((unit: Unit): boolean => unit.hasTrait(CoastBound)),
+      new Criterion((unit: Unit): boolean => unit.moves().value() === 0),
+      new Criterion((unit: Unit): boolean => !unit.tile().isCoast()),
+      new Criterion((): boolean => randomNumberGenerator() <= coastBoundLoss),
+      new Effect((unit: Unit): void => {
+        ruleRegistry.process(LostAtSea, unit as unknown as ITransport);
+      })
+    ),
+    new Moved(
+      // A unit that `AttackEndsTurn` can't attack again until next turn.
+      id('bomber/end-turn-after-attack'),
+      new High(),
+      new Criterion((unit: Unit): boolean => unit.hasTrait(AttackEndsTurn)),
+      new Criterion((unit: Unit, action: Action): boolean =>
+        attacks.some(
+          (AttackType: ActionType): boolean => action instanceof AttackType
+        )
+      ),
+      new Effect((unit: Unit): void => {
+        unit.moves().set(0);
+        unit.setActive(false);
+      })
+    ),
+    new Moved(
+      id('break-peace-treaty'),
+      // Any action with an enemy: a sneak attack or capture, or a covert action at peace.
+      new Criterion(
+        (unit: Unit, action: Action) =>
+          typeof (action as unknown as { enemy?: unknown }).enemy === 'function'
+      ),
+      new Effect((unit: Unit, action: Action) => {
+        const enemy = (action as unknown as { enemy(): Player }).enemy(),
+          peaceTreaties = interactionRegistry
+            .getByPlayers(unit.player(), enemy)
+            .filter(
+              (interaction): interaction is Peace =>
+                interaction instanceof Peace && interaction.active()
+            );
+
+        peaceTreaties.forEach((peaceTreaty) =>
+          peaceTreaty.expire(unit.player())
+        );
+
+        // The victim of an attack in peacetime holds a grudge; walking onto or pillaging its land only ends the treaty.
+        if (
+          peaceTreaties.length > 0 &&
+          !noVendetta.some(
+            (ActionType: ActionType): boolean => action instanceof ActionType
+          ) &&
+          !hasVendetta(enemy, unit.player(), interactionRegistry)
+        ) {
+          interactionRegistry.register(
+            new Vendetta(enemy, unit.player(), new Never(), ruleRegistry)
+          );
+        }
+      })
+    ),
+  ];
+};
+
+export default movedRules;

package/lib/playerAction.d.ts

@@ -0,0 +1,22 @@
+import Player from '@civ-clone/core-player/Player';
+import PlayerAction from '@civ-clone/core-player/PlayerAction';
+import Unit from '@civ-clone/core-unit/Unit';
+import UnitRegistry from '@civ-clone/core-unit/UnitRegistry';
+export type UnitPlayerActionType<T extends PlayerAction> = new (
+  player: Player,
+  unit: Unit
+) => T;
+export declare const hasActiveUnits: (
+  unitRegistry: UnitRegistry
+) => (player: Player) => boolean;
+export declare const activeUnits: <T extends PlayerAction<any>>(
+  unitRegistry: UnitRegistry,
+  PlayerActionType: UnitPlayerActionType<T>
+) => (player: Player) => T[];
+export declare const hasInactiveUnits: (
+  unitRegistry: UnitRegistry
+) => (player: Player) => boolean;
+export declare const inactiveUnits: <T extends PlayerAction<any>>(
+  unitRegistry: UnitRegistry,
+  PlayerActionType: UnitPlayerActionType<T>
+) => (player: Player) => T[];

package/lib/playerAction.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inactiveUnits = exports.hasInactiveUnits = exports.activeUnits = exports.hasActiveUnits = void 0;
+// The player has an active unit with moves left.
+const hasActiveUnits = (unitRegistry) => (player) => unitRegistry
+    .getByPlayer(player)
+    .some((unit) => unit.active() && unit.moves().value());
+exports.hasActiveUnits = hasActiveUnits;
+// The player's active units with moves left, as `PlayerActionType`s.
+const activeUnits = (unitRegistry, PlayerActionType) => (player) => unitRegistry
+    .getByPlayer(player)
+    .filter((unit) => unit.active() && unit.moves().value() > 0)
+    .sort((a, b) => (a.waiting() ? 1 : 0) - (b.waiting() ? 1 : 0))
+    .map((unit) => new PlayerActionType(player, unit));
+exports.activeUnits = activeUnits;
+// The player has a unit that is inactive or has no moves left.
+const hasInactiveUnits = (unitRegistry) => (player) => unitRegistry
+    .getByPlayer(player)
+    .some((unit) => !unit.active() || !unit.moves().value());
+exports.hasInactiveUnits = hasInactiveUnits;
+// The player's units that are inactive or have no moves left, as `PlayerActionType`s.
+const inactiveUnits = (unitRegistry, PlayerActionType) => (player) => unitRegistry
+    .getByPlayer(player)
+    .filter((unit) => !unit.active() || unit.moves().value() === 0)
+    .sort((a, b) => (a.waiting() ? 1 : 0) - (b.waiting() ? 1 : 0))
+    .map((unit) => new PlayerActionType(player, unit));
+exports.inactiveUnits = inactiveUnits;
+//# sourceMappingURL=playerAction.js.map

package/lib/playerAction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"playerAction.js","sourceRoot":"","sources":["playerAction.ts"],"names":[],"mappings":";;;AAeA,iDAAiD;AAC1C,MAAM,cAAc,GACzB,CAAC,YAA0B,EAAE,EAAE,CAC/B,CAAC,MAAc,EAAW,EAAE,CAC1B,YAAY;KACT,WAAW,CAAC,MAAM,CAAC;KACnB,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,CAAC,CAAC;AALhD,QAAA,cAAc,kBAKkC;AAE7D,qEAAqE;AAC9D,MAAM,WAAW,GACtB,CACE,YAA0B,EAC1B,gBAAyC,EACzC,EAAE,CACJ,CAAC,MAAc,EAAO,EAAE,CACtB,YAAY;KACT,WAAW,CAAC,MAAM,CAAC;KACnB,MAAM,CACL,CAAC,IAAU,EAAW,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,GAAG,CAAC,CACnE;KACA,IAAI,CACH,CAAC,CAAO,EAAE,CAAO,EAAU,EAAE,CAC3B,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAChD;KACA,GAAG,CAAC,CAAC,IAAU,EAAK,EAAE,CAAC,IAAI,gBAAgB,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC;AAfrD,QAAA,WAAW,eAe0C;AAElE,+DAA+D;AACxD,MAAM,gBAAgB,GAC3B,CAAC,YAA0B,EAAE,EAAE,CAC/B,CAAC,MAAc,EAAW,EAAE,CAC1B,YAAY;KACT,WAAW,CAAC,MAAM,CAAC;KACnB,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,CAAC,CAAC;AALlD,QAAA,gBAAgB,oBAKkC;AAE/D,sFAAsF;AAC/E,MAAM,aAAa,GACxB,CACE,YAA0B,EAC1B,gBAAyC,EACzC,EAAE,CACJ,CAAC,MAAc,EAAO,EAAE,CACtB,YAAY;KACT,WAAW,CAAC,MAAM,CAAC;KACnB,MAAM,CAAC,CAAC,IAAU,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;KACpE,IAAI,CACH,CAAC,CAAO,EAAE,CAAO,EAAU,EAAE,CAC3B,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAChD;KACA,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,gBAAgB,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC;AAb5C,QAAA,aAAa,iBAa+B"}

package/lib/playerAction.ts

@@ -0,0 +1,64 @@
+import Player from '@civ-clone/core-player/Player';
+import PlayerAction from '@civ-clone/core-player/PlayerAction';
+import Unit from '@civ-clone/core-unit/Unit';
+import UnitRegistry from '@civ-clone/core-unit/UnitRegistry';
+
+// What a ruleset's player `Action` rules ask and offer: the player's units that can take orders this turn, and those
+//  that can't. Each list puts waiting units last and otherwise keeps the registry's order. `PlayerActionType` is the
+//  player action each unit is offered as (an active unit, an inactive one).
+
+// The constructor of a player action for one unit.
+export type UnitPlayerActionType<T extends PlayerAction> = new (
+  player: Player,
+  unit: Unit
+) => T;
+
+// The player has an active unit with moves left.
+export const hasActiveUnits =
+  (unitRegistry: UnitRegistry) =>
+  (player: Player): boolean =>
+    unitRegistry
+      .getByPlayer(player)
+      .some((unit) => unit.active() && unit.moves().value());
+
+// The player's active units with moves left, as `PlayerActionType`s.
+export const activeUnits =
+  <T extends PlayerAction>(
+    unitRegistry: UnitRegistry,
+    PlayerActionType: UnitPlayerActionType<T>
+  ) =>
+  (player: Player): T[] =>
+    unitRegistry
+      .getByPlayer(player)
+      .filter(
+        (unit: Unit): boolean => unit.active() && unit.moves().value() > 0
+      )
+      .sort(
+        (a: Unit, b: Unit): number =>
+          (a.waiting() ? 1 : 0) - (b.waiting() ? 1 : 0)
+      )
+      .map((unit: Unit): T => new PlayerActionType(player, unit));
+
+// The player has a unit that is inactive or has no moves left.
+export const hasInactiveUnits =
+  (unitRegistry: UnitRegistry) =>
+  (player: Player): boolean =>
+    unitRegistry
+      .getByPlayer(player)
+      .some((unit) => !unit.active() || !unit.moves().value());
+
+// The player's units that are inactive or have no moves left, as `PlayerActionType`s.
+export const inactiveUnits =
+  <T extends PlayerAction>(
+    unitRegistry: UnitRegistry,
+    PlayerActionType: UnitPlayerActionType<T>
+  ) =>
+  (player: Player): T[] =>
+    unitRegistry
+      .getByPlayer(player)
+      .filter((unit: Unit) => !unit.active() || unit.moves().value() === 0)
+      .sort(
+        (a: Unit, b: Unit): number =>
+          (a.waiting() ? 1 : 0) - (b.waiting() ? 1 : 0)
+      )
+      .map((unit) => new PlayerActionType(player, unit));

package/lib/stowed.d.ts

@@ -0,0 +1,2 @@
+import Unit from '@civ-clone/core-unit/Unit';
+export declare const sleepAboard: (unit: Unit) => void;

package/lib/stowed.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sleepAboard = void 0;
+const Sleep_1 = require("@civ-clone/base-unit-action-sleep/Sleep");
+// A unit that has just boarded a transport sleeps aboard it. Returns what `unit.action` returns.
+const sleepAboard = (unit) => unit.action(new Sleep_1.default(unit.tile(), unit.tile(), unit));
+exports.sleepAboard = sleepAboard;
+//# sourceMappingURL=stowed.js.map

package/lib/stowed.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stowed.js","sourceRoot":"","sources":["stowed.ts"],"names":[],"mappings":";;;AAAA,mEAA4D;AAG5D,iGAAiG;AAC1F,MAAM,WAAW,GAAG,CAAC,IAAU,EAAE,EAAE,CACxC,IAAI,CAAC,MAAM,CAAC,IAAI,eAAK,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,IAAI,CAAC,IAAI,EAAE,EAAE,IAAI,CAAC,CAAC,CAAC;AAD5C,QAAA,WAAW,eACiC"}

package/lib/stowed.ts

@@ -0,0 +1,6 @@
+import Sleep from '@civ-clone/base-unit-action-sleep/Sleep';
+import Unit from '@civ-clone/core-unit/Unit';
+
+// A unit that has just boarded a transport sleeps aboard it. Returns what `unit.action` returns.
+export const sleepAboard = (unit: Unit) =>
+  unit.action(new Sleep(unit.tile(), unit.tile(), unit));

package/lib/treatyPartner.d.ts

@@ -0,0 +1,26 @@
+import { InteractionRegistry } from '@civ-clone/core-diplomacy/InteractionRegistry';
+import { TileImprovementRegistry } from '@civ-clone/core-tile-improvement/TileImprovementRegistry';
+import { WorkedTileRegistry } from '@civ-clone/core-city/WorkedTileRegistry';
+import Player from '@civ-clone/core-player/Player';
+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';
+export interface TreatyPartnerDependencies {
+  interactionRegistry?: InteractionRegistry;
+  tileImprovementRegistry?: TileImprovementRegistry;
+  workedTileRegistry?: WorkedTileRegistry;
+}
+/**
+ * Whose land a tile is, among a unit's treaty partners, or `null`: a tile that one of the partner's cities is working
+ * and that has one of `improvements` on it, for a land unit that isn't a `NonCombatant`. Moving onto or pillaging such
+ * a tile breaks the treaty. A tile counts as land while it's worked (Civ1's territory model, simplified).
+ */
+export declare const treatyPartner: (
+  improvements: (typeof TileImprovement)[],
+  {
+    interactionRegistry,
+    tileImprovementRegistry,
+    workedTileRegistry,
+  }?: TreatyPartnerDependencies
+) => (unit: Unit, tile: Tile) => Player | null;
+export default treatyPartner;

package/lib/treatyPartner.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.treatyPartner = void 0;
+const InteractionRegistry_1 = require("@civ-clone/core-diplomacy/InteractionRegistry");
+const TileImprovementRegistry_1 = require("@civ-clone/core-tile-improvement/TileImprovementRegistry");
+const WorkedTileRegistry_1 = require("@civ-clone/core-city/WorkedTileRegistry");
+const Land_1 = require("@civ-clone/base-unit-type-land/Land");
+const NonCombatant_1 = require("@civ-clone/base-unit-trait-non-combatant/NonCombatant");
+const Declarations_1 = require("@civ-clone/library-diplomacy/Declarations");
+const traits_1 = require("@civ-clone/core-unit/traits");
+/**
+ * Whose land a tile is, among a unit's treaty partners, or `null`: a tile that one of the partner's cities is working
+ * and that has one of `improvements` on it, for a land unit that isn't a `NonCombatant`. Moving onto or pillaging such
+ * a tile breaks the treaty. A tile counts as land while it's worked (Civ1's territory model, simplified).
+ */
+const treatyPartner = (improvements, { interactionRegistry = InteractionRegistry_1.instance, tileImprovementRegistry = TileImprovementRegistry_1.instance, workedTileRegistry = WorkedTileRegistry_1.instance, } = {}) => (unit, tile) => {
+    if (!(0, traits_1.isA)(unit, Land_1.default) || unit.hasTrait(NonCombatant_1.default)) {
+        return null;
+    }
+    const workedTile = workedTileRegistry.getByTile(tile);
+    if (workedTile === null) {
+        return null;
+    }
+    const partner = workedTile.city().player();
+    if (partner === unit.player() ||
+        !interactionRegistry
+            .getByPlayers(unit.player(), partner)
+            .some((interaction) => interaction instanceof Declarations_1.Peace && interaction.active()) ||
+        !tileImprovementRegistry
+            .getByTile(tile)
+            .some((improvement) => improvements.some((Improvement) => improvement instanceof Improvement))) {
+        return null;
+    }
+    return partner;
+};
+exports.treatyPartner = treatyPartner;
+exports.default = exports.treatyPartner;
+//# sourceMappingURL=treatyPartner.js.map

package/lib/treatyPartner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"treatyPartner.js","sourceRoot":"","sources":["treatyPartner.ts"],"names":[],"mappings":";;;AAAA,uFAGuD;AACvD,sGAGkE;AAClE,gFAGiD;AACjD,8DAAuD;AACvD,wFAAiF;AACjF,4EAAkE;AAKlE,wDAAkD;AAQlD;;;;GAIG;AACI,MAAM,aAAa,GACxB,CACE,YAAwC,EACxC,EACE,mBAAmB,GAAG,8BAA2B,EACjD,uBAAuB,GAAG,kCAA+B,EACzD,kBAAkB,GAAG,6BAA0B,MAClB,EAAE,EACjC,EAAE,CACJ,CAAC,IAAU,EAAE,IAAU,EAAiB,EAAE;IACxC,IAAI,CAAC,IAAA,YAAG,EAAC,IAAI,EAAE,cAAI,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,sBAAY,CAAC,EAAE;QACnD,OAAO,IAAI,CAAC;KACb;IAED,MAAM,UAAU,GAAG,kBAAkB,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;IAEtD,IAAI,UAAU,KAAK,IAAI,EAAE;QACvB,OAAO,IAAI,CAAC;KACb;IAED,MAAM,OAAO,GAAG,UAAU,CAAC,IAAI,EAAE,CAAC,MAAM,EAAE,CAAC;IAE3C,IACE,OAAO,KAAK,IAAI,CAAC,MAAM,EAAE;QACzB,CAAC,mBAAmB;aACjB,YAAY,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,OAAO,CAAC;aACpC,IAAI,CACH,CAAC,WAAW,EAAwB,EAAE,CACpC,WAAW,YAAY,oBAAK,IAAI,WAAW,CAAC,MAAM,EAAE,CACvD;QACH,CAAC,uBAAuB;aACrB,SAAS,CAAC,IAAI,CAAC;aACf,IAAI,CAAC,CAAC,WAA4B,EAAW,EAAE,CAC9C,YAAY,CAAC,IAAI,CACf,CAAC,WAAmC,EAAW,EAAE,CAC/C,WAAW,YAAY,WAAW,CACrC,CACF,EACH;QACA,OAAO,IAAI,CAAC;KACb;IAED,OAAO,OAAO,CAAC;AACjB,CAAC,CAAC;AA3CS,QAAA,aAAa,iBA2CtB;AAEJ,kBAAe,qBAAa,CAAC"}

package/lib/treatyPartner.ts

@@ -0,0 +1,78 @@
+import {
+  InteractionRegistry,
+  instance as interactionRegistryInstance,
+} from '@civ-clone/core-diplomacy/InteractionRegistry';
+import {
+  TileImprovementRegistry,
+  instance as tileImprovementRegistryInstance,
+} from '@civ-clone/core-tile-improvement/TileImprovementRegistry';
+import {
+  WorkedTileRegistry,
+  instance as workedTileRegistryInstance,
+} from '@civ-clone/core-city/WorkedTileRegistry';
+import Land from '@civ-clone/base-unit-type-land/Land';
+import NonCombatant from '@civ-clone/base-unit-trait-non-combatant/NonCombatant';
+import { Peace } from '@civ-clone/library-diplomacy/Declarations';
+import Player from '@civ-clone/core-player/Player';
+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 { isA } from '@civ-clone/core-unit/traits';
+
+export interface TreatyPartnerDependencies {
+  interactionRegistry?: InteractionRegistry;
+  tileImprovementRegistry?: TileImprovementRegistry;
+  workedTileRegistry?: WorkedTileRegistry;
+}
+
+/**
+ * Whose land a tile is, among a unit's treaty partners, or `null`: a tile that one of the partner's cities is working
+ * and that has one of `improvements` on it, for a land unit that isn't a `NonCombatant`. Moving onto or pillaging such
+ * a tile breaks the treaty. A tile counts as land while it's worked (Civ1's territory model, simplified).
+ */
+export const treatyPartner =
+  (
+    improvements: (typeof TileImprovement)[],
+    {
+      interactionRegistry = interactionRegistryInstance,
+      tileImprovementRegistry = tileImprovementRegistryInstance,
+      workedTileRegistry = workedTileRegistryInstance,
+    }: TreatyPartnerDependencies = {}
+  ) =>
+  (unit: Unit, tile: Tile): Player | null => {
+    if (!isA(unit, Land) || unit.hasTrait(NonCombatant)) {
+      return null;
+    }
+
+    const workedTile = workedTileRegistry.getByTile(tile);
+
+    if (workedTile === null) {
+      return null;
+    }
+
+    const partner = workedTile.city().player();
+
+    if (
+      partner === unit.player() ||
+      !interactionRegistry
+        .getByPlayers(unit.player(), partner)
+        .some(
+          (interaction): interaction is Peace =>
+            interaction instanceof Peace && interaction.active()
+        ) ||
+      !tileImprovementRegistry
+        .getByTile(tile)
+        .some((improvement: TileImprovement): boolean =>
+          improvements.some(
+            (Improvement: typeof TileImprovement): boolean =>
+              improvement instanceof Improvement
+          )
+        )
+    ) {
+      return null;
+    }
+
+    return partner;
+  };
+
+export default treatyPartner;

package/lib/unsupported.d.ts

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

package/lib/unsupported.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitUnsupported = void 0;
+// Emits `unit:unsupported` with the city that could no longer support the unit, and the unit.
+const emitUnsupported = (engine) => (city, unit) => {
+    engine.emit('unit:unsupported', city, unit);
+};
+exports.emitUnsupported = emitUnsupported;
+//# sourceMappingURL=unsupported.js.map

package/lib/unsupported.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unsupported.js","sourceRoot":"","sources":["unsupported.ts"],"names":[],"mappings":";;;AAIA,8FAA8F;AACvF,MAAM,eAAe,GAC1B,CAAC,MAAc,EAAE,EAAE,CACnB,CAAC,IAAU,EAAE,IAAU,EAAQ,EAAE;IAC/B,MAAM,CAAC,IAAI,CAAC,kBAAkB,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;AAC9C,CAAC,CAAC;AAJS,QAAA,eAAe,mBAIxB"}

package/lib/unsupported.ts

@@ -0,0 +1,10 @@
+import City from '@civ-clone/core-city/City';
+import Engine from '@civ-clone/core-engine/Engine';
+import Unit from '@civ-clone/core-unit/Unit';
+
+// Emits `unit:unsupported` with the city that could no longer support the unit, and the unit.
+export const emitUnsupported =
+  (engine: Engine) =>
+  (city: City, unit: Unit): void => {
+    engine.emit('unit:unsupported', city, unit);
+  };

package/lib/validateMove.d.ts

@@ -0,0 +1,11 @@
+import Unit from '@civ-clone/core-unit/Unit';
+export declare const hasMovesFor: (unit: Unit, movementCost: number) => boolean;
+export declare const spendMoves: (unit: Unit, movementCost: number) => boolean;
+export declare const shortOfMovesFor: (
+  unit: Unit,
+  movementCost: number
+) => boolean;
+export declare const spendShort: (
+  shortfallFactor: number,
+  randomNumberGenerator: () => number
+) => (unit: Unit, movementCost: number) => boolean;