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

package/lib/fuelRules.ts

@@ -0,0 +1,277 @@
+import { OutOfFuel, Refuel } from './Rules';
+import {
+  RuleRegistry,
+  instance as ruleRegistryInstance,
+} from '@civ-clone/core-rule/RuleRegistry';
+import {
+  UnitImprovementRegistry,
+  instance as unitImprovementRegistryInstance,
+} from '@civ-clone/core-unit-improvement/UnitImprovementRegistry';
+import {
+  UnitRegistry,
+  instance as unitRegistryInstance,
+} from '@civ-clone/core-unit/UnitRegistry';
+import Action from '@civ-clone/core-unit/Action';
+import Aloft from './Aloft';
+import Criterion from '@civ-clone/core-rule/Criterion';
+import Effect from '@civ-clone/core-rule/Effect';
+import Fuel from './Fuel';
+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';
+import UnitImprovement from '@civ-clone/core-unit-improvement/UnitImprovement';
+
+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 const fuelRange: Range = (unit: Unit): number => {
+  const [range] = unit.yield(new Fuel());
+
+  return range.value();
+};
+
+/** `unit`'s `Aloft` mark, if it has one. */
+export const aloftOf = (
+  unitImprovementRegistry: UnitImprovementRegistry,
+  unit: Unit
+): Aloft | undefined =>
+  unitImprovementRegistry
+    .getByUnit(unit)
+    .find(
+      (unitImprovement: UnitImprovement): boolean =>
+        unitImprovement instanceof Aloft
+    ) as Aloft | undefined;
+
+/** How many turns `unit` has ended away from a refuelling point since it last refuelled. */
+export const turnsAloft = (
+  unitImprovementRegistry: UnitImprovementRegistry,
+  unit: Unit
+): number => aloftOf(unitImprovementRegistry, unit)?.turns() ?? 0;
+
+/** Whether `unit` refuels on `tile` (see `Refuel`). */
+export const refuels = (
+  ruleRegistry: RuleRegistry,
+  unit: Unit,
+  tile: Tile = unit.tile()
+): boolean =>
+  ruleRegistry
+    .process(Refuel, unit, tile)
+    .some((answer: boolean | void): boolean => answer === true);
+
+/**
+ * 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 const checkFuel =
+  (
+    ruleRegistry: RuleRegistry,
+    unitImprovementRegistry: UnitImprovementRegistry,
+    unitRegistry: UnitRegistry,
+    range: Range
+  ) =>
+  (player: Player): void =>
+    unitRegistry.getByPlayer(player).forEach((unit: Unit): void => {
+      if (unit.destroyed()) {
+        return;
+      }
+
+      const unitRange = range(unit);
+
+      if (!(unitRange > 0)) {
+        return;
+      }
+
+      const aloft = aloftOf(unitImprovementRegistry, unit);
+
+      if (refuels(ruleRegistry, unit)) {
+        if (aloft !== undefined) {
+          unitImprovementRegistry.unregister(aloft);
+        }
+
+        return;
+      }
+
+      const turns = (aloft?.turns() ?? 0) + 1;
+
+      if (turns < unitRange) {
+        if (aloft === undefined) {
+          unitImprovementRegistry.register(new Aloft(unit, turns));
+
+          return;
+        }
+
+        aloft.setTurns(turns);
+
+        return;
+      }
+
+      if (aloft !== undefined) {
+        unitImprovementRegistry.unregister(aloft);
+      }
+
+      ruleRegistry.process(OutOfFuel, unit);
+    });
+
+/**
+ * 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 const checkFuelAfterMove =
+  (
+    ruleRegistry: RuleRegistry,
+    unitImprovementRegistry: UnitImprovementRegistry,
+    range: Range,
+    isAttack: (unit: Unit, action: Action) => boolean
+  ) =>
+  (unit: Unit, action: Action): void => {
+    if (unit.destroyed()) {
+      return;
+    }
+
+    const unitRange = range(unit);
+
+    if (!(unitRange > 0)) {
+      return;
+    }
+
+    const aloft = aloftOf(unitImprovementRegistry, unit),
+      landed =
+        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 = (aloft?.turns() ?? 0) + 1;
+
+    if (turns < unitRange) {
+      if (aloft === undefined) {
+        unitImprovementRegistry.register(new Aloft(unit, turns));
+
+        return;
+      }
+
+      aloft.setTurns(turns);
+
+      return;
+    }
+
+    if (aloft !== undefined) {
+      unitImprovementRegistry.unregister(aloft);
+    }
+
+    ruleRegistry.process(OutOfFuel, unit);
+  };
+
+/**
+ * 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 const fuelRules = (
+  {
+    ruleRegistry = ruleRegistryInstance,
+    unitImprovementRegistry = unitImprovementRegistryInstance,
+    unitRegistry = unitRegistryInstance,
+  }: FuelDependencies,
+  {
+    prefix,
+    range = fuelRange,
+    countOn = 'turn-end',
+    countsAsMove = (unit: Unit, action: Action): boolean =>
+      action.from() !== action.to(),
+    isAttack = (unit: Unit, action: Action): boolean =>
+      unit.tile() !== action.to(),
+  }: FuelOptions = {}
+): (TurnEnd | Moved | OutOfFuel)[] => {
+  const id = (name: string): string[] =>
+    prefix === undefined ? [] : [`${prefix}:${name}`];
+
+  return [
+    countOn === 'out-of-moves'
+      ? new Moved(
+          ...id('unit/moved/fuel'),
+          new Criterion(countsAsMove),
+          new Effect(
+            checkFuelAfterMove(
+              ruleRegistry,
+              unitImprovementRegistry,
+              range,
+              isAttack
+            )
+          )
+        )
+      : new TurnEnd(
+          ...id('player/turn-end/fuel'),
+          new Effect(
+            checkFuel(
+              ruleRegistry,
+              unitImprovementRegistry,
+              unitRegistry,
+              range
+            )
+          )
+        ),
+    new OutOfFuel(
+      ...id('unit/out-of-fuel/destroy'),
+      new Effect((unit: Unit): void => unit.destroy())
+    ),
+  ];
+};
+
+export default fuelRules;

package/lib/reach.d.ts

@@ -0,0 +1,41 @@
+import { Range } from './fuelRules';
+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 UnitImprovementRegistry from '@civ-clone/core-unit-improvement/UnitImprovementRegistry';
+export interface FuelState {
+  /** The unit's range. */
+  range: number;
+  /** The turns it has ended away from a refuelling point since it last refuelled. */
+  turnsAloft: number;
+  /**
+   * The turns it has left, this one included: it must be somewhere it refuels by the end of the last of them. 1 means
+   *  by the end of this turn.
+   */
+  turnsLeft: number;
+  /** How many moves it has before then: its moves left, and its full movement for each turn after this one. */
+  reach: number;
+}
+/** Where a fuelled `unit` stands, for a computer player deciding where to send it; `null` for a unit with no range. */
+export declare const fuelState: (
+  unitImprovementRegistry: UnitImprovementRegistry,
+  unit: Unit,
+  range?: Range
+) => FuelState | null;
+export interface RefuelInReachOptions {
+  range?: Range;
+  /** How many moves apart two squares are: `Tile.distanceFrom` by default. */
+  distance?: (from: Tile, to: Tile) => number;
+  /** The squares to look at: by default the area around the unit as far as its reach. */
+  candidates?: (unit: Unit, reach: number) => Tile[];
+}
+/**
+ * The nearest square within `unit`'s reach (see `fuelState`) where it refuels (`Refuel`), its own square first; `null`
+ *  if there is none, or the unit has no range. The first of equally near squares.
+ */
+export declare const refuelInReach: (
+  ruleRegistry: RuleRegistry,
+  unitImprovementRegistry: UnitImprovementRegistry,
+  unit: Unit,
+  { range, distance, candidates }?: RefuelInReachOptions
+) => Tile | null;

