@civ-clone/base-unit-fuel 0.0.0-stage → 0.1.0

package/.gitattributes

@@ -0,0 +1,4 @@
+**/*.d.ts linguist-generated=true
+**/*.js linguist-generated=true
+**/*.js.map 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,58 @@
-# Temporary Holding Version
+# base-unit-fuel
 
-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.
+Fuel for units that must return to base: a range, the turns a unit has ended out, where it refuels, and running out. A
+library: nothing registers on import, and a game that registers none of it has no fuel.
+
+## API
+
+Deep-import the modules; there is no index.
+
+- `lib/Fuel`: `Fuel`, the unit yield that gives a unit's range: how many of its player's turns it can end away from a
+  refuelling point, counting the one it set out in (1: it must refuel every turn; 2: it can stay out one turn). 0, as
+  with no `Yield` rule for it, needs no fuel.
+- `lib/fuelRules`: `fuelRules({ ruleRegistry, unitImprovementRegistry, unitRegistry }, { prefix?, range?, countOn?,
+  countsAsMove?, isAttack? })`:
+  - a rule that counts turns out, as `countOn` says (see below);
+  - an `OutOfFuel` rule that destroys the unit. A game adds its own `OutOfFuel` rules for anything else (a notice).
+  - `range(unit)` is the unit's `Fuel` yield by default (`fuelRange`); a game can read its own table instead.
+  - helpers: `refuels(ruleRegistry, unit, tile?)`, `turnsAloft(unitImprovementRegistry, unit)`, `aloftOf(...)`,
+    `checkFuel(...)` and `checkFuelAfterMove(...)`.
+  - Rule ids `<prefix>:player/turn-end/fuel` (or `<prefix>:unit/moved/fuel`) and `<prefix>:unit/out-of-fuel/destroy`.
+- `lib/Rules`: `Refuel(unit, tile) → boolean` (a unit refuels on a square if any rule's criteria match and its effect
+  answers `true`) and `OutOfFuel(unit)`.
+- `lib/refuel`, `Refuel` rules a game registers, each with an optional `applies(unit)` filter and id:
+  `refuelInOwnCity(cityRegistry)`, `refuelOnTileImprovement(Improvement, tileImprovementRegistry)`,
+  `refuelInStackWith(isBase(base, unit), unitRegistry)` (another of the player's units on the square, such as one that
+  carries it) and `refuelAboard(transportRegistry)`.
+- `lib/reach`, for computer players:
+  - `fuelState(unitImprovementRegistry, unit, range?)`: `{ range, turnsAloft, turnsLeft, reach }`, `turnsLeft` counting
+    this turn, and `reach` the moves before the end of the last of them (moves left, then full movement each turn);
+    `null` for a unit with no range.
+  - `refuelInReach(ruleRegistry, unitImprovementRegistry, unit, { range?, distance?, candidates? })`: the nearest
+    square within reach where the unit refuels, or `null`.
+
+## When fuel is counted
+
+`countOn` chooses:
+
+- `'turn-end'` (the default): a `TurnEnd` rule. At the end of each of the player's turns, a unit with a range that
+  refuels where it is loses its count; any other has ended one more turn out, and runs out of fuel (`OutOfFuel`) when
+  that reaches its range. It doesn't matter whether the unit spent its moves. This is how civ1-unit's own fuel rule
+  counts, so that rule can move onto this package later with the same behaviour.
+- `'out-of-moves'`: a `Moved` rule, as OpenCiv2 (github.com/richardpenman/civ2, read at 49f26ec,
+  `unit_move_dir_air_fuel`) counts. After a move (`countsAsMove`, by default an action to another square), a unit that
+  refuels where it is has landed: it loses its count and its remaining moves. The exception is a unit with a range of 1
+  that attacked (`isAttack`, by default it didn't end up on its target) and still has moves, which hasn't landed. A unit
+  anywhere else, left with no moves, has spent one more turn out, and runs out of fuel when that reaches its range. A
+  unit that ends its turn with moves unspent isn't counted, as in the original.
+
+The places the original refuels (a city, an airbase, a stack with a unit that carries it) are the rules in
+`lib/refuel`.
+
+## The count is saved
+
+`Aloft` (a `UnitImprovement` holding the count) exists only for a unit that is out, and goes when it refuels, so a
+unit at its base carries and saves nothing extra. A game that saves registers it in its
+`AvailableUnitImprovementRegistry` (`tests/save.test.ts` round-trips it through core-save-game; without that, loading
+fails with "Unknown entity type 'Aloft'"). It is also sent to clients in a unit's `improvements`, so a client should leave it
+out of what it shows (or show the count).

package/lib/Aloft.d.ts

@@ -0,0 +1,14 @@
+import Unit from '@civ-clone/core-unit/Unit';
+import UnitImprovement from '@civ-clone/core-unit-improvement/UnitImprovement';
+/**
+ * How many of its player's turns a fuelled unit has ended away from somewhere it refuels. Only a unit that is out has
+ *  one, and it goes when the unit refuels, so a unit at its base carries and saves nothing extra. A game that saves
+ *  needs it in its `AvailableUnitImprovementRegistry`.
+ */
+export declare class Aloft extends UnitImprovement {
+  private _turns;
+  constructor(unit: Unit, turns?: number);
+  turns(): number;
+  setTurns(turns: number): void;
+}
+export default Aloft;

