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

package/lib/created.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.workCityTile = exports.registerCityGrowth = exports.registerCityBuild = void 0;
+const AvailableSpecialistRegistry_1 = require("@civ-clone/core-city/AvailableSpecialistRegistry");
+const CityGrowthRegistry_1 = require("@civ-clone/core-city-growth/CityGrowthRegistry");
+const PlayerWorldRegistry_1 = require("@civ-clone/core-player-world/PlayerWorldRegistry");
+const RuleRegistry_1 = require("@civ-clone/core-rule/RuleRegistry");
+const SpecialistRegistry_1 = require("@civ-clone/core-city/SpecialistRegistry");
+const WorkedTileRegistry_1 = require("@civ-clone/core-city/WorkedTileRegistry");
+const CityBuild_1 = require("@civ-clone/core-city-build/CityBuild");
+const CityGrowth_1 = require("@civ-clone/core-city-growth/CityGrowth");
+const TileReassigned_1 = require("@civ-clone/core-city/Rules/TileReassigned");
+const WorkedTile_1 = require("@civ-clone/core-city/WorkedTile");
+const assignWorkers_1 = require("./assignWorkers");
+/**
+ * Gives a new city its build, whose first item is asked for as a new city's (civ-clone/web-renderer#716).
+ */
+const registerCityBuild = (city, cityBuildRegistry, availableBuildItemsRegistry, ruleRegistry = RuleRegistry_1.instance) => {
+    const cityBuild = new CityBuild_1.default(city, availableBuildItemsRegistry, ruleRegistry);
+    cityBuild.setCleared('created');
+    cityBuildRegistry.register(cityBuild);
+    return cityBuild;
+};
+exports.registerCityBuild = registerCityBuild;
+/**
+ * Gives a new city its growth: its size and food store.
+ */
+const registerCityGrowth = (city, cityGrowthRegistry = CityGrowthRegistry_1.instance, ruleRegistry = RuleRegistry_1.instance) => {
+    const cityGrowth = new CityGrowth_1.default(city, ruleRegistry);
+    cityGrowthRegistry.register(cityGrowth);
+    return cityGrowth;
+};
+exports.registerCityGrowth = registerCityGrowth;
+/**
+ * A new city works its own centre, taking it from any city that worked it, which its `TileReassigned` rules then let
+ * choose another, and puts its citizens to work.
+ */
+const workCityTile = (city, ruleRegistry = RuleRegistry_1.instance, playerWorldRegistry = PlayerWorldRegistry_1.instance, cityGrowthRegistry = CityGrowthRegistry_1.instance, workedTileRegistry = WorkedTileRegistry_1.instance, specialistRegistry = SpecialistRegistry_1.instance, availableSpecialistRegistry = AvailableSpecialistRegistry_1.instance) => {
+    const existingWorkedTile = workedTileRegistry.getByTile(city.tile());
+    if (existingWorkedTile !== null) {
+        workedTileRegistry.unregister(existingWorkedTile);
+    }
+    workedTileRegistry.register(new WorkedTile_1.default(city.tile(), city));
+    // Give the existing City the chance to reassign its worker before...
+    if (existingWorkedTile !== null) {
+        ruleRegistry.process(TileReassigned_1.default, existingWorkedTile.city(), existingWorkedTile.tile());
+    }
+    // ...assigning the remaining workers.
+    (0, assignWorkers_1.default)(city, playerWorldRegistry, cityGrowthRegistry, workedTileRegistry, specialistRegistry, availableSpecialistRegistry);
+};
+exports.workCityTile = workCityTile;
+//# sourceMappingURL=created.js.map

