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

package/lib/assignWorkers.ts

@@ -0,0 +1,372 @@
+// Lifted from library-city 0.1.4 (`lib/assignWorkers.ts`), unchanged but for where the yields come from, so a game's
+//  rules can place a city's citizens without depending on library-city (civ-clone/web-renderer Civ2 M2a, R3b).
+//  library-city re-exports this in R3b.
+import {
+  AvailableSpecialistRegistry,
+  instance as availableSpecialistRegistryInstance,
+} from '@civ-clone/core-city/AvailableSpecialistRegistry';
+import {
+  CityGrowthRegistry,
+  instance as cityGrowthRegistryInstance,
+} from '@civ-clone/core-city-growth/CityGrowthRegistry';
+import Food from '@civ-clone/base-terrain-yield-food/Food';
+import Production from '@civ-clone/base-terrain-yield-production/Production';
+import Trade from '@civ-clone/base-terrain-yield-trade/Trade';
+import {
+  PlayerWorldRegistry,
+  instance as playerWorldRegistryInstance,
+} from '@civ-clone/core-player-world/PlayerWorldRegistry';
+import {
+  SpecialistRegistry,
+  instance as specialistRegistryInstance,
+} from '@civ-clone/core-city/SpecialistRegistry';
+import {
+  WorkedTileRegistry,
+  instance as workedTileRegistryInstance,
+} from '@civ-clone/core-city/WorkedTileRegistry';
+import City from '@civ-clone/core-city/City';
+import Tile from '@civ-clone/core-world/Tile';
+import Yield from '@civ-clone/core-yield/Yield';
+import { reduceYield } from '@civ-clone/core-yield/lib/reduceYields';
+import WorkedTile from '@civ-clone/core-city/WorkedTile';
+import CityGrowth from '@civ-clone/core-city-growth/CityGrowth';
+import Specialist from '@civ-clone/core-city/Specialist';
+
+/**
+ * How many citizens `city` has placed: one per worked tile, the city centre included, and one per `Specialist`. A city
+ * of size `n` has `n + 1`.
+ */
+export const citizenCount = (
+  city: City,
+  workedTileRegistry: WorkedTileRegistry = workedTileRegistryInstance,
+  specialistRegistry: SpecialistRegistry = specialistRegistryInstance
+): number =>
+  workedTileRegistry.getByCity(city).length +
+  specialistRegistry.getByCity(city).length;
+
+/**
+ * Makes a citizen of `city` a `Specialist` of the first available kind (an Entertainer, in Civ1). Returns `null` when
+ * the ruleset offers no specialists.
+ */
+export const addSpecialist = (
+  city: City,
+  specialistRegistry: SpecialistRegistry = specialistRegistryInstance,
+  availableSpecialistRegistry: AvailableSpecialistRegistry = availableSpecialistRegistryInstance
+): Specialist | null => {
+  const [SpecialistType] = availableSpecialistRegistry.entries();
+
+  if (!SpecialistType) {
+    return null;
+  }
+
+  const specialist = new SpecialistType(city);
+
+  specialistRegistry.register(specialist);
+
+  return specialist;
+};
+
+/**
+ * Turns `specialist` into the next available kind, wrapping back to the first. Returns the `Specialist` that replaces
+ * it, or `specialist` itself when there is nothing to change it to.
+ */
+export const changeSpecialist = (
+  specialist: Specialist,
+  specialistRegistry: SpecialistRegistry = specialistRegistryInstance,
+  availableSpecialistRegistry: AvailableSpecialistRegistry = availableSpecialistRegistryInstance
+): Specialist => {
+  const city = specialist.city(),
+    types = availableSpecialistRegistry.entries(),
+    NextType =
+      types[
+        (types.indexOf(specialist.constructor as typeof Specialist) + 1) %
+          types.length
+      ];
+
+  if (!NextType || specialist instanceof NextType) {
+    return specialist;
+  }
+
+  const replacement = new NextType(city);
+
+  specialistRegistry.unregister(specialist);
+  specialistRegistry.register(replacement);
+
+  return replacement;
+};
+
+/**
+ * Puts one of `city`'s specialists back to work, preferring the first available kind (Entertainers), and returns
+ * whether there was one to remove.
+ */
+const removeSpecialist = (
+  city: City,
+  specialistRegistry: SpecialistRegistry,
+  availableSpecialistRegistry: AvailableSpecialistRegistry
+): boolean => {
+  const specialists = specialistRegistry.getByCity(city),
+    [DefaultType] = availableSpecialistRegistry.entries(),
+    specialist =
+      specialists.find(
+        (specialist) => DefaultType && specialist instanceof DefaultType
+      ) ?? specialists[specialists.length - 1];
+
+  if (!specialist) {
+    return false;
+  }
+
+  specialistRegistry.unregister(specialist);
+
+  return true;
+};
+
+export const getHighestValueCityTiles = (city: City) =>
+  sortTiles(city.tiles().entries(), city);
+
+export const sortTiles = (
+  tiles: Tile[],
+  city: City,
+  weights: [typeof Yield, number][] = [
+    [Food, 8],
+    [
+      Production,
+      3 *
+        (reduceYield(city.tilesWorked().yields(city.player()), Production) === 0
+          ? 3
+          : 1),
+    ],
+    [
+      Trade,
+      1 *
+        (reduceYield(city.tilesWorked().yields(city.player()), Trade) === 0
+          ? 2
+          : 1),
+    ],
+  ]
+): Tile[] =>
+  tiles.sort(
+    (a: Tile, b: Tile) =>
+      b.score(city.player(), weights) - a.score(city.player(), weights)
+  );
+
+export const getHighestValueAvailableCityTiles = (
+  city: City,
+  playerWorldRegistry: PlayerWorldRegistry = playerWorldRegistryInstance,
+  workedTileRegistry: WorkedTileRegistry = workedTileRegistryInstance
+) =>
+  getHighestValueCityTiles(city).filter(
+    (tile) =>
+      workedTileRegistry.tileCanBeWorkedBy(tile, city) &&
+      playerWorldRegistry.getByPlayer(city.player()).includes(tile)
+  );
+
+/**
+ * Rearranges the tiles `city` works from scratch. Its specialists stay as they are.
+ */
+export const reassignWorkers = (
+  city: City,
+  playerWorldRegistry: PlayerWorldRegistry = playerWorldRegistryInstance,
+  cityGrowthRegistry: CityGrowthRegistry = cityGrowthRegistryInstance,
+  workedTileRegistry: WorkedTileRegistry = workedTileRegistryInstance,
+  specialistRegistry: SpecialistRegistry = specialistRegistryInstance,
+  availableSpecialistRegistry: AvailableSpecialistRegistry = availableSpecialistRegistryInstance
+) => {
+  workedTileRegistry
+    .getBy('city', city)
+    .forEach((workedTile: WorkedTile) =>
+      workedTileRegistry.unregister(workedTile)
+    );
+
+  workedTileRegistry.register(new WorkedTile(city.tile(), city));
+
+  assignWorkers(
+    city,
+    playerWorldRegistry,
+    cityGrowthRegistry,
+    workedTileRegistry,
+    specialistRegistry,
+    availableSpecialistRegistry
+  );
+};
+
+/**
+ * Places each of `city`'s citizens that has no job on the best tile available, or makes them a specialist if there is
+ * no tile left to work.
+ */
+export const assignWorkers: (
+  city: City,
+  playerWorldRegistry?: PlayerWorldRegistry,
+  cityGrowthRegistry?: CityGrowthRegistry,
+  workedTileRegistry?: WorkedTileRegistry,
+  specialistRegistry?: SpecialistRegistry,
+  availableSpecialistRegistry?: AvailableSpecialistRegistry
+) => void = (
+  city: City,
+  playerWorldRegistry: PlayerWorldRegistry = playerWorldRegistryInstance,
+  cityGrowthRegistry: CityGrowthRegistry = cityGrowthRegistryInstance,
+  workedTileRegistry: WorkedTileRegistry = workedTileRegistryInstance,
+  specialistRegistry: SpecialistRegistry = specialistRegistryInstance,
+  availableSpecialistRegistry: AvailableSpecialistRegistry = availableSpecialistRegistryInstance
+): void => {
+  const cityGrowth = cityGrowthRegistry.getByCity(city),
+    placed = () =>
+      citizenCount(city, workedTileRegistry, specialistRegistry) >=
+      cityGrowth.size() + 1;
+
+  getHighestValueAvailableCityTiles(
+    city,
+    playerWorldRegistry,
+    workedTileRegistry
+  ).some((tile) => {
+    if (placed()) {
+      return true;
+    }
+
+    workedTileRegistry.register(new WorkedTile(tile, city));
+
+    return false;
+  });
+
+  while (
+    !placed() &&
+    addSpecialist(city, specialistRegistry, availableSpecialistRegistry)
+  ) {}
+};
+
+/**
+ * Places one new citizen of `city` on the best tile available, or makes them a specialist if there is no tile left.
+ */
+export const assignWorker: (
+  city: City,
+  playerWorldRegistry?: PlayerWorldRegistry,
+  cityGrowthRegistry?: CityGrowthRegistry,
+  workedTileRegistry?: WorkedTileRegistry,
+  specialistRegistry?: SpecialistRegistry,
+  availableSpecialistRegistry?: AvailableSpecialistRegistry
+) => void = (
+  city: City,
+  playerWorldRegistry: PlayerWorldRegistry = playerWorldRegistryInstance,
+  cityGrowthRegistry: CityGrowthRegistry = cityGrowthRegistryInstance,
+  workedTileRegistry: WorkedTileRegistry = workedTileRegistryInstance,
+  specialistRegistry: SpecialistRegistry = specialistRegistryInstance,
+  availableSpecialistRegistry: AvailableSpecialistRegistry = availableSpecialistRegistryInstance
+): void => {
+  const [newTile] = getHighestValueAvailableCityTiles(
+    city,
+    playerWorldRegistry,
+    workedTileRegistry
+  );
+
+  if (!newTile) {
+    addSpecialist(city, specialistRegistry, availableSpecialistRegistry);
+
+    return;
+  }
+
+  workedTileRegistry.register(new WorkedTile(newTile, city));
+};
+
+export type WorkedTileChange = 'removed' | 'added' | 'reassigned' | 'none';
+
+/**
+ * Changes whether `tile` is worked by `city`, as a player clicking it on the city map would.
+ *
+ * A tile the city works stops being worked, and its worker becomes a specialist. Any other tile is worked by a
+ * specialist, or by a citizen with no job, if the city has one and is allowed to work it. With every citizen already
+ * working a tile, the city's workers are reassigned instead. The city centre is always worked.
+ */
+export const changeWorkedTile: (
+  city: City,
+  tile: Tile,
+  playerWorldRegistry?: PlayerWorldRegistry,
+  cityGrowthRegistry?: CityGrowthRegistry,
+  workedTileRegistry?: WorkedTileRegistry,
+  specialistRegistry?: SpecialistRegistry,
+  availableSpecialistRegistry?: AvailableSpecialistRegistry
+) => WorkedTileChange = (
+  city: City,
+  tile: Tile,
+  playerWorldRegistry: PlayerWorldRegistry = playerWorldRegistryInstance,
+  cityGrowthRegistry: CityGrowthRegistry = cityGrowthRegistryInstance,
+  workedTileRegistry: WorkedTileRegistry = workedTileRegistryInstance,
+  specialistRegistry: SpecialistRegistry = specialistRegistryInstance,
+  availableSpecialistRegistry: AvailableSpecialistRegistry = availableSpecialistRegistryInstance
+): WorkedTileChange => {
+  if (tile === city.tile() || !city.tiles().includes(tile)) {
+    return 'none';
+  }
+
+  if (workedTileRegistry.getByTile(tile)?.city() === city) {
+    workedTileRegistry.unregisterByTile(tile);
+
+    addSpecialist(city, specialistRegistry, availableSpecialistRegistry);
+
+    return 'removed';
+  }
+
+  const size = cityGrowthRegistry.getByCity(city).size();
+
+  if (workedTileRegistry.getByCity(city).length >= size + 1) {
+    reassignWorkers(
+      city,
+      playerWorldRegistry,
+      cityGrowthRegistry,
+      workedTileRegistry,
+      specialistRegistry,
+      availableSpecialistRegistry
+    );
+
+    return 'reassigned';
+  }
+
+  if (
+    !workedTileRegistry.tileCanBeWorkedBy(tile, city) ||
+    !playerWorldRegistry.getByPlayer(city.player()).includes(tile)
+  ) {
+    return 'none';
+  }
+
+  if (citizenCount(city, workedTileRegistry, specialistRegistry) >= size + 1) {
+    removeSpecialist(city, specialistRegistry, availableSpecialistRegistry);
+  }
+
+  workedTileRegistry.register(new WorkedTile(tile, city));
+
+  return 'added';
+};
+
+/**
+ * Takes jobs away from `city`'s citizens until it has no more than its size allows: specialists first, then the
+ * workers on the least valuable tiles.
+ */
+export const releaseCitizens = (
+  city: City,
+  cityGrowth: CityGrowth,
+  workedTileRegistry: WorkedTileRegistry = workedTileRegistryInstance,
+  specialistRegistry: SpecialistRegistry = specialistRegistryInstance
+): void => {
+  const specialists = specialistRegistry.getByCity(city);
+
+  while (
+    specialists.length > 0 &&
+    citizenCount(city, workedTileRegistry, specialistRegistry) >
+      cityGrowth.size() + 1
+  ) {
+    specialistRegistry.unregister(specialists.pop()!);
+  }
+
+  reduceWorkers(city, cityGrowth).forEach((tile: Tile): void =>
+    workedTileRegistry.unregisterByTile(tile)
+  );
+};
+
+export const reduceWorkers = (city: City, cityGrowth: CityGrowth): Tile[] =>
+  sortTiles(
+    city
+      .tilesWorked()
+      .entries()
+      .filter((tile: Tile) => tile !== city.tile()),
+    city
+  ).slice(cityGrowth.size());
+
+export default assignWorkers;

