@civ-clone/base-city-lifecycle 0.0.0-stage → 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/canBeWorked.d.ts

@@ -0,0 +1,28 @@
+import City from '@civ-clone/core-city/City';
+import { CityRegistry } from '@civ-clone/core-city/CityRegistry';
+import Tile from '@civ-clone/core-world/Tile';
+import { UnitRegistry } from '@civ-clone/core-unit/UnitRegistry';
+import { WorkedTileRegistry } from '@civ-clone/core-city/WorkedTileRegistry';
+/**
+ * Whether no city works `tile` yet.
+ */
+export declare const isNotWorked: (
+  tile: Tile,
+  workedTileRegistry: WorkedTileRegistry
+) => boolean;
+/**
+ * Whether no other player's unit stands on `tile`.
+ */
+export declare const isNotOccupiedByEnemy: (
+  tile: Tile,
+  city: City,
+  unitRegistry: UnitRegistry
+) => boolean;
+/**
+ * Whether `tile` is not the centre of a city other than `city`.
+ */
+export declare const isNotAnotherCity: (
+  tile: Tile,
+  city: City,
+  cityRegistry: CityRegistry
+) => boolean;

package/lib/canBeWorked.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNotAnotherCity = exports.isNotOccupiedByEnemy = exports.isNotWorked = void 0;
+/**
+ * Whether no city works `tile` yet.
+ */
+const isNotWorked = (tile, workedTileRegistry) => !workedTileRegistry.tileIsWorked(tile);
+exports.isNotWorked = isNotWorked;
+/**
+ * Whether no other player's unit stands on `tile`.
+ */
+const isNotOccupiedByEnemy = (tile, city, unitRegistry) => !unitRegistry
+    .getByTile(tile)
+    .some((unit) => unit.player() !== city.player());
+exports.isNotOccupiedByEnemy = isNotOccupiedByEnemy;
+/**
+ * Whether `tile` is not the centre of a city other than `city`.
+ */
+const isNotAnotherCity = (tile, city, cityRegistry) => {
+    const otherTileCity = cityRegistry.getByTile(tile);
+    if (otherTileCity === null) {
+        return true;
+    }
+    return otherTileCity === city;
+};
+exports.isNotAnotherCity = isNotAnotherCity;
+//# sourceMappingURL=canBeWorked.js.map

package/lib/canBeWorked.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"canBeWorked.js","sourceRoot":"","sources":["canBeWorked.ts"],"names":[],"mappings":";;;AAOA;;GAEG;AACI,MAAM,WAAW,GAAG,CACzB,IAAU,EACV,kBAAsC,EAC7B,EAAE,CAAC,CAAC,kBAAkB,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;AAHxC,QAAA,WAAW,eAG6B;AAErD;;GAEG;AACI,MAAM,oBAAoB,GAAG,CAClC,IAAU,EACV,IAAU,EACV,YAA0B,EACjB,EAAE,CACX,CAAC,YAAY;KACV,SAAS,CAAC,IAAI,CAAC;KACf,IAAI,CAAC,CAAC,IAAU,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,KAAK,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;AAP9C,QAAA,oBAAoB,wBAO0B;AAE3D;;GAEG;AACI,MAAM,gBAAgB,GAAG,CAC9B,IAAU,EACV,IAAU,EACV,YAA0B,EACjB,EAAE;IACX,MAAM,aAAa,GAAG,YAAY,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;IAEnD,IAAI,aAAa,KAAK,IAAI,EAAE;QAC1B,OAAO,IAAI,CAAC;KACb;IAED,OAAO,aAAa,KAAK,IAAI,CAAC;AAChC,CAAC,CAAC;AAZW,QAAA,gBAAgB,oBAY3B"}

package/lib/canBeWorked.ts

@@ -0,0 +1,43 @@
+import City from '@civ-clone/core-city/City';
+import { CityRegistry } from '@civ-clone/core-city/CityRegistry';
+import Tile from '@civ-clone/core-world/Tile';
+import Unit from '@civ-clone/core-unit/Unit';
+import { UnitRegistry } from '@civ-clone/core-unit/UnitRegistry';
+import { WorkedTileRegistry } from '@civ-clone/core-city/WorkedTileRegistry';
+
+/**
+ * Whether no city works `tile` yet.
+ */
+export const isNotWorked = (
+  tile: Tile,
+  workedTileRegistry: WorkedTileRegistry
+): boolean => !workedTileRegistry.tileIsWorked(tile);
+
+/**
+ * Whether no other player's unit stands on `tile`.
+ */
+export const isNotOccupiedByEnemy = (
+  tile: Tile,
+  city: City,
+  unitRegistry: UnitRegistry
+): boolean =>
+  !unitRegistry
+    .getByTile(tile)
+    .some((unit: Unit) => unit.player() !== city.player());
+
+/**
+ * Whether `tile` is not the centre of a city other than `city`.
+ */
+export const isNotAnotherCity = (
+  tile: Tile,
+  city: City,
+  cityRegistry: CityRegistry
+): boolean => {
+  const otherTileCity = cityRegistry.getByTile(tile);
+
+  if (otherTileCity === null) {
+    return true;
+  }
+
+  return otherTileCity === city;
+};

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

@@ -0,0 +1,12 @@
+import City from '@civ-clone/core-city/City';
+/**
+ * What keeps the names cities have been given: a game's `cityNames` (core-civilization's `CityNameRegistry`), of which
+ *  only this much is asked.
+ */
+export type CityNames = {
+  claim(name: string): void;
+};
+/**
+ * `city`'s name is claimed, so that no city founded later is given it too.
+ */
+export declare const claimName: (city: City, cityNames: CityNames) => void;

package/lib/claimName.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.claimName = void 0;
+/**
+ * `city`'s name is claimed, so that no city founded later is given it too.
+ */
+const claimName = (city, cityNames) => cityNames.claim(city.name());
+exports.claimName = claimName;
+//# sourceMappingURL=claimName.js.map

package/lib/claimName.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"claimName.js","sourceRoot":"","sources":["claimName.ts"],"names":[],"mappings":";;;AAQA;;GAEG;AACI,MAAM,SAAS,GAAG,CAAC,IAAU,EAAE,SAAoB,EAAQ,EAAE,CAClE,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;AADlB,QAAA,SAAS,aACS"}

package/lib/claimName.ts

@@ -0,0 +1,13 @@
+import City from '@civ-clone/core-city/City';
+
+/**
+ * What keeps the names cities have been given: a game's `cityNames` (core-civilization's `CityNameRegistry`), of which
+ *  only this much is asked.
+ */
+export type CityNames = { claim(name: string): void };
+
+/**
+ * `city`'s name is claimed, so that no city founded later is given it too.
+ */
+export const claimName = (city: City, cityNames: CityNames): void =>
+  cityNames.claim(city.name());

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;