@johnmorrisdotca/uchusen-rockets 0.9.0 → 0.11.0

package/dist/model/fleet/ship-02/tanks.js

@@ -0,0 +1,131 @@
+// The four fuel tanks: 80 m across and 440 m long, domed at both ends, in the corners of the cross round the spine. Banded insulation, cradle rings braced to the spine, a feed manifold facing the
+// spine, vent stacks on the domes, valve houses, access hatches and service lettering. The inside of all four (the propellant, baffles and pumps) is a separate part so a cutaway can open them.
+import { beam, box, cyl, onFace, onHull, pipe, polar, revolve, ring, rng, stencil } from "./adapter.js";
+import { SPINE, TANK } from "./dims.js";
+const R = TANK.radius;
+const H = 440;
+/** The outline of a tank from its tail dome up to its forward dome. */
+const outline = (r, h) => {
+    const pts = [];
+    const dome = TANK.bodyFrom;
+    for (let i = 0; i <= 8; i++) {
+        const t = (i / 8) * (Math.PI / 2);
+        pts.push([r * Math.sin(t), dome - dome * Math.cos(t) * (r / R)]);
+    }
+    pts[0] = [0.001, 0];
+    pts.push([r, TANK.bodyTo]);
+    for (let i = 1; i <= 8; i++) {
+        const t = (i / 8) * (Math.PI / 2);
+        pts.push([r * Math.cos(t), TANK.bodyTo + dome * Math.sin(t) * (r / R)]);
+    }
+    pts[pts.length - 1] = [0.001, h];
+    return pts;
+};
+/** A tank standing at the origin of its own frame; `toward` is the angle from +z towards +x that points at the spine. */
+export function tank(toward, seed, label, sz) {
+    const r = rng(seed);
+    const out = [];
+    out.push(revolve("hull-grey", [0, 0], outline(R, H), 40, { outline: true, only: undefined, rings: [20, 420], welds: [140, 300] }));
+    // the wall as real separate shells, outside to inside (src/model/fleet/ship-02/specs.ts, HULL_STACK_TANK): skin, insulation, micrometeoroid shell, structural shell and liner, each its own ring with a hair's gap
+    {
+        let rr = R;
+        for (const [m, t] of [["hull-white", 0.02], ["blanket", 0.3], ["hull-grey", 0.5], ["hull-grey", 1.4], ["engine-pale", 0.1]]) {
+            out.push(ring(m, [0, 0], rr - t, rr - 0.02, TANK.bodyFrom, TANK.bodyTo, 40));
+            rr -= t + 0.06;
+        }
+    }
+    // insulation blankets: bands of cream and orange panels part of the way round, in three tiers
+    const tiers = [[30, 130, "hull-white"], [130, 170, "hull-orange"], [170, 290, "hull-white"], [290, 330, "hull-orange"], [330, 410, "hull-white"]];
+    for (const [y0, y1, m] of tiers)
+        for (let k = 0; k < 16; k++) {
+            const a = (k / 16) * 2 * Math.PI;
+            if (Math.abs(((a - toward + Math.PI * 3) % (2 * Math.PI)) - Math.PI) < 0.45)
+                continue;
+            out.push(onHull(m, [0, 0], a, R, (y0 + y1) / 2, 12.2, y1 - y0 - 0.8, 0.5 + 0.25 * r.next()));
+        }
+    // cradle rings, each braced to the spine by four struts
+    const sp = polar(toward, Math.hypot(TANK.offset, TANK.offset));
+    for (const y of [50, 160, 270, 380]) {
+        out.push(ring("engine-metal", [0, 0], R + 0.4, R + 3.6, y - 3, y + 3, 40, { outline: true, only: undefined }));
+        for (let k = 0; k < 6; k++) {
+            const a = toward + (k - 2.5) * 0.28;
+            const [x0, z0] = polar(a, R + 3);
+            out.push(box("dark", [x0, y, z0], [4, 7, 4]));
+        }
+        for (const dz of [-1, 1])
+            for (const dx of [-1, 1]) {
+                const a = toward + dz * 0.5;
+                const [x0, z0] = polar(a, R + 3);
+                const t = polar(toward, 1);
+                const c = [sp[0] + dx * SPINE.half * 0.85 * t[1] + dz * SPINE.half * 0.85 * t[0], y, sp[1] - dx * SPINE.half * 0.85 * t[0] + dz * SPINE.half * 0.85 * t[1]];
+                out.push(beam("hull-grey", [x0, y, z0], c, 3.4, 3.4, false));
+            }
+    }
+    // the feed manifold facing the spine: a trunk and two lines, with valve houses and clamps
+    const [mx, mz] = polar(toward, R + 2.6);
+    out.push(pipe("coolant", [mx, 16, mz], [mx, 424, mz], 1.9, 10));
+    for (const d of [-1, 1]) {
+        const [x1, z1] = polar(toward + d * 0.09, R + 2.2);
+        out.push(pipe(d > 0 ? "hull-white" : "hull-orange", [x1, 16, z1], [x1, 424, z1], 1.2, 8));
+    }
+    for (let y = 30; y < 420; y += 30) {
+        out.push(onHull("dark", [0, 0], toward, R + 1.8, y, 6, 5, 3.2), onHull("hull-yellow", [0, 0], toward, R + 4.2, y, 3, 2, 1.2));
+        out.push(onHull("black", [0, 0], toward + 0.09, R + 1.2, y + 7, 3.4, 1.6, 1), onHull("black", [0, 0], toward - 0.09, R + 1.2, y + 7, 3.4, 1.6, 1));
+    }
+    // vent stacks, relief valves and sensor domes on both domes
+    for (const [y, d] of [[H - 6, 1], [6, -1]]) {
+        for (let k = 0; k < 4; k++) {
+            const [x, z] = polar((k / 4) * 2 * Math.PI + 0.4, 12);
+            out.push(pipe("engine-pale", [x, y, z], [x, y + d * 11, z], 1.6, 8), pipe("dark", [x, y + d * 11, z], [x, y + d * 13, z], 2.2, 8));
+        }
+        out.push(cyl("dark", [0, 0], 5, y, y + d * 8, 16), cyl("engine-pale", [0, 0], 3, y + d * 8, y + d * 14, 12));
+    }
+    // access hatches round the barrel and hazard bands at the tiers' joints, markings
+    for (let i = 0; i < 12; i++) {
+        const a = toward + Math.PI + (r.next() - 0.5) * 2.6;
+        const y = 50 + i * 30 + r.next() * 8;
+        out.push(onHull("dark", [0, 0], a, R - 0.1, y, 6.4, 8.4, 0.9), onHull(i % 3 === 0 ? "hull-yellow" : "hull-orange", [0, 0], a, R + 0.8, y, 5, 7, 0.5), onHull("dark", [0, 0], a, R + 1.3, y, 0.5, 4, 0.5));
+    }
+    for (const y of [130, 170, 290, 330]) {
+        for (let k = 0; k < 24; k++) {
+            const a = (k / 24) * 2 * Math.PI;
+            if (k % 2 === 0)
+                out.push(onHull("hull-yellow", [0, 0], a, R + 0.3, y, 6.4, 3, 0.4), onHull("black", [0, 0], a + 0.0, R + 0.3, y, 0.1, 0.1, 0.1));
+            else
+                out.push(onHull("black", [0, 0], a, R + 0.3, y, 6.4, 3, 0.4));
+        }
+    }
+    // lettering on the outboard flat: the tank's number big, its service tag small, and a gauge of level marks beside them
+    const ang = sz > 0 ? 0 : Math.PI;
+    for (const y of [110, 310]) {
+        const f = { c: [R * Math.sin(ang), y, R * Math.cos(ang) + sz * 0.8], k: 2, s: sz, a: 11, b: 14 };
+        out.push(onFace("dark", f, 0, 0, 24, 30, 1.6, 0, false), ...stencil(f, label, 0, 5, 9, "hull-white", 1.7), ...stencil(f, "PROP", 0, -9, 3.6, "hull-yellow", 1.7));
+        for (let i = 0; i < 6; i++)
+            out.push(onFace("hull-white", f, -9, -12 + i * 4.4, i % 2 ? 2.6 : 4.4, 0.5, 0.4, 1.7));
+    }
+    return out;
+}
+/** The propellant and the works inside all four tanks, in the frame of the whole cross: filled to 90%, with anti-slosh rings, a central standpipe and the pump deck. */
+export function tankInside() {
+    const out = [];
+    const r = rng(2005);
+    for (const sx of [-1, 1])
+        for (const sz of [-1, 1]) {
+            const at = [sx * TANK.offset, sz * TANK.offset];
+            out.push(revolve("fuel", at, [[0.001, 6], [R - 1.4, 6], [R - 1.4, 366], [0.001, 366]], 36));
+            for (let y = 30; y < 420; y += 36)
+                out.push(ring("engine-metal", at, R - 7, R - 1.2, y, y + 1.6, 36));
+            out.push(pipe("coolant", [at[0], 6, at[1]], [at[0], 424, at[1]], 2.6, 12));
+            for (let k = 0; k < 4; k++) {
+                const [x, z] = polar((k / 4) * 2 * Math.PI, 8, at);
+                out.push(cyl("dark", [x, z], 2.8, 6, 20, 12), beam("hull-grey", [x, 20, z], [at[0], 40, at[1]], 1, 1));
+            }
+            for (let y = 60; y < 420; y += 60)
+                for (let k = 0; k < 6; k++) {
+                    const a = (k / 6) * 2 * Math.PI + r.next();
+                    const [x, z] = polar(a, R - 3, at);
+                    out.push(box("engine-pale", [x, y, z], [1.2, 14, 1.2]));
+                }
+        }
+    return out;
+}