package/lib/captured.d.ts

@@ -0,0 +1,12 @@
+import CityBuild from '@civ-clone/core-city-build/CityBuild';
+/**
+ * Clears what a captured city was building, so its new owner chooses: the item was its previous owner's choice, at
+ * its previous owner's price (civ-clone/web-renderer#670, #500). The city is asked for as a captured city's even if
+ * its previous owner had chosen nothing (civ-clone/web-renderer#716).
+ */
+export declare const clearCapturedBuild: (cityBuild: CityBuild) => void;
+/**
+ * A captured city keeps what it was building, at its new owner's price, without its previous owner's queue
+ * (civ-clone/web-renderer#670). Asked for as a captured city's if nothing was being built (civ-clone/web-renderer#716).
+ */
+export declare const keepCapturedBuild: (cityBuild: CityBuild) => void;

package/lib/captured.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keepCapturedBuild = exports.clearCapturedBuild = void 0;
+/**
+ * Clears what a captured city was building, so its new owner chooses: the item was its previous owner's choice, at
+ * its previous owner's price (civ-clone/web-renderer#670, #500). The city is asked for as a captured city's even if
+ * its previous owner had chosen nothing (civ-clone/web-renderer#716).
+ */
+const clearCapturedBuild = (cityBuild) => {
+    if (cityBuild.building() === null) {
+        cityBuild.setCleared('captured');
+        return;
+    }
+    cityBuild.cancel('captured');
+};
+exports.clearCapturedBuild = clearCapturedBuild;
+/**
+ * A captured city keeps what it was building, at its new owner's price, without its previous owner's queue
+ * (civ-clone/web-renderer#670). Asked for as a captured city's if nothing was being built (civ-clone/web-renderer#716).
+ */
+const keepCapturedBuild = (cityBuild) => {
+    if (cityBuild.building() === null) {
+        cityBuild.setCleared('captured');
+        return;
+    }
+    cityBuild.clearQueue();
+    cityBuild.reprice();
+};
+exports.keepCapturedBuild = keepCapturedBuild;
+//# sourceMappingURL=captured.js.map