package/lib/Aloft.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Aloft = void 0;
+const UnitImprovement_1 = require("@civ-clone/core-unit-improvement/UnitImprovement");
+/**
+ * How many of its player's turns a fuelled unit has ended away from somewhere it refuels. Only a unit that is out has
+ *  one, and it goes when the unit refuels, so a unit at its base carries and saves nothing extra. A game that saves
+ *  needs it in its `AvailableUnitImprovementRegistry`.
+ */
+class Aloft extends UnitImprovement_1.default {
+    constructor(unit, turns = 1) {
+        super(unit);
+        this._turns = turns;
+        this.addKey('turns');
+    }
+    turns() {
+        return this._turns;
+    }
+    setTurns(turns) {
+        this._turns = turns;
+    }
+}
+exports.Aloft = Aloft;
+exports.default = Aloft;
+//# sourceMappingURL=Aloft.js.map

package/lib/Aloft.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Aloft.js","sourceRoot":"","sources":["Aloft.ts"],"names":[],"mappings":";;;AACA,sFAA+E;AAE/E;;;;GAIG;AACH,MAAa,KAAM,SAAQ,yBAAe;IAGxC,YAAY,IAAU,EAAE,QAAgB,CAAC;QACvC,KAAK,CAAC,IAAI,CAAC,CAAC;QAEZ,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;QAEpB,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IACvB,CAAC;IAED,KAAK;QACH,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAED,QAAQ,CAAC,KAAa;QACpB,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;IACtB,CAAC;CACF;AAlBD,sBAkBC;AAED,kBAAe,KAAK,CAAC"}

package/lib/Aloft.ts

@@ -0,0 +1,29 @@
+import Unit from '@civ-clone/core-unit/Unit';
+import UnitImprovement from '@civ-clone/core-unit-improvement/UnitImprovement';
+
+/**
+ * How many of its player's turns a fuelled unit has ended away from somewhere it refuels. Only a unit that is out has
+ *  one, and it goes when the unit refuels, so a unit at its base carries and saves nothing extra. A game that saves
+ *  needs it in its `AvailableUnitImprovementRegistry`.
+ */
+export class Aloft extends UnitImprovement {
+  private _turns: number;
+
+  constructor(unit: Unit, turns: number = 1) {
+    super(unit);
+
+    this._turns = turns;
+
+    this.addKey('turns');
+  }
+
+  turns(): number {
+    return this._turns;
+  }
+
+  setTurns(turns: number): void {
+    this._turns = turns;
+  }
+}
+
+export default Aloft;

package/lib/Fuel.d.ts

@@ -0,0 +1,8 @@
+import Yield from '@civ-clone/core-yield/Yield';
+/**
+ * How many of its player's turns a unit can end away from somewhere it refuels (see `Refuel`), counting the one it set
+ *  out in: at 1 it must refuel by the end of each turn, at 2 it can stay out for one turn. A unit with none (0, as a
+ *  game that registers no `Yield` rule for it leaves every unit) needs no fuel.
+ */
+export declare class Fuel extends Yield {}
+export default Fuel;

