@johnmorrisdotca/uchusen-rockets 0.9.0 → 0.11.0

package/dist/model/fleet/kit.js

@@ -0,0 +1,345 @@
+import { blank } from "../../data/types.js";
+import { COLLARS, mates } from "./collars.js";
+import { beam, place, rod } from "./detail.js";
+import { isCoarse } from "./levels.js";
+import { meshOf } from "../pieces.js";
+import { INSETS } from "./insets.js";
+import { KIT } from "./modules.js";
+export { COLLARS, COLLAR_CLASSES, collar, mates } from "./collars.js";
+export * as DETAIL from "./detail.js";
+export { LIVERY, ROOMS } from "./detail.js";
+export { FLEET_PALETTE } from "./palette.js";
+export { BUILDERS, KIT } from "./modules.js";
+export { BUILD_BUDGET_MS, isCoarse } from "./levels.js";
+export { INSETS } from "./insets.js";
+/**
+ * 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 function assemble(ship) {
+    const placed = [];
+    const issues = [];
+    const taken = new Set();
+    let cursor = 0;
+    let last;
+    let mass = 0;
+    let propellant = 0;
+    let length = 0;
+    let width = 0;
+    let depth = 0;
+    ship.forEach((spot, index) => {
+        const module = KIT[spot.module];
+        if (!module) {
+            issues.push({ place: index, code: "unknown-module", message: `There is no module "${spot.module}".` });
+            return;
+        }
+        let at = [0, cursor, 0];
+        let how = "spine";
+        if (spot.on) {
+            how = "port";
+            const parent = placed.find((p) => p.index === spot.on?.place);
+            const port = parent?.module.ports.find((one) => one.id === spot.on?.port);
+            if (!parent || !port)
+                issues.push({ place: index, code: "no-such-port", message: `Place ${spot.on.place} has no port "${spot.on.port}".` });
+            else {
+                const key = `${parent.index}/${port.id}`;
+                if (taken.has(key))
+                    issues.push({ place: index, code: "port-taken", message: `Port ${key} already holds a module.` });
+                taken.add(key);
+                if (!mates(port.collar, module.bottom))
+                    issues.push({ place: index, code: "collar-mismatch", message: `${module.name} stands on a ${module.bottom ?? "no"} collar; the port is ${port.collar}.` });
+                at = [parent.at[0] + port.at[0], parent.at[1] + port.at[1], parent.at[2] + port.at[2]];
+            }
+        }
+        else if (spot.beside) {
+            how = "beside";
+            at = [spot.beside.x, spot.beside.y ?? Math.max(0, cursor - module.length), spot.beside.z];
+        }
+        else {
+            if (last && !mates(last.top, module.bottom))
+                issues.push({ place: index, code: "collar-mismatch", message: last.top ? `${last.name} ends in a ${last.top} collar and ${module.name} starts with ${module.bottom ? `a ${module.bottom}` : "none"}.` : `${last.name} has no collar on its top: nothing stands on it.` });
+            if (!last && module.bottom === undefined && index > 0)
+                issues.push({ place: index, code: "no-spine", message: `${module.name} has no bottom collar.` });
+            cursor += module.length;
+            last = module;
+        }
+        placed.push({ index, module, at, turn: spot.turn ?? 0, how });
+        mass += module.mass;
+        propellant += module.propellant;
+        length = Math.max(length, at[1] + module.length);
+        width = Math.max(width, 2 * Math.abs(at[0]) + module.width);
+        depth = Math.max(depth, 2 * Math.abs(at[2]) + module.depth);
+    });
+    return { placed, issues, mass, propellant, length, width, depth, ok: issues.length === 0 };
+}
+/**
+ * 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 function shipPieces(ship, options = {}) {
+    const { placed } = assemble(ship);
+    const out = [];
+    for (const p of placed) {
+        const spot = ship[p.index];
+        out.push(...place(p.module.pieces({ ...options, seed: spot.seed ?? `${options.seed ?? ""}${p.index}`, ...(spot.separation ? { separation: spot.separation } : {}) }), { at: p.at, yaw: p.turn }));
+        if (p.how !== "spine")
+            out.push(...clamps(p));
+    }
+    return out;
+}
+/** Clamps from a hung module to the axis: a ring of struts at three heights. */
+function clamps(p) {
+    const out = [];
+    const d = Math.hypot(p.at[0], p.at[2]);
+    if (d < 0.5)
+        return out;
+    const dir = [p.at[0] / d, 0, p.at[2] / d];
+    const r = p.module.width / 2;
+    for (const f of [0.12, 0.5, 0.88]) {
+        const y = p.at[1] + p.module.length * f;
+        const a = [p.at[0] - dir[0] * r, y, p.at[2] - dir[2] * r];
+        const b = [dir[0] * Math.max(0.5, d - r - 4), y, dir[2] * Math.max(0.5, d - r - 4)];
+        out.push(beam("hull-grey-dark", a, b, 0.5, 0.35), rod("hazard", [a[0], y + 0.28, a[2]], [a[0] - dir[0] * 0.4, y + 0.28, a[2] - dir[2] * 0.4], 0.28, 8));
+    }
+    return out;
+}
+const KIND_OF = { engine: "engine", thruster: "engine", tank: "tank", cargo: "module", habitat: "module", lab: "module", sensor: "module", reactor: "module", radiator: "module", node: "module", truss: "module", adapter: "adapter", shield: "module" };
+const NOTE = blank("This package's own design, with no source.");
+/** The record every part has, for a kit module. */
+export function recordOf(module, id = module.id, rocket = "fleet-kit") {
+    return {
+        id,
+        kind: KIND_OF[module.kind],
+        name: module.name,
+        rocket,
+        trueTo: [id],
+        height: module.length,
+        diameter: Math.max(module.width, module.depth),
+        sourced: { height: NOTE, diameter: NOTE },
+        joints: {
+            ...(module.top ? { top: { kind: "stage", y: module.length, diameter: COLLARS[module.top].outer } } : {}),
+            ...(module.bottom ? { bottom: { kind: "stage", y: 0, diameter: COLLARS[module.bottom].outer } } : {}),
+        },
+        painted: null,
+        drawnFrom: `This package's own design, from real hardware (${module.ancestor}): ${module.note}`,
+    };
+}
+/** Every module as a part of the registry, drawn at full detail, plus its cutaway where it has one. */
+export function kitEntries(groupOf) {
+    const out = [];
+    for (const module of Object.values(KIT)) {
+        const rocket = groupOf(module);
+        out.push({ record: recordOf(module, module.id, rocket), pieces: () => module.pieces() });
+        if (module.inside)
+            out.push({ record: { ...recordOf(module, `${module.id}-cutaway`, rocket), name: `${module.name}, cutaway` }, pieces: () => module.pieces({ cutaway: true }) });
+    }
+    return out;
+}
+/**
+ * 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 function shipParts(ship, list, options = {}, rocket = ship, variant = ship) {
+    const assembly = assemble(list);
+    const entries = [];
+    const slots = [];
+    const partIds = {};
+    for (const p of assembly.placed) {
+        const spot = list[p.index];
+        const slot = `${p.module.id}-${p.index + 1}`;
+        const id = `${ship}-${slot}`;
+        const base = recordOf(p.module, id);
+        const record = { ...base, ...(p.how !== "spine" ? { strapOn: { x: p.at[0], z: p.at[2], y: p.at[1] } } : {}), rocket, trueTo: [variant] };
+        entries.push({ record, pieces: () => p.module.pieces({ ...options, seed: spot.seed ?? `${options.seed ?? ""}${p.index}`, ...(spot.separation ? { separation: spot.separation } : {}) }) });
+        slots.push(slot);
+        partIds[slot] = id;
+    }
+    return { entries, slots, partIds, assembly };
+}
+/**
+ * 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 const SAMPLE_SHIPS = {
+    hauler: [
+        { module: "engine-fusion-7" },
+        { module: "tank-cryo-24" },
+        { module: "reactor-fusion" },
+        { module: "cargo-bay-4" },
+        { module: "container-12", on: { place: 3, port: "bay1" } },
+        { module: "container-12-cold", on: { place: 3, port: "bay2" } },
+        { module: "container-12", on: { place: 3, port: "bay3" } },
+        { module: "container-12", on: { place: 3, port: "bay4" } },
+        { module: "habitat-drum-large" },
+        { module: "adapter-l-m" },
+        { module: "common-area-m" },
+        { module: "habitat-ring-16" },
+        { module: "eva-lock-m" },
+        { module: "pod-survey-m" },
+        { module: "lab-m" },
+        { module: "deck-nav-m" },
+        { module: "mast-sensor-40" },
+    ],
+    scout: [{ module: "engine-fusion-3" }, { module: "tank-cryo-12" }, { module: "reactor-fusion" }, { module: "adapter-l-m" }, { module: "tank-header-9" }, { module: "habitat-ring-16" }, { module: "pod-medical-m" }, { module: "lab-m" }, { module: "radiator-deployed" }, { module: "deck-nav-m" }, { module: "mast-sensor-40" }],
+    bulwark: [{ module: "engine-fusion-4" }, { module: "reactor-fusion" }, { module: "truss-l-24" }, { module: "farm-drum" }, { module: "node-four" }, { module: "shield-forward" }],
+};
+/**
+ * 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 function swapsFor(id) {
+    const own = KIT[id];
+    if (!own?.slot)
+        return [];
+    return Object.values(KIT).filter((one) => one.id !== id && one.slot === own.slot && one.top === own.top && one.bottom === own.bottom && one.length === own.length);
+}
+/** The registry's entries for the system insets: one part for each numbered sub-part, placed in its inset's assembly. */
+export function insetEntries() {
+    return Object.values(INSETS).flatMap((inset) => inset.parts.map((one) => ({
+        record: {
+            id: `inset-${inset.id}-${one.n}`,
+            kind: "module",
+            name: `${one.n}. ${one.name}`,
+            rocket: "fleet-insets",
+            trueTo: [inset.id],
+            height: one.size[1],
+            diameter: Math.max(one.size[0], one.size[2]),
+            sourced: { height: NOTE, diameter: NOTE },
+            joints: {},
+            strapOn: { x: one.at[0], z: one.at[2], y: one.at[1] },
+            painted: null,
+            drawnFrom: `This package's own design: ${one.does}`,
+        },
+        pieces: one.pieces,
+    })));
+}
+/**
+ * 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 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 function designation(code) {
+    if (!/^[A-Z0-9]+(-[A-Z0-9]+)*$/.test(code))
+        throw new Error(`"${code}" is not a designation code.`);
+    return `SPX-${code}`;
+}
+/**
+ * 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 function shipLevels(ship, options = {}, order) {
+    const { placed } = assemble(ship);
+    const coarse = shipPieces(ship, { ...options, level: "coarse" });
+    const sequence = order ? order.map((i) => placed.find((p) => p.index === i)).filter((p) => p !== undefined) : placed;
+    return {
+        coarse,
+        *fine() {
+            for (const p of sequence) {
+                const spot = ship[p.index];
+                const own = p.module.pieces({ ...options, level: "fine", seed: spot.seed ?? `${options.seed ?? ""}${p.index}`, ...(spot.separation ? { separation: spot.separation } : {}) }).filter((piece) => !isCoarse(piece));
+                yield { place: p.index, pieces: place(own, { at: p.at, yaw: p.turn }) };
+            }
+        },
+    };
+}
+/**
+ * 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 function timeBuild(ship, level, options = {}) {
+    const start = performance.now();
+    const pieces = shipPieces(ship, { ...options, level });
+    const mesh = meshOf(pieces);
+    let triangles = 0;
+    for (const faces of mesh.faces.values())
+        triangles += faces.indices.length / 3;
+    return { level, ms: performance.now() - start, pieces: pieces.length, triangles };
+}

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

@@ -0,0 +1,84 @@
+import type { MaterialName } from "../materials.ts";
+import type { Piece } from "../pieces.ts";
+/**
+ * One layer of a hull: its place in the stack (1 is the outside), what it is, what it is made of, its thickness in millimetres, and what it is for.
+ *
+ * @example
+ * ```ts
+ * import { HULL_STACKS, type HullLayer } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const outer: HullLayer = HULL_STACKS.transport.layers[0];
+ * console.log(outer.n, outer.name, outer.mm);
+ * ```
+ */
+export interface HullLayer {
+    n: number;
+    id: "ablative" | "whipple" | "armour" | "foam" | "pressure" | "frame" | "lining" | "water" | "radiation";
+    name: string;
+    /** What the mesh is drawn in. */
+    material: MaterialName;
+    /** The material in words. */
+    made: string;
+    /** Thickness in millimetres. */
+    mm: number;
+    note: string;
+}
+/**
+ * A stack of hull layers for a role, outside in.
+ *
+ * @example
+ * ```ts
+ * import { HULL_STACKS, type HullStack } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const stack: HullStack = HULL_STACKS.explorer;
+ * console.log(stack.role, stack.layers.length);
+ * ```
+ */
+export interface HullStack {
+    role: string;
+    /** What the stack is chosen for. */
+    why: string;
+    layers: readonly HullLayer[];
+}
+/**
+ * The name of a preset in `HULL_STACKS`.
+ *
+ * @example
+ * ```ts
+ * import type { HullStackName } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const role: HullStackName = "transport";
+ * console.log(role);
+ * ```
+ */
+export type HullStackName = "transport" | "explorer" | "command" | "liner" | "tanker";
+/**
+ * The hull-layer presets by role. Every stack runs outside in: ablative skin, micrometeoroid shield, armour, foam absorber, pressure hull, frame, lining; a role changes the thicknesses, drops layers it does
+ * not need and adds the ones it does (a transport adds water and polymer radiation shielding). Thicknesses are millimetres; the cutaway draws them as separate shells at their real thickness.
+ *
+ * @example
+ * ```ts
+ * import { HULL_STACKS } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * for (const [name, stack] of Object.entries(HULL_STACKS)) console.log(name, stack.layers.reduce((sum, one) => sum + one.mm, 0), "mm");
+ * ```
+ */
+export declare const HULL_STACKS: Readonly<Record<HullStackName, HullStack>>;
+/**
+ * The total thickness of a stack in metres.
+ *
+ * @param stack A stack from `HULL_STACKS`.
+ * @returns Its thickness in metres.
+ * @example
+ * ```ts
+ * import { HULL_STACKS, stackDepth } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(stackDepth(HULL_STACKS.transport));
+ * ```
+ */
+export declare const stackDepth: (stack: HullStack) => number;
+/**
+ * The shells of a stack at a cutaway: one concentric shell for each layer at its real thickness, outside in from the radius `R`, and at the two cut edges a flat face for each layer, so the stack reads layer by layer.
+ * `arc` is the part of the circle the hull covers.
+ */
+export declare function layerShells(R: number, y0: number, y1: number, stack: HullStack, arc: readonly [number, number], segs?: number): Piece[];