package/lib/captured.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"captured.js","sourceRoot":"","sources":["captured.ts"],"names":[],"mappings":";;;AAEA;;;;GAIG;AACI,MAAM,kBAAkB,GAAG,CAAC,SAAoB,EAAQ,EAAE;IAC/D,IAAI,SAAS,CAAC,QAAQ,EAAE,KAAK,IAAI,EAAE;QACjC,SAAS,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC;QAEjC,OAAO;KACR;IAED,SAAS,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;AAC/B,CAAC,CAAC;AARW,QAAA,kBAAkB,sBAQ7B;AAEF;;;GAGG;AACI,MAAM,iBAAiB,GAAG,CAAC,SAAoB,EAAQ,EAAE;IAC9D,IAAI,SAAS,CAAC,QAAQ,EAAE,KAAK,IAAI,EAAE;QACjC,SAAS,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC;QAEjC,OAAO;KACR;IAED,SAAS,CAAC,UAAU,EAAE,CAAC;IACvB,SAAS,CAAC,OAAO,EAAE,CAAC;AACtB,CAAC,CAAC;AATW,QAAA,iBAAiB,qBAS5B"}

package/lib/captured.ts

@@ -0,0 +1,31 @@
+import CityBuild from '@civ-clone/core-city-build/CityBuild';
+
+/**
+ * Clears what a captured city was building, so its new owner chooses: the item was its previous owner's choice, at
+ * its previous owner's price (civ-clone/web-renderer#670, #500). The city is asked for as a captured city's even if
+ * its previous owner had chosen nothing (civ-clone/web-renderer#716).
+ */
+export const clearCapturedBuild = (cityBuild: CityBuild): void => {
+  if (cityBuild.building() === null) {
+    cityBuild.setCleared('captured');
+
+    return;
+  }
+
+  cityBuild.cancel('captured');
+};
+
+/**
+ * A captured city keeps what it was building, at its new owner's price, without its previous owner's queue
+ * (civ-clone/web-renderer#670). Asked for as a captured city's if nothing was being built (civ-clone/web-renderer#716).
+ */
+export const keepCapturedBuild = (cityBuild: CityBuild): void => {
+  if (cityBuild.building() === null) {
+    cityBuild.setCleared('captured');
+
+    return;
+  }
+
+  cityBuild.clearQueue();
+  cityBuild.reprice();
+};