package/lib/created.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"created.js","sourceRoot":"","sources":["created.ts"],"names":[],"mappings":";;;AAAA,kGAG0D;AAC1D,uFAGwD;AACxD,0FAG0D;AAC1D,oEAG2C;AAC3C,gFAGiD;AACjD,gFAGiD;AAGjD,oEAA6D;AAE7D,uEAAgE;AAChE,8EAAuE;AACvE,gEAAyD;AACzD,mDAA4C;AAE5C;;GAEG;AACI,MAAM,iBAAiB,GAAG,CAC/B,IAAU,EACV,iBAAoC,EACpC,2BAA4D,EAC5D,eAA6B,uBAAoB,EACtC,EAAE;IACb,MAAM,SAAS,GAAG,IAAI,mBAAS,CAC7B,IAAI,EACJ,2BAA2B,EAC3B,YAAY,CACb,CAAC;IAEF,SAAS,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;IAEhC,iBAAiB,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;IAEtC,OAAO,SAAS,CAAC;AACnB,CAAC,CAAC;AAjBW,QAAA,iBAAiB,qBAiB5B;AAEF;;GAEG;AACI,MAAM,kBAAkB,GAAG,CAChC,IAAU,EACV,qBAAyC,6BAA0B,EACnE,eAA6B,uBAAoB,EACrC,EAAE;IACd,MAAM,UAAU,GAAG,IAAI,oBAAU,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;IAEtD,kBAAkB,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;IAExC,OAAO,UAAU,CAAC;AACpB,CAAC,CAAC;AAVW,QAAA,kBAAkB,sBAU7B;AAEF;;;GAGG;AACI,MAAM,YAAY,GAAG,CAC1B,IAAU,EACV,eAA6B,uBAAoB,EACjD,sBAA2C,8BAA2B,EACtE,qBAAyC,6BAA0B,EACnE,qBAAyC,6BAA0B,EACnE,qBAAyC,6BAA0B,EACnE,8BAA2D,sCAAmC,EACxF,EAAE;IACR,MAAM,kBAAkB,GAAG,kBAAkB,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;IAErE,IAAI,kBAAkB,KAAK,IAAI,EAAE;QAC/B,kBAAkB,CAAC,UAAU,CAAC,kBAAkB,CAAC,CAAC;KACnD;IAED,kBAAkB,CAAC,QAAQ,CAAC,IAAI,oBAAU,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,IAAI,CAAC,CAAC,CAAC;IAE/D,qEAAqE;IACrE,IAAI,kBAAkB,KAAK,IAAI,EAAE;QAC/B,YAAY,CAAC,OAAO,CAClB,wBAAc,EACd,kBAAkB,CAAC,IAAI,EAAE,EACzB,kBAAkB,CAAC,IAAI,EAAE,CAC1B,CAAC;KACH;IAED,sCAAsC;IACtC,IAAA,uBAAa,EACX,IAAI,EACJ,mBAAmB,EACnB,kBAAkB,EAClB,kBAAkB,EAClB,kBAAkB,EAClB,2BAA2B,CAC5B,CAAC;AACJ,CAAC,CAAC;AAnCW,QAAA,YAAY,gBAmCvB"}

package/lib/created.ts

@@ -0,0 +1,110 @@
+import {
+  AvailableSpecialistRegistry,
+  instance as availableSpecialistRegistryInstance,
+} from '@civ-clone/core-city/AvailableSpecialistRegistry';
+import {
+  CityGrowthRegistry,
+  instance as cityGrowthRegistryInstance,
+} from '@civ-clone/core-city-growth/CityGrowthRegistry';
+import {
+  PlayerWorldRegistry,
+  instance as playerWorldRegistryInstance,
+} from '@civ-clone/core-player-world/PlayerWorldRegistry';
+import {
+  RuleRegistry,
+  instance as ruleRegistryInstance,
+} from '@civ-clone/core-rule/RuleRegistry';
+import {
+  SpecialistRegistry,
+  instance as specialistRegistryInstance,
+} from '@civ-clone/core-city/SpecialistRegistry';
+import {
+  WorkedTileRegistry,
+  instance as workedTileRegistryInstance,
+} from '@civ-clone/core-city/WorkedTileRegistry';
+import { AvailableCityBuildItemsRegistry } from '@civ-clone/core-city-build/AvailableCityBuildItemsRegistry';
+import City from '@civ-clone/core-city/City';
+import CityBuild from '@civ-clone/core-city-build/CityBuild';
+import { CityBuildRegistry } from '@civ-clone/core-city-build/CityBuildRegistry';
+import CityGrowth from '@civ-clone/core-city-growth/CityGrowth';
+import TileReassigned from '@civ-clone/core-city/Rules/TileReassigned';
+import WorkedTile from '@civ-clone/core-city/WorkedTile';
+import assignWorkers from './assignWorkers';
+
+/**
+ * Gives a new city its build, whose first item is asked for as a new city's (civ-clone/web-renderer#716).
+ */
+export const registerCityBuild = (
+  city: City,
+  cityBuildRegistry: CityBuildRegistry,
+  availableBuildItemsRegistry: AvailableCityBuildItemsRegistry,
+  ruleRegistry: RuleRegistry = ruleRegistryInstance
+): CityBuild => {
+  const cityBuild = new CityBuild(
+    city,
+    availableBuildItemsRegistry,
+    ruleRegistry
+  );
+
+  cityBuild.setCleared('created');
+
+  cityBuildRegistry.register(cityBuild);
+
+  return cityBuild;
+};
+
+/**
+ * Gives a new city its growth: its size and food store.
+ */
+export const registerCityGrowth = (
+  city: City,
+  cityGrowthRegistry: CityGrowthRegistry = cityGrowthRegistryInstance,
+  ruleRegistry: RuleRegistry = ruleRegistryInstance
+): CityGrowth => {
+  const cityGrowth = new CityGrowth(city, ruleRegistry);
+
+  cityGrowthRegistry.register(cityGrowth);
+
+  return cityGrowth;
+};
+
+/**
+ * A new city works its own centre, taking it from any city that worked it, which its `TileReassigned` rules then let
+ * choose another, and puts its citizens to work.
+ */
+export const workCityTile = (
+  city: City,
+  ruleRegistry: RuleRegistry = ruleRegistryInstance,
+  playerWorldRegistry: PlayerWorldRegistry = playerWorldRegistryInstance,
+  cityGrowthRegistry: CityGrowthRegistry = cityGrowthRegistryInstance,
+  workedTileRegistry: WorkedTileRegistry = workedTileRegistryInstance,
+  specialistRegistry: SpecialistRegistry = specialistRegistryInstance,
+  availableSpecialistRegistry: AvailableSpecialistRegistry = availableSpecialistRegistryInstance
+): void => {
+  const existingWorkedTile = workedTileRegistry.getByTile(city.tile());
+
+  if (existingWorkedTile !== null) {
+    workedTileRegistry.unregister(existingWorkedTile);
+  }
+
+  workedTileRegistry.register(new WorkedTile(city.tile(), city));
+
+  // Give the existing City the chance to reassign its worker before...
+  if (existingWorkedTile !== null) {
+    ruleRegistry.process(
+      TileReassigned,
+      existingWorkedTile.city(),
+      existingWorkedTile.tile()
+    );
+  }
+
+  // ...assigning the remaining workers.
+  assignWorkers(
+    city,
+    playerWorldRegistry,
+    cityGrowthRegistry,
+    workedTileRegistry,
+    specialistRegistry,
+    availableSpecialistRegistry
+  );
+};

