@civ-clone/base-city-happiness-status 0.1.0 → 0.1.1

package/README.md

@@ -11,6 +11,11 @@ is a `core-pending-effect` `PendingEffect` on the city, named by the ruleset's o
   - `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/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,6 @@
 {
   "name": "@civ-clone/base-city-happiness-status",
-  "version": "0.1.0",
+  "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": [
@@ -29,7 +29,10 @@
   },
   "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-pending-effect": "^0.1.2",
+    "@civ-clone/core-rule": "^0.1.9",
+    "@civ-clone/core-yield": "^0.1.6"
   }
 }

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