@johnmorrisdotca/uchusen-rockets 0.9.0 → 0.10.0

package/dist/model/fleet/ship-03/hulls.js

@@ -0,0 +1,140 @@
+// How Miyamoto's boxy hulls are dressed. A hull is a box of plated faces; a face is cut into slots, each slot is plated or holds one piece of hardware (a hatch, a vent, a row of windows, a conduit stub, a lamp row, a sensor
+// post, a hazard frame, a number, a cluster of machinery), and a slot with hardware is left unplated so the hardware sits in a recess. Walls of a cutaway are real separate shells, one for each hull layer, stepped back so
+// the stack shows at the cut edge. Pure: no three.js and no DOM.
+import { cub, pipeRun, rng, rod } from "./adapter.js";
+import { bolts, conduit, faceOf, frame, hatch, hazard, lamp, on, pt, rail, skin, stencil, vent, windows } from "./faces.js";
+const ALL = ["hatch", "vent", "windows", "lamps", "greeble", "number", "stub", "bolts", "hazard", "sensor"];
+/** A hardware item in its slot, standing out of the (lifted) face. */
+function hardware(kind, f, a, b, sa, sb, random, seed) {
+    const small = Math.min(sa, sb);
+    if (kind === "hatch")
+        return hatch(f, a, b, Math.max(1.2, small * 0.36));
+    if (kind === "vent")
+        return vent(f, a, b, sa * 0.62, sb * 0.46, 6 + Math.floor(random() * 4));
+    if (kind === "windows")
+        return windows(f, b, a - sa * 0.36, a + sa * 0.36, 3 + Math.floor(random() * 3), Math.min(1.1, sb * 0.28));
+    if (kind === "lamps")
+        return [...lamp(f, a - sa * 0.3, b, "amber", 0.18), ...lamp(f, a, b, "blue", 0.18), ...lamp(f, a + sa * 0.3, b, random() < 0.5 ? "red" : "amber", 0.18)];
+    if (kind === "number")
+        return stencil(f, String(10 + Math.floor(random() * 89)), a, b, Math.min(2.4, sb * 0.5));
+    if (kind === "stub")
+        return conduit(f, b, a - sa * 0.42, a + sa * 0.42, { count: 2 + Math.floor(random() * 3), seed });
+    if (kind === "bolts")
+        return [...bolts(f, b - sb * 0.18, a - sa * 0.4, a + sa * 0.4, 0.8), ...bolts(f, b + sb * 0.18, a - sa * 0.4, a + sa * 0.4, 0.8), ...frame(f, a, b, sa * 0.8, sb * 0.46, 0.14, 0.12, "hull-grey-dark")];
+    if (kind === "hazard")
+        return [...frame(f, a, b, sa * 0.66, sb * 0.56, 0.3, 0.22, "hull-grey-dark"), ...hazard(f, b, a - sa * 0.33, a + sa * 0.33, 0.36, 0.7)];
+    if (kind === "sensor") {
+        const h = 0.9 + random() * 0.8;
+        return [rod("hull-grey-dark", pt(f, a, b, 0), pt(f, a, b, h), 0.16, 6), rod("lamp-red", pt(f, a, b, h), pt(f, a, b, h + 0.3), 0.1, 6), ...[-1, 1].map((s) => rod("hull-grey", pt(f, a, b, h * 0.7), pt(f, a + s * 0.6, b, h * 0.8), 0.05, 5))];
+    }
+    // a cluster of machinery: junction boxes, valve wheels, pump housings
+    const out = [];
+    for (let i = 0; i < 6; i++) {
+        const ca = a + (random() - 0.5) * sa * 0.7;
+        const cb = b + (random() - 0.5) * sb * 0.6;
+        const k = random();
+        const size = 0.25 + random() * 0.5;
+        if (k < 0.4)
+            out.push(on(f, ca, cb, size * 1.5, size, 0, size * 0.7, random() < 0.5 ? "hull-grey-dark" : "panel-dark"), on(f, ca, cb, size * 0.4, size * 0.4, size * 0.7, size * 0.9, "lamp-amber"));
+        else if (k < 0.65)
+            out.push(rod("hull-grey", pt(f, ca, cb, 0), pt(f, ca, cb, 0.15 + size), size * 0.4, 8), rod("hull-yellow", pt(f, ca - size * 0.5, cb, 0.2 + size), pt(f, ca + size * 0.5, cb, 0.2 + size), 0.05, 5));
+        else
+            out.push(rod("hull-grey-dark", pt(f, ca, cb, 0), pt(f, ca, cb, size * 0.8), size * 0.5, 8), rod("copper", pt(f, ca, cb, size * 0.8), pt(f, ca, cb, size * 1.1), size * 0.36, 8));
+    }
+    return out;
+}
+/** One face of a hull, plated and dressed. `lift` is how far the hardware stands out of the base (the plating's depth). */
+export function dressedFace(face, o) {
+    const random = rng(`${o.seed}/dress/${face.n}${face.sign}/${face.at.toFixed(1)}`);
+    const [sa, sb] = o.slot ?? [9, 6];
+    const detail = Math.max(0.2, Math.min(1, o.detail ?? 1));
+    const density = (o.density ?? 0.3) * detail;
+    const kinds = o.kinds ?? ALL;
+    const na = Math.max(1, Math.floor((face.a[1] - face.a[0]) / sa));
+    const nb = Math.max(1, Math.floor((face.b[1] - face.b[0]) / sb));
+    const wa = (face.a[1] - face.a[0]) / na;
+    const wb = (face.b[1] - face.b[0]) / nb;
+    const lift = o.raise ?? 0.26;
+    const base = { ...face, at: face.at + face.sign * lift * 0.45 };
+    const taken = [];
+    const out = [];
+    for (let i = 0; i < na; i++)
+        for (let j = 0; j < nb; j++) {
+            const a = face.a[0] + (i + 0.5) * wa;
+            const b = face.b[0] + (j + 0.5) * wb;
+            if (o.avoid?.(a, b) || random() >= density)
+                continue;
+            taken.push([a, b]);
+            // a recess: a coaming round the slot's hardware, so it sits in the hull and not on it
+            const kind = kinds[Math.floor(random() * kinds.length)];
+            const small = kind === "sensor" || kind === "lamps" || kind === "greeble" || kind === "number";
+            const k = small ? 0.5 : 0.9;
+            out.push(...frame(base, a, b, wa * k, wb * k * 0.95, 0.22, lift * 1.5, "hull-grey-dark"), on(base, a, b, wa * k, wb * k * 0.95, -0.02, 0.1, o.scheme.worn));
+            out.push(...hardware(kind, base, a, b, wa, wb, random, o.seed));
+        }
+    // structural ribs along the slot lines: thin standing bars, so the plating reads in bays with depth between them
+    for (let i = 0; i <= na; i++)
+        out.push(on(base, face.a[0] + i * wa, (face.b[0] + face.b[1]) / 2, 0.22, face.b[1] - face.b[0], 0, lift * 2.6, "hull-grey"));
+    for (let j = 0; j <= nb; j++)
+        out.push(on(base, (face.a[0] + face.a[1]) / 2, face.b[0] + j * wb, face.a[1] - face.a[0], 0.22, 0, lift * 2.2, "hull-grey-dark"));
+    const inSlot = (a, b) => taken.some(([ta, tb]) => Math.abs(a - ta) < wa * 0.5 && Math.abs(b - tb) < wb * 0.5);
+    out.push(...skin(face, o.scheme, o.seed, { detail, blanket: o.blanket, cell: o.cell ?? (o.blanket ? [Math.max(4, wa * 0.7), Math.max(3.2, wb * 0.7)] : [Math.max(2.5, wa / 2), Math.max(2, wb / 2)]), raise: lift, skip: (a, b) => inSlot(a, b) || Boolean(o.avoid?.(a, b)) }));
+    return out;
+}
+/** The six faces of a box: +x, -x, +y, -y, +z, -z. */
+export const facesOf = (box) => ({ stbd: faceOf(box, "x", 1), port: faceOf(box, "x", -1), bow: faceOf(box, "y", 1), aft: faceOf(box, "y", -1), dorsal: faceOf(box, "z", 1), ventral: faceOf(box, "z", -1) });
+/** A solid hull: the core box in the dark under-colour (it is what shows in every seam), and every wanted face dressed. */
+export function hullBox(box, core, faces, o) {
+    const out = [cub(core, box.x, box.y, box.z, { only: undefined })];
+    const all = facesOf(box);
+    for (const key of faces)
+        out.push(...dressedFace(all[key], o));
+    // the twelve edges of the box carry a corner beam, with a bolt every few metres
+    const edge = 0.7;
+    for (const x of box.x)
+        for (const z of box.z)
+            out.push(cub("hull-grey", [x - edge / 2, x + edge / 2], box.y, [z - edge / 2, z + edge / 2]));
+    for (const x of box.x)
+        for (const y of box.y)
+            out.push(cub("hull-grey", [x - edge / 2, x + edge / 2], [y - edge / 2, y + edge / 2], box.z));
+    for (const z of box.z)
+        for (const y of box.y)
+            out.push(cub("hull-grey", box.x, [y - edge / 2, y + edge / 2], [z - edge / 2, z + edge / 2]));
+    return out;
+}
+/** The walls of a hull as separate shells, one for each layer of a stack, outermost first; each inner layer stands in `step` metres at its ends so the stack shows at a cut. `axis` is the way the wall's thickness runs. */
+export function wallShells(stack, o) {
+    const out = [];
+    let outer = o.at;
+    const scale = o.scale ?? 1;
+    let inset = 0;
+    for (const layer of stack.layers) {
+        const thick = (layer.mm / 1000) * scale;
+        const lo = Math.min(outer, outer - o.sign * thick);
+        const hi = Math.max(outer, outer - o.sign * thick);
+        const across = [o.across[0] + inset, o.across[1] - inset];
+        out.push(o.axis === "z" ? cub(layer.material, across, o.y, [lo, hi]) : cub(layer.material, [lo, hi], o.y, across));
+        outer -= o.sign * thick;
+        inset += o.step ?? 0.18;
+    }
+    return out;
+}
+/** A row of rails and posts: a catwalk of grating with a handrail, along Y at (x, z). */
+export function catwalk(y0, y1, x, z, width = 1.8) {
+    const out = [cub("deck", [x - width / 2, x + width / 2], [y0, y1], [z - 0.08, z + 0.08], { only: "mesh" })];
+    for (const s of [-1, 1]) {
+        out.push(rod("hull-yellow", [x + (s * width) / 2, y0, z + 1.05], [x + (s * width) / 2, y1, z + 1.05], 0.05, 12));
+        for (let y = y0; y <= y1 + 0.01; y += 2.4)
+            out.push(rod("hull-grey-dark", [x + (s * width) / 2, y, z], [x + (s * width) / 2, y, z + 1.05], 0.04, 10));
+    }
+    for (let y = y0 + 0.4; y < y1; y += 0.5)
+        out.push(cub("hull-grey-dark", [x - width / 2, x + width / 2], [y, y + 0.06], [z - 0.14, z - 0.08]));
+    return out;
+}
+/** A pipe run from a to b: a round tube with a bend half way, flanges at the ends and a valve block on it, for the feed lines. */
+export function pipe(a, b, r, material = "coolant") {
+    const mid = [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2, (a[2] + b[2]) / 2];
+    const bend = [b[0], a[1] * 0.5 + mid[1] * 0.5, a[2]];
+    return [...pipeRun(material, [a, bend, b], r, { clampEvery: 3.5 }), rod("hull-grey-dark", [mid[0], mid[1] - r * 1.1, mid[2]], [mid[0], mid[1] + r * 1.1, mid[2]], r * 1.7, 12), rod("lamp-amber", [mid[0], mid[1] + r * 1.1, mid[2]], [mid[0], mid[1] + r * 1.5, mid[2]], r * 0.6, 8)];
+}
+export { rail };