package/dist/model/fleet/layers.js

@@ -0,0 +1,122 @@
+const layer = (n, id, name, material, made, mm, note) => ({ n, id, name, material, made, mm, note });
+/**
+ * The hull-layer presets by role. Every stack runs outside in: ablative skin, micrometeoroid shield, armour, foam absorber, pressure hull, frame, lining; a role changes the thicknesses, drops layers it does
+ * not need and adds the ones it does (a transport adds water and polymer radiation shielding). Thicknesses are millimetres; the cutaway draws them as separate shells at their real thickness.
+ *
+ * @example
+ * ```ts
+ * import { HULL_STACKS } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * for (const [name, stack] of Object.entries(HULL_STACKS)) console.log(name, stack.layers.reduce((sum, one) => sum + one.mm, 0), "mm");
+ * ```
+ */
+export const HULL_STACKS = {
+    transport: {
+        role: "Heavy transport",
+        why: "Thick radiation shielding for a hull that carries people and cargo for years: water and polymer between a heavy bumper and the pressure hull.",
+        layers: [
+            layer(1, "ablative", "Ablative skin", "tile-plain", "ceramic-felt tile on a carbon mat", 40, "Takes dust and gas at speed and sheds heat."),
+            layer(2, "whipple", "Micrometeoroid shield", "hull-grey", "spaced aluminium-ceramic bumper sheets", 120, "Breaks a fast grain into vapour before it reaches the armour."),
+            layer(3, "armour", "Armour plate", "hull-grey-dark", "steel-titanium laminate", 180, "Stops what the bumper does not."),
+            layer(4, "radiation", "Radiation shield", "hull-blue", "borated polymer", 260, "Slows neutrons from the drive and the cosmic background."),
+            layer(5, "water", "Water jacket", "fuel", "water in cells", 300, "Absorbs radiation, and doubles as the emergency reserve."),
+            layer(6, "foam", "Foam absorber", "foam", "metal foam", 90, "Spreads an impact's load before the pressure hull."),
+            layer(7, "pressure", "Pressure hull", "hull-white", "aluminium-lithium shell", 60, "Holds the air in."),
+            layer(8, "frame", "Frame", "hull-grey-dark", "titanium ring frames and stringers", 350, "Carries the loads of thrust and docking."),
+            layer(9, "lining", "Interior lining", "hull-white-worn", "fire-proof panels on cable runs", 30, "What a crew sees, with services behind it."),
+        ],
+    },
+    explorer: {
+        role: "Explorer",
+        why: "A lighter whipple shield: two bumpers and a thin armour layer, because a survey ship trades mass for speed.",
+        layers: [
+            layer(1, "ablative", "Ablative skin", "tile-plain", "ceramic-felt tile", 20, "Dust and gas at speed."),
+            layer(2, "whipple", "Whipple bumper", "hull-grey", "thin aluminium sheet, spaced", 60, "Turns a grain to vapour."),
+            layer(3, "whipple", "Second bumper", "hull-grey", "woven ceramic cloth, spaced", 50, "Spreads the vapour."),
+            layer(4, "foam", "Foam absorber", "foam", "aluminium foam", 70, "Takes the rest."),
+            layer(5, "pressure", "Pressure hull", "hull-white", "aluminium-lithium shell", 40, "Holds the air in."),
+            layer(6, "frame", "Frame", "hull-grey-dark", "carbon-fibre frames", 200, "Light structure."),
+            layer(7, "lining", "Interior lining", "hull-white-worn", "panels on cable runs", 25, "The cabin wall."),
+        ],
+    },
+    command: {
+        role: "Command ship",
+        why: "Armour: a thick laminate and an impact absorber that spreads a hit, for a ship made to be shot at or to take a collision.",
+        layers: [
+            layer(1, "ablative", "Ablative skin", "tile-plain", "ceramic tile", 50, "Heat and dust."),
+            layer(2, "armour", "Outer armour", "hull-grey-dark", "ceramic-metal composite", 260, "Defeats a hard hit."),
+            layer(3, "foam", "Impact absorber", "foam", "layered metal foam", 160, "Spreads the shock."),
+            layer(4, "armour", "Inner armour", "hull-grey", "titanium laminate", 140, "Catches spall."),
+            layer(5, "whipple", "Micrometeoroid shield", "hull-blue", "spaced fabric bumpers", 80, "Dust and small grains."),
+            layer(6, "pressure", "Pressure hull", "hull-white", "aluminium-lithium shell", 60, "Holds the air in."),
+            layer(7, "frame", "Frame", "hull-grey-dark", "titanium frames", 320, "Carries the armour."),
+            layer(8, "lining", "Interior lining", "hull-white-worn", "panels on cable runs", 30, "The wall of the rooms."),
+        ],
+    },
+    liner: {
+        role: "Passenger liner",
+        why: "Comfort and safety for many people: a medium shield, a thick foam layer and a quiet lining.",
+        layers: [
+            layer(1, "ablative", "Ablative skin", "tile-plain", "ceramic-felt tile", 30, "Dust and gas."),
+            layer(2, "whipple", "Micrometeoroid shield", "hull-grey", "spaced aluminium sheets", 90, "Breaks a grain."),
+            layer(3, "radiation", "Radiation shield", "hull-blue", "polyethylene", 180, "Slows neutrons and protons."),
+            layer(4, "foam", "Foam absorber", "foam", "metal foam", 100, "Spreads an impact."),
+            layer(5, "pressure", "Pressure hull", "hull-white", "aluminium-lithium shell", 50, "Holds the air in."),
+            layer(6, "frame", "Frame", "hull-grey-dark", "titanium frames", 260, "Structure."),
+            layer(7, "lining", "Interior lining", "hull-white-worn", "padded panels", 45, "A quiet cabin wall, services behind."),
+        ],
+    },
+    tanker: {
+        role: "Tanker",
+        why: "A tank wall: a bumper, an insulating foam and a thick pressure wall, with little else, because the cargo is the shield.",
+        layers: [
+            layer(1, "ablative", "Ablative skin", "tile-plain", "ceramic-felt tile", 25, "Dust and gas."),
+            layer(2, "whipple", "Micrometeoroid shield", "hull-grey", "aluminium bumper, spaced", 80, "Breaks a grain."),
+            layer(3, "foam", "Insulating foam", "foam", "closed-cell foam", 140, "Keeps the propellant cold."),
+            layer(4, "pressure", "Tank wall", "hull-white", "aluminium-lithium shell", 80, "Holds the propellant."),
+            layer(5, "frame", "Frame", "hull-grey-dark", "ring frames", 220, "Baffle and ring supports."),
+            layer(6, "lining", "Inner lining", "frost", "frost-proof liner", 20, "Faces the cold liquid."),
+        ],
+    },
+};
+/**
+ * The total thickness of a stack in metres.
+ *
+ * @param stack A stack from `HULL_STACKS`.
+ * @returns Its thickness in metres.
+ * @example
+ * ```ts
+ * import { HULL_STACKS, stackDepth } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(stackDepth(HULL_STACKS.transport));
+ * ```
+ */
+export const stackDepth = (stack) => stack.layers.reduce((sum, one) => sum + one.mm, 0) / 1000;
+/**
+ * The shells of a stack at a cutaway: one concentric shell for each layer at its real thickness, outside in from the radius `R`, and at the two cut edges a flat face for each layer, so the stack reads layer by layer.
+ * `arc` is the part of the circle the hull covers.
+ */
+export function layerShells(R, y0, y1, stack, arc, segs = 40) {
+    const out = [];
+    let r = R;
+    for (const l of stack.layers) {
+        const inner = r - l.mm / 1000;
+        const shell = { kind: "lathe", material: l.material, segs, only: "mesh", profile: [[inner, y0], [inner, y1], [r, y1], [r, y0], [inner, y0]], arc: () => arc };
+        out.push(shell);
+        r = inner;
+    }
+    // a flat face at each cut edge for each layer: a plate standing across the stack's radius
+    for (const a of arc) {
+        let outer = R;
+        for (const l of stack.layers) {
+            const thick = l.mm / 1000;
+            const mid = outer - thick / 2;
+            const u = [Math.sin(a), 0, Math.cos(a)];
+            const w = [Math.cos(a), 0, -Math.sin(a)];
+            const plate = { kind: "plate", material: l.material, frame: { o: [u[0] * mid, (y0 + y1) / 2, u[2] * mid], u, v: [0, 1, 0], w }, outline: [[-thick / 2, -(y1 - y0) / 2], [thick / 2, -(y1 - y0) / 2], [thick / 2, (y1 - y0) / 2], [-thick / 2, (y1 - y0) / 2]], thickness: 0.02, plain: true, only: "mesh" };
+            out.push(plate);
+            outer -= thick;
+        }
+    }
+    return out;
+}

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

