@civ-clone/base-city-happiness-status 0.0.0-stage → 0.1.1

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,21 @@
-# Temporary Holding Version
+# base-city-happiness-status
 
-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.
+Keeps a city's status, such as being in disorder or celebrating, from one turn to the next and in the save. Each status
+is a `core-pending-effect` `PendingEffect` on the city, named by the ruleset's own handler id, so the save records it:
+
+- `lib/cityStatus`:
+  - `cityStatus(handler, city, pendingEffects?)`: the city's recorded status, or `null`. Read before this turn's
+    update, it's the status carried over from the last turn (a second turn of disorder, a celebration that goes on).
+  - `updateCityStatus(handler, city, active, recorded, pendingEffects?, onStart?)`: records a status that has started
+    (calling `onStart` first) and ends one that has stopped.
+  - `registerCityStatusHandler(handler, event, pendingEffects?, engine?)`: emits `event` with the city when its status
+    ends. Register it when the rules are created, so a status loaded from a save can still end.
+  - `forgetCityStatuses(city, handlers, pendingEffects?)`: drops statuses without ending them, for a city that's gone.
+- `lib/statusTurn`: `cityStatusTurn(cities, options)` checks each city's `CivilDisorder` and `CelebrateLeader` rules
+  on one set of yields, emits `city:civil-disorder` and `city:leader-celebration`, and records or ends both statuses.
+  The ruleset passes its handlers and its own turns of the rule through hooks: `onDisorderContinues` (a second turn of
+  disorder, such as a Democracy falling), `onCelebrationChecked` (with whether the city celebrates again, for growth),
+  `forgetCelebration` (drop rather than end) and `celebrationSurvivesDisorder`.
+
+A library: it registers no rules. See `civ1-city-happiness` for Civilization's civil disorder and "We Love the King
+Day".

package/lib/cityStatus.d.ts

@@ -0,0 +1,50 @@
+import { Engine } from '@civ-clone/core-engine/Engine';
+import {
+  PendingEffect,
+  PendingEffectRegistry,
+} from '@civ-clone/core-pending-effect';
+import City from '@civ-clone/core-city/City';
+/**
+ * A city's status (in disorder, celebrating and the like) is kept as a `PendingEffect` on the city, named by the
+ * ruleset's `handler`. Pending effects are saved, so a loaded game knows which cities already had a status, and a
+ * status recorded at the start of one turn is still there at the start of the next: that's how a ruleset tells a
+ * city's second turn of disorder, or of celebrating, from its first.
+ */
+export declare const cityStatus: (
+  handler: string,
+  city: City,
+  pendingEffects?: PendingEffectRegistry
+) => PendingEffect | null;
+/**
+ * Emits `event` with the city when its status `handler` ends. Register it whenever the rules are created, so a status
+ * loaded from a save can still end.
+ */
+export declare const registerCityStatusHandler: (
+  handler: string,
+  event: string,
+  pendingEffects?: PendingEffectRegistry,
+  engine?: Engine
+) => void;
+/**
+ * Records the city's status `handler` when it has started (`active` with nothing `recorded`), calling `onStart` first,
+ * and ends it when it has stopped (not `active` with one `recorded`), which emits the event its handler was registered
+ * with. `recorded` is the city's status as it was before this turn's check (`cityStatus`), so a ruleset can act on a
+ * status carried over from the last turn before it's updated.
+ */
+export declare const updateCityStatus: (
+  handler: string,
+  city: City,
+  active: boolean,
+  recorded: PendingEffect | null,
+  pendingEffects?: PendingEffectRegistry,
+  onStart?: () => void
+) => void;
+/**
+ * Drops the city's statuses named in `handlers` without ending them, so no event is emitted: for a city that's gone,
+ * which would otherwise stay in the save.
+ */
+export declare const forgetCityStatuses: (
+  city: City,
+  handlers: string[],
+  pendingEffects?: PendingEffectRegistry
+) => void;