package/lib/destroyed.d.ts

@@ -0,0 +1,23 @@
+import { SpecialistRegistry } from '@civ-clone/core-city/SpecialistRegistry';
+import City from '@civ-clone/core-city/City';
+import Unit from '@civ-clone/core-unit/Unit';
+import { WorkedTileRegistry } from '@civ-clone/core-city/WorkedTileRegistry';
+/**
+ * Destroys each of `units` (a city's own, say) that isn't destroyed already: when the city was its player's last, the
+ * first unit to go defeats the player, which destroys the rest (civ-clone/web-renderer#600).
+ */
+export declare const destroyUnits: (units: Unit[]) => void;
+/**
+ * The tiles a city that's gone worked are free for another to work.
+ */
+export declare const releaseWorkedTiles: (
+  city: City,
+  workedTileRegistry: WorkedTileRegistry
+) => void;
+/**
+ * A city that's gone has no specialists.
+ */
+export declare const releaseSpecialists: (
+  city: City,
+  specialistRegistry: SpecialistRegistry
+) => void;

package/lib/destroyed.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.releaseSpecialists = exports.releaseWorkedTiles = exports.destroyUnits = void 0;
+/**
+ * Destroys each of `units` (a city's own, say) that isn't destroyed already: when the city was its player's last, the
+ * first unit to go defeats the player, which destroys the rest (civ-clone/web-renderer#600).
+ */
+const destroyUnits = (units) => units.forEach((unit) => {
+    if (unit.destroyed()) {
+        return;
+    }
+    unit.destroy();
+});
+exports.destroyUnits = destroyUnits;
+/**
+ * The tiles a city that's gone worked are free for another to work.
+ */
+const releaseWorkedTiles = (city, workedTileRegistry) => workedTileRegistry
+    .getByCity(city)
+    .forEach((workedTile) => workedTileRegistry.unregister(workedTile));
+exports.releaseWorkedTiles = releaseWorkedTiles;
+/**
+ * A city that's gone has no specialists.
+ */
+const releaseSpecialists = (city, specialistRegistry) => specialistRegistry
+    .getByCity(city)
+    .forEach((specialist) => specialistRegistry.unregister(specialist));
+exports.releaseSpecialists = releaseSpecialists;
+//# sourceMappingURL=destroyed.js.map