package/lib/reach.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.refuelInReach = exports.fuelState = void 0;
+const fuelRules_1 = require("./fuelRules");
+/** Where a fuelled `unit` stands, for a computer player deciding where to send it; `null` for a unit with no range. */
+const fuelState = (unitImprovementRegistry, unit, range = fuelRules_1.fuelRange) => {
+    const unitRange = range(unit);
+    if (!(unitRange > 0)) {
+        return null;
+    }
+    const aloft = (0, fuelRules_1.turnsAloft)(unitImprovementRegistry, unit), turnsLeft = Math.max(0, unitRange - aloft);
+    return {
+        range: unitRange,
+        turnsAloft: aloft,
+        turnsLeft,
+        reach: turnsLeft === 0
+            ? 0
+            : unit.moves().value() + unit.movement().value() * (turnsLeft - 1),
+    };
+};
+exports.fuelState = fuelState;
+/**
+ * The nearest square within `unit`'s reach (see `fuelState`) where it refuels (`Refuel`), its own square first; `null`
+ *  if there is none, or the unit has no range. The first of equally near squares.
+ */
+const refuelInReach = (ruleRegistry, unitImprovementRegistry, unit, { range = fuelRules_1.fuelRange, distance = (from, to) => from.distanceFrom(to), candidates = (candidate, reach) => candidate.tile().getSurroundingArea(Math.floor(reach)).entries(), } = {}) => {
+    const state = (0, exports.fuelState)(unitImprovementRegistry, unit, range);
+    if (state === null) {
+        return null;
+    }
+    const from = unit.tile();
+    if ((0, fuelRules_1.refuels)(ruleRegistry, unit, from)) {
+        return from;
+    }
+    let nearest = null;
+    candidates(unit, state.reach).forEach((tile) => {
+        const away = distance(from, tile);
+        if (away <= state.reach &&
+            (nearest === null || away < nearest[1]) &&
+            (0, fuelRules_1.refuels)(ruleRegistry, unit, tile)) {
+            nearest = [tile, away];
+        }
+    });
+    return nearest === null ? null : nearest[0];
+};
+exports.refuelInReach = refuelInReach;
+//# sourceMappingURL=reach.js.map