package/dist/model/fleet/ship-03/index.d.ts

@@ -0,0 +1,37 @@
+import type { PartKind } from "../../../parts.ts";
+import { type Piece } from "./adapter.ts";
+/** How much small detail to build, 0.25 to 1: coarse first, fine as the viewer comes near. */
+export declare const LEVELS: readonly [0.25, 0.6, 1];
+export interface BuildOptions {
+    detail?: number;
+    /** `coarse`: only the pieces the kit's `isCoarse` keeps, for a first picture in a moment; `fine` (the default): all of them. */
+    level?: "coarse" | "fine";
+}
+export interface MiyamotoPart {
+    /** The slot, and the id after `fleet-ship-03-`. */
+    id: string;
+    name: string;
+    kind: PartKind;
+    /** Where it stands in the ship: its base on the spine (y), and across (x) and up (z) for a part that is placed, not stacked. */
+    y0: number;
+    place?: {
+        x: number;
+        z: number;
+    };
+    /** The size as built, metres: along the spine, and the widest across. */
+    height: number;
+    diameter: number;
+    /** Stacked parts mate at the spine collars (a 12 m class L collar). */
+    top?: boolean;
+    bottom?: boolean;
+    /** What it is, in a line. */
+    note: string;
+    /** The pieces, in the part's own metres. */
+    pieces: (options?: BuildOptions) => Piece[];
+}
+declare const COLLAR_L = 12;
+/** The stacked modules, tail to bow, in their plain and their cut form. */
+export declare const STACK: (cut: boolean) => MiyamotoPart[];
+/** Every part of the ship, each once. */
+export declare function parts(): MiyamotoPart[];
+export { COLLAR_L };