@@ -0,0 +1,30 @@
+import { type Piece } from "../pieces.ts";
+/**
+ * Whether a piece belongs to the coarse level: a body of revolution that is part of the main body or has an outline (a hull, a bell, a collar's flange), or a solid that is at least a metre and a half every way (a container's box).
+ * Everything else is detail and is added in the fine pass.
+ *
+ * @param piece A piece of a module.
+ * @returns True for the coarse level.
+ * @example
+ * ```ts
+ * import { isCoarse, KIT } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const pieces = KIT["tank-cryo-12"].pieces();
+ * console.log(pieces.filter(isCoarse).length, "of", pieces.length);
+ * ```
+ */
+export declare function isCoarse(piece: Piece): boolean;
+/**
+ * How long a build may take, in milliseconds, on a normal laptop: the first picture (coarse) within a second and full detail within three. `test/fleet-kit.test.ts` fails when a sample assembly goes over.
+ *
+ * @example
+ * ```ts
+ * import { BUILD_BUDGET_MS } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(BUILD_BUDGET_MS.coarse, BUILD_BUDGET_MS.fine);
+ * ```
+ */
+export declare const BUILD_BUDGET_MS: {
+    readonly coarse: 1000;
+    readonly fine: 3000;
+};

package/dist/model/fleet/levels.js

