@civ-clone/base-unit-submarine 0.1.1 → 0.1.2

package/.github/workflows/build-on-push.yml

@@ -6,10 +6,34 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v1
-      - uses: actions/setup-node@v1
+      - uses: actions/checkout@v4
+      - uses: pnpm/action-setup@v4
         with:
-          node-version: 12
-      - run: yarn install
-      - run: yarn prettier:check
-#      - run: yarn test
+          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/README.md

@@ -1,4 +1,6 @@
 # base-unit-submarine
 
-This is a template repo.
+The `Submarine` unit type, a naval unit. What it can do (that it is submerged, what it attacks, what it carries) is
+up to the ruleset's rules and traits.
 
+A library: no `main`, so it registers nothing on its own. Import it as `@civ-clone/base-unit-submarine/Submarine`.

package/Submarine.d.ts

@@ -1,3 +1,3 @@
-import Naval from '@civ-clone/base-unit-type-naval/Naval';
-export declare class Submarine extends Naval {}
+import NavalTransport from '@civ-clone/base-unit-type-naval-transport/NavalTransport';
+export declare class Submarine extends NavalTransport {}
 export default Submarine;

package/Submarine.js

@@ -1,8 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Submarine = void 0;
-const Naval_1 = require("@civ-clone/base-unit-type-naval/Naval");
-class Submarine extends Naval_1.default {
+const NavalTransport_1 = require("@civ-clone/base-unit-type-naval-transport/NavalTransport");
+// A transport, so a ruleset can give it a hold (for missiles, say). It carries nothing until the ruleset's rules say
+//  so: with no `Capacity` yield rule for it, its capacity is 0, so it never has room and `stow` refuses. That is the
+//  only guard. With no `Carries` trait, no `CanStow` rule applies to it, and `canStow()` (every applicable rule agrees)
+//  is then true for any unit, so anything asking whether it can carry a unit must also ask `hasCapacity()`.
+class Submarine extends NavalTransport_1.default {
 }
 exports.Submarine = Submarine;
 exports.default = Submarine;

package/Submarine.js.map

@@ -1 +1 @@
-{"version":3,"file":"Submarine.js","sourceRoot":"","sources":["Submarine.ts"],"names":[],"mappings":";;;AAAA,iEAA0D;AAE1D,MAAa,SAAU,SAAQ,eAAK;CAAG;AAAvC,8BAAuC;AAEvC,kBAAe,SAAS,CAAC"}
+{"version":3,"file":"Submarine.js","sourceRoot":"","sources":["Submarine.ts"],"names":[],"mappings":";;;AAAA,6FAAsF;AAEtF,qHAAqH;AACrH,qHAAqH;AACrH,wHAAwH;AACxH,4GAA4G;AAC5G,MAAa,SAAU,SAAQ,wBAAc;CAAG;AAAhD,8BAAgD;AAEhD,kBAAe,SAAS,CAAC"}

package/Submarine.ts

@@ -1,5 +1,9 @@
-import Naval from '@civ-clone/base-unit-type-naval/Naval';
+import NavalTransport from '@civ-clone/base-unit-type-naval-transport/NavalTransport';
 
-export class Submarine extends Naval {}
+// A transport, so a ruleset can give it a hold (for missiles, say). It carries nothing until the ruleset's rules say
+//  so: with no `Capacity` yield rule for it, its capacity is 0, so it never has room and `stow` refuses. That is the
+//  only guard. With no `Carries` trait, no `CanStow` rule applies to it, and `canStow()` (every applicable rule agrees)
+//  is then true for any unit, so anything asking whether it can carry a unit must also ask `hasCapacity()`.
+export class Submarine extends NavalTransport {}
 
 export default Submarine;

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@civ-clone/base-unit-submarine",
-  "version": "0.1.1",
+  "version": "0.1.2",
+  "description": "The Submarine unit type.",
   "repository": "git@github.com:civ-clone/base-unit-submarine.git",
   "keywords": [
     "typescript",
@@ -11,16 +12,31 @@
   "private": false,
   "scripts": {
     "build": "npm run ts:compile && npm run prettier:format",
-    "prettier:check": "prettier --config .prettierrc '**/*.ts'",
+    "prettier:check": "prettier --config .prettierrc --check '**/*.ts'",
     "prettier:format": "prettier --config .prettierrc '**/*.ts' --write",
+    "test": "ts-mocha ./tests/*.test.ts",
     "ts:compile": "tsc --build tsconfig.json"
   },
   "devDependencies": {
-    "@types/node": "^14.11.2",
-    "prettier": "^2.1.2",
-    "typescript": "^4.0.3"
+    "@civ-clone/base-unit-type-naval": "^0.1.0",
+    "@civ-clone/core-data-object": "^0.1.19",
+    "@civ-clone/core-game": "^0.1.17",
+    "@civ-clone/core-player": "^0.1.10",
+    "@civ-clone/core-rule": "^0.1.9",
+    "@civ-clone/core-unit": "^0.1.32",
+    "@civ-clone/core-unit-transport": "^0.1.10",
+    "@civ-clone/core-world": "^0.1.24",
+    "@civ-clone/core-yield": "^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/base-unit-type-naval": "^0.1.0"
+    "@civ-clone/base-unit-type-naval-transport": "^0.1.3"
   }
 }

package/tests/NavalTransport.test.ts

@@ -0,0 +1,167 @@
+import { Capacity, CargoWeight } from '@civ-clone/core-unit-transport/Yields';
+import Criterion from '@civ-clone/core-rule/Criterion';
+import Effect from '@civ-clone/core-rule/Effect';
+import { Game } from '@civ-clone/core-game/Game';
+import { ITransport } from '@civ-clone/core-unit-transport/Transport';
+import Naval from '@civ-clone/base-unit-type-naval/Naval';
+import NavalTransport from '@civ-clone/base-unit-type-naval-transport/NavalTransport';
+import Player from '@civ-clone/core-player/Player';
+import RuleRegistry from '@civ-clone/core-rule/RuleRegistry';
+import Submarine from '../Submarine';
+import Tile from '@civ-clone/core-world/Tile';
+import TransportRegistry from '@civ-clone/core-unit-transport/TransportRegistry';
+import Unit from '@civ-clone/core-unit/Unit';
+import UnitYield from '@civ-clone/core-unit/Rules/Yield';
+import YieldValue from '@civ-clone/core-yield/Yield';
+import { expect } from 'chai';
+import generateInheritance from '@civ-clone/core-data-object/lib/generateInheritance';
+import CanStow from '@civ-clone/core-unit-transport/Rules/CanStow';
+
+// The Submarine as a `NavalTransport` (civ-clone/web-renderer#1007, M2b): Civ2's carries missiles, Civ1's carries
+//  nothing. A ruleset that gives it no hold (Civ1) must see the same unit as before.
+
+// What the Submarine was before it became a transport.
+class NavalSubmarine extends Naval {}
+class Passenger extends Unit {}
+
+const setup = () => {
+  const ruleRegistry = new RuleRegistry(),
+    transportRegistry = new TransportRegistry(),
+    args: [null, Player, Tile, RuleRegistry, TransportRegistry] = [
+      null,
+      null as unknown as Player,
+      null as unknown as Tile,
+      ruleRegistry,
+      transportRegistry,
+    ];
+
+  // As civ1-unit's: the cargo weight is what is aboard, for every unit.
+  ruleRegistry.register(
+    new UnitYield(
+      new Criterion(
+        (unit: Unit, unitYield: YieldValue): unitYield is CargoWeight =>
+          unitYield instanceof CargoWeight
+      ),
+      new Effect((unit: Unit, unitYield: YieldValue): void =>
+        unitYield.set(
+          transportRegistry.getByTransport(unit as unknown as ITransport).length
+        )
+      )
+    )
+  );
+
+  return { args, ruleRegistry, transportRegistry };
+};
+
+describe('Submarine as a NavalTransport', (): void => {
+  it('is a naval transport', (): void => {
+    const { args } = setup(),
+      submarine = new Submarine(...args);
+
+    expect(submarine).instanceOf(NavalTransport);
+    expect(submarine).instanceOf(Naval);
+  });
+
+  it('has no room and stows nothing when the ruleset gives it no hold', (): void => {
+    const { args, transportRegistry } = setup(),
+      submarine = new Submarine(...args),
+      passenger = new Passenger(
+        null,
+        null as unknown as Player,
+        null as unknown as Tile
+      );
+
+    expect(submarine.capacity().value()).equal(0);
+    expect(submarine.hasCapacity()).false;
+    expect(submarine.hasCargo()).false;
+    expect(submarine.cargo()).deep.equal([]);
+    // No `CanStow` rule applies, so `canStow` agrees to anything: capacity 0 is what keeps it empty.
+    expect(submarine.canStow(passenger)).true;
+    expect(submarine.stow(passenger, null as unknown as Tile)).false;
+    expect(transportRegistry.entries()).deep.equal([]);
+  });
+
+  it('carries what the ruleset gives it room for', (): void => {
+    const { args, ruleRegistry } = setup(),
+      submarine = new Submarine(...args),
+      passenger = new Passenger(
+        null,
+        null as unknown as Player,
+        null as unknown as Tile
+      );
+
+    ruleRegistry.register(
+      new UnitYield(
+        new Criterion(
+          (unit: Unit, unitYield: YieldValue): unitYield is Capacity =>
+            unitYield instanceof Capacity
+        ),
+        new Criterion((unit: Unit): boolean => unit instanceof Submarine),
+        new Effect((unit: Unit, unitYield: YieldValue): void =>
+          unitYield.set(8)
+        )
+      ),
+      new CanStow(
+        new Effect(
+          (transport: ITransport, unit: Unit): boolean =>
+            unit instanceof Passenger
+        )
+      )
+    );
+
+    expect(submarine.stow(passenger, null as unknown as Tile)).true;
+    expect(submarine.cargo()).deep.equal([passenger]);
+  });
+
+  it('saves exactly what it did as a plain naval unit, and sends the same fields', (): void => {
+    const { args } = setup(),
+      submarine = new Submarine(...args),
+      before = new NavalSubmarine(...args);
+
+    expect(submarine.stateKeys()).deep.equal(before.stateKeys());
+    expect(submarine.keys()).deep.equal(before.keys());
+  });
+
+  it("names its new ancestors in the client payload's class chain", (): void => {
+    const { args } = setup();
+
+    // `toPlainObject` sends `keys()` (unchanged, above) and the class chain as `__`. A client asking whether it is a
+    //  `Naval` or a `Unit` gets the same answer; one asking about `NavalTransport` or `Transport` now finds them.
+    expect(generateInheritance(new Submarine(...args))).deep.equal(
+      generateInheritance(new NavalSubmarine(...args)).flatMap(
+        (name: string): string[] =>
+          name === 'NavalSubmarine'
+            ? ['Submarine', 'NavalTransport', 'Transport']
+            : [name]
+      )
+    );
+  });
+
+  it('gets its transport collaborators from Game.inject when loaded from a save made before it was a transport', (): void => {
+    const game = new Game(),
+      { args } = setup(),
+      before = new NavalSubmarine(...args) as unknown as Record<
+        string,
+        unknown
+      >,
+      // What a save written before this change holds for a Submarine: its saved fields, restored onto the class as it
+      //  is now without running the constructor, as core-save-game's `hydrate` does.
+      loaded = Object.create(Submarine.prototype) as Submarine;
+
+    new NavalSubmarine(...args).stateKeys().forEach((key: string): void => {
+      (loaded as unknown as Record<string, unknown>)[key] = before[key];
+    });
+
+    game.inject(loaded);
+
+    expect(
+      (loaded as unknown as { _transportRegistry: unknown })._transportRegistry
+    ).equal(game.transports);
+    expect(
+      (loaded as unknown as { _transportRuleRegistry: unknown })
+        ._transportRuleRegistry
+    ).equal(game.rules);
+    expect(loaded.hasCargo()).false;
+    expect(loaded.cargo()).deep.equal([]);
+  });
+});

package/tests/Submarine.test.ts

@@ -0,0 +1,41 @@
+import Naval from '@civ-clone/base-unit-type-naval/Naval';
+import Player from '@civ-clone/core-player/Player';
+import RuleRegistry from '@civ-clone/core-rule/RuleRegistry';
+import Submarine from '../Submarine';
+import Tile from '@civ-clone/core-world/Tile';
+import Unit from '@civ-clone/core-unit/Unit';
+import { expect } from 'chai';
+
+// A naval unit with nothing of its own, to compare the Submarine with: what a game saves of one is what it saves of
+//  any naval unit.
+class PlainNaval extends Naval {}
+
+const unitArgs = (
+  ruleRegistry: RuleRegistry = new RuleRegistry()
+): [null, Player, Tile, RuleRegistry] => [
+  null,
+  null as unknown as Player,
+  null as unknown as Tile,
+  ruleRegistry,
+];
+
+describe('Submarine', (): void => {
+  it('is a naval unit', (): void => {
+    const submarine = new Submarine(...unitArgs());
+
+    expect(submarine).instanceOf(Naval);
+    expect(submarine).instanceOf(Unit);
+  });
+
+  it('saves exactly what any naval unit saves', (): void => {
+    expect(new Submarine(...unitArgs()).stateKeys()).deep.equal(
+      new PlainNaval(...unitArgs()).stateKeys()
+    );
+  });
+
+  it('sends the client exactly what any naval unit sends', (): void => {
+    expect(new Submarine(...unitArgs()).keys()).deep.equal(
+      new PlainNaval(...unitArgs()).keys()
+    );
+  });
+});