package/lib/destroyed.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"destroyed.js","sourceRoot":"","sources":["destroyed.ts"],"names":[],"mappings":";;;AAKA;;;GAGG;AACI,MAAM,YAAY,GAAG,CAAC,KAAa,EAAQ,EAAE,CAClD,KAAK,CAAC,OAAO,CAAC,CAAC,IAAU,EAAQ,EAAE;IACjC,IAAI,IAAI,CAAC,SAAS,EAAE,EAAE;QACpB,OAAO;KACR;IAED,IAAI,CAAC,OAAO,EAAE,CAAC;AACjB,CAAC,CAAC,CAAC;AAPQ,QAAA,YAAY,gBAOpB;AAEL;;GAEG;AACI,MAAM,kBAAkB,GAAG,CAChC,IAAU,EACV,kBAAsC,EAChC,EAAE,CACR,kBAAkB;KACf,SAAS,CAAC,IAAI,CAAC;KACf,OAAO,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,kBAAkB,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,CAAC;AAN3D,QAAA,kBAAkB,sBAMyC;AAExE;;GAEG;AACI,MAAM,kBAAkB,GAAG,CAChC,IAAU,EACV,kBAAsC,EAChC,EAAE,CACR,kBAAkB;KACf,SAAS,CAAC,IAAI,CAAC;KACf,OAAO,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,kBAAkB,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,CAAC;AAN3D,QAAA,kBAAkB,sBAMyC"}

package/lib/destroyed.ts

@@ -0,0 +1,39 @@
+import { SpecialistRegistry } from '@civ-clone/core-city/SpecialistRegistry';
+import City from '@civ-clone/core-city/City';
+import Unit from '@civ-clone/core-unit/Unit';
+import { WorkedTileRegistry } from '@civ-clone/core-city/WorkedTileRegistry';
+
+/**
+ * Destroys each of `units` (a city's own, say) that isn't destroyed already: when the city was its player's last, the
+ * first unit to go defeats the player, which destroys the rest (civ-clone/web-renderer#600).
+ */
+export const destroyUnits = (units: Unit[]): void =>
+  units.forEach((unit: Unit): void => {
+    if (unit.destroyed()) {
+      return;
+    }
+
+    unit.destroy();
+  });
+
+/**
+ * The tiles a city that's gone worked are free for another to work.
+ */
+export const releaseWorkedTiles = (
+  city: City,
+  workedTileRegistry: WorkedTileRegistry
+): void =>
+  workedTileRegistry
+    .getByCity(city)
+    .forEach((workedTile) => workedTileRegistry.unregister(workedTile));
+
+/**
+ * A city that's gone has no specialists.
+ */
+export const releaseSpecialists = (
+  city: City,
+  specialistRegistry: SpecialistRegistry
+): void =>
+  specialistRegistry
+    .getByCity(city)
+    .forEach((specialist) => specialistRegistry.unregister(specialist));

package/lib/events.d.ts

@@ -0,0 +1,39 @@
+import { IBuildable as Buildable } from '@civ-clone/core-city-build/Buildable';
+import City from '@civ-clone/core-city/City';
+import CityBuild from '@civ-clone/core-city-build/CityBuild';
+import { Engine } from '@civ-clone/core-engine/Engine';
+import Tile from '@civ-clone/core-world/Tile';
+/**
+ * Tells clients that `city` now works `tile`, so they can redraw it and show who works it.
+ */
+export declare const emitTileWorked: (
+  city: City,
+  tile: Tile,
+  engine: Engine
+) => void;
+/**
+ * Tells clients that `city` no longer works `tile`, so they can redraw it.
+ */
+export declare const emitTileReleased: (
+  city: City,
+  tile: Tile,
+  engine: Engine
+) => void;
+/**
+ * Tells clients that `cityBuild`'s `item` is paid for but held back, with the ids of the `Hold` rules holding it (`null`
+ *  for a rule without one), for a client to word.
+ */
+export declare const emitBuildingHeld: (
+  cityBuild: CityBuild,
+  item: Buildable,
+  held: (string | null)[],
+  engine: Engine
+) => void;
+/**
+ * Tells clients that `cityBuild` has built `built`.
+ */
+export declare const emitBuildingComplete: (
+  cityBuild: CityBuild,
+  built: unknown,
+  engine: Engine
+) => void;