package/lib/cityStatus.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.forgetCityStatuses = exports.updateCityStatus = exports.registerCityStatusHandler = exports.cityStatus = void 0;
+const Engine_1 = require("@civ-clone/core-engine/Engine");
+const core_pending_effect_1 = require("@civ-clone/core-pending-effect");
+/**
+ * A city's status (in disorder, celebrating and the like) is kept as a `PendingEffect` on the city, named by the
+ * ruleset's `handler`. Pending effects are saved, so a loaded game knows which cities already had a status, and a
+ * status recorded at the start of one turn is still there at the start of the next: that's how a ruleset tells a
+ * city's second turn of disorder, or of celebrating, from its first.
+ */
+const cityStatus = (handler, city, pendingEffects = core_pending_effect_1.instance) => {
+    var _a;
+    return (_a = pendingEffects
+        .getByTarget(city)
+        .find((pendingEffect) => pendingEffect.handler() === handler)) !== null && _a !== void 0 ? _a : null;
+};
+exports.cityStatus = cityStatus;
+/**
+ * Emits `event` with the city when its status `handler` ends. Register it whenever the rules are created, so a status
+ * loaded from a save can still end.
+ */
+const registerCityStatusHandler = (handler, event, pendingEffects = core_pending_effect_1.instance, engine = Engine_1.instance) => pendingEffects.handler(handler, (pendingEffect) => engine.emit(event, pendingEffect.target()));
+exports.registerCityStatusHandler = registerCityStatusHandler;
+/**
+ * Records the city's status `handler` when it has started (`active` with nothing `recorded`), calling `onStart` first,
+ * and ends it when it has stopped (not `active` with one `recorded`), which emits the event its handler was registered
+ * with. `recorded` is the city's status as it was before this turn's check (`cityStatus`), so a ruleset can act on a
+ * status carried over from the last turn before it's updated.
+ */
+const updateCityStatus = (handler, city, active, recorded, pendingEffects = core_pending_effect_1.instance, onStart = () => { }) => {
+    if (active && recorded === null) {
+        onStart();
+        pendingEffects.register(new core_pending_effect_1.PendingEffect(handler, city));
+    }
+    if (!active && recorded !== null) {
+        pendingEffects.discharge(recorded);
+    }
+};
+exports.updateCityStatus = updateCityStatus;
+/**
+ * Drops the city's statuses named in `handlers` without ending them, so no event is emitted: for a city that's gone,
+ * which would otherwise stay in the save.
+ */
+const forgetCityStatuses = (city, handlers, pendingEffects = core_pending_effect_1.instance) => pendingEffects
+    .getByTarget(city)
+    .filter((pendingEffect) => handlers.includes(pendingEffect.handler()))
+    .forEach((pendingEffect) => pendingEffects.unregister(pendingEffect));
+exports.forgetCityStatuses = forgetCityStatuses;
+//# sourceMappingURL=cityStatus.js.map

package/lib/cityStatus.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cityStatus.js","sourceRoot":"","sources":["cityStatus.ts"],"names":[],"mappings":";;;AAAA,0DAGuC;AACvC,wEAIwC;AAGxC;;;;;GAKG;AACI,MAAM,UAAU,GAAG,CACxB,OAAe,EACf,IAAU,EACV,iBAAwC,8BAA6B,EAC/C,EAAE;;IACxB,OAAA,MAAA,cAAc;SACX,WAAW,CAAC,IAAI,CAAC;SACjB,IAAI,CACH,CAAC,aAA4B,EAAW,EAAE,CACxC,aAAa,CAAC,OAAO,EAAE,KAAK,OAAO,CACtC,mCAAI,IAAI,CAAA;CAAA,CAAC;AAVD,QAAA,UAAU,cAUT;AAEd;;;GAGG;AACI,MAAM,yBAAyB,GAAG,CACvC,OAAe,EACf,KAAa,EACb,iBAAwC,8BAA6B,EACrE,SAAiB,iBAAc,EACzB,EAAE,CACR,cAAc,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,aAA4B,EAAE,EAAE,CAC/D,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,aAAa,CAAC,MAAM,EAAE,CAAC,CAC3C,CAAC;AARS,QAAA,yBAAyB,6BAQlC;AAEJ;;;;;GAKG;AACI,MAAM,gBAAgB,GAAG,CAC9B,OAAe,EACf,IAAU,EACV,MAAe,EACf,QAA8B,EAC9B,iBAAwC,8BAA6B,EACrE,UAAsB,GAAG,EAAE,GAAE,CAAC,EACxB,EAAE;IACR,IAAI,MAAM,IAAI,QAAQ,KAAK,IAAI,EAAE;QAC/B,OAAO,EAAE,CAAC;QAEV,cAAc,CAAC,QAAQ,CAAC,IAAI,mCAAa,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC;KAC3D;IAED,IAAI,CAAC,MAAM,IAAI,QAAQ,KAAK,IAAI,EAAE;QAChC,cAAc,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;KACpC;AACH,CAAC,CAAC;AAjBW,QAAA,gBAAgB,oBAiB3B;AAEF;;;GAGG;AACI,MAAM,kBAAkB,GAAG,CAChC,IAAU,EACV,QAAkB,EAClB,iBAAwC,8BAA6B,EAC/D,EAAE,CACR,cAAc;KACX,WAAW,CAAC,IAAI,CAAC;KACjB,MAAM,CAAC,CAAC,aAA4B,EAAW,EAAE,CAChD,QAAQ,CAAC,QAAQ,CAAC,aAAa,CAAC,OAAO,EAAE,CAAC,CAC3C;KACA,OAAO,CAAC,CAAC,aAA4B,EAAQ,EAAE,CAC9C,cAAc,CAAC,UAAU,CAAC,aAAa,CAAC,CACzC,CAAC;AAZO,QAAA,kBAAkB,sBAYzB"}

package/lib/cityStatus.ts