package/dist/model/fleet/ship-02/tips.d.ts

@@ -0,0 +1,3 @@
+import { type Piece } from "./adapter.ts";
+export declare function relayTip(): Piece[];
+export declare function tugTip(): Piece[];

package/dist/model/fleet/ship-02/tips.js

@@ -0,0 +1,18 @@
+// Mounts at the radiator wing tips: a small module hung on the end of each wing. The relay mast carries a dish and lights for talking to the stations; the tug is a short drum with three vernier-class nozzles for pushing
+// other ships about. Local frame: the module's own centre at the origin, its axis along y, the wing on the -x side for the starboard tip.
+import { beam, box, collar, cyl, dish, drum, mast, revolve, ring, rng } from "./adapter.js";
+import { vernier } from "./drive.js";
+export function relayTip() {
+    const r = rng(2110);
+    const out = [drum("hull-grey", [0, 0], 6, -20, 20, 16), ring("hull-yellow", [0, 0], 6, 6.6, -4, 0, 16), ring("dark", [0, 0], 6, 7, 12, 14, 16)];
+    out.push(...mast([0, 20, 0], [0, 60, 0], 0.9), ...dish([0, 0], 24, 11), ...dish([0, 0], 4, 6, "hull-orange"));
+    for (let k = 0; k < 6; k++)
+        out.push(box(r.pick(["lamp-red", "lamp-blue", "hull-yellow"]), [6.4 * Math.sin((k / 6) * 6.283), -14 + (k % 3) * 12, 6.4 * Math.cos((k / 6) * 6.283)], [1.6, 1.6, 1.6]));
+    out.push(beam("hull-orange", [-6, 0, 0], [-30, 0, 0], 3, 3, false));
+    return out;
+}
+export function tugTip() {
+    const out = [drum("hull-orange", [0, 0], 8, 0, 40, 20), ring("hull-grey", [0, 0], 8, 9, 20, 24, 20), ring("dark", [0, 0], 8, 9.4, 4, 8, 20), ...vernier(0, 0, -14).map((p) => p)];
+    out.push(...collar([0, 0], 40, 1, 5), cyl("engine-pale", [0, 0], 4, 40, 46, 12), revolve("coolant", [0, 0], [[3, 46], [3, 52]], 8), beam("hull-orange", [-8, 20, 0], [-30, 20, 0], 3, 3));
+    return out;
+}

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