package/lib/events.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitBuildingComplete = exports.emitBuildingHeld = exports.emitTileReleased = exports.emitTileWorked = void 0;
+/**
+ * Tells clients that `city` now works `tile`, so they can redraw it and show who works it.
+ */
+const emitTileWorked = (city, tile, engine) => {
+    engine.emit('city:tile-worked', city, tile);
+};
+exports.emitTileWorked = emitTileWorked;
+/**
+ * Tells clients that `city` no longer works `tile`, so they can redraw it.
+ */
+const emitTileReleased = (city, tile, engine) => {
+    engine.emit('city:tile-released', city, tile);
+};
+exports.emitTileReleased = emitTileReleased;
+/**
+ * Tells clients that `cityBuild`'s `item` is paid for but held back, with the ids of the `Hold` rules holding it (`null`
+ *  for a rule without one), for a client to word.
+ */
+const emitBuildingHeld = (cityBuild, item, held, engine) => {
+    engine.emit('city:building-held', cityBuild, item, held);
+};
+exports.emitBuildingHeld = emitBuildingHeld;
+/**
+ * Tells clients that `cityBuild` has built `built`.
+ */
+const emitBuildingComplete = (cityBuild, built, engine) => {
+    engine.emit('city:building-complete', cityBuild, built);
+};
+exports.emitBuildingComplete = emitBuildingComplete;
+//# sourceMappingURL=events.js.map

package/lib/events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.js","sourceRoot":"","sources":["events.ts"],"names":[],"mappings":";;;AAMA;;GAEG;AACI,MAAM,cAAc,GAAG,CAC5B,IAAU,EACV,IAAU,EACV,MAAc,EACR,EAAE;IACR,MAAM,CAAC,IAAI,CAAC,kBAAkB,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;AAC9C,CAAC,CAAC;AANW,QAAA,cAAc,kBAMzB;AAEF;;GAEG;AACI,MAAM,gBAAgB,GAAG,CAC9B,IAAU,EACV,IAAU,EACV,MAAc,EACR,EAAE;IACR,MAAM,CAAC,IAAI,CAAC,oBAAoB,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;AAChD,CAAC,CAAC;AANW,QAAA,gBAAgB,oBAM3B;AAEF;;;GAGG;AACI,MAAM,gBAAgB,GAAG,CAC9B,SAAoB,EACpB,IAAe,EACf,IAAuB,EACvB,MAAc,EACR,EAAE;IACR,MAAM,CAAC,IAAI,CAAC,oBAAoB,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;AAC3D,CAAC,CAAC;AAPW,QAAA,gBAAgB,oBAO3B;AAEF;;GAEG;AACI,MAAM,oBAAoB,GAAG,CAClC,SAAoB,EACpB,KAAc,EACd,MAAc,EACR,EAAE;IACR,MAAM,CAAC,IAAI,CAAC,wBAAwB,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC;AAC1D,CAAC,CAAC;AANW,QAAA,oBAAoB,wBAM/B"}

package/lib/events.ts

@@ -0,0 +1,51 @@
+import { IBuildable as Buildable } from '@civ-clone/core-city-build/Buildable';
+import City from '@civ-clone/core-city/City';
+import CityBuild from '@civ-clone/core-city-build/CityBuild';
+import { Engine } from '@civ-clone/core-engine/Engine';
+import Tile from '@civ-clone/core-world/Tile';
+
+/**
+ * Tells clients that `city` now works `tile`, so they can redraw it and show who works it.
+ */
+export const emitTileWorked = (
+  city: City,
+  tile: Tile,
+  engine: Engine
+): void => {
+  engine.emit('city:tile-worked', city, tile);
+};
+
+/**
+ * Tells clients that `city` no longer works `tile`, so they can redraw it.
+ */
+export const emitTileReleased = (
+  city: City,
+  tile: Tile,
+  engine: Engine
+): void => {
+  engine.emit('city:tile-released', city, tile);
+};
+
+/**
+ * Tells clients that `cityBuild`'s `item` is paid for but held back, with the ids of the `Hold` rules holding it (`null`
+ *  for a rule without one), for a client to word.
+ */
+export const emitBuildingHeld = (
+  cityBuild: CityBuild,
+  item: Buildable,
+  held: (string | null)[],
+  engine: Engine
+): void => {
+  engine.emit('city:building-held', cityBuild, item, held);
+};
+
+/**
+ * Tells clients that `cityBuild` has built `built`.
+ */
+export const emitBuildingComplete = (
+  cityBuild: CityBuild,
+  built: unknown,
+  engine: Engine
+): void => {
+  engine.emit('city:building-complete', cityBuild, built);
+};

package/lib/famine.d.ts