@@ -0,0 +1,85 @@
+import {
+  Engine,
+  instance as engineInstance,
+} from '@civ-clone/core-engine/Engine';
+import {
+  PendingEffect,
+  PendingEffectRegistry,
+  instance as pendingEffectRegistryInstance,
+} from '@civ-clone/core-pending-effect';
+import City from '@civ-clone/core-city/City';
+
+/**
+ * A city's status (in disorder, celebrating and the like) is kept as a `PendingEffect` on the city, named by the
+ * ruleset's `handler`. Pending effects are saved, so a loaded game knows which cities already had a status, and a
+ * status recorded at the start of one turn is still there at the start of the next: that's how a ruleset tells a
+ * city's second turn of disorder, or of celebrating, from its first.
+ */
+export const cityStatus = (
+  handler: string,
+  city: City,
+  pendingEffects: PendingEffectRegistry = pendingEffectRegistryInstance
+): PendingEffect | null =>
+  pendingEffects
+    .getByTarget(city)
+    .find(
+      (pendingEffect: PendingEffect): boolean =>
+        pendingEffect.handler() === handler
+    ) ?? null;
+
+/**
+ * Emits `event` with the city when its status `handler` ends. Register it whenever the rules are created, so a status
+ * loaded from a save can still end.
+ */
+export const registerCityStatusHandler = (
+  handler: string,
+  event: string,
+  pendingEffects: PendingEffectRegistry = pendingEffectRegistryInstance,
+  engine: Engine = engineInstance
+): void =>
+  pendingEffects.handler(handler, (pendingEffect: PendingEffect) =>
+    engine.emit(event, pendingEffect.target())
+  );
+
+/**
+ * Records the city's status `handler` when it has started (`active` with nothing `recorded`), calling `onStart` first,
+ * and ends it when it has stopped (not `active` with one `recorded`), which emits the event its handler was registered
+ * with. `recorded` is the city's status as it was before this turn's check (`cityStatus`), so a ruleset can act on a
+ * status carried over from the last turn before it's updated.
+ */
+export const updateCityStatus = (
+  handler: string,
+  city: City,
+  active: boolean,
+  recorded: PendingEffect | null,
+  pendingEffects: PendingEffectRegistry = pendingEffectRegistryInstance,
+  onStart: () => void = () => {}
+): void => {
+  if (active && recorded === null) {
+    onStart();
+
+    pendingEffects.register(new PendingEffect(handler, city));
+  }
+
+  if (!active && recorded !== null) {
+    pendingEffects.discharge(recorded);
+  }
+};
+
+/**
+ * Drops the city's statuses named in `handlers` without ending them, so no event is emitted: for a city that's gone,
+ * which would otherwise stay in the save.
+ */
+export const forgetCityStatuses = (
+  city: City,
+  handlers: string[],
+  pendingEffects: PendingEffectRegistry = pendingEffectRegistryInstance
+): void =>
+  pendingEffects
+    .getByTarget(city)
+    .filter((pendingEffect: PendingEffect): boolean =>
+      handlers.includes(pendingEffect.handler())
+    )
+    .forEach((pendingEffect: PendingEffect): void =>
+      pendingEffects.unregister(pendingEffect)
+    );

package/lib/statusTurn.d.ts

@@ -0,0 +1,70 @@
+import {
+  PendingEffect,
+  PendingEffectRegistry,
+} from '@civ-clone/core-pending-effect';
+import City from '@civ-clone/core-city/City';
+import { Engine } from '@civ-clone/core-engine/Engine';
+import { RuleRegistry } from '@civ-clone/core-rule/RuleRegistry';
+import Yield from '@civ-clone/core-yield/Yield';
+/** What a city's check found this turn, and what was recorded before it. */
+export type CityStatusCheck = {
+  city: City;
+  /** The yields the city was judged on, worked out once for both checks. */
+  yields: Yield[];
+  /** Whether the city is in civil disorder now. */
+  disorder: boolean;
+  /** Whether the city celebrates now. */
+  celebrating: boolean;
+  /** The city's disorder as recorded before this turn's check, or `null`. */
+  recordedDisorder: PendingEffect | null;
+  /** The city's celebration as recorded before this turn's check, or `null`. */
+  recordedCelebration: PendingEffect | null;
+};
+/** How a ruleset keeps its cities' disorder and celebrations from one turn to the next. */
+export type CityStatusTurn = {
+  /** The status `handler`s the ruleset records disorder and celebration under (see `cityStatus`). */
+  disorderHandler: string;
+  celebrationHandler: string;
+  pendingEffects: PendingEffectRegistry;
+  ruleRegistry: RuleRegistry;
+  engine: Engine;
+  /**
+   * Whether a city that celebrated before, and is in disorder now without celebrating, keeps its celebration (Civ1
+   *  keeps it, without a word, until order returns); otherwise its celebration is ended or forgotten as usual.
+   */
+  celebrationSurvivesDisorder?: boolean;
+  /** Called for a city in disorder for a second turn running (or more), before its status is updated. */
+  onDisorderContinues?: (check: CityStatusCheck) => void;
+  /**
+   * Called for each city whose celebration is updated, before it is, with whether it celebrates for a second turn
+   *  running (or more): what a ruleset grows a city for.
+   */
+  onCelebrationChecked?: (check: CityStatusCheck, again: boolean) => void;
+  /**
+   * Whether a celebration that has stopped is dropped without its end being told (no event), rather than ended.
+   *  Ended, by default.
+   */
+  forgetCelebration?: (check: CityStatusCheck) => boolean;
+};
+/**
+ * Checks each of `cities` for civil disorder and for celebrating, at the start of their player's turn, emitting
+ * `city:civil-disorder` for each city in disorder, and records the statuses that start and ends those that stop
+ * (`updateCityStatus`), emitting `city:leader-celebration` as a celebration starts. The handlers' events (registered
+ * with `registerCityStatusHandler`) tell of order restored and celebrations ended. The cities are taken in order, and a
+ * hook may change the player's government part-way through them.
+ */
+export declare const cityStatusTurn: (
+  cities: City[],
+  {
+    disorderHandler,
+    celebrationHandler,
+    pendingEffects,
+    ruleRegistry,
+    engine,
+    celebrationSurvivesDisorder,
+    onDisorderContinues,
+    onCelebrationChecked,
+    forgetCelebration,
+  }: CityStatusTurn
+) => void;
+export default cityStatusTurn;