package/lib/reach.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reach.js","sourceRoot":"","sources":["reach.ts"],"names":[],"mappings":";;;AAAA,2CAAoE;AAoBpE,uHAAuH;AAChH,MAAM,SAAS,GAAG,CACvB,uBAAgD,EAChD,IAAU,EACV,QAAe,qBAAS,EACN,EAAE;IACpB,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC;IAE9B,IAAI,CAAC,CAAC,SAAS,GAAG,CAAC,CAAC,EAAE;QACpB,OAAO,IAAI,CAAC;KACb;IAED,MAAM,KAAK,GAAG,IAAA,sBAAU,EAAC,uBAAuB,EAAE,IAAI,CAAC,EACrD,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,SAAS,GAAG,KAAK,CAAC,CAAC;IAE7C,OAAO;QACL,KAAK,EAAE,SAAS;QAChB,UAAU,EAAE,KAAK;QACjB,SAAS;QACT,KAAK,EACH,SAAS,KAAK,CAAC;YACb,CAAC,CAAC,CAAC;YACH,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,GAAG,CAAC,SAAS,GAAG,CAAC,CAAC;KACvE,CAAC;AACJ,CAAC,CAAC;AAvBW,QAAA,SAAS,aAuBpB;AAUF;;;GAGG;AACI,MAAM,aAAa,GAAG,CAC3B,YAA0B,EAC1B,uBAAgD,EAChD,IAAU,EACV,EACE,KAAK,GAAG,qBAAS,EACjB,QAAQ,GAAG,CAAC,IAAU,EAAE,EAAQ,EAAU,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,EAAE,CAAC,EAClE,UAAU,GAAG,CAAC,SAAe,EAAE,KAAa,EAAU,EAAE,CACtD,SAAS,CAAC,IAAI,EAAE,CAAC,kBAAkB,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,EAAE,MAC1C,EAAE,EACf,EAAE;IACf,MAAM,KAAK,GAAG,IAAA,iBAAS,EAAC,uBAAuB,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;IAE9D,IAAI,KAAK,KAAK,IAAI,EAAE;QAClB,OAAO,IAAI,CAAC;KACb;IAED,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC;IAEzB,IAAI,IAAA,mBAAO,EAAC,YAAY,EAAE,IAAI,EAAE,IAAI,CAAC,EAAE;QACrC,OAAO,IAAI,CAAC;KACb;IAED,IAAI,OAAO,GAA0B,IAAI,CAAC;IAE1C,UAAU,CAAC,IAAI,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,CAAC,IAAU,EAAQ,EAAE;QACzD,MAAM,IAAI,GAAG,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QAElC,IACE,IAAI,IAAI,KAAK,CAAC,KAAK;YACnB,CAAC,OAAO,KAAK,IAAI,IAAI,IAAI,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;YACvC,IAAA,mBAAO,EAAC,YAAY,EAAE,IAAI,EAAE,IAAI,CAAC,EACjC;YACA,OAAO,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;SACxB;IACH,CAAC,CAAC,CAAC;IAEH,OAAO,OAAO,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAE,OAA0B,CAAC,CAAC,CAAC,CAAC;AAClE,CAAC,CAAC;AAtCW,QAAA,aAAa,iBAsCxB"}