@@ -0,0 +1,41 @@
+import CityGrowth from '@civ-clone/core-city-growth/CityGrowth';
+import { Engine } from '@civ-clone/core-engine/Engine';
+import Unit from '@civ-clone/core-unit/Unit';
+import Yield from '@civ-clone/core-yield/Yield';
+/**
+ * A yield a city pays for one of its units, which knows that unit (or `null`).
+ */
+export type UnitYieldType = abstract new (...args: any[]) => Yield & {
+  unit(): Unit | null;
+};
+/**
+ * The first unit `cityGrowth`'s city feeds, as a `FoodSupportType` yield, in the order of the city's yields (the order
+ *  its units were built), or `null`.
+ */
+export declare const foodSupportedUnit: (
+  cityGrowth: CityGrowth,
+  FoodSupportType: UnitYieldType
+) => Unit | null;
+/**
+ * Tells clients that `cityGrowth`'s city has run out of food, with the unit it will lose for it, when there is one.
+ */
+export declare const emitFoodStorageExhausted: (
+  cityGrowth: CityGrowth,
+  unit: Unit | null,
+  engine: Engine
+) => void;
+/**
+ * The city loses the first unit it feeds (see `foodSupportedUnit`), which must exist.
+ */
+export declare const loseFoodSupportedUnit: (
+  cityGrowth: CityGrowth,
+  FoodSupportType: UnitYieldType
+) => void;
+/**
+ * The city shrinks, because its food ran out.
+ */
+export declare const shrinkFromFamine: (cityGrowth: CityGrowth) => void;
+/**
+ * The city's food store is emptied.
+ */
+export declare const emptyFoodStore: (cityGrowth: CityGrowth) => void;

package/lib/famine.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emptyFoodStore = exports.shrinkFromFamine = exports.loseFoodSupportedUnit = exports.emitFoodStorageExhausted = exports.foodSupportedUnit = void 0;
+const FoodExhausted_1 = require("@civ-clone/core-city-growth/Rules/FoodExhausted");
+/**
+ * The first unit `cityGrowth`'s city feeds, as a `FoodSupportType` yield, in the order of the city's yields (the order
+ *  its units were built), or `null`.
+ */
+const foodSupportedUnit = (cityGrowth, FoodSupportType) => {
+    var _a, _b;
+    return (_b = (_a = cityGrowth
+        .city()
+        .yields()
+        .find((cityYield) => cityYield instanceof FoodSupportType &&
+        cityYield.unit() !== null)) === null || _a === void 0 ? void 0 : _a.unit()) !== null && _b !== void 0 ? _b : null;
+};
+exports.foodSupportedUnit = foodSupportedUnit;
+/**
+ * Tells clients that `cityGrowth`'s city has run out of food, with the unit it will lose for it, when there is one.
+ */
+const emitFoodStorageExhausted = (cityGrowth, unit, engine) => {
+    if (unit === null) {
+        engine.emit('city:food-storage-exhausted', cityGrowth.city());
+        return;
+    }
+    engine.emit('city:food-storage-exhausted', cityGrowth.city(), unit);
+};
+exports.emitFoodStorageExhausted = emitFoodStorageExhausted;
+/**
+ * The city loses the first unit it feeds (see `foodSupportedUnit`), which must exist.
+ */
+const loseFoodSupportedUnit = (cityGrowth, FoodSupportType) => (0, exports.foodSupportedUnit)(cityGrowth, FoodSupportType).destroy();
+exports.loseFoodSupportedUnit = loseFoodSupportedUnit;
+/**
+ * The city shrinks, because its food ran out.
+ */
+const shrinkFromFamine = (cityGrowth) => cityGrowth.shrink(FoodExhausted_1.default);
+exports.shrinkFromFamine = shrinkFromFamine;
+/**
+ * The city's food store is emptied.
+ */
+const emptyFoodStore = (cityGrowth) => cityGrowth.empty();
+exports.emptyFoodStore = emptyFoodStore;
+//# sourceMappingURL=famine.js.map