@@ -0,0 +1,41 @@
+import type { MaterialName } from "../../materials.ts";
+import type { Lathe, Piece, Plate, Vec3 } from "../../pieces.ts";
+export { annulus, antenna, beam, box, disc, horn, hoop, lamps, LIVERY, place, post, ringOf, rng, rod, seams, stamp, tileShield } from "../detail.ts";
+export type { Lamp, Pose, Rng } from "../detail.ts";
+export { collar, COLLARS } from "../collars.ts";
+export { contextOf, drum } from "../hull.ts";
+export { BUILD_BUDGET_MS, isCoarse } from "../levels.ts";
+export { designation, FLEET_MAKER } from "../kit.ts";
+export { HULL_STACKS, layerShells, stackDepth } from "../layers.ts";
+export type { HullLayer, HullStack } from "../layers.ts";
+export { FLEET_PALETTE } from "../palette.ts";
+export type { Section, SectionRole } from "../sections.ts";
+export type { Inset, InsetPart } from "../insets.ts";
+export type { EngineCard } from "../engines.ts";
+export type { Lathe, MaterialName, Piece, Plate, Vec3 };
+type Extra = Partial<Omit<Plate, "kind" | "material" | "frame" | "outline" | "thickness">>;
+/** A box from a range on each axis, any of them the thin one. Mesh only unless `extra` says otherwise. */
+export declare function cub(material: MaterialName, x: readonly [number, number], y: readonly [number, number], z: readonly [number, number], extra?: Extra): Plate;
+/** A prism up the spine: the convex outline in (x, z), standing from y0 to y1. */
+export declare function prism(material: MaterialName, outline: readonly (readonly [number, number])[], y0: number, y1: number, extra?: Extra): Plate;
+/** An octagon-ish outline: half widths `hx`, `hz` with the corners cut `c` metres. */
+export declare const chamfered: (hx: number, hz: number, c: number, cx?: number, cz?: number) => [number, number][];
+/** A flat quad through four points that lie in one plane, with a thickness: for the slopes of a taper. */
+export declare function quad(material: MaterialName, a: Vec3, b: Vec3, c: Vec3, d: Vec3, thickness: number, extra?: Extra): Plate;
+/** A regular polygon (a disc, near enough) facing along Z, at (x, y), standing from z0 to z1. */
+export declare function discZ(material: MaterialName, x: number, y: number, z0: number, z1: number, r: number, sides?: number, extra?: Extra): Plate;
+/** The same facing along X, at (y, z), standing from x0 to x1. */
+export declare function discX(material: MaterialName, y: number, z: number, x0: number, x1: number, r: number, sides?: number, extra?: Extra): Plate;
+/** An I-beam from a to b, `h` deep (along `up`) and `w` wide: the kit's section. A brace is this, a channel or a round strut; never a plain square bar. */
+export declare const ibeam: (material: MaterialName, a: Vec3, b: Vec3, h: number, w: number, up?: Vec3) => Plate[];
+/** A pipe run through a path of points, with the kit's flanges, clamps and round bends. `clampEvery` is the spacing of the clamp brackets and `bracket` the way their legs go. */
+export declare const pipeRun: (material: MaterialName, points: readonly Vec3[], r: number, o?: {
+    sides?: number;
+    clampEvery?: number;
+    bracket?: Vec3;
+}) => Piece[];
+/** A round strut as the lunar module's legs are: the kit's tube with its collars and caps, and a white ball joint on each end. */
+export declare function roundStrut(material: MaterialName, a: Vec3, b: Vec3, r: number, o?: {
+    joint?: MaterialName;
+    sides?: number;
+}): Piece[];

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

