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

package/package.json

@@ -1,6 +1,45 @@
 {
   "name": "@civ-clone/base-unit-fuel",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Fuel for units that must return to base: a range, the turns a unit has spent out, the places it refuels, and running out of fuel.",
+  "repository": "git@github.com:civ-clone/base-unit-fuel.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": {
+    "@civ-clone/core-game": "^0.1.17",
+    "@civ-clone/core-save-game": "^0.1.23",
+    "@civ-clone/core-terrain": "^0.1.0",
+    "@civ-clone/core-world-generator": "^0.1.0",
+    "@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.19",
+    "@civ-clone/core-player": "^0.1.10",
+    "@civ-clone/core-rule": "^0.1.9",
+    "@civ-clone/core-tile-improvement": "^0.1.6",
+    "@civ-clone/core-unit": "^0.1.32",
+    "@civ-clone/core-unit-improvement": "^0.1.0",
+    "@civ-clone/core-unit-transport": "^0.1.10",
+    "@civ-clone/core-world": "^0.1.24",
+    "@civ-clone/core-yield": "^0.1.0"
+  }
+}

package/tests/fuel.test.ts

@@ -0,0 +1,460 @@
+import { OutOfFuel, Refuel } from '../lib/Rules';
+import fuelRules, { CountOn, refuels, turnsAloft } from '../lib/fuelRules';
+import { fuelState, refuelInReach } from '../lib/reach';
+import {
+  refuelAboard,
+  refuelInOwnCity,
+  refuelInStackWith,
+  refuelOnTileImprovement,
+} from '../lib/refuel';
+import Action from '@civ-clone/core-unit/Action';
+import Aloft from '../lib/Aloft';
+import City from '@civ-clone/core-city/City';
+import CityRegistry from '@civ-clone/core-city/CityRegistry';
+import Criterion from '@civ-clone/core-rule/Criterion';
+import Destroyed from '@civ-clone/core-unit/Rules/Destroyed';
+import Effect from '@civ-clone/core-rule/Effect';
+import Fuel from '../lib/Fuel';
+import Generator from '@civ-clone/core-world-generator/Generator';
+import { Movement } from '@civ-clone/core-unit/Yields';
+import Moved from '@civ-clone/core-unit/Rules/Moved';
+import Player from '@civ-clone/core-player/Player';
+import RuleRegistry from '@civ-clone/core-rule/RuleRegistry';
+import Terrain from '@civ-clone/core-terrain/Terrain';
+import Tile from '@civ-clone/core-world/Tile';
+import TileImprovement from '@civ-clone/core-tile-improvement/TileImprovement';
+import TileImprovementRegistry from '@civ-clone/core-tile-improvement/TileImprovementRegistry';
+import TransportManifest from '@civ-clone/core-unit-transport/TransportManifest';
+import TransportRegistry from '@civ-clone/core-unit-transport/TransportRegistry';
+import TurnEnd from '@civ-clone/core-player/Rules/TurnEnd';
+import Unit from '@civ-clone/core-unit/Unit';
+import UnitImprovementRegistry from '@civ-clone/core-unit-improvement/UnitImprovementRegistry';
+import UnitRegistry from '@civ-clone/core-unit/UnitRegistry';
+import World from '@civ-clone/core-world/World';
+import { Yield as YieldRule } from '@civ-clone/core-unit/Rules/Yield';
+import YieldValue from '@civ-clone/core-yield/Yield';
+import { expect } from 'chai';
+
+// OpenCiv2 (github.com/richardpenman/civ2, read at 49f26ec), `unit_move_dir_air_fuel`: a unit refuels in a city, on an
+//  airbase or in a stack with a unit that carries it; each time it is left out its count goes up, and it is lost once
+//  the count reaches its range. A range of 1 must refuel every turn; 2 can stay out one turn. Counted here at the end
+//  of each turn, as civ1-unit's fuel rule counts it.
+
+class Airfield extends TileImprovement {}
+
+class Step extends Action {}
+
+const setUp = (countOn: CountOn = 'turn-end') => {
+  const ruleRegistry = new RuleRegistry(),
+    unitRegistry = new UnitRegistry(),
+    cityRegistry = new CityRegistry(),
+    unitImprovementRegistry = new UnitImprovementRegistry(),
+    tileImprovementRegistry = new TileImprovementRegistry(),
+    transportRegistry = new TransportRegistry(),
+    world = new World(new Generator(1, 10)),
+    tiles = Array.from(
+      { length: 10 },
+      (_, x: number): Tile => new Tile(x, 0, new Terrain(), world)
+    ),
+    player = new Player(),
+    ranges = new Map<Unit, number>(),
+    events: [string, Unit][] = [],
+    unit = (
+      tile: Tile,
+      range: number = 0,
+      owner: Player = player,
+      movement: number = 10
+    ): Unit => {
+      const created = new Unit(null, owner, tile, ruleRegistry);
+
+      ranges.set(created, range);
+      unitRegistry.register(created);
+      created.moves().set(movement);
+
+      return created;
+    },
+    city = (tile: Tile, owner: Player = player): City => {
+      const created = new City(owner, tile, 'City', ruleRegistry);
+
+      cityRegistry.register(created);
+
+      return created;
+    };
+
+  ruleRegistry.register(
+    new YieldRule(
+      new Criterion((unit: Unit): boolean => ranges.has(unit)),
+      new Effect((unit: Unit, unitYield: YieldValue): void => {
+        if (unitYield instanceof Fuel) {
+          unitYield.set(ranges.get(unit)!);
+        }
+
+        if (unitYield instanceof Movement) {
+          unitYield.set(10);
+        }
+      })
+    ),
+    new Destroyed(
+      new Effect((destroyed: Unit): void => {
+        events.push(['destroyed', destroyed]);
+        destroyed.setDestroyed();
+      })
+    ),
+    new OutOfFuel(
+      new Effect((lost: Unit): void => {
+        events.push(['out-of-fuel', lost]);
+      })
+    ),
+    ...fuelRules(
+      { ruleRegistry, unitImprovementRegistry, unitRegistry },
+      { prefix: 'test', countOn }
+    ),
+    refuelInOwnCity(cityRegistry),
+    refuelOnTileImprovement(Airfield, tileImprovementRegistry)
+  );
+
+  const endTurn = (forPlayer: Player = player): void =>
+      ruleRegistry.process(TurnEnd, forPlayer),
+    // Moves `moving` to `to` (or attacks `to`, staying where it is), leaving it `movesLeft`, as a move action does
+    //  before processing `Moved`.
+    move = (
+      moving: Unit,
+      to: Tile,
+      movesLeft: number,
+      attack: boolean = false
+    ): void => {
+      const from = moving.tile();
+
+      if (!attack) {
+        moving.setTile(to);
+      }
+
+      moving.moves().set(movesLeft);
+      ruleRegistry.process(
+        Moved,
+        moving,
+        new Step(from, to, moving, ruleRegistry)
+      );
+    };
+
+  return {
+    city,
+    endTurn,
+    events,
+    move,
+    player,
+    ruleRegistry,
+    tileImprovementRegistry,
+    tiles,
+    transportRegistry,
+    unit,
+    unitImprovementRegistry,
+    unitRegistry,
+  };
+};
+
+describe('fuelRules', (): void => {
+  it('should lose a range-1 unit that ends its turn away from a refuelling point', (): void => {
+    const { endTurn, events, tiles, unit } = setUp(),
+      out = unit(tiles[3], 1);
+
+    endTurn();
+
+    expect(events).to.deep.equal([
+      ['out-of-fuel', out],
+      ['destroyed', out],
+    ]);
+  });
+
+  it('should let a range-2 unit stay out one turn, counting it, and lose it at the second', (): void => {
+    const { endTurn, events, tiles, unit, unitImprovementRegistry } = setUp(),
+      out = unit(tiles[3], 2);
+
+    endTurn();
+
+    expect(events).to.deep.equal([]);
+    expect(turnsAloft(unitImprovementRegistry, out)).to.equal(1);
+
+    endTurn();
+
+    expect(events.map(([name]) => name)).to.deep.equal([
+      'out-of-fuel',
+      'destroyed',
+    ]);
+    expect(unitImprovementRegistry.getByUnit(out)).to.deep.equal([]);
+  });
+
+  it('should refuel in an own city or on the improvement, clearing the count', (): void => {
+    const {
+        city,
+        endTurn,
+        events,
+        tileImprovementRegistry,
+        tiles,
+        unit,
+        unitImprovementRegistry,
+      } = setUp(),
+      inCity = unit(tiles[0], 1),
+      onAirfield = unit(tiles[3], 2);
+
+    city(tiles[0]);
+    endTurn();
+
+    expect(turnsAloft(unitImprovementRegistry, onAirfield)).to.equal(1);
+
+    tileImprovementRegistry.register(new Airfield(tiles[3]));
+    endTurn();
+
+    expect(events).to.deep.equal([]);
+    expect(turnsAloft(unitImprovementRegistry, inCity)).to.equal(0);
+    expect(unitImprovementRegistry.getByUnit(onAirfield)).to.deep.equal([]);
+  });
+
+  it("should not refuel in another player's city", (): void => {
+    const { city, endTurn, events, tiles, unit } = setUp(),
+      out = unit(tiles[0], 1);
+
+    city(tiles[0], new Player());
+    endTurn();
+
+    expect(events[0]).to.deep.equal(['out-of-fuel', out]);
+  });
+
+  it("should leave units with no range, and other players' units, alone", (): void => {
+    const { endTurn, events, tiles, unit, unitImprovementRegistry } = setUp(),
+      grounded = unit(tiles[3]),
+      foreign = unit(tiles[3], 1, new Player());
+
+    endTurn();
+
+    expect(events).to.deep.equal([]);
+    expect(unitImprovementRegistry.getByUnit(grounded)).to.deep.equal([]);
+    expect(foreign.destroyed()).to.equal(false);
+  });
+
+  it('should keep the count on a saved field of the mark only', (): void => {
+    const { endTurn, tiles, unit, unitImprovementRegistry } = setUp(),
+      out = unit(tiles[3], 3);
+
+    endTurn();
+    endTurn();
+
+    const [aloft] = unitImprovementRegistry.getByUnit(out) as Aloft[];
+
+    expect(aloft).to.be.instanceOf(Aloft);
+    expect(aloft.turns()).to.equal(2);
+    expect(Object.keys(out)).not.to.include('_turns');
+  });
+
+  it('should name its rules with the prefix', (): void => {
+    expect(
+      fuelRules({}, { prefix: 'test' }).map((rule) => rule.id())
+    ).to.deep.equal([
+      'test:player/turn-end/fuel',
+      'test:unit/out-of-fuel/destroy',
+    ]);
+  });
+});
+
+describe('refuel rules', (): void => {
+  it('should refuel in a stack with a base, only for the units it applies to', (): void => {
+    const { player, ruleRegistry, tiles, unit, unitRegistry } = setUp(),
+      mothership = unit(tiles[5]),
+      plane = unit(tiles[5], 1),
+      other = unit(tiles[5], 1),
+      bases = new Set<Unit>([mothership]);
+
+    ruleRegistry.register(
+      refuelInStackWith(
+        (base: Unit): boolean => bases.has(base),
+        unitRegistry,
+        (refuelling: Unit): boolean => refuelling !== other
+      )
+    );
+
+    expect(refuels(ruleRegistry, plane)).to.equal(true);
+    expect(refuels(ruleRegistry, other)).to.equal(false);
+    expect(refuels(ruleRegistry, mothership)).to.equal(false);
+    expect(player).to.be.instanceOf(Player);
+  });
+
+  it('should refuel aboard a transport', (): void => {
+    const { ruleRegistry, tiles, transportRegistry, unit } = setUp(),
+      transport = unit(tiles[5]),
+      plane = unit(tiles[5], 1);
+
+    ruleRegistry.register(refuelAboard(transportRegistry));
+
+    expect(refuels(ruleRegistry, plane)).to.equal(false);
+
+    transportRegistry.register(
+      new TransportManifest(transport as any, plane, tiles[5])
+    );
+
+    expect(refuels(ruleRegistry, plane)).to.equal(true);
+  });
+
+  it('should ignore a rule whose effect does not answer true', (): void => {
+    const { ruleRegistry, tiles, unit } = setUp(),
+      plane = unit(tiles[5], 1);
+
+    ruleRegistry.register(new Refuel(new Effect((): boolean => false)));
+
+    expect(refuels(ruleRegistry, plane)).to.equal(false);
+  });
+});
+
+describe('reach', (): void => {
+  it('should give the turns left and the moves before the last of them', (): void => {
+    const { endTurn, tiles, unit, unitImprovementRegistry } = setUp(),
+      out = unit(tiles[3], 2, undefined, 4);
+
+    expect(fuelState(unitImprovementRegistry, out)).to.deep.equal({
+      range: 2,
+      turnsAloft: 0,
+      turnsLeft: 2,
+      reach: 14,
+    });
+
+    endTurn();
+
+    expect(fuelState(unitImprovementRegistry, out)).to.deep.equal({
+      range: 2,
+      turnsAloft: 1,
+      turnsLeft: 1,
+      reach: 4,
+    });
+    expect(fuelState(unitImprovementRegistry, unit(tiles[3]))).to.equal(null);
+  });
+
+  it('should find the nearest refuelling point within reach', (): void => {
+    const {
+        city,
+        endTurn,
+        ruleRegistry,
+        tiles,
+        unit,
+        unitImprovementRegistry,
+      } = setUp(),
+      out = unit(tiles[5], 2, undefined, 2),
+      options = {
+        distance: (from: Tile, to: Tile): number => Math.abs(from.x() - to.x()),
+        candidates: (): Tile[] => tiles,
+      };
+
+    city(tiles[0]);
+    city(tiles[9]);
+
+    // 2 moves left and 10 more next turn: both cities, 4 and 5 away; the nearer.
+    expect(
+      refuelInReach(ruleRegistry, unitImprovementRegistry, out, options)
+    ).to.equal(tiles[9]);
+
+    endTurn();
+    out.moves().set(3);
+
+    // Out a turn already, with 3 moves: neither.
+    expect(
+      refuelInReach(ruleRegistry, unitImprovementRegistry, out, options)
+    ).to.equal(null);
+
+    out.moves().set(4);
+
+    expect(
+      refuelInReach(ruleRegistry, unitImprovementRegistry, out, options)
+    ).to.equal(tiles[9]);
+  });
+});
+
+describe('fuelRules, counting when a unit runs out of moves (`unit_move_dir_air_fuel`)', (): void => {
+  it('should count a turn out only when a move leaves the unit with no moves, and not at the end of the turn', (): void => {
+    const { endTurn, events, move, tiles, unit, unitImprovementRegistry } =
+        setUp('out-of-moves'),
+      out = unit(tiles[0], 2);
+
+    move(out, tiles[1], 5);
+    endTurn();
+
+    // Moves left, and no count at the end of the turn: the original's rule.
+    expect(turnsAloft(unitImprovementRegistry, out)).to.equal(0);
+
+    move(out, tiles[2], 0);
+
+    expect(turnsAloft(unitImprovementRegistry, out)).to.equal(1);
+    expect(events).to.deep.equal([]);
+
+    move(out, tiles[3], 0);
+
+    expect(events).to.deep.equal([
+      ['out-of-fuel', out],
+      ['destroyed', out],
+    ]);
+  });
+
+  it('should lose a range-1 unit as soon as it runs out of moves away from a refuelling point', (): void => {
+    const { events, move, tiles, unit } = setUp('out-of-moves'),
+      out = unit(tiles[0], 1);
+
+    move(out, tiles[1], 0);
+
+    expect(events[0]).to.deep.equal(['out-of-fuel', out]);
+  });
+
+  it('should land where it refuels: the count goes, and so do its moves', (): void => {
+    const { city, move, tiles, unit, unitImprovementRegistry } =
+        setUp('out-of-moves'),
+      out = unit(tiles[2], 2);
+
+    city(tiles[0]);
+    move(out, tiles[3], 0);
+
+    expect(turnsAloft(unitImprovementRegistry, out)).to.equal(1);
+
+    move(out, tiles[0], 4);
+
+    expect(turnsAloft(unitImprovementRegistry, out)).to.equal(0);
+    expect(out.moves().value()).to.equal(0);
+  });
+
+  it('should not land a range-1 unit that attacked with moves to spare, but land one that attacked with none', (): void => {
+    const { city, events, move, tiles, unit } = setUp('out-of-moves'),
+      fresh = unit(tiles[0], 1),
+      spent = unit(tiles[0], 1),
+      longer = unit(tiles[0], 2);
+
+    city(tiles[0]);
+
+    // Attacking the next square from its city, staying there.
+    move(fresh, tiles[1], 4, true);
+    move(longer, tiles[1], 4, true);
+
+    expect(fresh.moves().value()).to.equal(4);
+    expect(longer.moves().value()).to.equal(0);
+
+    move(spent, tiles[1], 0, true);
+
+    expect(spent.moves().value()).to.equal(0);
+    expect(events).to.deep.equal([]);
+  });
+
+  it('should ignore an action on its own square, and units with no range', (): void => {
+    const { events, move, tiles, unit, unitImprovementRegistry } =
+        setUp('out-of-moves'),
+      out = unit(tiles[3], 1),
+      grounded = unit(tiles[3]);
+
+    move(out, tiles[3], 0);
+    move(grounded, tiles[4], 0);
+
+    expect(events).to.deep.equal([]);
+    expect(unitImprovementRegistry.getByUnit(grounded)).to.deep.equal([]);
+  });
+
+  it('should name its counting rule for moves', (): void => {
+    expect(
+      fuelRules({}, { prefix: 'test', countOn: 'out-of-moves' }).map((rule) =>
+        rule.id()
+      )
+    ).to.deep.equal(['test:unit/moved/fuel', 'test:unit/out-of-fuel/destroy']);
+  });
+});