package/lib/famine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"famine.js","sourceRoot":"","sources":["famine.ts"],"names":[],"mappings":";;;AAEA,mFAA4E;AAW5E;;;GAGG;AACI,MAAM,iBAAiB,GAAG,CAC/B,UAAsB,EACtB,eAA8B,EACjB,EAAE;;IACf,OAAA,MAAA,MACE,UAAU;SACP,IAAI,EAAE;SACN,MAAM,EAAE;SACR,IAAI,CACH,CAAC,SAAgB,EAAW,EAAE,CAC5B,SAAS,YAAY,eAAe;QACnC,SAAyC,CAAC,IAAI,EAAE,KAAK,IAAI,CAEjE,0CAAE,IAAI,EAAE,mCAAI,IAAI,CAAA;CAAA,CAAC;AAbP,QAAA,iBAAiB,qBAaV;AAEpB;;GAEG;AACI,MAAM,wBAAwB,GAAG,CACtC,UAAsB,EACtB,IAAiB,EACjB,MAAc,EACR,EAAE;IACR,IAAI,IAAI,KAAK,IAAI,EAAE;QACjB,MAAM,CAAC,IAAI,CAAC,6BAA6B,EAAE,UAAU,CAAC,IAAI,EAAE,CAAC,CAAC;QAE9D,OAAO;KACR;IAED,MAAM,CAAC,IAAI,CAAC,6BAA6B,EAAE,UAAU,CAAC,IAAI,EAAE,EAAE,IAAI,CAAC,CAAC;AACtE,CAAC,CAAC;AAZW,QAAA,wBAAwB,4BAYnC;AAEF;;GAEG;AACI,MAAM,qBAAqB,GAAG,CACnC,UAAsB,EACtB,eAA8B,EACxB,EAAE,CAAC,IAAA,yBAAiB,EAAC,UAAU,EAAE,eAAe,CAAE,CAAC,OAAO,EAAE,CAAC;AAHxD,QAAA,qBAAqB,yBAGmC;AAErE;;GAEG;AACI,MAAM,gBAAgB,GAAG,CAAC,UAAsB,EAAQ,EAAE,CAC/D,UAAU,CAAC,MAAM,CAAC,uBAAa,CAAC,CAAC;AADtB,QAAA,gBAAgB,oBACM;AAEnC;;GAEG;AACI,MAAM,cAAc,GAAG,CAAC,UAAsB,EAAQ,EAAE,CAC7D,UAAU,CAAC,KAAK,EAAE,CAAC;AADR,QAAA,cAAc,kBACN"}

package/lib/famine.ts

@@ -0,0 +1,68 @@
+import CityGrowth from '@civ-clone/core-city-growth/CityGrowth';
+import { Engine } from '@civ-clone/core-engine/Engine';
+import FoodExhausted from '@civ-clone/core-city-growth/Rules/FoodExhausted';
+import Unit from '@civ-clone/core-unit/Unit';
+import Yield from '@civ-clone/core-yield/Yield';
+
+/**
+ * A yield a city pays for one of its units, which knows that unit (or `null`).
+ */
+export type UnitYieldType = abstract new (...args: any[]) => Yield & {
+  unit(): Unit | null;
+};
+
+/**
+ * The first unit `cityGrowth`'s city feeds, as a `FoodSupportType` yield, in the order of the city's yields (the order
+ *  its units were built), or `null`.
+ */
+export const foodSupportedUnit = (
+  cityGrowth: CityGrowth,
+  FoodSupportType: UnitYieldType
+): Unit | null =>
+  (
+    cityGrowth
+      .city()
+      .yields()
+      .find(
+        (cityYield: Yield): boolean =>
+          cityYield instanceof FoodSupportType &&
+          (cityYield as InstanceType<UnitYieldType>).unit() !== null
+      ) as InstanceType<UnitYieldType> | undefined
+  )?.unit() ?? null;
+
+/**
+ * Tells clients that `cityGrowth`'s city has run out of food, with the unit it will lose for it, when there is one.
+ */
+export const emitFoodStorageExhausted = (
+  cityGrowth: CityGrowth,
+  unit: Unit | null,
+  engine: Engine
+): void => {
+  if (unit === null) {
+    engine.emit('city:food-storage-exhausted', cityGrowth.city());
+
+    return;
+  }
+
+  engine.emit('city:food-storage-exhausted', cityGrowth.city(), unit);
+};
+
+/**
+ * The city loses the first unit it feeds (see `foodSupportedUnit`), which must exist.
+ */
+export const loseFoodSupportedUnit = (
+  cityGrowth: CityGrowth,
+  FoodSupportType: UnitYieldType
+): void => foodSupportedUnit(cityGrowth, FoodSupportType)!.destroy();
+
+/**
+ * The city shrinks, because its food ran out.
+ */
+export const shrinkFromFamine = (cityGrowth: CityGrowth): void =>
+  cityGrowth.shrink(FoodExhausted);
+
+/**
+ * The city's food store is emptied.
+ */
+export const emptyFoodStore = (cityGrowth: CityGrowth): void =>
+  cityGrowth.empty();

package/lib/foodStorage.d.ts