package/lib/statusTurn.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cityStatusTurn = void 0;
+const cityStatus_1 = require("./cityStatus");
+const CelebrateLeader_1 = require("@civ-clone/core-city-happiness/Rules/CelebrateLeader");
+const CivilDisorder_1 = require("@civ-clone/core-city-happiness/Rules/CivilDisorder");
+/**
+ * Checks each of `cities` for civil disorder and for celebrating, at the start of their player's turn, emitting
+ * `city:civil-disorder` for each city in disorder, and records the statuses that start and ends those that stop
+ * (`updateCityStatus`), emitting `city:leader-celebration` as a celebration starts. The handlers' events (registered
+ * with `registerCityStatusHandler`) tell of order restored and celebrations ended. The cities are taken in order, and a
+ * hook may change the player's government part-way through them.
+ */
+const cityStatusTurn = (cities, { disorderHandler, celebrationHandler, pendingEffects, ruleRegistry, engine, celebrationSurvivesDisorder = false, onDisorderContinues = () => { }, onCelebrationChecked = () => { }, forgetCelebration = () => false, }) => cities.forEach((city) => {
+    // Both rules read the same yields, and working them out isn't cheap (civ-clone/web-renderer#315).
+    const yields = city.yields(), check = {
+        city,
+        yields,
+        disorder: ruleRegistry
+            .process(CivilDisorder_1.default, city, yields)
+            .some((result) => result),
+        celebrating: ruleRegistry
+            .process(CelebrateLeader_1.default, city, yields)
+            .some((result) => result),
+        recordedDisorder: (0, cityStatus_1.cityStatus)(disorderHandler, city, pendingEffects),
+        recordedCelebration: (0, cityStatus_1.cityStatus)(celebrationHandler, city, pendingEffects),
+    };
+    if (check.disorder) {
+        engine.emit('city:civil-disorder', city);
+    }
+    if (check.disorder && check.recordedDisorder !== null) {
+        onDisorderContinues(check);
+    }
+    onCelebrationChecked(check, check.celebrating && check.recordedCelebration !== null);
+    // Records disorder that has started, and ends disorder that has stopped.
+    (0, cityStatus_1.updateCityStatus)(disorderHandler, city, check.disorder, check.recordedDisorder, pendingEffects);
+    if (celebrationSurvivesDisorder && check.disorder && !check.celebrating) {
+        return;
+    }
+    if (!check.celebrating &&
+        check.recordedCelebration !== null &&
+        forgetCelebration(check)) {
+        (0, cityStatus_1.forgetCityStatuses)(city, [celebrationHandler], pendingEffects);
+        return;
+    }
+    (0, cityStatus_1.updateCityStatus)(celebrationHandler, city, check.celebrating, check.recordedCelebration, pendingEffects, () => engine.emit('city:leader-celebration', city));
+});
+exports.cityStatusTurn = cityStatusTurn;
+exports.default = exports.cityStatusTurn;
+//# sourceMappingURL=statusTurn.js.map