package/lib/created.d.ts

@@ -0,0 +1,41 @@
+import { AvailableSpecialistRegistry } from '@civ-clone/core-city/AvailableSpecialistRegistry';
+import { CityGrowthRegistry } from '@civ-clone/core-city-growth/CityGrowthRegistry';
+import { PlayerWorldRegistry } from '@civ-clone/core-player-world/PlayerWorldRegistry';
+import { RuleRegistry } from '@civ-clone/core-rule/RuleRegistry';
+import { SpecialistRegistry } from '@civ-clone/core-city/SpecialistRegistry';
+import { WorkedTileRegistry } 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';
+/**
+ * Gives a new city its build, whose first item is asked for as a new city's (civ-clone/web-renderer#716).
+ */
+export declare const registerCityBuild: (
+  city: City,
+  cityBuildRegistry: CityBuildRegistry,
+  availableBuildItemsRegistry: AvailableCityBuildItemsRegistry,
+  ruleRegistry?: RuleRegistry
+) => CityBuild;
+/**
+ * Gives a new city its growth: its size and food store.
+ */
+export declare const registerCityGrowth: (
+  city: City,
+  cityGrowthRegistry?: CityGrowthRegistry,
+  ruleRegistry?: RuleRegistry
+) => 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 declare const workCityTile: (
+  city: City,
+  ruleRegistry?: RuleRegistry,
+  playerWorldRegistry?: PlayerWorldRegistry,
+  cityGrowthRegistry?: CityGrowthRegistry,
+  workedTileRegistry?: WorkedTileRegistry,
+  specialistRegistry?: SpecialistRegistry,
+  availableSpecialistRegistry?: AvailableSpecialistRegistry
+) => void;

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;