@johnmorrisdotca/uchusen-rockets 0.9.0 → 0.11.0

package/dist/model/fleet/hull.js

@@ -0,0 +1,174 @@
+// The shared body builder: a drum of the fleet's plating with collars at its ends, hatches, conduits, pipe rings, trays, vents, ladders, hazard bands, lamps, a stencilled number and scattered machinery. Most modules
+// are a drum with something added. Pure: no three.js and no DOM.
+import { deg } from "../../framing.js";
+import { COLLARS, collar } from "./collars.js";
+import { annulus, beam, box, cableTray, conduitRun, floodlight, foilBand, greebles, hatch, hazardBand, hullPanels, ladder, lamps, LIVERY, navLight, patch, pipeRing, post, rng, ringOf, sagOf, stencil, vent } from "./detail.js";
+import { HULL_STACKS, layerShells, stackDepth } from "./layers.js";
+/** Settles a module's options. */
+export function contextOf(id, own, options = {}, hull = "transport") {
+    const stack = HULL_STACKS[options.hull ?? hull];
+    const detail = Math.max(0.25, Math.min(1, options.detail ?? 1));
+    const liveryName = options.livery ?? own;
+    return { detail, cutaway: options.cutaway ?? false, livery: LIVERY[liveryName], liveryName, seed: `${id}/${options.seed ?? ""}`, stack, depth: stackDepth(stack), coarse: options.level === "coarse" };
+}
+/** A count scaled by the detail level, at least 1 if it was more than 0. */
+export const some = (ctx, n) => (n <= 0 ? 0 : Math.max(1, Math.round(n * ctx.detail)));
+/** The part of the circle a cutaway leaves: the hull is open on the windward side. */
+export const CUT = [deg(58), deg(302)];
+const span0 = (az) => az[1] - az[0];
+/** The radius of the end cone's far end: where the drum meets a collar. */
+const collarRadius = (c) => (c ? COLLARS[c].outer / 2 : 0);
+/** How long the cone from the hull to a collar is. */
+export const shoulder = (R, c) => (c && R > collarRadius(c) + 0.05 ? Math.max(0.5, (R - collarRadius(c)) * 0.8) : 0);
+/** The straight part of a drum: from y0 to y1. */
+export function straight(spec) {
+    return [shoulder(spec.R, spec.bottom), spec.L - shoulder(spec.R, spec.top)];
+}
+/** A drum: the hull, its collars, and all its detail. */
+export function drum(ctx, spec) {
+    const { R, L } = spec;
+    const random = rng(`${ctx.seed}/drum`);
+    const [y0, y1] = straight(spec);
+    const open = ctx.cutaway;
+    const az = open ? CUT : [0, 2 * Math.PI];
+    const out = [];
+    const under = spec.under ?? ctx.livery.under;
+    const profile = [];
+    if (spec.bottom && y0 > 0)
+        profile.push([collarRadius(spec.bottom), 0]);
+    profile.push([R, y0], [R, y1]);
+    if (spec.top && y1 < L)
+        profile.push([collarRadius(spec.top), L]);
+    if (!spec.bottom)
+        profile[0] = [R, 0];
+    if (!spec.top)
+        profile[profile.length - 1] = [R, L];
+    const ringYs = (spec.rings ?? [0.25, 0.5, 0.75]).map((f) => y0 + (y1 - y0) * f);
+    const shell = { kind: "lathe", material: under, segs: 56, body: true, outline: true, profile, welds: [y0, y1, ...ringYs], ...(open ? { arc: () => az, outline: false } : {}) };
+    out.push(shell);
+    if (open)
+        out.push(...layerShells(R, y0, y1, ctx.stack, az));
+    if (spec.bottom)
+        out.push(...collar(spec.bottom, 0, -1));
+    if (spec.top)
+        out.push(...collar(spec.top, L, 1));
+    if (ctx.coarse)
+        return out;
+    // the shoulders: a stiffening ring and a row of fixings where the hull steps to the collar
+    for (const [yy, end] of [[y0, spec.bottom], [y1, spec.top]])
+        if (end && Math.abs(yy - (yy === y0 ? 0 : L)) > 0.3)
+            out.push(...pipeRing("hull-grey-dark", R, yy, 0.1));
+    const span = az[1] - az[0];
+    const spot = (i, n) => az[0] + span * ((i + 0.5 + (random() - 0.5) * 0.3) / n);
+    const mid = (a, b) => a + (b - a) * (0.15 + random() * 0.7);
+    // what stands on the hull is placed first, and the plating leaves room for it: a flat panel on a curved hull stands proud at its edges by its sag, so a rail, a ring or a pipe stands clear of that
+    const panelSize = spec.panels === false ? null : (spec.panels ?? { wide: 2.4, tall: 1.6 });
+    const proud = 0.22 + (panelSize ? sagOf(R, panelSize.wide / Math.sqrt(ctx.detail)) : 0);
+    const nHatch = some(ctx, spec.hatches ?? 4);
+    const hatches = Array.from({ length: nHatch }, (_, i) => ({ az: spot(i, nHatch), y: mid(y0, y1), size: 0.9 + random() * 0.6 }));
+    const nConduit = some(ctx, spec.conduits ?? 3);
+    const conduits = Array.from({ length: nConduit }, (_, i) => ({ az: spot(i, nConduit) + 0.05, count: 2 + Math.floor(random() * 3), pipe: 0.06 + random() * 0.05 }));
+    const nTray = some(ctx, spec.trays ?? 2);
+    const trays = Array.from({ length: nTray }, (_, i) => spot(i, nTray) + 0.12);
+    const nVent = some(ctx, spec.vents ?? 3);
+    const vents = Array.from({ length: nVent }, (_, i) => ({ az: spot(i, nVent) - 0.08, y: mid(y0, y1) }));
+    const nLadder = some(ctx, spec.ladders ?? 1);
+    const ladders = Array.from({ length: nLadder }, (_, i) => spot(i, nLadder) + 0.2);
+    const stencilAt = az[0] + span * (open ? 0.5 : 0.62);
+    const strip = (a, wide) => ({ az: a, y: (y0 + y1) / 2, wide, tall: y1 - y0 });
+    const clear = [...hatches.map((h) => ({ az: h.az, y: h.y, wide: h.size * 1.3, tall: h.size * 1.3 })), ...conduits.map((c) => strip(c.az, c.count * c.pipe * 3 + 0.3)), ...trays.map((a) => strip(a, 0.6)), ...vents.map((v) => ({ az: v.az, y: v.y, wide: 1.2, tall: 0.8 })), ...ladders.map((a) => strip(a, 0.6)), { az: stencilAt, y: (y0 + y1) / 2, wide: Math.min(1.6, R * 0.4) * 0.8, tall: Math.min(1.6, R * 0.4) * 1.3 }];
+    if (panelSize)
+        out.push(...hullPanels({ r: R, y0: y0 + 0.15, y1: y1 - 0.15, az: open ? az : undefined, livery: ctx.livery, seed: ctx.seed, wide: panelSize.wide / Math.sqrt(ctx.detail), tall: panelSize.tall / Math.sqrt(ctx.detail), raise: 0.09, clear }));
+    // crinkled foil cuffs where the hull steps down to a collar: multi-layer insulation wrapped round the joint, as on a real service module
+    if (R >= 2)
+        for (const [yy, end, low] of [[y0, spec.bottom, true], [y1, spec.top, false]])
+            if (end)
+                out.push(...foilBand(ctx.livery.foil ?? "foil", R + 0.07, low ? yy + 0.08 : yy - 0.56, low ? yy + 0.6 : yy - 0.04, az[0], az[1], ctx.seed, Math.max(0.3, R * 0.07), 0.035));
+    // stringers up the hull stand well proud of the plating, so a close view has depth and the key light throws shadows between them: each is a T-rail, a web with a flange along its top
+    const stringers = some(ctx, Math.max(12, Math.round(R * 3.2)));
+    for (let i = 0; i < stringers; i++) {
+        const a = az[0] + (span0(az) * (i + 0.5)) / stringers;
+        const f = patch(R, a, 0);
+        const at = (lift, y) => [f.o[0] + f.w[0] * lift, y, f.o[2] + f.w[2] * lift];
+        const material = i % 3 === 0 ? "pipe-steel" : "hull-grey";
+        out.push(beam(material, at((proud + 0.12) / 2, y0 + 0.3), at((proud + 0.12) / 2, y1 - 0.3), 0.05, proud + 0.1), beam(material, at(proud + 0.12, y0 + 0.3), at(proud + 0.12, y1 - 0.3), 0.2, 0.05));
+    }
+    for (const y of [y0 + 0.1, ...ringYs, y1 - 0.1])
+        out.push(annulus("hull-grey-dark", R + 0.02, R + proud + 0.1, y - 0.1, y + 0.1, 40, { only: "mesh", ...(open ? { arc: () => az } : {}) }));
+    for (const y of ringYs)
+        out.push(...pipeRing(random() < 0.25 ? "coolant" : "pipe-steel", R + proud, y, 0.1, 48));
+    for (const h of hatches)
+        out.push(...hatch({ r: R + 0.04, az: h.az, y: h.y, size: h.size, round: spec.roundHatches ? hatches.indexOf(h) % 2 === 0 : false }));
+    for (const c of conduits)
+        out.push(...conduitRun({ r: R + 0.05, az: c.az, y0: y0 + 0.3, y1: y1 - 0.3, count: c.count, pipe: c.pipe, seed: ctx.seed }));
+    for (const a of trays)
+        out.push(...cableTray(R + 0.05, a, y0 + 0.5, y1 - 0.5, 0.45, ctx.seed));
+    for (const v of vents)
+        out.push(...vent(R + 0.04, v.az, v.y, 1.1, 0.7, 6));
+    for (const a of ladders)
+        out.push(...ladder(R + 0.05, a, y0 + 0.4, Math.min(y1 - 0.4, y0 + 7)));
+    // hazard stencils: a few short stripes by the shoulders, where a person works, not a ring of yellow round the whole hull
+    if (spec.hazard !== false)
+        for (const k of [0.12, 0.45, 0.8])
+            out.push(...hazardBand(R, y0, y0 + 0.36, 5, [az[0] + span * k, az[0] + span * k + deg(26)]), ...hazardBand(R, y1 - 0.36, y1, 5, [az[0] + span * (k + 0.1), az[0] + span * (k + 0.1) + deg(26)]));
+    out.push(...greebles({ r: R + 0.14, y0: y0 + 0.2, y1: y1 - 0.2, az, count: some(ctx, spec.junk ?? Math.round(R * (y1 - y0) * 0.35)), seed: ctx.seed, livery: ctx.livery }));
+    out.push(...stencil(spec.digits ?? "07", R + 0.045, az[0] + span * (open ? 0.5 : 0.62), y0 + (y1 - y0) * 0.5, Math.min(1.6, R * 0.4), "black"));
+    // navigation lamps at the shoulders
+    const lampRing = (y, colour) => ringOf(4, R + proud * 0.6, y, 45).map((p) => ({ at: p.at, colour, size: 0.14 }));
+    if (!open) {
+        out.push(...lamps([...lampRing(y1 - 0.5, "amber"), ...lampRing(y0 + 0.5, "red")]));
+        // red to port, green to starboard, a white strobe on top, and floodlights over the joint, all lit with the engines
+        out.push(...navLight("port", R + proud * 0.8, deg(270), y1 - 1.0), ...navLight("starboard", R + proud * 0.8, deg(90), y1 - 1.0), ...navLight("strobe", R + proud * 0.8, 0, y1 - 1.0));
+        for (const a of [deg(150), deg(210)])
+            out.push(...floodlight(R + proud * 0.8, a, y1 - 1.3, 0.3));
+    }
+    return out;
+}
+/** Decks across a drum: discs at a spacing with a hatch shaft through the middle, then walls, doors and furniture in rooms, set so the open side shows them. For the inside of a cutaway. */
+export function decks(ctx, R, y0, y1, spacing, furniture) {
+    const random = rng(`${ctx.seed}/decks`);
+    const out = [];
+    const wall = R - ctx.depth - 0.05;
+    const n = Math.max(1, Math.floor((y1 - y0) / spacing));
+    const gap = (y1 - y0) / n;
+    for (let d = 0; d <= n; d++) {
+        const y = y0 + d * gap;
+        out.push({ kind: "lathe", material: "deck", segs: 40, only: "mesh", profile: [[0.01, y], [wall, y]] });
+        out.push({ kind: "lathe", material: "hull-grey-dark", segs: 40, only: "mesh", profile: [[wall, y - 0.12], [wall, y + 0.04]] });
+        if (d === n)
+            continue;
+        const room = y + 0.04;
+        const height = gap * 0.8;
+        // walls across the room, facing the open side, with a door in each
+        const rows = Math.max(1, Math.round(wall / 3.4));
+        for (let k = 0; k < rows; k++) {
+            const z = -wall * 0.8 + (1.6 * wall * (k + 0.5)) / rows;
+            const half = Math.sqrt(Math.max(0.5, wall * wall - z * z)) - 0.3;
+            const door = (random() - 0.5) * half;
+            for (const [a, b] of [[-half, door - 0.6], [door + 0.6, half]])
+                if (b - a > 0.4)
+                    out.push(box("hull-white", [(a + b) / 2, room, z], b - a, 0.08, height));
+            out.push(box("hull-grey-dark", [door, room + height - 0.05, z], 1.4, 0.1, 0.1), box("lamp-amber", [door, room + height + 0.0, z + 0.07], 0.12, 0.05, 0.12));
+        }
+        const items = Math.max(4, Math.round(wall * 1.6 * ctx.detail));
+        for (let i = 0; i < items; i++) {
+            const a = (random() - 0.5) * 2.4;
+            const r = wall * (0.25 + random() * 0.65);
+            const at = [r * Math.sin(a), room, r * Math.cos(a)];
+            const yaw = random() < 0.5 ? 0 : 90;
+            if (furniture === "bunks")
+                out.push(box("hull-blue", at, 2.0, 0.9, 0.5, yaw), box("hull-white", [at[0], room + 0.5, at[2]], 1.9, 0.85, 0.12, yaw), box("hull-blue", [at[0], room + 1.1, at[2]], 2.0, 0.9, 0.5, yaw));
+            else if (furniture === "bench")
+                out.push(box("hull-grey", at, 2.2, 0.9, 0.9, yaw), box("hull-white", [at[0], room + 0.9, at[2]], 2.2, 0.9, 0.06, yaw), box("lamp-blue", [at[0], room + 1.1, at[2]], 0.6, 0.05, 0.4, yaw));
+            else if (furniture === "farm")
+                out.push(box("hull-grey", at, 2.4, 1.0, 0.6, yaw), box("plant", [at[0], room + 0.6, at[2]], 2.3, 0.9, 0.4, yaw), box("lamp-blue", [at[0], room + 1.9, at[2]], 2.4, 0.4, 0.06, yaw));
+            else if (furniture === "cargo")
+                out.push(box(random() < 0.5 ? "hull-orange" : "hull-yellow", at, 1.6, 1.2, 1.2, yaw));
+            else
+                out.push(box("panel-dark", at, 1.6, 0.8, 0.9, yaw), box("lamp-blue", [at[0], room + 0.9, at[2]], 1.2, 0.04, 0.5, yaw));
+        }
+    }
+    // the hatch shaft down the middle
+    out.push(post("hull-grey-dark", [0, 0], 0.7, y0, 0.7, y1, 12), post("hull-white", [0, 0], 0.62, y0, 0.62, y1, 12));
+    return out;
+}