package/lib/statusTurn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"statusTurn.js","sourceRoot":"","sources":["statusTurn.ts"],"names":[],"mappings":";;;AAIA,6CAAgF;AAChF,0FAAmF;AAEnF,sFAA+E;AA+C/E;;;;;;GAMG;AACI,MAAM,cAAc,GAAG,CAC5B,MAAc,EACd,EACE,eAAe,EACf,kBAAkB,EAClB,cAAc,EACd,YAAY,EACZ,MAAM,EACN,2BAA2B,GAAG,KAAK,EACnC,mBAAmB,GAAG,GAAG,EAAE,GAAE,CAAC,EAC9B,oBAAoB,GAAG,GAAG,EAAE,GAAE,CAAC,EAC/B,iBAAiB,GAAG,GAAG,EAAE,CAAC,KAAK,GAChB,EACX,EAAE,CACR,MAAM,CAAC,OAAO,CAAC,CAAC,IAAU,EAAQ,EAAE;IAClC,kGAAkG;IAClG,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,EAAE,EAC1B,KAAK,GAAoB;QACvB,IAAI;QACJ,MAAM;QACN,QAAQ,EAAE,YAAY;aACnB,OAAO,CAAC,uBAAa,EAAE,IAAI,EAAE,MAAM,CAAC;aACpC,IAAI,CAAC,CAAC,MAAe,EAAW,EAAE,CAAC,MAAM,CAAC;QAC7C,WAAW,EAAE,YAAY;aACtB,OAAO,CAAC,yBAAe,EAAE,IAAI,EAAE,MAAM,CAAC;aACtC,IAAI,CAAC,CAAC,MAAe,EAAW,EAAE,CAAC,MAAM,CAAC;QAC7C,gBAAgB,EAAE,IAAA,uBAAU,EAAC,eAAe,EAAE,IAAI,EAAE,cAAc,CAAC;QACnE,mBAAmB,EAAE,IAAA,uBAAU,EAC7B,kBAAkB,EAClB,IAAI,EACJ,cAAc,CACf;KACF,CAAC;IAEJ,IAAI,KAAK,CAAC,QAAQ,EAAE;QAClB,MAAM,CAAC,IAAI,CAAC,qBAAqB,EAAE,IAAI,CAAC,CAAC;KAC1C;IAED,IAAI,KAAK,CAAC,QAAQ,IAAI,KAAK,CAAC,gBAAgB,KAAK,IAAI,EAAE;QACrD,mBAAmB,CAAC,KAAK,CAAC,CAAC;KAC5B;IAED,oBAAoB,CAClB,KAAK,EACL,KAAK,CAAC,WAAW,IAAI,KAAK,CAAC,mBAAmB,KAAK,IAAI,CACxD,CAAC;IAEF,yEAAyE;IACzE,IAAA,6BAAgB,EACd,eAAe,EACf,IAAI,EACJ,KAAK,CAAC,QAAQ,EACd,KAAK,CAAC,gBAAgB,EACtB,cAAc,CACf,CAAC;IAEF,IAAI,2BAA2B,IAAI,KAAK,CAAC,QAAQ,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE;QACvE,OAAO;KACR;IAED,IACE,CAAC,KAAK,CAAC,WAAW;QAClB,KAAK,CAAC,mBAAmB,KAAK,IAAI;QAClC,iBAAiB,CAAC,KAAK,CAAC,EACxB;QACA,IAAA,+BAAkB,EAAC,IAAI,EAAE,CAAC,kBAAkB,CAAC,EAAE,cAAc,CAAC,CAAC;QAE/D,OAAO;KACR;IAED,IAAA,6BAAgB,EACd,kBAAkB,EAClB,IAAI,EACJ,KAAK,CAAC,WAAW,EACjB,KAAK,CAAC,mBAAmB,EACzB,cAAc,EACd,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,yBAAyB,EAAE,IAAI,CAAC,CACnD,CAAC;AACJ,CAAC,CAAC,CAAC;AA9EQ,QAAA,cAAc,kBA8EtB;AAEL,kBAAe,sBAAc,CAAC"}

package/lib/statusTurn.ts