package/lib/Fuel.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Fuel = void 0;
+const Yield_1 = require("@civ-clone/core-yield/Yield");
+/**
+ * How many of its player's turns a unit can end away from somewhere it refuels (see `Refuel`), counting the one it set
+ *  out in: at 1 it must refuel by the end of each turn, at 2 it can stay out for one turn. A unit with none (0, as a
+ *  game that registers no `Yield` rule for it leaves every unit) needs no fuel.
+ */
+class Fuel extends Yield_1.default {
+}
+exports.Fuel = Fuel;
+exports.default = Fuel;
+//# sourceMappingURL=Fuel.js.map

package/lib/Fuel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Fuel.js","sourceRoot":"","sources":["Fuel.ts"],"names":[],"mappings":";;;AAAA,uDAAgD;AAEhD;;;;GAIG;AACH,MAAa,IAAK,SAAQ,eAAK;CAAG;AAAlC,oBAAkC;AAElC,kBAAe,IAAI,CAAC"}

package/lib/Fuel.ts

@@ -0,0 +1,10 @@
+import Yield from '@civ-clone/core-yield/Yield';
+
+/**
+ * How many of its player's turns a unit can end away from somewhere it refuels (see `Refuel`), counting the one it set
+ *  out in: at 1 it must refuel by the end of each turn, at 2 it can stay out for one turn. A unit with none (0, as a
+ *  game that registers no `Yield` rule for it leaves every unit) needs no fuel.
+ */
+export class Fuel extends Yield {}
+
+export default Fuel;

package/lib/Rules.d.ts

@@ -0,0 +1,10 @@
+import Rule from '@civ-clone/core-rule/Rule';
+import Tile from '@civ-clone/core-world/Tile';
+import Unit from '@civ-clone/core-unit/Unit';
+/**
+ * Whether `unit` refuels on `tile`: it does if any rule's criteria match and its effect returns `true`. A game says
+ *  where with its criteria (see `refuelInOwnCity`, `refuelOnTileImprovement`, `refuelInStackWith`, `refuelAboard`).
+ */
+export declare class Refuel extends Rule<[unit: Unit, tile: Tile], boolean> {}
+/** `unit` ran out of fuel away from anywhere it refuels. `fuelRules` adds one that destroys it. */
+export declare class OutOfFuel extends Rule<[unit: Unit], void> {}

package/lib/Rules.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OutOfFuel = exports.Refuel = void 0;
+const Rule_1 = require("@civ-clone/core-rule/Rule");
+/**
+ * Whether `unit` refuels on `tile`: it does if any rule's criteria match and its effect returns `true`. A game says
+ *  where with its criteria (see `refuelInOwnCity`, `refuelOnTileImprovement`, `refuelInStackWith`, `refuelAboard`).
+ */
+class Refuel extends Rule_1.default {
+}
+exports.Refuel = Refuel;
+/** `unit` ran out of fuel away from anywhere it refuels. `fuelRules` adds one that destroys it. */
+class OutOfFuel extends Rule_1.default {
+}
+exports.OutOfFuel = OutOfFuel;
+//# sourceMappingURL=Rules.js.map

package/lib/Rules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Rules.js","sourceRoot":"","sources":["Rules.ts"],"names":[],"mappings":";;;AAAA,oDAA6C;AAI7C;;;GAGG;AACH,MAAa,MAAO,SAAQ,cAAuC;CAAG;AAAtE,wBAAsE;AAEtE,mGAAmG;AACnG,MAAa,SAAU,SAAQ,cAAwB;CAAG;AAA1D,8BAA0D"}

package/lib/Rules.ts

@@ -0,0 +1,12 @@
+import Rule from '@civ-clone/core-rule/Rule';
+import Tile from '@civ-clone/core-world/Tile';
+import Unit from '@civ-clone/core-unit/Unit';
+
+/**
+ * Whether `unit` refuels on `tile`: it does if any rule's criteria match and its effect returns `true`. A game says
+ *  where with its criteria (see `refuelInOwnCity`, `refuelOnTileImprovement`, `refuelInStackWith`, `refuelAboard`).
+ */
+export class Refuel extends Rule<[unit: Unit, tile: Tile], boolean> {}
+
+/** `unit` ran out of fuel away from anywhere it refuels. `fuelRules` adds one that destroys it. */
+export class OutOfFuel extends Rule<[unit: Unit], void> {}

package/lib/fuelRules.d.ts