package/tests/save.test.ts

@@ -0,0 +1,54 @@
+import Aloft from '../lib/Aloft';
+import { Game } from '@civ-clone/core-game/Game';
+import Player from '@civ-clone/core-player/Player';
+import Tile from '@civ-clone/core-world/Tile';
+import Unit from '@civ-clone/core-unit/Unit';
+import { expect } from 'chai';
+import { gameForLoad } from '@civ-clone/core-save-game/gameForLoad';
+import { hydrate } from '@civ-clone/core-save-game/hydrate';
+import { registerClasses } from '@civ-clone/core-save-game/registerClasses';
+import { save } from '@civ-clone/core-save-game/save';
+
+class Flyer extends Unit {}
+
+describe('saving `Aloft`', (): void => {
+  it('should round-trip the count through core-save-game, once the game offers the class', (): void => {
+    const game = new Game(),
+      player = new Player(game.rules),
+      out = new Flyer(null, player, null as unknown as Tile, game.rules),
+      home = new Flyer(null, player, null as unknown as Tile, game.rules);
+
+    game.engine.registerPlugins({ '@civ-clone/base-unit-fuel': 'test' });
+    // What a ruleset does: offer the class, as it offers `Veteran`.
+    game.availableUnitImprovements.register(Aloft);
+    registerClasses(game);
+    game.classes.register(Flyer);
+    game.units.register(out, home);
+    game.unitImprovements.register(new Aloft(out, 2));
+
+    const file = save(game, { name: 'test', createdAt: 0 }),
+      loaded = gameForLoad({
+        availableUnitImprovements: game.availableUnitImprovements,
+        classes: game.classes,
+        engine: game.engine,
+        rules: game.rules,
+      });
+
+    hydrate(file, loaded);
+
+    const [loadedOut, loadedHome] = loaded.units.entries(),
+      [aloft] = loaded.unitImprovements.getByUnit(loadedOut) as Aloft[];
+
+    expect(aloft).to.be.instanceOf(Aloft);
+    expect(aloft.turns()).to.equal(2);
+    expect(aloft.unit()).to.equal(loadedOut);
+    expect(loaded.unitImprovements.getByUnit(loadedHome)).to.deep.equal([]);
+    // Saved again, the entities are the same (the id counters move with each new `Game`).
+    expect(
+      JSON.stringify(save(loaded, { name: 'test', createdAt: 0 }).entities)
+    ).to.equal(JSON.stringify(file.entities));
+    expect(
+      file.entities.find(({ id }) => id === aloft.id())!.state
+    ).to.have.property('_turns', 2);
+  });
+});

package/tsconfig.json

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