@@ -0,0 +1,142 @@
+import {
+  PendingEffect,
+  PendingEffectRegistry,
+} from '@civ-clone/core-pending-effect';
+import { cityStatus, forgetCityStatuses, updateCityStatus } from './cityStatus';
+import CelebrateLeader from '@civ-clone/core-city-happiness/Rules/CelebrateLeader';
+import City from '@civ-clone/core-city/City';
+import CivilDisorder from '@civ-clone/core-city-happiness/Rules/CivilDisorder';
+import { Engine } from '@civ-clone/core-engine/Engine';
+import { RuleRegistry } from '@civ-clone/core-rule/RuleRegistry';
+import Yield from '@civ-clone/core-yield/Yield';
+
+/** What a city's check found this turn, and what was recorded before it. */
+export type CityStatusCheck = {
+  city: City;
+  /** The yields the city was judged on, worked out once for both checks. */
+  yields: Yield[];
+  /** Whether the city is in civil disorder now. */
+  disorder: boolean;
+  /** Whether the city celebrates now. */
+  celebrating: boolean;
+  /** The city's disorder as recorded before this turn's check, or `null`. */
+  recordedDisorder: PendingEffect | null;
+  /** The city's celebration as recorded before this turn's check, or `null`. */
+  recordedCelebration: PendingEffect | null;
+};
+
+/** How a ruleset keeps its cities' disorder and celebrations from one turn to the next. */
+export type CityStatusTurn = {
+  /** The status `handler`s the ruleset records disorder and celebration under (see `cityStatus`). */
+  disorderHandler: string;
+  celebrationHandler: string;
+  pendingEffects: PendingEffectRegistry;
+  ruleRegistry: RuleRegistry;
+  engine: Engine;
+  /**
+   * Whether a city that celebrated before, and is in disorder now without celebrating, keeps its celebration (Civ1
+   *  keeps it, without a word, until order returns); otherwise its celebration is ended or forgotten as usual.
+   */
+  celebrationSurvivesDisorder?: boolean;
+  /** Called for a city in disorder for a second turn running (or more), before its status is updated. */
+  onDisorderContinues?: (check: CityStatusCheck) => void;
+  /**
+   * Called for each city whose celebration is updated, before it is, with whether it celebrates for a second turn
+   *  running (or more): what a ruleset grows a city for.
+   */
+  onCelebrationChecked?: (check: CityStatusCheck, again: boolean) => void;
+  /**
+   * Whether a celebration that has stopped is dropped without its end being told (no event), rather than ended.
+   *  Ended, by default.
+   */
+  forgetCelebration?: (check: CityStatusCheck) => boolean;
+};
+
+/**
+ * Checks each of `cities` for civil disorder and for celebrating, at the start of their player's turn, emitting
+ * `city:civil-disorder` for each city in disorder, and records the statuses that start and ends those that stop
+ * (`updateCityStatus`), emitting `city:leader-celebration` as a celebration starts. The handlers' events (registered
+ * with `registerCityStatusHandler`) tell of order restored and celebrations ended. The cities are taken in order, and a
+ * hook may change the player's government part-way through them.
+ */
+export const cityStatusTurn = (
+  cities: City[],
+  {
+    disorderHandler,
+    celebrationHandler,
+    pendingEffects,
+    ruleRegistry,
+    engine,
+    celebrationSurvivesDisorder = false,
+    onDisorderContinues = () => {},
+    onCelebrationChecked = () => {},
+    forgetCelebration = () => false,
+  }: CityStatusTurn
+): void =>
+  cities.forEach((city: City): void => {
+    // Both rules read the same yields, and working them out isn't cheap (civ-clone/web-renderer#315).
+    const yields = city.yields(),
+      check: CityStatusCheck = {
+        city,
+        yields,
+        disorder: ruleRegistry
+          .process(CivilDisorder, city, yields)
+          .some((result: boolean): boolean => result),
+        celebrating: ruleRegistry
+          .process(CelebrateLeader, city, yields)
+          .some((result: boolean): boolean => result),
+        recordedDisorder: cityStatus(disorderHandler, city, pendingEffects),
+        recordedCelebration: cityStatus(
+          celebrationHandler,
+          city,
+          pendingEffects
+        ),
+      };
+
+    if (check.disorder) {
+      engine.emit('city:civil-disorder', city);
+    }
+
+    if (check.disorder && check.recordedDisorder !== null) {
+      onDisorderContinues(check);
+    }
+
+    onCelebrationChecked(
+      check,
+      check.celebrating && check.recordedCelebration !== null
+    );
+
+    // Records disorder that has started, and ends disorder that has stopped.
+    updateCityStatus(
+      disorderHandler,
+      city,
+      check.disorder,
+      check.recordedDisorder,
+      pendingEffects
+    );
+
+    if (celebrationSurvivesDisorder && check.disorder && !check.celebrating) {
+      return;
+    }
+
+    if (
+      !check.celebrating &&
+      check.recordedCelebration !== null &&
+      forgetCelebration(check)
+    ) {
+      forgetCityStatuses(city, [celebrationHandler], pendingEffects);
+
+      return;
+    }
+
+    updateCityStatus(
+      celebrationHandler,
+      city,
+      check.celebrating,
+      check.recordedCelebration,
+      pendingEffects,
+      () => engine.emit('city:leader-celebration', city)
+    );
+  });
+
+export default cityStatusTurn;

package/package.json

@@ -1,6 +1,38 @@
 {
   "name": "@civ-clone/base-city-happiness-status",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "Keeps a city's status, such as disorder or celebrating, from one turn to the next and in the save.",
+  "repository": "git@github.com:civ-clone/base-city-happiness-status.git",
+  "keywords": [
+    "typescript",
+    "civilization"
+  ],
+  "author": "dom111 <dom111@users.noreply.github.com>",
+  "license": "MIT",
+  "private": false,
+  "scripts": {
+    "build": "npm run ts:compile && npm run prettier:format",
+    "prettier:check": "prettier --config .prettierrc --check '**/*.ts'",
+    "prettier:format": "prettier --config .prettierrc '**/*.ts' --write",
+    "test": "ts-mocha ./tests/*.test.ts",
+    "ts:compile": "tsc --build tsconfig.json"
+  },
+  "devDependencies": {
+    "@types/chai": "^4.0.0",
+    "@types/mocha": "^10.0.0",
+    "@types/node": "^16.0.0",
+    "chai": "^4.0.0",
+    "mocha": "^10.0.0",
+    "prettier": "^2.8.8",
+    "ts-mocha": "^10.0.0",
+    "typescript": "^4.0.0"
+  },
+  "dependencies": {
+    "@civ-clone/core-city": "^0.1.24",
+    "@civ-clone/core-city-happiness": "^0.1.2",
+    "@civ-clone/core-engine": "^0.1.6",
+    "@civ-clone/core-pending-effect": "^0.1.2",
+    "@civ-clone/core-rule": "^0.1.9",
+    "@civ-clone/core-yield": "^0.1.6"
+  }
+}

package/tests/cityStatus.test.ts