package/lib/reach.ts

@@ -0,0 +1,97 @@
+import { Range, fuelRange, refuels, turnsAloft } from './fuelRules';
+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 UnitImprovementRegistry from '@civ-clone/core-unit-improvement/UnitImprovementRegistry';
+
+export interface FuelState {
+  /** The unit's range. */
+  range: number;
+  /** The turns it has ended away from a refuelling point since it last refuelled. */
+  turnsAloft: number;
+  /**
+   * The turns it has left, this one included: it must be somewhere it refuels by the end of the last of them. 1 means
+   *  by the end of this turn.
+   */
+  turnsLeft: number;
+  /** How many moves it has before then: its moves left, and its full movement for each turn after this one. */
+  reach: number;
+}
+
+/** Where a fuelled `unit` stands, for a computer player deciding where to send it; `null` for a unit with no range. */
+export const fuelState = (
+  unitImprovementRegistry: UnitImprovementRegistry,
+  unit: Unit,
+  range: Range = fuelRange
+): FuelState | null => {
+  const unitRange = range(unit);
+
+  if (!(unitRange > 0)) {
+    return null;
+  }
+
+  const aloft = turnsAloft(unitImprovementRegistry, unit),
+    turnsLeft = Math.max(0, unitRange - aloft);
+
+  return {
+    range: unitRange,
+    turnsAloft: aloft,
+    turnsLeft,
+    reach:
+      turnsLeft === 0
+        ? 0
+        : unit.moves().value() + unit.movement().value() * (turnsLeft - 1),
+  };
+};
+
+export interface RefuelInReachOptions {
+  range?: Range;
+  /** How many moves apart two squares are: `Tile.distanceFrom` by default. */
+  distance?: (from: Tile, to: Tile) => number;
+  /** The squares to look at: by default the area around the unit as far as its reach. */
+  candidates?: (unit: Unit, reach: number) => Tile[];
+}
+
+/**
+ * The nearest square within `unit`'s reach (see `fuelState`) where it refuels (`Refuel`), its own square first; `null`
+ *  if there is none, or the unit has no range. The first of equally near squares.
+ */
+export const refuelInReach = (
+  ruleRegistry: RuleRegistry,
+  unitImprovementRegistry: UnitImprovementRegistry,
+  unit: Unit,
+  {
+    range = fuelRange,
+    distance = (from: Tile, to: Tile): number => from.distanceFrom(to),
+    candidates = (candidate: Unit, reach: number): Tile[] =>
+      candidate.tile().getSurroundingArea(Math.floor(reach)).entries(),
+  }: RefuelInReachOptions = {}
+): Tile | null => {
+  const state = fuelState(unitImprovementRegistry, unit, range);
+
+  if (state === null) {
+    return null;
+  }
+
+  const from = unit.tile();
+
+  if (refuels(ruleRegistry, unit, from)) {
+    return from;
+  }
+
+  let nearest: [Tile, number] | null = null;
+
+  candidates(unit, state.reach).forEach((tile: Tile): void => {
+    const away = distance(from, tile);
+
+    if (
+      away <= state.reach &&
+      (nearest === null || away < nearest[1]) &&
+      refuels(ruleRegistry, unit, tile)
+    ) {
+      nearest = [tile, away];
+    }
+  });
+
+  return nearest === null ? null : (nearest as [Tile, number])[0];
+};