@@ -0,0 +1,73 @@
+// The one door between Miyamoto and the fleet kit: everything ISV Miyamoto's parts take from the kit comes through here, and the three shapes the kit has no use for (an axis-aligned box on any axis, a prism up the spine and a planar quad)
+// are made here. When the kit changes, this is the only file of the ship to touch. Pure: no three.js and no DOM.
+import { iBeam as kitIBeam, pipeRun as kitPipeRun, strut as kitStrut } from "../detail.js";
+export { annulus, antenna, beam, box, disc, horn, hoop, lamps, LIVERY, place, post, ringOf, rng, rod, seams, stamp, tileShield } from "../detail.js";
+export { collar, COLLARS } from "../collars.js";
+export { contextOf, drum } from "../hull.js";
+export { BUILD_BUDGET_MS, isCoarse } from "../levels.js";
+export { designation, FLEET_MAKER } from "../kit.js";
+export { HULL_STACKS, layerShells, stackDepth } from "../layers.js";
+export { FLEET_PALETTE } from "../palette.js";
+/** A box from a range on each axis, any of them the thin one. Mesh only unless `extra` says otherwise. */
+export function cub(material, x, y, z, extra = {}) {
+    const f = { o: [(x[0] + x[1]) / 2, (y[0] + y[1]) / 2, (z[0] + z[1]) / 2], u: [1, 0, 0], v: [0, 1, 0], w: [0, 0, 1] };
+    const sx = Math.abs(x[1] - x[0]);
+    const sy = Math.abs(y[1] - y[0]);
+    return { kind: "plate", material, frame: f, outline: [[-sx / 2, -sy / 2], [sx / 2, -sy / 2], [sx / 2, sy / 2], [-sx / 2, sy / 2]], thickness: Math.abs(z[1] - z[0]), plain: true, only: "mesh", ...extra };
+}
+/** A prism up the spine: the convex outline in (x, z), standing from y0 to y1. */
+export function prism(material, outline, y0, y1, extra = {}) {
+    return { kind: "plate", material, frame: { o: [0, (y0 + y1) / 2, 0], u: [1, 0, 0], v: [0, 0, 1], w: [0, 1, 0] }, outline, thickness: Math.abs(y1 - y0), plain: true, only: "mesh", ...extra };
+}
+/** An octagon-ish outline: half widths `hx`, `hz` with the corners cut `c` metres. */
+export const chamfered = (hx, hz, c, cx = 0, cz = 0) => [
+    [cx - hx + c, cz - hz], [cx + hx - c, cz - hz], [cx + hx, cz - hz + c], [cx + hx, cz + hz - c], [cx + hx - c, cz + hz], [cx - hx + c, cz + hz], [cx - hx, cz + hz - c], [cx - hx, cz - hz + c],
+];
+/** A flat quad through four points that lie in one plane, with a thickness: for the slopes of a taper. */
+export function quad(material, a, b, c, d, thickness, extra = {}) {
+    const sub = (p, q) => [p[0] - q[0], p[1] - q[1], p[2] - q[2]];
+    const unit = (p) => {
+        const l = Math.hypot(...p) || 1;
+        return [p[0] / l, p[1] / l, p[2] / l];
+    };
+    const u = unit(sub(b, a));
+    const e = sub(d, a);
+    const k = e[0] * u[0] + e[1] * u[1] + e[2] * u[2];
+    const v = unit([e[0] - u[0] * k, e[1] - u[1] * k, e[2] - u[2] * k]);
+    const w = [u[1] * v[2] - u[2] * v[1], u[2] * v[0] - u[0] * v[2], u[0] * v[1] - u[1] * v[0]];
+    const o = [(a[0] + b[0] + c[0] + d[0]) / 4, (a[1] + b[1] + c[1] + d[1]) / 4, (a[2] + b[2] + c[2] + d[2]) / 4];
+    const at = (p) => {
+        const q = sub(p, o);
+        return [q[0] * u[0] + q[1] * u[1] + q[2] * u[2], q[0] * v[0] + q[1] * v[1] + q[2] * v[2]];
+    };
+    return { kind: "plate", material, frame: { o, u, v, w }, outline: [at(a), at(b), at(c), at(d)], thickness, plain: true, only: "mesh", ...extra };
+}
+/** A regular polygon (a disc, near enough) facing along Z, at (x, y), standing from z0 to z1. */
+export function discZ(material, x, y, z0, z1, r, sides = 16, extra = {}) {
+    const outline = Array.from({ length: sides }, (_, i) => [r * Math.cos((2 * Math.PI * i) / sides + Math.PI / sides), r * Math.sin((2 * Math.PI * i) / sides + Math.PI / sides)]);
+    return { kind: "plate", material, frame: { o: [x, y, (z0 + z1) / 2], u: [1, 0, 0], v: [0, 1, 0], w: [0, 0, 1] }, outline, thickness: Math.abs(z1 - z0), plain: true, only: "mesh", ...extra };
+}
+/** The same facing along X, at (y, z), standing from x0 to x1. */
+export function discX(material, y, z, x0, x1, r, sides = 16, extra = {}) {
+    const outline = Array.from({ length: sides }, (_, i) => [r * Math.cos((2 * Math.PI * i) / sides + Math.PI / sides), r * Math.sin((2 * Math.PI * i) / sides + Math.PI / sides)]);
+    return { kind: "plate", material, frame: { o: [(x0 + x1) / 2, y, z], u: [0, 1, 0], v: [0, 0, 1], w: [1, 0, 0] }, outline, thickness: Math.abs(x1 - x0), plain: true, only: "mesh", ...extra };
+}
+/** An I-beam from a to b, `h` deep (along `up`) and `w` wide: the kit's section. A brace is this, a channel or a round strut; never a plain square bar. */
+export const ibeam = (material, a, b, h, w, up = [0, 0, 1]) => {
+    const d = [b[0] - a[0], b[1] - a[1], b[2] - a[2]];
+    const l = Math.hypot(d[0], d[1], d[2]) || 1;
+    const k = (up[0] * d[0] + up[1] * d[1] + up[2] * d[2]) / l;
+    // the kit wants an up that is not along the beam: take the part of the hint across it, or any other axis
+    const across = [up[0] - (d[0] / l) * k, up[1] - (d[1] / l) * k, up[2] - (d[2] / l) * k];
+    const n = Math.hypot(...across);
+    const u = n > 1e-6 ? [across[0] / n, across[1] / n, across[2] / n] : Math.abs(d[0] / l) < 0.9 ? [1, 0, 0] : [0, 1, 0];
+    return kitIBeam(material, a, b, u, h, w);
+};
+/** A pipe run through a path of points, with the kit's flanges, clamps and round bends. `clampEvery` is the spacing of the clamp brackets and `bracket` the way their legs go. */
+export const pipeRun = (material, points, r, o = {}) => kitPipeRun(points, r, material, { ...(o.sides ? { sides: o.sides } : {}), ...(o.clampEvery ? { bracketEvery: o.clampEvery } : {}), ...(o.bracket ? { support: o.bracket } : {}) });
+/** A round strut as the lunar module's legs are: the kit's tube with its collars and caps, and a white ball joint on each end. */
+export function roundStrut(material, a, b, r, o = {}) {
+    const sides = o.sides ?? 12;
+    const ball = (p) => ({ kind: "lathe", material: o.joint ?? "hull-white", at: [p[0], p[2]], segs: sides, profile: [[0.001, p[1] - r * 1.5], [r * 1.1, p[1] - r * 1.05], [r * 1.5, p[1]], [r * 1.1, p[1] + r * 1.05], [0.001, p[1] + r * 1.5]], only: "mesh" });
+    return [...kitStrut(material, a, b, r, sides), ball(a), ball(b)];
+}

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