package/dist/model/fleet/ship-03/index.js

@@ -0,0 +1,134 @@
+import { isCoarse, place } from "./adapter.js";
+import { solarArray } from "./solar.js";
+import { bowLivery, citadelLivery, driveLivery, habitatLivery, hangarLivery } from "./ariake.js";
+import { bow } from "./bow.js";
+import { command } from "./command.js";
+import { ARRAY, BAYS, bayBox, RADIATOR, SHADOW_COLLAR, STATION } from "./dims.js";
+import { driveFrame, noCollar, shadowCollar } from "./drive.js";
+import { engineering } from "./engineering.js";
+import { noseRounded } from "./nose.js";
+import { ANCESTORS, SHIPS } from "./specs.js";
+import { BAY_OF, hangar } from "./hangar.js";
+import { habitat } from "./habitat.js";
+import { pod } from "./pod.js";
+import { radiators } from "./radiators.js";
+import { fuelSection } from "./tanks.js";
+/** How much small detail to build, 0.25 to 1: coarse first, fine as the viewer comes near. */
+export const LEVELS = [0.25, 0.6, 1];
+const local = (pieces, x, y, z, level) => {
+    const moved = place(pieces, { at: [-x, -y, -z] });
+    return level === "coarse" ? moved.filter(isCoarse) : moved;
+};
+const COLLAR_L = 12;
+const stack = (id, name, kind, [y0, y1], width, depth, note, build, cut, first = false, last = false) => ({
+    id: cut ? `${id}-cutaway` : id,
+    name: cut ? `${name}, cutaway` : name,
+    kind,
+    y0,
+    height: y1 - y0,
+    diameter: Math.max(width, depth),
+    ...(first ? {} : { bottom: true }),
+    ...(last ? {} : { top: true }),
+    note: note.includes("Descends from") ? note : `${note} Descends from ${ANCESTORS[id.replace("-ariake", "")]}.`,
+    pieces: (o) => local(build(cut, o?.detail ?? 1), 0, y0, 0, o?.level),
+});
+const BAY_NOTE = { rescue: "a rescue bay with a gantry, racks, a pressure vestibule, a cradle with clamp arms for an ATC (Auxiliary Transfer Craft) rescue cutter and guide rails to the door", survey: "a survey bay with three cradles, an access bridge and emergency shutters" };
+/** One hangar box. Miyamoto has two (starboard aft, port fore); Ariake has all four, and her four carry her pinstripes. */
+const shoulder = (bay, cut, ariake = false) => {
+    const { side, kind } = BAYS[bay];
+    const h = bayBox(bay);
+    const stationed = bay !== BAY_OF[side];
+    const id = `hangar-${stationed ? bay : side}${ariake ? "-ariake" : ""}${cut ? "-cutaway" : ""}`;
+    const where = side === "starboard" ? "Starboard" : "Port";
+    const fore = h.y[0] > 200 ? "fore" : "aft";
+    return {
+        id,
+        name: `${stationed ? `${where} ${fore}` : where} ${kind} hangar${ariake ? ", Ariake" : ""}${cut ? ", cutaway" : ""}`,
+        kind: "module",
+        y0: h.y[0],
+        place: { x: h.centre, z: 0 },
+        height: h.y[1] - h.y[0],
+        diameter: h.x[1] - h.x[0],
+        note: `The ${fore} shoulder on the ${side} side: ${BAY_NOTE[kind]}, opening to ${side}. Descends from ${ANCESTORS[`hangar-${side}`]}.`,
+        pieces: (o) => local([...hangar(ariake || stationed ? bay : side, cut, o?.detail ?? 1, ariake ? `hangar-${stationed ? bay : side}-ariake` : stationed ? `hangar-${bay}` : undefined), ...(ariake ? hangarLivery(bay) : [])], h.centre, h.y[0], 0, o?.level),
+    };
+};
+const missionPod = (kind) => ({
+    id: `pod-${kind}`,
+    name: kind === "relay" ? "Mission pod, relay" : kind === "relief" ? "Mission pod, relief" : "Mission pod, survey",
+    kind: "module",
+    y0: 174,
+    place: { x: 0, z: 0 },
+    height: 60,
+    diameter: 28,
+    note: `${kind === "relay" ? "A communications bay under a tower of dishes and phased arrays, on the keyed dorsal collar." : kind === "relief" ? "Six relief and equipment containers under a gantry, on the keyed dorsal collar." : "A survey bay on the keyed dorsal collar: a telescope in a yoke, a rack of six probes, a radar dish, a lidar drum, a magnetometer boom and two instrument containers."} Descends from ${ANCESTORS.pod}.`,
+    pieces: (o) => local(pod(kind, o?.detail ?? 1), 0, 174, 0, o?.level),
+});
+const solarPart = (state) => ({
+    id: `array-${state}`,
+    name: `Solar array, ${state}`,
+    kind: "module",
+    y0: ARRAY.y[0],
+    place: { x: 0, z: 0 },
+    height: ARRAY.y[1] - ARRAY.y[0],
+    diameter: state === "deployed" ? 100 : 14,
+    note: `${state === "stowed" ? "Ten gold-foil canisters of folded cell blankets on a root beam along the starboard side, with a rotary joint at each end, a beta gimbal and a hinge to each bay. For time near a star; the fusion plants are the ship's power." : "Ten bays of lattice masts 56 m long, a gold cell blanket each side of each mast (5,800 square metres of cells), the wing turned 35 degrees about its root beam, cells up and out, to face the star. For time near a star; the fusion plants are the ship's power."} Descends from ${ANCESTORS.array}.`,
+    pieces: (o) => local(solarArray(state, o?.detail ?? 1), 0, ARRAY.y[0], 0, o?.level),
+});
+const bank = (which, open) => ({
+    id: `radiators-${which}-${open ? "deployed" : "stowed"}`,
+    name: `Radiator bank, ${which}, ${open ? "deployed" : "stowed"}`,
+    kind: "module",
+    y0: RADIATOR.y[0],
+    place: { x: 0, z: 0 },
+    height: RADIATOR.y[1] - RADIATOR.y[0],
+    diameter: open ? 125 : 25,
+    note: `${open ? "Four leaves of 25 by 60 m on a mast, clear of the hangar corridors and the exhaust." : "Four leaves folded into a box on the habitation hull's rails."} Descends from ${ANCESTORS.radiators}.`,
+    pieces: (o) => local(radiators(which, open, o?.detail ?? 1), 0, RADIATOR.y[0], 0, o?.level),
+});
+/** The stacked modules, tail to bow, in their plain and their cut form. */
+export const STACK = (cut) => [
+    stack("drive", "Main drive and thrust frame", "engine", STATION.drive, 90, 46, "Two flush fusion-triggered nozzles with throat rings, field coils and feed manifolds, a blast bulkhead and four plasma verniers.", driveFrame, cut, true),
+    stack("engineering", "Engineering and isolators", "module", STATION.engineering, 28, 26, "Reactor chambers, a locked-out service corridor, two isolated auxiliary power units, the emergency battery room and the breakers.", engineering, cut),
+    stack("fuel-aft", "Aft fuel section", "tank", STATION.fuelAft, 62, 44, "The spine and the aft pair of propellant barrels, with a header tank slung under it.", (c, d) => fuelSection("aft", c, d), cut),
+    stack("fuel-fore", "Fore fuel section", "tank", STATION.fuelFore, 62, 66, "The spine and the fore pair of barrels, the keyed dorsal collar's base and the ventral keel with its dock.", (c, d) => fuelSection("fore", c, d), cut),
+    stack("habitat", "Habitation and medical", "module", STATION.habitat, 26, 28, "Four decks across the beam: triage and quarantine, crew bunks, mess and hydroponics, water and air recycling.", habitat, cut),
+    stack("command", "Armoured command citadel", "module", STATION.command, 42, 32, "An operations ring round a communications core, a navigation desk, a medical link and two escape passages, behind armour.", command, cut),
+    stack("bow", "Bow defence and navigation", "module", STATION.bow, 38, 38, "A rounded nose: three staggered round shield layers under a domed front, all in gold solar cells, with ranging apertures, optical heads and two debris-intercept mounts.", (c, d) => noseRounded(c, d), cut, false, true),
+];
+/** The shadow-shield collar, or none: two parts for one slot, so the viewer can swap them. Ariake's is clad in near-black hexagonal tiles in place of the white and gold bands. */
+const collarPart = (kind) => ({
+    id: kind === "none" ? "collar-none" : kind === "ariake" ? "shield-collar-ariake" : "shield-collar",
+    name: kind === "none" ? "Drive collar, none (bare neck)" : kind === "ariake" ? "Shadow-shield collar, Ariake" : "Shadow-shield collar",
+    kind: "module",
+    y0: SHADOW_COLLAR.y,
+    place: { x: 0, z: 0 },
+    height: kind === "none" ? 1 : SHADOW_COLLAR.length,
+    diameter: kind === "none" ? 24 : SHADOW_COLLAR.r * 2,
+    note: kind === "none" ? `The drive's neck meets the hull at a plain flange ring, as the neck of a bare engine section does in ${ANCESTORS.collar}. Descends from ${ANCESTORS.collar}.` : kind === "ariake" ? `A round cone clad in rows of raised near-black hexagonal tiles, with the orange removable panels left as on Miyamoto's. Descends from ${ANCESTORS.collar}.` : `A round ceramic-tile cone that steps from the engines to the hull. Descends from ${ANCESTORS.collar}.`,
+    pieces: (o) => (kind === "none" ? noCollar() : local(shadowCollar(false, o?.detail ?? 1, kind === "ariake" ? "shield-collar-ariake" : undefined, kind === "ariake"), 0, SHADOW_COLLAR.y, 0, o?.level)),
+});
+/** The parts that differ for the sister ship: the drive and the bow carry its registry marks and its dawn-gold pinstripes, the habitation drum and the hangars its pinstripes (and the drum a warm interior), the citadel its refit. */
+const sister = () => [
+    stack("drive-ariake", "Main drive and shrouds, Ariake", "engine", STATION.drive, 90, 46, `The sister ship's drive: the shrouds clad in rows of raised near-black hexagonal tiles in place of Miyamoto's white and gold bands, with the nozzle lips and the service windows left bare, and a pair of dawn-gold pinstripes on the neck. Descends from ${ANCESTORS.drive}.`, (c, d) => [...driveFrame(c, d, "drive-ariake", true), ...driveLivery()], false, true),
+    stack("drive-ariake", "Main drive and shrouds, Ariake", "engine", STATION.drive, 90, 46, `The sister ship's drive: the shrouds clad in rows of raised near-black hexagonal tiles in place of Miyamoto's white and gold bands, with the nozzle lips and the service windows left bare, and a pair of dawn-gold pinstripes on the neck. Descends from ${ANCESTORS.drive}.`, (c, d) => [...driveFrame(c, d, "drive-ariake", true), ...driveLivery()], true, true),
+    stack("habitat-ariake", "Habitation and medical, Ariake", "module", STATION.habitat, 26, 28, "The sister ship's habitation drum: two dawn-gold bands with their pinstripes, and rooms in warm wood and dawn-gold in place of blue.", (c, d) => [...habitat(c, d, "habitat-ariake", "dawn"), ...habitatLivery(false)], false),
+    stack("habitat-ariake", "Habitation and medical, Ariake", "module", STATION.habitat, 26, 28, "The sister ship's habitation drum: two dawn-gold bands with their pinstripes, and rooms in warm wood and dawn-gold in place of blue.", (c, d) => [...habitat(c, d, "habitat-ariake", "dawn"), ...habitatLivery(true)], true),
+    stack("command-ariake", "Armoured command citadel, Ariake", "module", STATION.command, 42, 32, "The sister ship's citadel after its refit: a lattice sensor mast aft of the dome, a solarium on each side of it, and dawn-gold pinstripes and bands.", (c, d) => [...command(c, d, "command-ariake", true), ...citadelLivery()], false),
+    stack("bow-ariake", "Bow defence and navigation, Ariake", "module", STATION.bow, 36, 40, `The sister ship's bow, with its hull marks 186 and a dawn-gold pinstripe on each shield layer. Descends from ${ANCESTORS.bow}.`, (c, d) => [...bow(c, d, "bow-ariake", SHIPS.ariake.marks), ...bowLivery()], false, false, true),
+    shoulder("starboard-aft", false, true),
+    shoulder("port-fore", false, true),
+    shoulder("starboard-fore", false, true),
+    shoulder("port-aft", false, true),
+];
+/** Every part of the ship, each once. */
+export function parts() {
+    const out = [...STACK(false), ...STACK(true)];
+    for (const cut of [false, true])
+        out.push(shoulder("starboard-aft", cut), shoulder("port-fore", cut));
+    out.push(...sister(), collarPart("plain"), collarPart("none"), collarPart("ariake"), missionPod("relay"), missionPod("relief"), missionPod("survey"), solarPart("stowed"), solarPart("deployed"));
+    for (const which of ["dorsal", "ventral"])
+        out.push(bank(which, false), bank(which, true));
+    return out;
+}
+export { COLLAR_L };