package/lib/refuel.d.ts

@@ -0,0 +1,38 @@
+import { CityRegistry } from '@civ-clone/core-city/CityRegistry';
+import { TileImprovementRegistry } from '@civ-clone/core-tile-improvement/TileImprovementRegistry';
+import { TransportRegistry } from '@civ-clone/core-unit-transport/TransportRegistry';
+import { UnitRegistry } from '@civ-clone/core-unit/UnitRegistry';
+import { Refuel } from './Rules';
+import TileImprovement from '@civ-clone/core-tile-improvement/TileImprovement';
+import Unit from '@civ-clone/core-unit/Unit';
+/** The units it applies to: all, without. */
+export type Refuels = (unit: Unit) => boolean;
+/** A `Refuel` rule: in one of the unit's player's own cities. */
+export declare const refuelInOwnCity: (
+  cityRegistry?: CityRegistry,
+  applies?: Refuels,
+  id?: string
+) => Refuel;
+/** A `Refuel` rule: on a square with an `Improvement` (an airfield, say). */
+export declare const refuelOnTileImprovement: (
+  Improvement: typeof TileImprovement,
+  tileImprovementRegistry?: TileImprovementRegistry,
+  applies?: Refuels,
+  id?: string
+) => Refuel;
+/**
+ * A `Refuel` rule: on a square with another of the player's units that `isBase` says the unit can refuel on (one that
+ *  carries it, say).
+ */
+export declare const refuelInStackWith: (
+  isBase: (base: Unit, unit: Unit) => boolean,
+  unitRegistry?: UnitRegistry,
+  applies?: Refuels,
+  id?: string
+) => Refuel;
+/** A `Refuel` rule: aboard a transport. */
+export declare const refuelAboard: (
+  transportRegistry?: TransportRegistry,
+  applies?: Refuels,
+  id?: string
+) => Refuel;

package/lib/refuel.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.refuelAboard = exports.refuelInStackWith = exports.refuelOnTileImprovement = exports.refuelInOwnCity = void 0;
+const CityRegistry_1 = require("@civ-clone/core-city/CityRegistry");
+const TileImprovementRegistry_1 = require("@civ-clone/core-tile-improvement/TileImprovementRegistry");
+const TransportRegistry_1 = require("@civ-clone/core-unit-transport/TransportRegistry");
+const UnitRegistry_1 = require("@civ-clone/core-unit/UnitRegistry");
+const Criterion_1 = require("@civ-clone/core-rule/Criterion");
+const Effect_1 = require("@civ-clone/core-rule/Effect");
+const Rules_1 = require("./Rules");
+const refuel = (id, applies, where) => new Rules_1.Refuel(...(id === undefined ? [] : [id]), new Criterion_1.default((unit) => applies(unit)), new Criterion_1.default(where), new Effect_1.default(() => true));
+const all = () => true;
+/** A `Refuel` rule: in one of the unit's player's own cities. */
+const refuelInOwnCity = (cityRegistry = CityRegistry_1.instance, applies = all, id) => refuel(id, applies, (unit, tile) => { var _a; return ((_a = cityRegistry.getByTile(tile)) === null || _a === void 0 ? void 0 : _a.player()) === unit.player(); });
+exports.refuelInOwnCity = refuelInOwnCity;
+/** A `Refuel` rule: on a square with an `Improvement` (an airfield, say). */
+const refuelOnTileImprovement = (Improvement, tileImprovementRegistry = TileImprovementRegistry_1.instance, applies = all, id) => refuel(id, applies, (unit, tile) => tileImprovementRegistry
+    .getByTile(tile)
+    .some((tileImprovement) => tileImprovement instanceof Improvement));
+exports.refuelOnTileImprovement = refuelOnTileImprovement;
+/**
+ * A `Refuel` rule: on a square with another of the player's units that `isBase` says the unit can refuel on (one that
+ *  carries it, say).
+ */
+const refuelInStackWith = (isBase, unitRegistry = UnitRegistry_1.instance, applies = all, id) => refuel(id, applies, (unit, tile) => unitRegistry
+    .getByTile(tile)
+    .some((base) => base !== unit &&
+    !base.destroyed() &&
+    base.player() === unit.player() &&
+    isBase(base, unit)));
+exports.refuelInStackWith = refuelInStackWith;
+/** A `Refuel` rule: aboard a transport. */
+const refuelAboard = (transportRegistry = TransportRegistry_1.instance, applies = all, id) => refuel(id, applies, (unit) => transportRegistry.hasUnit(unit));
+exports.refuelAboard = refuelAboard;
+//# sourceMappingURL=refuel.js.map