package/dist/model/fleet/insets.d.ts

@@ -0,0 +1,51 @@
+import type { Piece, Vec3 } from "../pieces.ts";
+/**
+ * One numbered sub-part of an inset: its number, name, what it does, its size in metres (width, height, depth), where it sits in the assembled inset and how to draw it.
+ *
+ * @example
+ * ```ts
+ * import { INSETS, type InsetPart } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const part: InsetPart = INSETS["reactor-core"].parts[0];
+ * console.log(part.n, part.name, part.size);
+ * ```
+ */
+export interface InsetPart {
+    n: number;
+    name: string;
+    does: string;
+    /** Width, height and depth in metres. */
+    size: readonly [number, number, number];
+    /** The middle of its base in the assembled inset, in metres. */
+    at: Vec3;
+    pieces: () => Piece[];
+}
+/**
+ * A system inset: an id and name, what it is, and its numbered sub-parts.
+ *
+ * @example
+ * ```ts
+ * import { INSETS, type Inset } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const inset: Inset = INSETS["life-support"];
+ * console.log(inset.name, inset.parts.length);
+ * ```
+ */
+export interface Inset {
+    id: string;
+    name: string;
+    note: string;
+    parts: readonly InsetPart[];
+}
+/**
+ * The four system insets by id: reactor core, navigation and sensor suite, life support, docking port, each with five or six numbered sub-parts. Each sub-part is a part of the registry, placed in the assembly,
+ * so a page's "apart" view opens the inset.
+ *
+ * @example
+ * ```ts
+ * import { INSETS } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * for (const inset of Object.values(INSETS)) console.log(inset.name, inset.parts.map((one) => `${one.n} ${one.name}`).join("; "));
+ * ```
+ */
+export declare const INSETS: Readonly<Record<string, Inset>>;