package/dist/model/fleet/ship-03/insets.d.ts

@@ -0,0 +1,18 @@
+import { type Inset, type Piece } from "./adapter.ts";
+/** Miyamoto's three insets. */
+export declare const SHIP_INSETS: Readonly<Record<string, Inset>>;
+/** The two propulsion cards: an engine on its own, true to its size, with its bell, throat, chamber, feed manifolds, coils and gimbal. */
+export declare const CARDS: {
+    readonly main: {
+        readonly id: "card-main";
+        readonly name: "Propulsion card: main nozzle";
+        readonly size: readonly [44, 56, 44];
+        readonly pieces: () => Piece[];
+    };
+    readonly vernier: {
+        readonly id: "card-vernier";
+        readonly name: "Propulsion card: plasma vernier";
+        readonly size: readonly [6, 12, 6];
+        readonly pieces: () => Piece[];
+    };
+};

package/dist/model/fleet/ship-03/insets.js

@@ -0,0 +1,55 @@
+// Miyamoto's own system insets, each opening into six numbered sub-parts that come apart: the command citadel, the hangars and the medical bay. (The reactor core, the navigation and sensor suite, life support and the
+// docking port are the fleet kit's four, shared by every ship.) The two propulsion cards, the main nozzle and a vernier, stand here too, each drawn on its own at a size where the throat, the coils and the feed lines
+// show. Every sub-part is its own part of the registry, placed in its inset's assembly. Pure: no three.js and no DOM.
+import { antenna, box, cub, HULL_STACKS, ibeam, pipeRun, rod, roundStrut } from "./adapter.js";
+import { nozzle, vernier } from "./drive.js";
+import { cradle } from "./hangar.js";
+import { pipe } from "./hulls.js";
+import { capsule, collarAt, ringAt, tubeAt } from "./shapes.js";
+const part = (n, name, does, size, at, pieces) => ({ n, name, does, size, at: [...at], pieces });
+const citadel = {
+    id: "ship-03-citadel",
+    name: "Command citadel",
+    note: "Miyamoto's command citadel opened into its six working parts.",
+    parts: [
+        part(1, "Communications core", "A tall tube through every deck, ringed with equipment and a cooling jacket.", [8, 20, 8], [0, 0, 0], () => [tubeAt("hull-grey", 0, 0, 3.6, 0, 20, { segs: 24 }), tubeAt("lamp-blue", 0, 0, 2.4, 0.5, 19.5, { segs: 16 }), ...[...Array(8).keys()].flatMap((k) => [ringAt("hull-grey-dark", 0, 0, 3.7, 1 + k * 2.4, 0.2), ringAt("copper", 0, 0, 4, 1.6 + k * 2.4, 0.12)]), ...antenna("dish", [0, 20, 0], [0, 1, 0], 5, "core")]),
+        part(2, "Operations ring", "Fourteen consoles facing the core, a lit display above each.", [26, 4, 26], [0, 0, 0], () => [collarAt("deck", 0, 0, 4.4, 12.2, 0, 0.4), collarAt("hull-yellow", 0, 0, 12.2, 12.5, 0, 0.5), ...[...Array(14).keys()].flatMap((k) => { const a = (Math.PI * 2 * k) / 14; return [box("hull-grey-dark", [10.2 * Math.sin(a), 0.4, 10.2 * Math.cos(a)], 2.4, 1.2, 1.1, (a * 180) / Math.PI), cub("lamp-blue", [11.5 * Math.sin(a) - 0.5, 11.5 * Math.sin(a) + 0.5], [1.7, 3], [11.5 * Math.cos(a) - 0.5, 11.5 * Math.cos(a) + 0.5])]; })]),
+        part(3, "Navigation desk", "A star-map table with three seats.", [12, 2, 10], [0, 0, 0], () => [cub("hull-grey-dark", [-6, 6], [0, 1], [-3, 3]), cub("lamp-blue", [-5.4, 5.4], [1, 1.08], [-2.4, 2.4]), ...[-4, 0, 4].map((x) => cub("hull-white-worn", [x - 0.6, x + 0.6], [0, 1.2], [4, 5.2])), cub("deck", [-7, 7], [-0.3, 0], [-5, 7])]),
+        part(4, "Medical link", "A transfer corridor to the habitation hull, with a hazard door.", [4, 8, 4], [0, 0, 0], () => [tubeAt("hull-white-worn", 0, 0, 1.6, 0, 8, { segs: 12 }), cub("hazard", [-1.8, 1.8], [0, 0.2], [-1.8, 1.8]), ringAt("hull-grey-dark", 0, 0, 1.7, 4, 0.12)]),
+        part(5, "Escape passage", "A tube with a ladder from the ring to a hatch in the armour.", [3, 24, 3], [0, 0, 0], () => [cub("hull-white-worn", [-1, 1], [0, 24], [-1, 1]), cub("hazard", [-1.1, 1.1], [0, 0.3], [-1.1, 1.1]), ...[...Array(40).keys()].map((k) => rod("hull-yellow", [-0.4, 0.6 * k, 0.9], [0.4, 0.6 * k, 0.9], 0.03, 4))]),
+        part(6, "Armour laminate", "The eight layers of the citadel's wall, outside in, stepped so each shows.", [10, 1.2, 10], [0, 0, 0], () => HULL_STACKS.command.layers.map((layer, i) => cub(layer.material, [-5 + i * 0.3, 5 - i * 0.3], [i * 0.1, i * 0.1 + 0.5], [-5 + i * 0.3, 5 - i * 0.3]))),
+    ],
+};
+const bays = {
+    id: "ship-03-hangars",
+    name: "Hangars",
+    note: "The two bays opened into their six working parts.",
+    parts: [
+        part(1, "Bay door and shutters", "Five orange leaves on rails, a hazard sill and a grey frame.", [30, 10, 3], [0, 0, 0], () => [cub("hull-grey", [-15, 15], [0, 10], [-0.5, 0.2]), ...[...Array(5).keys()].map((k) => cub(k % 2 ? "hull-orange" : "hull-orange-worn", [-15 + k * 6 + 0.1, -9 + k * 6 - 0.1 + 6], [0.5, 9.5], [0.2, 0.8 + (k % 2) * 0.3])), cub("hazard", [-15, 15], [0, 0.4], [0.2, 0.7])]),
+        part(2, "Gantry crane", "Two rails, a bridge, a trolley and a hook.", [20, 8, 40], [0, 0, 0], () => [cub("hull-yellow", [-10, -9.3], [0, 40], [7, 7.6]), cub("hull-yellow", [9.3, 10], [0, 40], [7, 7.6]), cub("hull-orange", [-10, 10], [19, 20.6], [6, 7.4]), cub("hull-yellow", [-1.6, 1.6], [18.4, 21.6], [4.8, 6]), rod("hull-grey-dark", [0, 20, 4.8], [0, 20, 0.5], 0.08, 6), cub("hazard", [-0.5, 0.5], [19.5, 20.5], [0, 0.8])]),
+        part(3, "Cradle with clamp arms", "Two I-beams and cross beams on feet, six clamp arms with hydraulic cylinders and padded jaws, and hazard chocks, ready for a craft.", [20, 34, 6], [0, 0, 0], () => cradle(0, 17, 34, 14, 0)),
+        part(4, "Maintenance racks", "Four shelves of crates along the wall.", [3, 12, 18], [0, 0, 0], () => [...[0, 1, 2, 3].map((t) => cub("hull-grey-dark", [0, 2.2], [0, 12], [t * 5, t * 5 + 0.25])), ...[0, 1, 2, 3].flatMap((t) => [0, 1, 2].map((k) => cub(k % 2 ? "hull-orange-worn" : "hull-yellow", [0.2, 1.9], [0.2 + k * 3.8, 3.6 + k * 3.8], [t * 5 + 0.25, t * 5 + 1.7])))]),
+        part(5, "Pressure vestibule", "A box with two doors and a status lamp between the bay and the spine.", [12, 5, 8], [0, 0, 0], () => [cub("hull-white-worn", [-6, 6], [0, 5], [0, 7]), cub("hull-grey-dark", [-3, 3], [5, 5.2], [0.2, 5.9]), cub("hazard", [-3.3, 3.3], [5.2, 5.35], [5.9, 6.4]), cub("lamp-blue", [-0.3, 0.3], [5.2, 5.4], [6.6, 7])]),
+        part(6, "Umbilical boom", "A pylon and a boom over the cradle, with hoses for fuel, coolant and power hanging to a connector head, and a hose reel.", [16, 12, 6], [0, 0, 0], () => [cub("hull-grey-dark", [0, 1], [-1.4, 1.4], [0, 8]), ...ibeam("hull-yellow", [0.5, 0, 7.2], [14, 0, 7.2], 1, 0.7, [0, 0, 1]), ...roundStrut("hull-grey-dark", [0.5, 0, 5.4], [8, 0, 7.1], 0.3), ...["fuel", "coolant", "copper"].flatMap((m, k) => pipeRun(m, [[13.5, -0.8 + 0.8 * k, 7.2], [14, -0.8 + 0.8 * k, 5.2], [15.4, -0.8 + 0.8 * k, 2.7], [15.4, -0.8 + 0.8 * k, 3.6]], 0.2, { clampEvery: 2.2 })), cub("hull-grey-dark", [14.6, 16.2], [-1.5, 1.5], [2.8, 3.8]), cub("lamp-amber", [14.9, 15.9], [-1.5, 1.5], [3.8, 3.95])]),
+    ],
+};
+const medical = {
+    id: "ship-03-medical",
+    name: "Medical bay",
+    note: "The triage bay opened into its six working parts.",
+    parts: [
+        part(1, "Triage berth", "A bed, a monitor arm, a glass hood and a lamp: six of them in two rows.", [2.4, 5, 4], [0, 0, 0], () => [cub("hull-white", [-1.1, 1.1], [0, 4.6], [0, 0.9]), cub("hull-grey-dark", [-0.9, 0.9], [0.2, 4.4], [0.9, 1.15]), cub("glass", [-1.15, 1.15], [0.2, 2.2], [1.2, 2.2]), rod("hull-grey", [0, -0.4, 0.9], [0, -0.4, 2.9], 0.07, 6), cub("lamp-blue", [-0.4, 0.4], [-0.7, -0.1], [2.9, 3])]),
+        part(2, "Monitor arm and curtain rail", "An arm for the screen and a rail for the curtain.", [4, 1, 3], [0, 0, 0], () => [rod("hull-yellow", [-1.5, 0, 3], [1.5, 0, 3], 0.03, 5), rod("hull-grey", [0, 0, 0], [0, 0, 3], 0.07, 6), cub("hull-grey-dark", [-0.5, 0.5], [-0.1, 0.1], [2.2, 2.9]), cub("lamp-blue", [-0.4, 0.4], [-0.12, -0.1], [2.3, 2.8])]),
+        part(3, "Quarantine room", "A glass-walled room with two berths and its own air.", [6, 5, 5], [0, 0, 0], () => [cub("glass", [-0.1, 0.1], [0, 5], [0, 5]), cub("hull-white-worn", [0.4, 5.6], [0.4, 2.6], [0, 0.9]), cub("hull-white-worn", [0.4, 5.6], [2.8, 4.6], [0, 0.9]), cub("hazard", [-0.2, 0.2], [0, 0.2], [0, 5]), capsule("hull-white", 3, 3, 0.5, 0, 2.4)]),
+        part(4, "Transfer lock", "An orange box with a door each way and a hazard frame.", [3.2, 8, 6], [0, 0, 0], () => [cub("hull-orange", [0, 3.2], [0, 8], [0, 5.2]), cub("hazard", [0, 3.2], [-0.2, 0.1], [0, 5.2]), cub("lamp-amber", [0.2, 0.8], [6, 6.4], [4.6, 5])]),
+        part(5, "Air and power isolation", "A panel that cuts the medical air and power from both bays.", [3, 3, 1], [0, 0, 0], () => [cub("panel-dark", [0, 3], [0, 3], [0, 0.5]), ...[0, 1, 2].flatMap((k) => [cub("hazard", [0.3 + k * 0.9, 0.9 + k * 0.9], [0.3, 2.7], [0.5, 0.6]), cub("lamp-red", [0.5 + k * 0.9, 0.7 + k * 0.9], [2.5, 2.7], [0.6, 0.7])]), ...pipe([0, 1, 0.5], [3, 1, 0.5], 0.1)]),
+        part(6, "Medical stores", "Three racks of cases, a cold box and a locked cabinet.", [6, 4, 3], [0, 0, 0], () => [...[0, 1, 2].map((k) => cub(k === 1 ? "frost" : "hull-white", [k * 2, k * 2 + 1.8], [0, 4], [0, 2.6])), cub("hull-grey-dark", [0, 6], [0, 0.2], [0, 3]), ...[0, 1, 2].map((k) => cub("lamp-blue", [k * 2 + 0.7, k * 2 + 1.1], [3, 3.2], [2.6, 2.7]))]),
+    ],
+};
+/** Miyamoto's three insets. */
+export const SHIP_INSETS = { [citadel.id]: citadel, [bays.id]: bays, [medical.id]: medical };
+/** The two propulsion cards: an engine on its own, true to its size, with its bell, throat, chamber, feed manifolds, coils and gimbal. */
+export const CARDS = {
+    main: { id: "card-main", name: "Propulsion card: main nozzle", size: [44, 56, 44], pieces: () => nozzle(0, true, "card") },
+    vernier: { id: "card-vernier", name: "Propulsion card: plasma vernier", size: [6, 12, 6], pieces: () => vernier(0, 0) },
+};