package/lib/refuel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"refuel.js","sourceRoot":"","sources":["refuel.ts"],"names":[],"mappings":";;;AAAA,oEAG2C;AAC3C,sGAGkE;AAClE,wFAG0D;AAC1D,oEAG2C;AAC3C,8DAAuD;AACvD,wDAAiD;AACjD,mCAAiC;AAQjC,MAAM,MAAM,GAAG,CACb,EAAsB,EACtB,OAAgB,EAChB,KAA0C,EAClC,EAAE,CACV,IAAI,cAAM,CACR,GAAI,CAAC,EAAE,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAc,EAC/C,IAAI,mBAAS,CAAC,CAAC,IAAU,EAAW,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,EACrD,IAAI,mBAAS,CAAC,KAAK,CAAC,EACpB,IAAI,gBAAM,CAAC,GAAY,EAAE,CAAC,IAAI,CAAC,CAChC,CAAC;AAEJ,MAAM,GAAG,GAAY,GAAY,EAAE,CAAC,IAAI,CAAC;AAEzC,iEAAiE;AAC1D,MAAM,eAAe,GAAG,CAC7B,eAA6B,uBAAoB,EACjD,UAAmB,GAAG,EACtB,EAAW,EACH,EAAE,CACV,MAAM,CACJ,EAAE,EACF,OAAO,EACP,CAAC,IAAU,EAAE,IAAU,EAAW,EAAE,WAClC,OAAA,CAAA,MAAA,YAAY,CAAC,SAAS,CAAC,IAAI,CAAC,0CAAE,MAAM,EAAE,MAAK,IAAI,CAAC,MAAM,EAAE,CAAA,EAAA,CAC3D,CAAC;AAVS,QAAA,eAAe,mBAUxB;AAEJ,6EAA6E;AACtE,MAAM,uBAAuB,GAAG,CACrC,WAAmC,EACnC,0BAAmD,kCAA+B,EAClF,UAAmB,GAAG,EACtB,EAAW,EACH,EAAE,CACV,MAAM,CAAC,EAAE,EAAE,OAAO,EAAE,CAAC,IAAU,EAAE,IAAU,EAAW,EAAE,CACtD,uBAAuB;KACpB,SAAS,CAAC,IAAI,CAAC;KACf,IAAI,CACH,CAAC,eAAgC,EAAW,EAAE,CAC5C,eAAe,YAAY,WAAW,CACzC,CACJ,CAAC;AAbS,QAAA,uBAAuB,2BAahC;AAEJ;;;GAGG;AACI,MAAM,iBAAiB,GAAG,CAC/B,MAA2C,EAC3C,eAA6B,uBAAoB,EACjD,UAAmB,GAAG,EACtB,EAAW,EACH,EAAE,CACV,MAAM,CAAC,EAAE,EAAE,OAAO,EAAE,CAAC,IAAU,EAAE,IAAU,EAAW,EAAE,CACtD,YAAY;KACT,SAAS,CAAC,IAAI,CAAC;KACf,IAAI,CACH,CAAC,IAAU,EAAW,EAAE,CACtB,IAAI,KAAK,IAAI;IACb,CAAC,IAAI,CAAC,SAAS,EAAE;IACjB,IAAI,CAAC,MAAM,EAAE,KAAK,IAAI,CAAC,MAAM,EAAE;IAC/B,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,CACrB,CACJ,CAAC;AAhBS,QAAA,iBAAiB,qBAgB1B;AAEJ,2CAA2C;AACpC,MAAM,YAAY,GAAG,CAC1B,oBAAuC,4BAAyB,EAChE,UAAmB,GAAG,EACtB,EAAW,EACH,EAAE,CACV,MAAM,CAAC,EAAE,EAAE,OAAO,EAAE,CAAC,IAAU,EAAW,EAAE,CAAC,iBAAiB,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;AALnE,QAAA,YAAY,gBAKuD"}