package/dist/model/fleet/insets.js

@@ -0,0 +1,69 @@
+// System insets: the four systems every ship has, each as an assembly of five or six numbered sub-parts that come apart (the view's "apart" opens it, so a page can open it on a click). A sub-part is its own part
+// of the registry, placed in the assembly rather than stacked, and drawn at a scale where its detail shows. All original designs of this package. Pure: no three.js and no DOM.
+import { deg } from "../../framing.js";
+import { collar } from "./collars.js";
+import { annulus, antenna, beam, box, disc, hoop, horn, lamps, post, ringOf, rod, stamp, stencil } from "./detail.js";
+const part = (n, name, does, size, at, pieces) => ({ n, name, does, size, at, pieces });
+const reactorCore = {
+    id: "reactor-core",
+    name: "Reactor core",
+    note: "A fusion core in six parts, from the coil to the injector.",
+    parts: [
+        part(1, "Toroidal field coil", "Superconducting hoops that hold the plasma off the walls.", [8, 3, 8], [0, 3, 0], () => [hoop("coil", 3.2, 1.5, 0.7, 36, 8), ...Array.from({ length: 12 }, (_, k) => hoop("copper", 3.2, 1.5, 0.78, 6, 4, { arc: () => [deg(30 * k), deg(30 * k + 9)] })), ...stamp([box("hull-grey-dark", [0, 0.2, 3.9], 0.9, 0.6, 0.5)], ringOf(12, 0, 0))]),
+        part(2, "Plasma vessel", "The ring where the fuel burns.", [7, 1.6, 7], [0, 3.7, 0], () => [hoop("hull-grey-dark", 3.2, 0.8, 0.45, 36, 8), hoop("core", 3.2, 0.8, 0.28, 36, 8), ...stamp([box("hull-grey", [0, 0.2, 3.75], 0.4, 0.4, 0.4)], ringOf(8, 0, 0))]),
+        part(3, "Breeding blanket", "Tiles that catch neutrons and make tritium.", [8.6, 2.4, 8.6], [0, 0.4, 0], () => stamp([box("hull-blue", [0, 0, 3.9], 1.2, 0.6, 1.6), box("hull-grey", [0, 1.6, 3.9], 1.3, 0.7, 0.12)], ringOf(16, 0, 0))),
+        part(4, "Neutron shield", "Water and polymer between the core and the crew.", [10, 5, 10], [0, 6.4, 0], () => [{ kind: "lathe", material: "hull-blue", segs: 32, body: true, outline: true, profile: [[4.8, 0], [5, 0.2], [5, 4.8], [4.8, 5]], welds: [2.5] }, annulus("hull-grey", 4.6, 5.0, 4.9, 5.1, 32), ...stamp([box("hazard", [0, 1.4, 5.04], 1.2, 0.05, 0.4)], ringOf(8, 0, 0)), ...stencil("37", 5.05, 0, 2.5, 1.2)]),
+        part(5, "Heat exchanger", "Takes the heat out to the radiators.", [3, 6, 3], [7.2, 0.4, 0], () => [{ kind: "lathe", material: "hull-white-worn", segs: 20, body: true, outline: true, profile: [[1.2, 0], [1.3, 0.3], [1.3, 5.7], [1.2, 6]], welds: [2, 4] }, ...Array.from({ length: 12 }, (_, f) => annulus("hull-grey", 1.3, 1.55, 0.4 + f * 0.44, 0.5 + f * 0.44, 20)), post("copper", [0, 0], 0.15, 5.9, 0.15, 6.8, 8)]),
+        part(6, "Fuel injector", "Meters deuterium and helium-3 into the vessel.", [3, 3, 3], [-6.6, 2.2, 0], () => [{ kind: "lathe", material: "hull-grey-dark", segs: 16, body: true, outline: true, profile: [[0.6, 0], [0.9, 0.4], [0.9, 2], [0.5, 2.6]] }, ...stamp([rod("copper", [0.9, 0.6, 0], [1.9, 1.6, 0], 0.09, 6)], ringOf(4, 0, 0)), ...lamps([{ at: [0, 2.6, 0], colour: "blue", size: 0.2 }])]),
+    ],
+};
+const navSuite = {
+    id: "nav-sensors",
+    name: "Navigation and sensor suite",
+    note: "How the ship knows where it is, in six parts.",
+    parts: [
+        part(1, "Star tracker", "Fixes the ship's place against the stars.", [2.4, 3, 2.4], [-5, 0, 3], () => [{ kind: "lathe", material: "hull-white", segs: 20, body: true, outline: true, profile: [[1.0, 0], [1.1, 0.3], [1.1, 1.4], [0.7, 1.7]] }, ...horn("hull-grey-dark", [0, 1.7, 0], [0, 3.0, 0], [0.7, 0.55, 0.4], 12), rod("glass", [0, 3.0, 0], [0, 3.06, 0], 0.4, 12)]),
+        part(2, "Inertial platform", "Keeps its own sense of direction.", [3, 3, 3], [0, 0, 3.5], () => [{ kind: "lathe", material: "hull-grey", segs: 24, body: true, outline: true, profile: Array.from({ length: 13 }, (_, i) => [Math.max(0.001, 1.1 * Math.sin((Math.PI * i) / 12)), 1.4 - 1.1 * Math.cos((Math.PI * i) / 12)]), rings: [1.4] }, hoop("hull-grey-dark", 1.35, 1.4, 0.07, 24, 4), rod("hull-grey-dark", [-1.4, 1.4, 0], [1.4, 1.4, 0], 0.12, 6), ...lamps([{ at: [0, 2.5, 0], colour: "amber", size: 0.1 }])]),
+        part(3, "Radar array", "Looks ahead for dust and rocks.", [5, 4, 1.4], [5, 0, 3], () => antenna("phased", [0, 0.2, 0], [0, 0.6, 0.8], 4.4, "radar")),
+        part(4, "Optical telescope", "A long tube for faint things far off.", [2.2, 5, 2.2], [-4, 0, -3], () => [box("hull-grey-dark", [0, 0, 0], 2.0, 2.0, 0.9), ...horn("hull-white", [0, 0.9, 0], [0, 4.6, 0], [0.85, 0.82, 0.8, 0.78, 0.76], 16), rod("glass", [0, 4.6, 0], [0, 4.66, 0], 0.72, 16), hoop("hull-grey-dark", 0.86, 3.6, 0.05, 16, 4)]),
+        part(5, "Navigation computer", "Works out the course, three times over.", [4, 3, 2.4], [0, 0, -3.5], () => stamp([box("panel-dark", [0, 0, 0], 1.0, 1.6, 2.6), box("lamp-blue", [0, 1.8, 0.82], 0.7, 0.04, 0.12)], [{ at: [-1.5, 0, 0] }, { at: [0, 0, 0] }, { at: [1.5, 0, 0] }])),
+        part(6, "Beacon receiver", "Hears the beacons of ports and other ships.", [3, 3.4, 3], [4.6, 0, -3.2], () => antenna("dish", [0, 0.2, 0], [0.3, 1, 0.2], 3.0, "beacon")),
+    ],
+};
+const lifeSupport = {
+    id: "life-support",
+    name: "Life support",
+    note: "Air, water, food and waste, in six parts, so a closed ship stays alive.",
+    parts: [
+        part(1, "Air scrubber", "Takes carbon dioxide out of the air.", [3, 4.6, 3], [-4.6, 0, 3], () => [{ kind: "lathe", material: "hull-white", segs: 20, body: true, outline: true, profile: [[1.3, 0], [1.4, 0.3], [1.4, 4.0], [1.0, 4.4]], welds: [1.5, 3] }, ...Array.from({ length: 6 }, (_, k) => post("copper", [1.6 * Math.sin(deg(60 * k)), 1.6 * Math.cos(deg(60 * k))], 0.1, 0.5, 0.1, 3.8, 6))]),
+        part(2, "Water recycler", "Cleans every drop again.", [4, 3.6, 3], [0, 0, 3.4], () => [box("hull-blue", [-0.9, 0, 0], 1.6, 2.2, 3.0), box("hull-blue", [0.9, 0, 0], 1.6, 2.2, 3.0), rod("copper", [-0.9, 3.0, 0], [0.9, 3.0, 0], 0.14, 8), box("hull-grey-dark", [0, 3.0, 0], 0.5, 0.5, 0.5)]),
+        part(3, "Oxygen generator", "Splits water into oxygen and hydrogen.", [3.4, 3, 3], [4.6, 0, 3], () => stamp([{ kind: "lathe", material: "hull-white", segs: 14, body: true, outline: true, profile: [[0.5, 0], [0.55, 0.2], [0.55, 2.3], [0.4, 2.6]] }], [{ at: [-1.1, 0, -0.8] }, { at: [0, 0, 0.8] }, { at: [1.1, 0, -0.8] }, { at: [0, 0, -1.1] }]).concat([beam("copper", [-1.1, 2.4, -0.8], [1.1, 2.4, -0.8], 0.12, 0.12)])),
+        part(4, "Waste processor", "Turns waste into water and mulch.", [3, 3, 3.4], [-4.6, 0, -3.4], () => [{ kind: "lathe", material: "hull-grey", segs: 18, body: true, outline: true, profile: [[1.2, 0], [1.3, 0.3], [1.3, 2.4], [0.8, 3.0]] }, box("hull-grey-dark", [0, 0, 1.6], 1.2, 0.8, 1.0), rod("copper", [0, 2.2, 1.3], [0, 2.2, 2.2], 0.1, 6), rod("hull-grey", [0, 1.2, 1.3], [0, 1.2, 2.2], 0.1, 6), ...lamps([{ at: [0, 3.0, 0], colour: "amber", size: 0.12 }])]),
+        part(5, "Hydroponic rack", "Grows greens under blue light.", [4, 3.2, 2], [0, 0, -3.6], () => [box("hull-grey", [0, 0, 0], 3.6, 1.6, 0.3), ...[0.4, 1.4, 2.4].flatMap((y) => [box("plant", [0, y, 0], 3.4, 1.4, 0.35), box("lamp-blue", [0, y + 0.8, 0], 3.4, 0.4, 0.05)]), ...[-1.7, 1.7].map((x) => box("hull-grey-dark", [x, 0, 0], 0.15, 1.6, 3.2))]),
+        part(6, "Control panel", "Shows the state of the air, water and food.", [2.6, 2.4, 1.2], [4.6, 0, -3.4], () => [box("panel-dark", [0, 0, 0], 2.4, 0.9, 1.8), box("lamp-blue", [0, 0.9, 0.2], 1.6, 0.8, 0.05), box("lamp-amber", [0.9, 0.95, 0.5], 0.3, 0.2, 0.06), box("lamp-red", [-0.9, 0.95, 0.5], 0.3, 0.2, 0.06)]),
+    ],
+};
+const dockingPort = {
+    id: "docking-port",
+    name: "Docking port",
+    note: "A standard collar port in five parts, from the flange to the guide lights.",
+    parts: [
+        part(1, "Collar flange", "The standard S collar: bolts, pins and latch dogs.", [3, 0.4, 3], [0, 0, 0], () => collar("S", 0.4, 1)),
+        part(2, "Capture ring", "Soft-captures the other ship before the latches close.", [3.6, 0.8, 3.6], [0, 0.4, 0], () => [annulus("hull-grey", 1.3, 1.8, 0, 0.5, 36), hoop("hull-yellow", 1.55, 0.55, 0.1, 28, 5), ...stamp([box("hull-grey-dark", [0, 0, 1.6], 0.5, 0.5, 0.7), rod("copper", [0, 0.7, 1.5], [0, 0.7, 1.0], 0.07, 6)], ringOf(6, 0, 0))]),
+        part(3, "Pressure door", "Holds the air in when no one is docked.", [2, 0.5, 2], [0, 1.2, 0], () => [disc("hull-grey", [0, 0], 0.95, 0, 0.2, 24), hoop("hull-grey-dark", 0.6, 0.22, 0.05, 20, 4), rod("hull-grey", [-0.6, 0.3, 0], [0.6, 0.3, 0], 0.05, 6), rod("hull-grey", [0, 0.3, -0.6], [0, 0.3, 0.6], 0.05, 6)]),
+        part(4, "Docking tunnel", "The way through, with handrails and lights.", [2.2, 3, 2.2], [0, 1.8, 0], () => [{ kind: "lathe", material: "hull-white-worn", segs: 20, outline: true, profile: [[1.05, 0], [1.05, 3]], welds: [1, 2] }, ...Array.from({ length: 4 }, (_, k) => rod("hull-yellow", [0.9 * Math.sin(deg(90 * k + 45)), 0.2, 0.9 * Math.cos(deg(90 * k + 45))], [0.9 * Math.sin(deg(90 * k + 45)), 2.8, 0.9 * Math.cos(deg(90 * k + 45))], 0.03, 5)), ...lamps(ringOf(4, 0.95, 2.9, 0).map((p) => ({ at: p.at, colour: "blue", size: 0.08 })))]),
+        part(5, "Guide lights and sensors", "Show the other pilot where to come in.", [3, 1.6, 3], [0, 5, 0], () => [...stamp([post("hull-grey-dark", [0, 1.55], 0.1, 0, 0.1, 0.9, 6), ...horn("hull-white", [0, 0.9, 1.55], [0, 1.1, 1.55], [0.2], 8)], ringOf(4, 0, 0)), ...lamps(ringOf(4, 1.55, 0.9, 45).map((p, i) => ({ at: p.at, colour: i % 2 ? "blue" : "amber", size: 0.16 })))]),
+    ],
+};
+/**
+ * The four system insets by id: reactor core, navigation and sensor suite, life support, docking port, each with five or six numbered sub-parts. Each sub-part is a part of the registry, placed in the assembly,
+ * so a page's "apart" view opens the inset.
+ *
+ * @example
+ * ```ts
+ * import { INSETS } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * for (const inset of Object.values(INSETS)) console.log(inset.name, inset.parts.map((one) => `${one.n} ${one.name}`).join("; "));
+ * ```
+ */
+export const INSETS = { [reactorCore.id]: reactorCore, [navSuite.id]: navSuite, [lifeSupport.id]: lifeSupport, [dockingPort.id]: dockingPort };