@@ -0,0 +1,12 @@
+import { type Piece } from "./adapter.ts";
+import { type BayId } from "./dims.ts";
+/** The habitation drum: two bands with their pinstripes, between the rings of portholes. */
+export declare function habitatLivery(cut?: boolean): Piece[];
+/** A hangar shoulder: a pair of pinstripes along the roof and the outer wall, above and below the bay door, and across both ends. The leaves of the door stay orange. */
+export declare function hangarLivery(bay: BayId): Piece[];
+/** The citadel: a pair of pinstripes along each flank and the dorsal side, and a broad accent band round the middle. */
+export declare function citadelLivery(): Piece[];
+/** The bow: the pinstripe round each of the three shield layers, and the accent on the foremost. */
+export declare function bowLivery(): Piece[];
+/** The drive's neck: two pinstripes under the shroud. */
+export declare function driveLivery(): Piece[];

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

@@ -0,0 +1,62 @@
+// What makes ISV Ariake (SPX-186) a sister and not a copy: the same model with a dawn-gold livery (a broad accent band and a pair of pinstripes in place of the plain hull), a survey pod by default, a refit (a sensor
+// mast, a solarium on each side of the dome) and a warm interior. Every function here only adds pieces to a part the sister shares with Miyamoto. Pure: no three.js and no DOM.
+import { annulus, cub, hoop } from "./adapter.js";
+import { BAYS, bayBox, BOW_LAYERS, CITADEL, STATION } from "./dims.js";
+const R_HAB = 13;
+const sorted = (a, b) => (a < b ? [a, b] : [b, a]);
+/** A band and its two pinstripes round a drum, at height y. */
+const ringBand = (r, y, wide, cut) => {
+    // the drum is cut over the same half as the kit's drum (58 to 302 degrees kept), turned a quarter with it
+    const arc = cut ? { arc: () => [(148 * Math.PI) / 180, (392 * Math.PI) / 180] } : {};
+    return [annulus("hull-dawn", r, r + 0.28, y, y + wide, 48, { only: "mesh", ...arc }), hoop("hull-dawn", r + 0.2, y - 0.7, 0.1, 48, 6, arc), hoop("hull-dawn", r + 0.2, y + wide + 0.7, 0.1, 48, 6, arc)];
+};
+/** The habitation drum: two bands with their pinstripes, between the rings of portholes. */
+export function habitatLivery(cut = false) {
+    const [y0] = STATION.habitat;
+    return [...ringBand(R_HAB + 0.4, y0 + 17, 1.4, cut), ...ringBand(R_HAB + 0.4, y0 + 31, 1.4, cut)];
+}
+/** A hangar shoulder: a pair of pinstripes along the roof and the outer wall, above and below the bay door, and across both ends. The leaves of the door stay orange. */
+export function hangarLivery(bay) {
+    const side = BAYS[bay].side;
+    const h = bayBox(bay);
+    const [y0, y1] = h.y;
+    const [x0, x1] = h.x;
+    const [z0, z1] = h.z;
+    const sgn = side === "starboard" ? 1 : -1;
+    const outer = side === "starboard" ? x1 : x0;
+    const out = [];
+    for (const dx of [-12, -11.4, 11.4, 12])
+        out.push(cub("hull-dawn", sorted(h.centre + dx - 0.1, h.centre + dx + 0.1), [y0 + 1, y1 - 1], [z1 + 0.35, z1 + 0.6]));
+    for (const z of [z0 + 2.3, z0 + 2.9, z1 - 3, z1 - 3.6])
+        out.push(cub("hull-dawn", sorted(outer, outer + sgn * 0.6), [y0 + 0.5, y1 - 0.5], [z - 0.1, z + 0.1]));
+    for (const y of [y0, y1])
+        for (const z of [z1 - 3, z1 - 3.6])
+            out.push(cub("hull-dawn", [x0 + 0.5, x1 - 0.5], sorted(y, y + (y === y0 ? -0.6 : 0.6)), [z - 0.1, z + 0.1]));
+    return out;
+}
+/** The citadel: a pair of pinstripes along each flank and the dorsal side, and a broad accent band round the middle. */
+export function citadelLivery() {
+    const [y0, y1] = STATION.command;
+    const hx = CITADEL.hx;
+    const hz = CITADEL.hz;
+    const out = [];
+    for (const sx of [-1, 1])
+        for (const z of [-4.6, -4, 4, 4.6])
+            out.push(cub("hull-dawn", sorted(sx * hx, sx * (hx + 0.7)), [y0 + 1, y1 - 1], [z - 0.1, z + 0.1]));
+    for (const x of [-12, -11.4, 11.4, 12])
+        out.push(cub("hull-dawn", [x - 0.1, x + 0.1], [y0 + 1, y1 - 1], [hz + 0.4, hz + 0.7]));
+    out.push(cub("hull-dawn", [-hx - 0.7, -hx], [y0 + 3, y0 + 4.6], [-hz + 8, hz - 8]), cub("hull-dawn", [hx, hx + 0.7], [y0 + 3, y0 + 4.6], [-hz + 8, hz - 8]));
+    return out;
+}
+/** The bow: the pinstripe round each of the three shield layers, and the accent on the foremost. */
+export function bowLivery() {
+    const out = [];
+    for (const layer of BOW_LAYERS)
+        for (const sx of [-1, 1])
+            out.push(cub("hull-dawn", sorted(sx * layer.hx, sx * (layer.hx + 0.7)), [layer.y[0] + 0.6, layer.y[1] - 0.6], [-0.35, 0.35]));
+    return out;
+}
+/** The drive's neck: two pinstripes under the shroud. */
+export function driveLivery() {
+    return [hoop("hull-dawn", 9.9, 44, 0.12, 40, 6), hoop("hull-dawn", 9.9, 44.8, 0.12, 40, 6), hoop("hull-dawn", 9.9, 52, 0.12, 40, 6)];
+}

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

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

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