@@ -0,0 +1,109 @@
+import {
+  PendingEffect,
+  PendingEffectRegistry,
+} from '@civ-clone/core-pending-effect';
+import {
+  cityStatus,
+  forgetCityStatuses,
+  registerCityStatusHandler,
+  updateCityStatus,
+} from '../lib/cityStatus';
+import City from '@civ-clone/core-city/City';
+import Engine from '@civ-clone/core-engine/Engine';
+import { expect } from 'chai';
+
+const UPSET = 'test:upset',
+  CHEERFUL = 'test:cheerful';
+
+describe('cityStatus', (): void => {
+  const setUp = () => {
+    const pendingEffects = new PendingEffectRegistry(),
+      events: [string, unknown][] = [],
+      engine = {
+        emit: (event: string, target: unknown) => events.push([event, target]),
+      } as unknown as Engine,
+      city = {} as City,
+      otherCity = {} as City;
+
+    registerCityStatusHandler(UPSET, 'city:calm', pendingEffects, engine);
+    registerCityStatusHandler(CHEERFUL, 'city:glum', pendingEffects, engine);
+
+    return { pendingEffects, events, city, otherCity };
+  };
+
+  it('has no status until one is recorded', (): void => {
+    const { pendingEffects, city } = setUp();
+
+    expect(cityStatus(UPSET, city, pendingEffects)).null;
+  });
+
+  it('records a status that has started, calling onStart first, and keeps it while it goes on', (): void => {
+    const { pendingEffects, events, city, otherCity } = setUp(),
+      started: number[] = [];
+
+    updateCityStatus(UPSET, city, true, null, pendingEffects, () =>
+      started.push(pendingEffects.entries().length)
+    );
+
+    const recorded = cityStatus(UPSET, city, pendingEffects);
+
+    expect(started).eql([0]);
+    expect(recorded?.handler()).equal(UPSET);
+    expect(recorded?.target()).equal(city);
+    expect(cityStatus(CHEERFUL, city, pendingEffects)).null;
+    expect(cityStatus(UPSET, otherCity, pendingEffects)).null;
+
+    // The next turn: still active, and the status recorded last turn is kept rather than recorded again.
+    updateCityStatus(UPSET, city, true, recorded, pendingEffects, () =>
+      started.push(-1)
+    );
+
+    expect(started).eql([0]);
+    expect(pendingEffects.getByTarget(city).length).equal(1);
+    expect(cityStatus(UPSET, city, pendingEffects)).equal(recorded);
+    expect(events).eql([]);
+  });
+
+  it('ends a status that has stopped, emitting its event', (): void => {
+    const { pendingEffects, events, city } = setUp();
+
+    updateCityStatus(UPSET, city, true, null, pendingEffects);
+    updateCityStatus(
+      UPSET,
+      city,
+      false,
+      cityStatus(UPSET, city, pendingEffects),
+      pendingEffects
+    );
+
+    expect(cityStatus(UPSET, city, pendingEffects)).null;
+    expect(events).eql([['city:calm', city]]);
+  });
+
+  it('does nothing for a status that is neither active nor recorded', (): void => {
+    const { pendingEffects, events, city } = setUp();
+
+    updateCityStatus(UPSET, city, false, null, pendingEffects);
+
+    expect(pendingEffects.entries()).eql([]);
+    expect(events).eql([]);
+  });
+
+  it('forgets only the named statuses of the city, without ending them', (): void => {
+    const { pendingEffects, events, city, otherCity } = setUp(),
+      unrelated = new PendingEffect('test:other', city);
+
+    pendingEffects.register(unrelated);
+    updateCityStatus(UPSET, city, true, null, pendingEffects);
+    updateCityStatus(CHEERFUL, city, true, null, pendingEffects);
+    updateCityStatus(UPSET, otherCity, true, null, pendingEffects);
+
+    forgetCityStatuses(city, [UPSET, CHEERFUL], pendingEffects);
+
+    expect(cityStatus(UPSET, city, pendingEffects)).null;
+    expect(cityStatus(CHEERFUL, city, pendingEffects)).null;
+    expect(cityStatus(UPSET, otherCity, pendingEffects)).not.null;
+    expect(pendingEffects.getByTarget(city)).eql([unrelated]);
+    expect(events).eql([]);
+  });
+});

package/tests/statusTurn.test.ts

