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

package/.gitattributes

@@ -0,0 +1,2 @@
+**/*.js linguist-generated=true
+

package/.github/workflows/build-on-push.yml

@@ -0,0 +1,39 @@
+name: Build and test application on push to remote
+
+on: [push]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: pnpm/action-setup@v4
+        with:
+          version: 11
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+      # No lock file, so this tests what a consumer resolves. The settings match
+      # web-renderer's pnpm-workspace.yaml: several @civ-clone packages depend on
+      # each other as `github:` URLs, this project's own releases are often only
+      # minutes old, and nothing here needs a dependency's build script.
+      - run: >-
+          pnpm install --no-frozen-lockfile
+          --config.block-exotic-subdeps=false
+          --config.minimum-release-age=0
+          --config.strict-dep-builds=false
+      - run: npm run --if-present prettier:check
+      # The tests load the committed `.js`, so compile to prove the source
+      # type-checks, and fail if the committed output is stale. `--force`
+      # because a fresh checkout's timestamps can make `tsc --build` treat the
+      # committed output as up to date and skip the compile entirely.
+      - run: npm run --if-present ts:compile -- --force
+      - run: npm run --if-present prettier:format
+      # Stale *or never committed* output fails: `git diff` alone misses a new
+      # module whose `.js` was never added, which the published package would
+      # then omit. Only the compiled extensions, so the lock file the install
+      # writes cannot fail it; `node_modules` is ignored, so it stays out.
+      - run: |
+          git status --short --untracked-files=all -- '*.js' '*.d.ts' '*.js.map'
+          test -z "$(git status --porcelain --untracked-files=all -- '*.js' '*.d.ts' '*.js.map')"
+      - run: npm run --if-present test

package/.prettierrc

@@ -0,0 +1,4 @@
+{
+  "semi": true,
+  "singleQuote": true
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Dom Hastings
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,32 @@
-# Temporary Holding Version
+# base-city-lifecycle
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A city's turn and what goes with it, as a library for a ruleset's city rules:
+
+- `lib/processYield`: `storeFood(food, city, cityGrowthRegistry)` puts a city's food for the turn into its store and
+  checks it. `buildWithProduction(production, city, cityYields, ProductionSupportType, cityBuildRegistry, ruleRegistry)`
+  puts its production into its build and checks it: while production net of unit support is below 0, the units it
+  can't support go to the `Unsupported` rules, furthest from the city first, and nothing is added while a
+  `CivilDisorder` rule holds.
+- `lib/foodStorage`: `hasFoodToGrow(cityGrowth)` and `grow(cityGrowth)`; `isFoodExhausted(cityGrowth)` (the store is
+  below 0) and `exhaustFood(cityGrowth, ruleRegistry)`, which runs the `FoodExhausted` rules.
+- `lib/famine`: `foodSupportedUnit(cityGrowth, FoodSupportType)`, the first unit a city feeds;
+  `emitFoodStorageExhausted(cityGrowth, unit, engine)`; `loseFoodSupportedUnit(cityGrowth, FoodSupportType)`,
+  `shrinkFromFamine(cityGrowth)` and `emptyFoodStore(cityGrowth)`.
+- `lib/canBeWorked`: `isNotWorked(tile, workedTileRegistry)`, `isNotOccupiedByEnemy(tile, city, unitRegistry)` and
+  `isNotAnotherCity(tile, city, cityRegistry)`.
+- `lib/occupiedTiles`: `enemyWorkedTile(unit, tile, workedTileRegistry)`, a tile another player's city works (not its
+  centre), and `releaseEnemyWorkedTile(unit, tile, workedTileRegistry, ruleRegistry)`, which takes it from that city
+  and runs its `TileReassigned` rules.
+- `lib/playerActions`: the city actions a player is offered, each as a check and a list: `hasCityToChooseProduction`
+  and `chooseProductionActions`, `hasCityToChangeProduction` and `changeProductionActions`, `hasCity` and
+  `changeWorkedTileActions`, `hasSpecialist` and `changeSpecialistActions`.
+- `lib/unsupported`: `disbandUnsupported(city, unit)`.
+- `lib/claimName`: `claimName(city, cityNames)` and the `CityNames` type.
+- `lib/events`: `emitTileWorked(city, tile, engine)`, `emitTileReleased(city, tile, engine)` and
+  `emitBuildingHeld(cityBuild, item, held, engine)`, for clients.
+
+The yield types a ruleset pays unit support with are passed in (`FoodSupportType`, `ProductionSupportType`: a yield
+that knows its `unit()`).
+
+A library: it registers no rules. The ruleset decides the rules, their ids and order, and when each runs. See
+`civ1-city` for Civilization's.

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

@@ -0,0 +1,31 @@
+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;

package/lib/events.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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;
+//# 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"}

package/lib/events.ts

@@ -0,0 +1,40 @@
+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);
+};

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);
+};

package/lib/occupiedTiles.d.ts

@@ -0,0 +1,25 @@
+import { RuleRegistry } from '@civ-clone/core-rule/RuleRegistry';
+import Tile from '@civ-clone/core-world/Tile';
+import Unit from '@civ-clone/core-unit/Unit';
+import WorkedTile from '@civ-clone/core-city/WorkedTile';
+import { WorkedTileRegistry } from '@civ-clone/core-city/WorkedTileRegistry';
+/**
+ * The `WorkedTile` for `tile` if a city of a player other than `unit`'s works it, other than as its centre (a city always
+ *  works its own centre, even while a unit capturing it is moving in), or `null`.
+ */
+export declare const enemyWorkedTile: (
+  unit: Unit,
+  tile: Tile,
+  workedTileRegistry: WorkedTileRegistry
+) => WorkedTile | null;
+/**
+ * `unit` has moved onto `tile`: if another player's city works it (see `enemyWorkedTile`), the city stops working it,
+ *  and its `TileReassigned` rules choose what it works instead. The tile is looked up again here rather than in a
+ *  `Criterion`, because an earlier `Moved` effect (cargo moving with its transport, say) may already have released it.
+ */
+export declare const releaseEnemyWorkedTile: (
+  unit: Unit,
+  tile: Tile,
+  workedTileRegistry: WorkedTileRegistry,
+  ruleRegistry: RuleRegistry
+) => void;