@@ -0,0 +1,101 @@
+// Bow defence and navigation, station 350 to 380 m: a short blunt stack of three staggered, spaced shield layers in the orange of removable shields, each narrower than the one behind, with spacer struts between them; steerable
+// ranging apertures and retracted optical heads on the front; two debris-intercept mounts; side apertures that keep working if the front is damaged. A cutaway opens the starboard side to the crush cells. Pure: no three.js and no DOM.
+import { chamfered, collar, cub, prism, rng, rod } from "./adapter.js";
+import { BOW_LAYERS, STATION } from "./dims.js";
+import { dressedFace } from "./hulls.js";
+import { frame, lamp, on, SHUTTER, stencil } from "./faces.js";
+import { ringAt, tubeAt } from "./shapes.js";
+const [Y0] = STATION.bow;
+/** One layer's extent: its gaps are shaved off so a layer stands clear of the next. */
+const layerY = (i) => [BOW_LAYERS[i].y[0] + (i > 0 ? 0.7 : 0), BOW_LAYERS[i].y[1] - 0.5];
+export function bow(cut, detail = 1, seed = "bow", marks = "452") {
+    const out = [];
+    const random = rng(`${seed}/bow`);
+    BOW_LAYERS.forEach((layer, i) => {
+        const [y0, y1] = layerY(i);
+        const { hx, hz } = layer;
+        const o = { seed: `${seed}${i}`, scheme: SHUTTER, detail, density: 0.3, cell: [2.4, 2.4], raise: 0.3, kinds: ["hatch", "lamps", "bolts", "hazard", "greeble", "number"] };
+        const outline = chamfered(hx, hz, 6 + i * 2);
+        if (cut) {
+            // starboard half only: the layer cut at x = 0, so its crush cells show
+            out.push(prism("hull-grey-dark", outline.map(([x, z]) => [Math.min(x, 0), z]), y0, y1, { only: undefined }));
+            for (let x = 0.6; x < hx - 0.3; x += 1.8)
+                out.push(cub(i === 1 ? "hull-white-worn" : "hull-orange-worn", [x, x + 0.14], [y0 + 0.4, y1 - 0.4], [-hz + 0.8, hz - 0.8]));
+            for (let z = -hz + 1.4; z < hz - 0.6; z += 1.8)
+                out.push(cub("hull-grey", [0.2, hx - 0.8], [y0 + 0.4, y1 - 0.4], [z, z + 0.14]));
+            for (const z of [-hz + 0.8, hz - 0.8])
+                out.push(cub("foam", [0.2, hx - 0.8], [y0 + 0.5, y1 - 0.5], [z - 0.3, z + 0.3]));
+            out.push(prism("hull-orange", outline.map(([x, z]) => [Math.min(x, 0) * 1, z]), y1 - 0.3, y1, { only: undefined }));
+        }
+        else {
+            out.push(prism("hull-grey-dark", outline, y0, y1, { only: undefined }));
+        }
+        const faces = [
+            { n: "y", sign: 1, at: y1, a: [-hz + 3 + i, hz - 3 - i], b: [-hx + 3 + i, hx - 3 - i] },
+            { n: "x", sign: -1, at: -hx, a: [y0, y1], b: [-hz + 3 + i, hz - 3 - i] },
+            { n: "z", sign: 1, at: hz, a: [-hx + 3 + i, hx - 3 - i], b: [y0, y1] },
+            { n: "z", sign: -1, at: -hz, a: [-hx + 3 + i, hx - 3 - i], b: [y0, y1] },
+            ...(cut ? [] : [{ n: "x", sign: 1, at: hx, a: [y0, y1], b: [-hz + 3 + i, hz - 3 - i] }]),
+        ];
+        for (const face of faces) {
+            if (face.n === "y") {
+                // the fore face is a mosaic of tiles in rows, each tile its own raised plate: the replaceable shield tiles
+                const tw = 2.6;
+                const th = 2.2;
+                for (let b = face.b[0]; b < face.b[1] - 0.3; b += tw)
+                    for (let a = face.a[0]; a < face.a[1] - 0.3; a += th)
+                        out.push(cub(random() < 0.18 ? "hull-orange-worn" : random() < 0.3 ? "hull-white-worn" : "hull-orange", [b + 0.07, Math.min(b + tw, face.b[1]) - 0.07], [face.at, face.at + 0.28 + random() * 0.12], [a + 0.07, Math.min(a + th, face.a[1]) - 0.07]));
+            }
+            else
+                out.push(...dressedFace(face, o));
+        }
+        // a ring of bolts round the layer's front edge
+        for (let x = -hx + 1.2; x < hx - 1; x += 2.2)
+            for (const z of [-hz + 0.9, hz - 0.9])
+                out.push(cub("hull-grey-dark", [x - 0.16, x + 0.16], [y1, y1 + 0.4], [z - 0.16, z + 0.16]));
+    });
+    // spacer struts between layers: eight columns each, with a clevis at each end
+    for (const i of [0, 1]) {
+        const a = layerY(i)[1];
+        const b = layerY(i + 1)[0];
+        const hx = BOW_LAYERS[i + 1].hx;
+        const hz = BOW_LAYERS[i + 1].hz;
+        for (const x of [-hx + 3, -hx / 3, hx / 3, hx - 3])
+            for (const z of [-hz + 3, hz - 3])
+                out.push(rod("hull-grey", [x, a, z], [x, b, z], 0.45, 8), rod("hull-grey-dark", [x, a, z], [x, a + 0.35, z], 0.7, 8), rod("hull-grey-dark", [x, b - 0.35, z], [x, b, z], 0.7, 8));
+    }
+    // the front: four steerable ranging apertures (a gimbal ring, a tilted lens), six retracted optical heads in recesses, a nav light row
+    const yF = layerY(2)[1] + 0.35;
+    const lay = BOW_LAYERS[2];
+    for (const [x, z] of [[-5, 4], [5, 4], [-5, -4], [5, -4]]) {
+        out.push(ringAt("hull-grey", x, z, 1.6, yF, 0.3), ringAt("hull-orange", x, z, 2.2, yF - 0.1, 0.18), tubeAt("glass", x, z, 1.1, yF - 0.2, yF + 0.4, { segs: 14 }), tubeAt("bell-inside", x + 0.2, z, 0.5, yF + 0.4, yF + 0.7, { segs: 10 }));
+        out.push(cub("hull-grey-dark", [x - 0.2, x + 0.2], [yF - 0.4, yF + 0.2], [z + 1.7, z + 2.4]), cub("lamp-amber", [x - 0.15, x + 0.15], [yF, yF + 0.2], [z - 2.4, z - 2]));
+    }
+    for (let k = 0; k < 6; k++) {
+        const x = -lay.hx + 2.5 + k * 3.6;
+        out.push(tubeAt("hull-grey-dark", x, 0, 0.9, yF - 0.1, yF + 0.1, { segs: 10 }), tubeAt("glass", x, 0, 0.55, yF + 0.1, yF + 0.45, { segs: 10 }));
+    }
+    out.push(...[-1, 1].flatMap((s) => lamp({ n: "y", sign: 1, at: yF, a: [-lay.hz, lay.hz], b: [-lay.hx, lay.hx] }, s * (lay.hz - 1), lay.hx - 1, "amber", 0.2)));
+    // side apertures: two on each flank of the first layer, each a recessed lens in a frame, so a damaged front still leaves the ship its eyes
+    const l0 = BOW_LAYERS[0];
+    for (const s of [-1, 1])
+        for (const y of [Y0 + 4, Y0 + 9]) {
+            const f = { n: "x", sign: s, at: s * l0.hx, a: [Y0, Y0 + 12], b: [-l0.hz, l0.hz] };
+            if (cut && s === 1)
+                continue;
+            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 face of the middle layer, a pair of barrels each, and a service hatch
+    const l1 = BOW_LAYERS[1];
+    const y1 = layerY(1);
+    for (const s of [1, -1]) {
+        const z = s * l1.hz;
+        out.push(cub("hull-grey-dark", [-2.6, 2.6], [y1[0] + 1, y1[1] - 1], [z, z + s * 1.4]), cub("hull-orange", [-2.4, 2.4], [y1[0] + 1.2, y1[1] - 1.2], [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] + 3, z + s * 2.6], 0.34, 8), rod("bell-inside", [x, y1[1] + 3, z + s * 2.6], [x, y1[1] + 3.15, 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]));
+    }
+    out.push(...stencil({ n: "x", sign: -1, at: -l0.hx, a: [Y0, Y0 + 12], b: [-l0.hz, l0.hz] }, marks, Y0 + 6, -4, 2.2));
+    out.push(...collar("L", Y0, -1));
+    return out;
+}

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

@@ -0,0 +1,8 @@
+import { type Piece } from "./adapter.ts";
+export declare function command(cut: boolean, detail?: number, seed?: string, refit?: boolean): Piece[];
+/** The separation joint at the citadel's aft face: the citadel leaves as a lifeboat, so the joint is hardware you can see. A separation collar (a split ring with a hazard seam), twelve latch dogs with their pyro bolts, eight separation springs, and two umbilical plates with their connector pins and a locking lever each. The part boundary is the plane y = Y0. */
+export declare function separationJoint(y: number, cut: boolean): Piece[];
+/** The armoured observation dome above the operations ring, and the solarium beside it: a glazed garden hall with grow-lamps and shutters, lit at night. The dome is a faceted cap of glass panes in an armoured ring with eight ribs; the solarium is a frame of I-beams holding glass, with plant beds, lamps and half-drawn orange shutters. Simple until the kit's own arrive. */
+export declare function observation(seed: string, twin?: boolean): Piece[];
+/** Ariake's refit: a lattice mast on the citadel's dorsal side aft of the dome, three round legs braced at every level, with a ring of lamps and a head of sensors (a gimballed telescope, a radar dish, a lidar turret and a magnetometer boom). */
+export declare function sensorMast(): Piece[];