@@ -0,0 +1,95 @@
+import { OutOfFuel } from './Rules';
+import { RuleRegistry } from '@civ-clone/core-rule/RuleRegistry';
+import { UnitImprovementRegistry } from '@civ-clone/core-unit-improvement/UnitImprovementRegistry';
+import { UnitRegistry } from '@civ-clone/core-unit/UnitRegistry';
+import Action from '@civ-clone/core-unit/Action';
+import Aloft from './Aloft';
+import Moved from '@civ-clone/core-unit/Rules/Moved';
+import Player from '@civ-clone/core-player/Player';
+import Tile from '@civ-clone/core-world/Tile';
+import TurnEnd from '@civ-clone/core-player/Rules/TurnEnd';
+import Unit from '@civ-clone/core-unit/Unit';
+export interface FuelDependencies {
+  ruleRegistry?: RuleRegistry;
+  unitImprovementRegistry?: UnitImprovementRegistry;
+  unitRegistry?: UnitRegistry;
+}
+/** A unit's range: how many turns it can end away from a refuelling point. */
+export type Range = (unit: Unit) => number;
+/**
+ * When a unit's turns out are counted:
+ *
+ * - `'turn-end'`: at the end of each of its player's turns, wherever it is (`checkFuel`);
+ * - `'out-of-moves'`: after each move, as the original does (`checkFuelAfterMove`).
+ */
+export type CountOn = 'turn-end' | 'out-of-moves';
+export interface FuelOptions {
+  /**
+   * The rules' ids are `<prefix>:player/turn-end/fuel` (or `<prefix>:unit/moved/fuel`) and
+   *  `<prefix>:unit/out-of-fuel/destroy`. Unnamed without.
+   */
+  prefix?: string;
+  /** A unit's range: its `Fuel` yield by default. */
+  range?: Range;
+  /** When turns out are counted: `'turn-end'` by default. */
+  countOn?: CountOn;
+  /** For `'out-of-moves'`, whether a `Moved` action is a move: by default, one to another square (attacks included). */
+  countsAsMove?: (unit: Unit, action: Action) => boolean;
+  /** For `'out-of-moves'`, whether the action was an attack: by default, the unit didn't end up on its target. */
+  isAttack?: (unit: Unit, action: Action) => boolean;
+}
+/** A unit's `Fuel` yield. */
+export declare const fuelRange: Range;
+/** `unit`'s `Aloft` mark, if it has one. */
+export declare const aloftOf: (
+  unitImprovementRegistry: UnitImprovementRegistry,
+  unit: Unit
+) => Aloft | undefined;
+/** How many turns `unit` has ended away from a refuelling point since it last refuelled. */
+export declare const turnsAloft: (
+  unitImprovementRegistry: UnitImprovementRegistry,
+  unit: Unit
+) => number;
+/** Whether `unit` refuels on `tile` (see `Refuel`). */
+export declare const refuels: (
+  ruleRegistry: RuleRegistry,
+  unit: Unit,
+  tile?: Tile
+) => boolean;
+/**
+ * At the end of `player`'s turn, for each of its units with a range (above 0): one that refuels where it is loses its
+ *  `Aloft` mark; any other has ended one more turn out, and runs out of fuel (`OutOfFuel`) once that reaches its range.
+ */
+export declare const checkFuel: (
+  ruleRegistry: RuleRegistry,
+  unitImprovementRegistry: UnitImprovementRegistry,
+  unitRegistry: UnitRegistry,
+  range: Range
+) => (player: Player) => void;
+/**
+ * After `unit` moves (OpenCiv2, `unit_move_dir_air_fuel`), for a unit with a range (above 0):
+ *
+ * - where it refuels, it loses its `Aloft` mark and its remaining moves (it has landed), except that a unit with a
+ *   range of 1 that attacked and still has moves left hasn't landed;
+ * - anywhere else, once it has no moves left, it has spent one more turn out, and runs out of fuel (`OutOfFuel`) when
+ *   that reaches its range.
+ */
+export declare const checkFuelAfterMove: (
+  ruleRegistry: RuleRegistry,
+  unitImprovementRegistry: UnitImprovementRegistry,
+  range: Range,
+  isAttack: (unit: Unit, action: Action) => boolean
+) => (unit: Unit, action: Action) => void;
+/**
+ * A ruleset's fuel rules: one that counts the turns each unit with a range spends away from a refuelling point, and an
+ *  `OutOfFuel` rule that destroys a unit that runs out. A game adds its own `Refuel` rules (see `lib/refuel`), and its
+ *  own `OutOfFuel` rules for anything else that should happen (a notice, say).
+ *
+ * With `countOn: 'turn-end'` (the default) the count is a `TurnEnd` rule (`checkFuel`): it doesn't matter whether a
+ *  unit spent its moves. With `'out-of-moves'` it is a `Moved` rule (`checkFuelAfterMove`), as the original counts it.
+ */
+export declare const fuelRules: (
+  { ruleRegistry, unitImprovementRegistry, unitRegistry }: FuelDependencies,
+  { prefix, range, countOn, countsAsMove, isAttack }?: FuelOptions
+) => (TurnEnd | Moved | OutOfFuel)[];
+export default fuelRules;