package/dist/model/fleet/ship-03/nose.d.ts

@@ -0,0 +1,2 @@
+import { type Piece } from "./adapter.ts";
+export declare function noseRounded(cut: boolean, detail?: number, seed?: string, marks?: string): Piece[];

package/dist/model/fleet/ship-03/nose.js

@@ -0,0 +1,136 @@
+// Miyamoto's rounded nose, station 350 to 380 m: the three staggered, spaced shield layers of the bow, but as round drums with rounded shoulders under a domed front, and every round surface covered in gold solar cells (a raised
+// plate each, in rows that follow the curve). The orange removable shield stays as a rim round the front of each layer; the steerable ranging apertures, the optical heads, the side apertures and the two debris-intercept mounts
+// stand where they stood on the square bow. Ariake keeps the square bow (`bow.ts`). A cutaway opens the starboard side to the crush cells. Pure: no three.js and no DOM.
+import { collar, cub, rng, rod } from "./adapter.js";
+import { STATION } from "./dims.js";
+import { frame, lamp, on, stencil } from "./faces.js";
+import { hexClad } from "./hex.js";
+import { OPEN_STARBOARD, ringAt, tubeAt } from "./shapes.js";
+const [Y0] = STATION.bow;
+/** The radius of each round layer, the metres of it, and where each stands: tail to nose. */
+const LAYERS = [
+    { r: 19, y: [Y0, Y0 + 11.5] },
+    { r: 15.5, y: [Y0 + 12.2, Y0 + 20.5] },
+    { r: 11.5, y: [Y0 + 21.2, Y0 + 24] },
+];
+const DOME = { y: Y0 + 24, r: 11.5, rise: 6 };
+/** The cells: gold, a little varied, the bright of the field coils and the foil of the kapton. */
+const CELLS = [[0.2, "coil"], [0.7, "gold"], [1, "kapton"]];
+/** The dome's height above its base at a radius. */
+const domeY = (r) => DOME.y + DOME.rise * Math.sqrt(Math.max(0, 1 - (r / DOME.r) ** 2));
+/** A layer's outline from its tail face to its rounded front shoulder. */
+const drum = (i) => {
+    const { r, y } = LAYERS[i];
+    return [[0.001, y[0]], [r - 1.4, y[0]], [r, y[0] + 1.4], [r, y[1] - 2.2], [r - 0.5, y[1] - 1], [r - 1.8, y[1]], [0.001, y[1]]];
+};
+const profileRadius = (profile, y) => {
+    const k = profile.findIndex(([, py], i) => i + 1 < profile.length && y >= Math.min(py, profile[i + 1][1]) && y <= Math.max(py, profile[i + 1][1]));
+    if (k < 0)
+        return 0;
+    const [r0, y0] = profile[k];
+    const [r1, y1] = profile[k + 1];
+    return y1 === y0 ? Math.max(r0, r1) : r0 + ((r1 - r0) * (y - y0)) / (y1 - y0);
+};
+export function noseRounded(cut, detail = 1, seed = "bow", marks = "452") {
+    const out = [];
+    const random = rng(`${seed}/nose`);
+    const arc = cut ? { arc: OPEN_STARBOARD } : {};
+    // the layers: a dark round core with a rounded shoulder, an orange removable rim round its front, bolts, and gold cells over its side
+    LAYERS.forEach((layer, i) => {
+        const { r, y } = layer;
+        const profile = drum(i);
+        out.push({ kind: "lathe", material: "hull-grey-dark", at: [0, 0], segs: 48, profile, body: true, outline: true, ...arc });
+        out.push(ringAt("hull-orange", 0, 0, r - 0.5, y[1] - 1.2, 0.5, arc), ringAt("hull-grey", 0, 0, r + 0.1, y[0] + 1.6, 0.35, arc));
+        for (let k = 0; k < 32; k++) {
+            const a = (Math.PI * 2 * k) / 32;
+            if (cut && Math.sin(a) > 0)
+                continue;
+            out.push(cub("hull-grey-dark", [(r - 0.3) * Math.sin(a) - 0.16, (r - 0.3) * Math.sin(a) + 0.16], [y[1] - 0.5, y[1] - 0.1], [(r - 0.3) * Math.cos(a) - 0.16, (r - 0.3) * Math.cos(a) + 0.16]));
+        }
+        // the cells, clear of the mounts and apertures that stand on this layer
+        const gaps = i === 0 ? [[Math.PI / 2, 0.2], [(3 * Math.PI) / 2, 0.2]] : i === 1 ? [[0, 0.3], [Math.PI, 0.3]] : [];
+        const arcs = () => {
+            const cuts = [...gaps].sort((p, q) => p[0] - q[0]);
+            const ranges = [];
+            let from = 0;
+            for (const [c, w] of cuts) {
+                if (c - w > from)
+                    ranges.push([from, c - w]);
+                from = c + w;
+            }
+            ranges.push([from, 2 * Math.PI]);
+            return cut ? ranges.map(([a0, a1]) => [Math.max(a0, Math.PI), a1]).filter(([a0, a1]) => a1 > a0) : ranges;
+        };
+        out.push(...hexClad({ radius: (yy) => profileRadius(profile, yy) + 0.02, y0: y[0] + 1.8, y1: y[1] - 2.4, at: [0, 0], tile: 1, cells: { w: detail < 0.5 ? 2.2 : 1.5, h: detail < 0.5 ? 2.2 : 1.5 }, raise: 0.12, tones: CELLS, arcs }, `${seed}/layer${i}`));
+    });
+    // the dome: a round front on the last layer, in cells, with the instruments set in it
+    const dome = [[0.001, DOME.y], ...Array.from({ length: 8 }, (_, k) => [DOME.r * Math.cos(((k + 1) / 8) * (Math.PI / 2)) || 0.001, DOME.y + DOME.rise * Math.sin(((k + 1) / 8) * (Math.PI / 2))])];
+    const domeProfile = [[DOME.r - 0.01, DOME.y], ...dome.slice(1)];
+    out.push({ kind: "lathe", material: "hull-grey-dark", at: [0, 0], segs: 48, profile: domeProfile, body: true, outline: true, ...arc });
+    const holes = [[-5, 4], [5, 4], [-5, -4], [5, -4]];
+    out.push(...hexClad({ radius: (yy) => profileRadius(domeProfile, yy) + 0.02, y0: DOME.y + 0.7, y1: DOME.y + DOME.rise - 0.6, at: [0, 0], tile: 1, cells: { w: 1.5, h: 1.5 }, raise: 0.12, tones: CELLS, arcs: () => (cut ? [[Math.PI, 2 * Math.PI]] : [[0, 2 * Math.PI]]) }, `${seed}/dome`).filter((p) => p.kind !== "plate" || !holes.some(([x, z]) => Math.hypot(p.frame.o[0] - x, p.frame.o[2] - z) < 3.2)));
+    // the front: four steerable ranging apertures, six retracted optical heads, a nav light row, all on the dome
+    for (const [x, z] of holes) {
+        const yy = domeY(Math.hypot(x, z)) - 0.15;
+        out.push(ringAt("hull-grey", x, z, 1.6, yy, 0.3), ringAt("hull-orange", x, z, 2.2, yy - 0.1, 0.18), tubeAt("glass", x, z, 1.1, yy - 0.2, yy + 0.4, { segs: 14 }), tubeAt("bell-inside", x + 0.2, z, 0.5, yy + 0.4, yy + 0.7, { segs: 10 }));
+        out.push(cub("hull-grey-dark", [x - 0.2, x + 0.2], [yy - 0.4, yy + 0.2], [z + 1.7, z + 2.4]), cub("lamp-amber", [x - 0.15, x + 0.15], [yy, yy + 0.2], [z - 2.4, z - 2]));
+    }
+    for (let k = 0; k < 6; k++) {
+        const a = (Math.PI * 2 * k) / 6 + 0.3;
+        const x = 7.4 * Math.sin(a);
+        const z = 7.4 * Math.cos(a);
+        if (cut && x > 0)
+            continue;
+        const yy = domeY(7.4);
+        out.push(tubeAt("hull-grey-dark", x, z, 0.9, yy - 0.2, yy + 0.1, { segs: 10 }), tubeAt("glass", x, z, 0.55, yy + 0.1, yy + 0.45, { segs: 10 }));
+    }
+    out.push(...[-1, 1].flatMap((s) => (cut && s > 0 ? [] : lamp({ n: "y", sign: 1, at: DOME.y + DOME.rise - 0.3, a: [-3, 3], b: [-3, 3] }, s * 2, 0, "amber", 0.2))));
+    // side apertures: two on each flank of the first layer, each a recessed lens in a frame on a flat pad, so a damaged front still leaves the ship its eyes
+    const r0 = LAYERS[0].r;
+    for (const s of [-1, 1]) {
+        if (cut && s === 1)
+            continue;
+        out.push(cub("hull-grey-dark", s === 1 ? [r0 - 0.4, r0 + 0.35] : [-r0 - 0.35, -r0 + 0.4], [Y0 + 1.5, Y0 + 12], [-2.6, 2.6]));
+        const f = { n: "x", sign: s, at: s * (r0 + 0.35), a: [Y0, Y0 + 12], b: [-3, 3] };
+        for (const y of [Y0 + 4, Y0 + 9])
+            out.push(...frame(f, y, 0, 2.2, 2.2, 0.4, 0.4, "hull-grey-dark"), on(f, y, 0, 2, 2, 0, 0.1, "glass"), on(f, y, 0, 0.7, 0.7, 0.1, 0.4, "lamp-blue"));
+    }
+    // the two debris-intercept mounts: a turret on the dorsal and the ventral side of the middle layer, a pair of barrels each, and a service hatch
+    const r1 = LAYERS[1].r;
+    const y1 = LAYERS[1].y;
+    for (const s of [1, -1]) {
+        const z = s * r1;
+        out.push(cub("hull-grey-dark", [-2.6, 2.6], [y1[0] + 1, y1[1] - 1.6], [z - s * 0.6, z + s * 1.4]), cub("hull-orange", [-2.4, 2.4], [y1[0] + 1.2, y1[1] - 1.8], [z + s * 1.4, z + s * 1.8]));
+        for (const x of [-1, 1])
+            out.push(rod("hull-grey", [x, y1[0] + 2, z + s * 2.6], [x, y1[1] + 2.4, z + s * 2.6], 0.34, 8), rod("bell-inside", [x, y1[1] + 2.4, z + s * 2.6], [x, y1[1] + 2.55, z + s * 2.6], 0.22, 8), ringAt("hull-grey-dark", x, z + s * 2.6, 0.45, y1[0] + 4, 0.1));
+        out.push(cub("hull-grey-dark", [-1.8, 1.8], [y1[0] + 1.6, y1[0] + 3.4], [z + s * 1.8, z + s * 2.8]));
+    }
+    // spacer struts between layers: eight round columns each, with a clevis at each end
+    for (const i of [0, 1]) {
+        const a = LAYERS[i].y[1];
+        const b = LAYERS[i + 1].y[0];
+        const rr = LAYERS[i + 1].r - 2.2;
+        for (let k = 0; k < 8; k++) {
+            const an = (Math.PI * 2 * k) / 8 + 0.2;
+            if (cut && Math.sin(an) > 0)
+                continue;
+            const x = rr * Math.sin(an);
+            const z = rr * Math.cos(an);
+            out.push(rod("hull-grey", [x, a - 0.2, z], [x, b + 0.2, z], 0.45, 8), rod("hull-grey-dark", [x, a - 0.2, z], [x, a + 0.35, z], 0.7, 8), rod("hull-grey-dark", [x, b - 0.35, z], [x, b + 0.2, z], 0.7, 8));
+        }
+    }
+    if (cut) {
+        // the crush cells inside the starboard half: ring walls and radial webs of the first two layers
+        for (const [i, rings] of [[0, [6, 11, 15]], [1, [5, 10]]])
+            for (const rr of rings)
+                out.push(...[tubeAt("hull-white-worn", 0, 0, rr, LAYERS[i].y[0] + 0.4, LAYERS[i].y[1] - 0.4, { segs: 36, arc: OPEN_STARBOARD })]);
+        for (let k = 0; k < 8; k++) {
+            const an = Math.PI + (Math.PI * (k + 0.5)) / 8;
+            for (const i of [0, 1])
+                out.push(rod(random() < 0.5 ? "hull-orange-worn" : "foam", [0, (LAYERS[i].y[0] + LAYERS[i].y[1]) / 2, 0], [(LAYERS[i].r - 1.5) * Math.sin(an), (LAYERS[i].y[0] + LAYERS[i].y[1]) / 2, (LAYERS[i].r - 1.5) * Math.cos(an)], 0.14, 6));
+        }
+    }
+    out.push(cub("hull-white-worn", [-r0 - 0.9, -r0 + 0.3], [Y0 + 3, Y0 + 9], [-7, 0]), ...stencil({ n: "x", sign: -1, at: -r0 - 0.9, a: [Y0, Y0 + 12], b: [-7, 0] }, marks, Y0 + 6, -3.5, 2.2));
+    out.push(...collar("L", Y0, -1));
+    return out;
+}

package/dist/model/fleet/ship-03/pod.d.ts

@@ -0,0 +1,3 @@
+import { type Piece } from "./adapter.ts";
+export type PodKind = "relay" | "relief" | "survey";
+export declare function pod(kind: PodKind, detail?: number, seed?: string): Piece[];