package/dist/model/fleet/kit.d.ts

@@ -0,0 +1,254 @@
+import type { PartRecord } from "../../parts.ts";
+import type { Piece, Vec3 } from "../pieces.ts";
+import type { KitModule, ModuleOptions, ShipList } from "./types.ts";
+export { COLLARS, COLLAR_CLASSES, collar, mates } from "./collars.ts";
+export type { CollarClass, CollarSpec } from "./collars.ts";
+export * as DETAIL from "./detail.ts";
+export { LIVERY, ROOMS } from "./detail.ts";
+export { FLEET_PALETTE } from "./palette.ts";
+export type { FleetColour } from "./palette.ts";
+export type { Livery, LiveryName, RoomKind, RoomSpec, SeparationOptions } from "./detail.ts";
+export { BUILDERS, KIT } from "./modules.ts";
+export { BUILD_BUDGET_MS, isCoarse } from "./levels.ts";
+export { INSETS } from "./insets.ts";
+export type { Inset, InsetPart } from "./insets.ts";
+export type { KitModule, ModuleKind, ModuleOptions, Port, ShipList, ShipPlace } from "./types.ts";
+/**
+ * One module placed on a ship: where its origin stands and how it is turned.
+ *
+ * @example
+ * ```ts
+ * import { assemble, type Placed } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const placed: Placed[] = assemble([{ module: "engine-fusion-3" }, { module: "tank-cryo-12" }]).placed;
+ * console.log(placed.map((one) => one.at[1]));
+ * ```
+ */
+export interface Placed {
+    index: number;
+    module: KitModule;
+    at: Vec3;
+    turn: number;
+    /** How it is held: on the spine, hung from a port, or beside the spine. */
+    how: "spine" | "port" | "beside";
+}
+/**
+ * What went wrong with a ship: which place, and why.
+ *
+ * @example
+ * ```ts
+ * import { assemble, type ShipIssue } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const issues: ShipIssue[] = assemble([{ module: "engine-fusion-7" }, { module: "container-12" }]).issues;
+ * console.log(issues[0]?.code, issues[0]?.message);
+ * ```
+ */
+export interface ShipIssue {
+    place: number;
+    code: "unknown-module" | "collar-mismatch" | "no-such-port" | "port-taken" | "no-spine";
+    message: string;
+}
+/**
+ * A ship put together: its places, its mass and size, and the problems found.
+ *
+ * @example
+ * ```ts
+ * import { assemble, type Assembly } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const ship: Assembly = assemble([{ module: "engine-fusion-3" }, { module: "tank-cryo-12" }]);
+ * console.log(ship.ok, ship.placed.length, ship.mass);
+ * ```
+ */
+export interface Assembly {
+    placed: Placed[];
+    issues: ShipIssue[];
+    /** Dry mass in tonnes, propellant when full in tonnes. */
+    mass: number;
+    propellant: number;
+    /** Metres: the box the placed modules fill (from their declared sizes). */
+    length: number;
+    width: number;
+    depth: number;
+    ok: boolean;
+}
+/**
+ * Puts a ship's list of modules in place and checks that every joint mates. On the spine each module stands on the end of the one before; hung from a port it stands on that port of an earlier place;
+ * `beside` it stands parallel to the spine at an offset.
+ *
+ * @param ship A ship's list of places, the bottom of the spine first.
+ * @returns Where each module stands, the ship's mass and size, and any problem (a collar of the wrong class, an unknown module, a port that is not there or is taken).
+ * @example
+ * ```ts
+ * import { assemble } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const ship = assemble([{ module: "engine-fusion-7" }, { module: "tank-cryo-12" }]);
+ * console.log(ship.ok, ship.length, ship.mass);
+ * ```
+ */
+export declare function assemble(ship: ShipList): Assembly;
+/**
+ * The pieces of a whole ship: every module in its place, with clamps from the spine to the modules hung beside it. A ship's mesh is these pieces.
+ *
+ * @param ship A ship's list of places.
+ * @param options What to draw, for every module. `detail` is lowered for a ship of many modules.
+ * @returns The pieces, in metres, the bottom of the spine at y = 0.
+ * @example
+ * ```ts
+ * import { shipPieces } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const pieces = shipPieces([{ module: "tank-cryo-12" }], { detail: 0.5 });
+ * console.log(pieces.length > 100);
+ * ```
+ */
+export declare function shipPieces(ship: ShipList, options?: ModuleOptions): Piece[];
+/** The record every part has, for a kit module. */
+export declare function recordOf(module: KitModule, id?: string, rocket?: string): PartRecord;
+/** A part entry's shape, as the registry has it. */
+export interface KitEntry {
+    record: PartRecord;
+    pieces: () => Piece[];
+}
+/** Every module as a part of the registry, drawn at full detail, plus its cutaway where it has one. */
+export declare function kitEntries(groupOf: (module: KitModule) => string): KitEntry[];
+/**
+ * What a ship hands the registry: one part for each place, with its record, so together, apart and one-part-alone work.
+ *
+ * @example
+ * ```ts
+ * import { shipParts, type ShipParts } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const parts: ShipParts = shipParts("demo", [{ module: "engine-fusion-3" }, { module: "tank-cryo-12" }]);
+ * console.log(parts.slots, Object.keys(parts.partIds).length);
+ * ```
+ */
+export interface ShipParts {
+    entries: KitEntry[];
+    slots: string[];
+    partIds: Record<string, string>;
+    assembly: Assembly;
+}
+/**
+ * A ship's parts for the registry: one entry for each place, named `<ship>-<place>-<module>`, with a record that carries its joints and, for a module hung beside or on a port, where it stands.
+ *
+ * @param ship The ship's id, as its rocket and variant will name it.
+ * @param list The ship's list of places.
+ * @param options What to draw, for every module.
+ * @param rocket The rocket the parts belong to. Left out: the ship's id.
+ * @param variant The variant the parts are true for. Left out: the ship's id.
+ * @returns The entries, the slot names in stacking order, the slot-to-part ids, and the assembly.
+ * @example
+ * ```ts
+ * import { shipParts } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const parts = shipParts("demo", [{ module: "engine-fusion-3" }, { module: "tank-cryo-12" }]);
+ * console.log(parts.slots, parts.assembly.ok);
+ * ```
+ */
+export declare function shipParts(ship: string, list: ShipList, options?: ModuleOptions, rocket?: string, variant?: string): ShipParts;
+/**
+ * The kit's sample ships: three lists of modules, from a hauler with parallel cargo to a short scout and a bulwark with a shield. Each is a good ship list to copy.
+ *
+ * @example
+ * ```ts
+ * import { assemble, SAMPLE_SHIPS } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(assemble(SAMPLE_SHIPS.hauler).length);
+ * ```
+ */
+export declare const SAMPLE_SHIPS: Readonly<Record<string, ShipList>>;
+/**
+ * The modules that swap for a module: those that share its slot, with the same collars and the same length. A mission pod is one: the survey pod and the medical pod stand in the same place on a ship.
+ *
+ * @param id A module's id.
+ * @returns The other modules of its slot, or none for a module with no slot.
+ * @example
+ * ```ts
+ * import { swapsFor } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(swapsFor("pod-survey-m").map((module) => module.name));
+ * ```
+ */
+export declare function swapsFor(id: string): KitModule[];
+/** The registry's entries for the system insets: one part for each numbered sub-part, placed in its inset's assembly. */
+export declare function insetEntries(): KitEntry[];
+/**
+ * The maker of every ship of the fleet, as the maker field says it: SPX, short. A ship's designation starts with `SPX-` (`designation("03")` is "SPX-03"). Only this text: no logo or wordmark is drawn on any hull.
+ *
+ * @example
+ * ```ts
+ * import { FLEET_MAKER } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(FLEET_MAKER);
+ * ```
+ */
+export declare const FLEET_MAKER = "SPX";
+/**
+ * A fleet ship's designation: `SPX-` and its code, such as "02" or "KIT-H". It throws for a code that is empty or has anything but capitals, digits and hyphens.
+ *
+ * @param code The class code and number, such as "03".
+ * @returns The designation, such as "SPX-03".
+ * @example
+ * ```ts
+ * import { designation } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(designation("02"));
+ * ```
+ */
+export declare function designation(code: string): string;
+/**
+ * A ship in two passes: the coarse pieces of every module at once, for a first picture, and the fine pass as one batch of pieces for each module, nearest first if `order` says so. Adding the batches one after another
+ * gives the same ship as `shipPieces` at the fine level; a viewer adds one a frame, so the picture never waits for the detail.
+ *
+ * @param ship The ship's list.
+ * @param options What to draw, for every module.
+ * @param order The places in the order the fine pass should take them. Left out: the order of the list.
+ * @returns The coarse pieces, and a function that yields the fine batches.
+ * @example
+ * ```ts
+ * import { SAMPLE_SHIPS, shipLevels } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const { coarse, fine } = shipLevels(SAMPLE_SHIPS.scout);
+ * console.log(coarse.length, [...fine()].length);
+ * ```
+ */
+export declare function shipLevels(ship: ShipList, options?: ModuleOptions, order?: readonly number[]): {
+    coarse: Piece[];
+    fine: () => Generator<{
+        place: number;
+        pieces: Piece[];
+    }>;
+};
+/**
+ * How long a build took, and what it made.
+ *
+ * @example
+ * ```ts
+ * import { SAMPLE_SHIPS, timeBuild, type BuildTime } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const took: BuildTime = timeBuild(SAMPLE_SHIPS.scout, "coarse");
+ * console.log(took.level, took.ms < 1000, took.pieces);
+ * ```
+ */
+export interface BuildTime {
+    level: "coarse" | "fine";
+    /** Milliseconds for the pieces of the whole ship and their mesh. */
+    ms: number;
+    pieces: number;
+    triangles: number;
+}
+/**
+ * Builds a ship at a level and times it: the pieces of every module and then the mesh the viewer would be handed. The budget for it is `BUILD_BUDGET_MS`.
+ *
+ * @param ship The ship's list.
+ * @param level `coarse` or `fine`.
+ * @param options What to draw, for every module.
+ * @returns The milliseconds, the number of pieces and of triangles.
+ * @example
+ * ```ts
+ * import { SAMPLE_SHIPS, timeBuild } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const coarse = timeBuild(SAMPLE_SHIPS.scout, "coarse");
+ * console.log(coarse.ms < 1000, coarse.pieces, coarse.triangles);
+ * ```
+ */
+export declare function timeBuild(ship: ShipList, level: "coarse" | "fine", options?: ModuleOptions): BuildTime;