package/lib/fuelRules.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fuelRules = exports.checkFuelAfterMove = exports.checkFuel = exports.refuels = exports.turnsAloft = exports.aloftOf = exports.fuelRange = void 0;
+const Rules_1 = require("./Rules");
+const RuleRegistry_1 = require("@civ-clone/core-rule/RuleRegistry");
+const UnitImprovementRegistry_1 = require("@civ-clone/core-unit-improvement/UnitImprovementRegistry");
+const UnitRegistry_1 = require("@civ-clone/core-unit/UnitRegistry");
+const Aloft_1 = require("./Aloft");
+const Criterion_1 = require("@civ-clone/core-rule/Criterion");
+const Effect_1 = require("@civ-clone/core-rule/Effect");
+const Fuel_1 = require("./Fuel");
+const Moved_1 = require("@civ-clone/core-unit/Rules/Moved");
+const TurnEnd_1 = require("@civ-clone/core-player/Rules/TurnEnd");
+/** A unit's `Fuel` yield. */
+const fuelRange = (unit) => {
+    const [range] = unit.yield(new Fuel_1.default());
+    return range.value();
+};
+exports.fuelRange = fuelRange;
+/** `unit`'s `Aloft` mark, if it has one. */
+const aloftOf = (unitImprovementRegistry, unit) => unitImprovementRegistry
+    .getByUnit(unit)
+    .find((unitImprovement) => unitImprovement instanceof Aloft_1.default);
+exports.aloftOf = aloftOf;
+/** How many turns `unit` has ended away from a refuelling point since it last refuelled. */
+const turnsAloft = (unitImprovementRegistry, unit) => { var _a, _b; return (_b = (_a = (0, exports.aloftOf)(unitImprovementRegistry, unit)) === null || _a === void 0 ? void 0 : _a.turns()) !== null && _b !== void 0 ? _b : 0; };
+exports.turnsAloft = turnsAloft;
+/** Whether `unit` refuels on `tile` (see `Refuel`). */
+const refuels = (ruleRegistry, unit, tile = unit.tile()) => ruleRegistry
+    .process(Rules_1.Refuel, unit, tile)
+    .some((answer) => answer === true);
+exports.refuels = refuels;
+/**
+ * At the end of `player`'s turn, for each of its units with a range (above 0): one that refuels where it is loses its
+ *  `Aloft` mark; any other has ended one more turn out, and runs out of fuel (`OutOfFuel`) once that reaches its range.
+ */
+const checkFuel = (ruleRegistry, unitImprovementRegistry, unitRegistry, range) => (player) => unitRegistry.getByPlayer(player).forEach((unit) => {
+    var _a;
+    if (unit.destroyed()) {
+        return;
+    }
+    const unitRange = range(unit);
+    if (!(unitRange > 0)) {
+        return;
+    }
+    const aloft = (0, exports.aloftOf)(unitImprovementRegistry, unit);
+    if ((0, exports.refuels)(ruleRegistry, unit)) {
+        if (aloft !== undefined) {
+            unitImprovementRegistry.unregister(aloft);
+        }
+        return;
+    }
+    const turns = ((_a = aloft === null || aloft === void 0 ? void 0 : aloft.turns()) !== null && _a !== void 0 ? _a : 0) + 1;
+    if (turns < unitRange) {
+        if (aloft === undefined) {
+            unitImprovementRegistry.register(new Aloft_1.default(unit, turns));
+            return;
+        }
+        aloft.setTurns(turns);
+        return;
+    }
+    if (aloft !== undefined) {
+        unitImprovementRegistry.unregister(aloft);
+    }
+    ruleRegistry.process(Rules_1.OutOfFuel, unit);
+});
+exports.checkFuel = checkFuel;
+/**
+ * After `unit` moves (OpenCiv2, `unit_move_dir_air_fuel`), for a unit with a range (above 0):
+ *
+ * - where it refuels, it loses its `Aloft` mark and its remaining moves (it has landed), except that a unit with a
+ *   range of 1 that attacked and still has moves left hasn't landed;
+ * - anywhere else, once it has no moves left, it has spent one more turn out, and runs out of fuel (`OutOfFuel`) when
+ *   that reaches its range.
+ */
+const checkFuelAfterMove = (ruleRegistry, unitImprovementRegistry, range, isAttack) => (unit, action) => {
+    var _a;
+    if (unit.destroyed()) {
+        return;
+    }
+    const unitRange = range(unit);
+    if (!(unitRange > 0)) {
+        return;
+    }
+    const aloft = (0, exports.aloftOf)(unitImprovementRegistry, unit), landed = (0, exports.refuels)(ruleRegistry, unit) &&
+        !(unitRange === 1 &&
+            unit.moves().value() > 0 &&
+            isAttack(unit, action));
+    if (landed) {
+        if (aloft !== undefined) {
+            unitImprovementRegistry.unregister(aloft);
+        }
+        unit.moves().set(0);
+        return;
+    }
+    if (unit.moves().value() > 0) {
+        return;
+    }
+    const turns = ((_a = aloft === null || aloft === void 0 ? void 0 : aloft.turns()) !== null && _a !== void 0 ? _a : 0) + 1;
+    if (turns < unitRange) {
+        if (aloft === undefined) {
+            unitImprovementRegistry.register(new Aloft_1.default(unit, turns));
+            return;
+        }
+        aloft.setTurns(turns);
+        return;
+    }
+    if (aloft !== undefined) {
+        unitImprovementRegistry.unregister(aloft);
+    }
+    ruleRegistry.process(Rules_1.OutOfFuel, unit);
+};
+exports.checkFuelAfterMove = checkFuelAfterMove;
+/**
+ * A ruleset's fuel rules: one that counts the turns each unit with a range spends away from a refuelling point, and an
+ *  `OutOfFuel` rule that destroys a unit that runs out. A game adds its own `Refuel` rules (see `lib/refuel`), and its
+ *  own `OutOfFuel` rules for anything else that should happen (a notice, say).
+ *
+ * With `countOn: 'turn-end'` (the default) the count is a `TurnEnd` rule (`checkFuel`): it doesn't matter whether a
+ *  unit spent its moves. With `'out-of-moves'` it is a `Moved` rule (`checkFuelAfterMove`), as the original counts it.
+ */
+const fuelRules = ({ ruleRegistry = RuleRegistry_1.instance, unitImprovementRegistry = UnitImprovementRegistry_1.instance, unitRegistry = UnitRegistry_1.instance, }, { prefix, range = exports.fuelRange, countOn = 'turn-end', countsAsMove = (unit, action) => action.from() !== action.to(), isAttack = (unit, action) => unit.tile() !== action.to(), } = {}) => {
+    const id = (name) => prefix === undefined ? [] : [`${prefix}:${name}`];
+    return [
+        countOn === 'out-of-moves'
+            ? new Moved_1.default(...id('unit/moved/fuel'), new Criterion_1.default(countsAsMove), new Effect_1.default((0, exports.checkFuelAfterMove)(ruleRegistry, unitImprovementRegistry, range, isAttack)))
+            : new TurnEnd_1.default(...id('player/turn-end/fuel'), new Effect_1.default((0, exports.checkFuel)(ruleRegistry, unitImprovementRegistry, unitRegistry, range))),
+        new Rules_1.OutOfFuel(...id('unit/out-of-fuel/destroy'), new Effect_1.default((unit) => unit.destroy())),
+    ];
+};
+exports.fuelRules = fuelRules;
+exports.default = exports.fuelRules;
+//# sourceMappingURL=fuelRules.js.map

package/lib/fuelRules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fuelRules.js","sourceRoot":"","sources":["fuelRules.ts"],"names":[],"mappings":"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"}