@@ -0,0 +1,187 @@
+import { CityStatusCheck, cityStatusTurn } from '../lib/statusTurn';
+import { cityStatus, registerCityStatusHandler } from '../lib/cityStatus';
+import CelebrateLeader from '@civ-clone/core-city-happiness/Rules/CelebrateLeader';
+import City from '@civ-clone/core-city/City';
+import CivilDisorder from '@civ-clone/core-city-happiness/Rules/CivilDisorder';
+import Effect from '@civ-clone/core-rule/Effect';
+import Engine from '@civ-clone/core-engine/Engine';
+import { PendingEffectRegistry } from '@civ-clone/core-pending-effect';
+import RuleRegistry from '@civ-clone/core-rule/RuleRegistry';
+import { expect } from 'chai';
+
+const UPSET = 'test:upset',
+  CHEERFUL = 'test:cheerful';
+
+describe('cityStatusTurn', (): void => {
+  const setUp = () => {
+    const pendingEffects = new PendingEffectRegistry(),
+      ruleRegistry = new RuleRegistry(),
+      events: [string, unknown][] = [],
+      engine = {
+        emit: (event: string, target: unknown) => events.push([event, target]),
+      } as unknown as Engine,
+      // What each city's check finds this turn, by name.
+      state: { [name: string]: { disorder: boolean; celebrating: boolean } } =
+        {},
+      yieldsAsked: string[] = [],
+      city = (name: string) =>
+        ({
+          name,
+          yields: () => {
+            yieldsAsked.push(name);
+
+            return [name];
+          },
+        } as unknown as City),
+      a = city('a'),
+      b = city('b');
+
+    ruleRegistry.register(
+      new CivilDisorder(
+        new Effect(
+          (city: City, yields: unknown[]): boolean =>
+            yields[0] === (city as any).name &&
+            state[(city as any).name].disorder
+        )
+      ),
+      new CelebrateLeader(
+        new Effect(
+          (city: City, yields: unknown[]): boolean =>
+            yields[0] === (city as any).name &&
+            state[(city as any).name].celebrating
+        )
+      )
+    );
+
+    registerCityStatusHandler(
+      UPSET,
+      'city:order-restored',
+      pendingEffects,
+      engine
+    );
+    registerCityStatusHandler(
+      CHEERFUL,
+      'city:celebration-ended',
+      pendingEffects,
+      engine
+    );
+
+    const turn = (extra: object = {}) =>
+      cityStatusTurn([a, b], {
+        disorderHandler: UPSET,
+        celebrationHandler: CHEERFUL,
+        pendingEffects,
+        ruleRegistry,
+        engine,
+        ...extra,
+      });
+
+    return { pendingEffects, events, state, yieldsAsked, a, b, turn };
+  };
+
+  it('works out the yields once per city, records disorder and celebrations as they start and ends them as they stop', (): void => {
+    const { pendingEffects, events, state, yieldsAsked, a, b, turn } = setUp();
+
+    state.a = { disorder: true, celebrating: false };
+    state.b = { disorder: false, celebrating: true };
+
+    turn();
+
+    expect(yieldsAsked).eql(['a', 'b']);
+    expect(events).eql([
+      ['city:civil-disorder', a],
+      ['city:leader-celebration', b],
+    ]);
+    expect(cityStatus(UPSET, a, pendingEffects)).not.null;
+    expect(cityStatus(CHEERFUL, b, pendingEffects)).not.null;
+
+    events.length = 0;
+    state.a = { disorder: false, celebrating: false };
+    state.b = { disorder: false, celebrating: false };
+
+    turn();
+
+    expect(events).eql([
+      ['city:order-restored', a],
+      ['city:celebration-ended', b],
+    ]);
+    expect(pendingEffects.entries()).empty;
+  });
+
+  it('calls the hooks with the check, telling a second turn running from a first', (): void => {
+    const { state, a, b, turn } = setUp(),
+      continued: City[] = [],
+      checked: [City, boolean][] = [];
+
+    state.a = { disorder: true, celebrating: false };
+    state.b = { disorder: false, celebrating: true };
+
+    const hooks = {
+      onDisorderContinues: ({ city }: CityStatusCheck) => continued.push(city),
+      onCelebrationChecked: ({ city }: CityStatusCheck, again: boolean) =>
+        checked.push([city, again]),
+    };
+
+    turn(hooks);
+    turn(hooks);
+
+    expect(continued).eql([a]);
+    expect(checked).eql([
+      [a, false],
+      [b, false],
+      [a, false],
+      [b, true],
+    ]);
+  });
+
+  it('keeps a celebration through disorder only when the ruleset says so', (): void => {
+    const { pendingEffects, events, state, a, turn } = setUp();
+
+    state.a = { disorder: false, celebrating: true };
+    state.b = { disorder: false, celebrating: false };
+
+    turn();
+
+    state.a = { disorder: true, celebrating: false };
+    events.length = 0;
+
+    turn({ celebrationSurvivesDisorder: true });
+
+    expect(cityStatus(CHEERFUL, a, pendingEffects)).not.null;
+    expect(events).eql([['city:civil-disorder', a]]);
+
+    turn();
+
+    expect(cityStatus(CHEERFUL, a, pendingEffects)).null;
+    expect(events).eql([
+      ['city:civil-disorder', a],
+      ['city:civil-disorder', a],
+      ['city:celebration-ended', a],
+    ]);
+  });
+
+  it('drops a celebration without a word when the ruleset forgets it', (): void => {
+    const { pendingEffects, events, state, a, turn } = setUp(),
+      asked: boolean[] = [];
+
+    state.a = { disorder: false, celebrating: true };
+    state.b = { disorder: false, celebrating: false };
+
+    turn();
+
+    state.a = { disorder: true, celebrating: false };
+    events.length = 0;
+
+    turn({
+      forgetCelebration: ({ disorder }: CityStatusCheck) => {
+        asked.push(disorder);
+
+        return disorder;
+      },
+    });
+
+    expect(asked).eql([true]);
+    expect(cityStatus(CHEERFUL, a, pendingEffects)).null;
+    expect(events).eql([['city:civil-disorder', a]]);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "declaration": true,
+    "lib": [
+      "es2020"
+    ],
+    "module": "commonjs",
+    "sourceMap": true,
+    "strict": true,
+    "target": "ES2018"
+  },
+  "exclude": [
+    "node_modules",
+    "tests"
+  ]
+}