@@ -0,0 +1,41 @@
+// The two levels of every module: coarse (the hull, the collars and the big shapes) and fine (all the detail). A ship builds coarse first, for a first picture in a moment, and adds the fine pass after, module by module,
+// nearest the camera first; the detail pass is the pieces that are not coarse. Build time is measured here so a test can hold it to a budget. Pure: no three.js and no DOM.
+import {} from "../pieces.js";
+/**
+ * Whether a piece belongs to the coarse level: a body of revolution that is part of the main body or has an outline (a hull, a bell, a collar's flange), or a solid that is at least a metre and a half every way (a container's box).
+ * Everything else is detail and is added in the fine pass.
+ *
+ * @param piece A piece of a module.
+ * @returns True for the coarse level.
+ * @example
+ * ```ts
+ * import { isCoarse, KIT } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const pieces = KIT["tank-cryo-12"].pieces();
+ * console.log(pieces.filter(isCoarse).length, "of", pieces.length);
+ * ```
+ */
+export function isCoarse(piece) {
+    if (piece.kind === "lathe")
+        return Boolean(piece.body || piece.outline);
+    if (piece.kind === "plate") {
+        // a solid, not a beam, a sheet or a panel of the plating: thick, wide and deep all at once
+        if (!piece.plain)
+            return false;
+        const us = piece.outline.map(([a]) => a);
+        const vs = piece.outline.map(([, b]) => b);
+        return Math.min(Math.max(...us) - Math.min(...us), Math.max(...vs) - Math.min(...vs), piece.thickness) >= 1.5;
+    }
+    return false;
+}
+/**
+ * How long a build may take, in milliseconds, on a normal laptop: the first picture (coarse) within a second and full detail within three. `test/fleet-kit.test.ts` fails when a sample assembly goes over.
+ *
+ * @example
+ * ```ts
+ * import { BUILD_BUDGET_MS } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(BUILD_BUDGET_MS.coarse, BUILD_BUDGET_MS.fine);
+ * ```
+ */
+export const BUILD_BUDGET_MS = { coarse: 1000, fine: 3000 };