@@ -0,0 +1,21 @@
+import CityGrowth from '@civ-clone/core-city-growth/CityGrowth';
+import { RuleRegistry } from '@civ-clone/core-rule/RuleRegistry';
+/**
+ * Whether a city's food store holds enough for it to grow.
+ */
+export declare const hasFoodToGrow: (cityGrowth: CityGrowth) => boolean;
+/**
+ * The city grows.
+ */
+export declare const grow: (cityGrowth: CityGrowth) => void;
+/**
+ * Whether a city's food store has run out: it is below 0 once the turn's food is added.
+ */
+export declare const isFoodExhausted: (cityGrowth: CityGrowth) => boolean;
+/**
+ * The city's food has run out: its `FoodExhausted` rules decide what that costs it.
+ */
+export declare const exhaustFood: (
+  cityGrowth: CityGrowth,
+  ruleRegistry: RuleRegistry
+) => void;

package/lib/foodStorage.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exhaustFood = exports.isFoodExhausted = exports.grow = exports.hasFoodToGrow = void 0;
+const FoodExhausted_1 = require("@civ-clone/core-city-growth/Rules/FoodExhausted");
+/**
+ * Whether a city's food store holds enough for it to grow.
+ */
+const hasFoodToGrow = (cityGrowth) => cityGrowth.progress().value() >= cityGrowth.cost().value();
+exports.hasFoodToGrow = hasFoodToGrow;
+/**
+ * The city grows.
+ */
+const grow = (cityGrowth) => cityGrowth.grow();
+exports.grow = grow;
+/**
+ * Whether a city's food store has run out: it is below 0 once the turn's food is added.
+ */
+const isFoodExhausted = (cityGrowth) => cityGrowth.progress().value() < 0;
+exports.isFoodExhausted = isFoodExhausted;
+/**
+ * The city's food has run out: its `FoodExhausted` rules decide what that costs it.
+ */
+const exhaustFood = (cityGrowth, ruleRegistry) => {
+    ruleRegistry.process(FoodExhausted_1.default, cityGrowth);
+};
+exports.exhaustFood = exhaustFood;
+//# sourceMappingURL=foodStorage.js.map

package/lib/foodStorage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"foodStorage.js","sourceRoot":"","sources":["foodStorage.ts"],"names":[],"mappings":";;;AACA,mFAA4E;AAG5E;;GAEG;AACI,MAAM,aAAa,GAAG,CAAC,UAAsB,EAAW,EAAE,CAC/D,UAAU,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,IAAI,UAAU,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,CAAC;AADhD,QAAA,aAAa,iBACmC;AAE7D;;GAEG;AACI,MAAM,IAAI,GAAG,CAAC,UAAsB,EAAQ,EAAE,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC;AAA3D,QAAA,IAAI,QAAuD;AAExE;;GAEG;AACI,MAAM,eAAe,GAAG,CAAC,UAAsB,EAAW,EAAE,CACjE,UAAU,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;AADvB,QAAA,eAAe,mBACQ;AAEpC;;GAEG;AACI,MAAM,WAAW,GAAG,CACzB,UAAsB,EACtB,YAA0B,EACpB,EAAE;IACR,YAAY,CAAC,OAAO,CAAC,uBAAa,EAAE,UAAU,CAAC,CAAC;AAClD,CAAC,CAAC;AALW,QAAA,WAAW,eAKtB"}

package/lib/foodStorage.ts

@@ -0,0 +1,30 @@
+import CityGrowth from '@civ-clone/core-city-growth/CityGrowth';
+import FoodExhausted from '@civ-clone/core-city-growth/Rules/FoodExhausted';
+import { RuleRegistry } from '@civ-clone/core-rule/RuleRegistry';
+
+/**
+ * Whether a city's food store holds enough for it to grow.
+ */
+export const hasFoodToGrow = (cityGrowth: CityGrowth): boolean =>
+  cityGrowth.progress().value() >= cityGrowth.cost().value();
+
+/**
+ * The city grows.
+ */
+export const grow = (cityGrowth: CityGrowth): void => cityGrowth.grow();
+
+/**
+ * Whether a city's food store has run out: it is below 0 once the turn's food is added.
+ */
+export const isFoodExhausted = (cityGrowth: CityGrowth): boolean =>
+  cityGrowth.progress().value() < 0;
+
+/**
+ * The city's food has run out: its `FoodExhausted` rules decide what that costs it.
+ */
+export const exhaustFood = (
+  cityGrowth: CityGrowth,
+  ruleRegistry: RuleRegistry
+): void => {
+  ruleRegistry.process(FoodExhausted, cityGrowth);
+};