package/lib/refuel.ts

@@ -0,0 +1,98 @@
+import {
+  CityRegistry,
+  instance as cityRegistryInstance,
+} from '@civ-clone/core-city/CityRegistry';
+import {
+  TileImprovementRegistry,
+  instance as tileImprovementRegistryInstance,
+} from '@civ-clone/core-tile-improvement/TileImprovementRegistry';
+import {
+  TransportRegistry,
+  instance as transportRegistryInstance,
+} from '@civ-clone/core-unit-transport/TransportRegistry';
+import {
+  UnitRegistry,
+  instance as unitRegistryInstance,
+} from '@civ-clone/core-unit/UnitRegistry';
+import Criterion from '@civ-clone/core-rule/Criterion';
+import Effect from '@civ-clone/core-rule/Effect';
+import { Refuel } from './Rules';
+import Tile from '@civ-clone/core-world/Tile';
+import TileImprovement from '@civ-clone/core-tile-improvement/TileImprovement';
+import Unit from '@civ-clone/core-unit/Unit';
+
+/** The units it applies to: all, without. */
+export type Refuels = (unit: Unit) => boolean;
+
+const refuel = (
+  id: string | undefined,
+  applies: Refuels,
+  where: (unit: Unit, tile: Tile) => boolean
+): Refuel =>
+  new Refuel(
+    ...((id === undefined ? [] : [id]) as string[]),
+    new Criterion((unit: Unit): boolean => applies(unit)),
+    new Criterion(where),
+    new Effect((): boolean => true)
+  );
+
+const all: Refuels = (): boolean => true;
+
+/** A `Refuel` rule: in one of the unit's player's own cities. */
+export const refuelInOwnCity = (
+  cityRegistry: CityRegistry = cityRegistryInstance,
+  applies: Refuels = all,
+  id?: string
+): Refuel =>
+  refuel(
+    id,
+    applies,
+    (unit: Unit, tile: Tile): boolean =>
+      cityRegistry.getByTile(tile)?.player() === unit.player()
+  );
+
+/** A `Refuel` rule: on a square with an `Improvement` (an airfield, say). */
+export const refuelOnTileImprovement = (
+  Improvement: typeof TileImprovement,
+  tileImprovementRegistry: TileImprovementRegistry = tileImprovementRegistryInstance,
+  applies: Refuels = all,
+  id?: string
+): Refuel =>
+  refuel(id, applies, (unit: Unit, tile: Tile): boolean =>
+    tileImprovementRegistry
+      .getByTile(tile)
+      .some(
+        (tileImprovement: TileImprovement): boolean =>
+          tileImprovement instanceof Improvement
+      )
+  );
+
+/**
+ * A `Refuel` rule: on a square with another of the player's units that `isBase` says the unit can refuel on (one that
+ *  carries it, say).
+ */
+export const refuelInStackWith = (
+  isBase: (base: Unit, unit: Unit) => boolean,
+  unitRegistry: UnitRegistry = unitRegistryInstance,
+  applies: Refuels = all,
+  id?: string
+): Refuel =>
+  refuel(id, applies, (unit: Unit, tile: Tile): boolean =>
+    unitRegistry
+      .getByTile(tile)
+      .some(
+        (base: Unit): boolean =>
+          base !== unit &&
+          !base.destroyed() &&
+          base.player() === unit.player() &&
+          isBase(base, unit)
+      )
+  );
+
+/** A `Refuel` rule: aboard a transport. */
+export const refuelAboard = (
+  transportRegistry: TransportRegistry = transportRegistryInstance,
+  applies: Refuels = all,
+  id?: string
+): Refuel =>
+  refuel(id, applies, (unit: Unit): boolean => transportRegistry.hasUnit(unit));