@johnmorrisdotca/uchusen-rockets 0.9.0 → 0.11.0

package/dist/model/detail.d.ts

@@ -0,0 +1,10 @@
+import type { Piece } from "./pieces.ts";
+export type DetailLevel = "full" | "coarse";
+/** The level in force while a part's pieces are being made. Set by `build`, never by hand. */
+export declare const detail: {
+    level: DetailLevel;
+};
+/** The smallest a 3D-only piece may be, in metres, and stay in the coarse level. */
+export declare const COARSE_MIN = 6;
+/** The coarse level of a part: what is drawn in the line drawings stays, and so does any 3D piece over `COARSE_MIN` metres; the small detail goes. */
+export declare const coarsen: (pieces: readonly Piece[]) => Piece[];

package/dist/model/detail.js

@@ -0,0 +1,19 @@
+/** The level in force while a part's pieces are being made. Set by `build`, never by hand. */
+export const detail = { level: "full" };
+/** The smallest a 3D-only piece may be, in metres, and stay in the coarse level. */
+export const COARSE_MIN = 6;
+const sizeOf = (piece) => {
+    if (piece.kind === "plate") {
+        const us = piece.outline.map(([a]) => a);
+        const vs = piece.outline.map(([, b]) => b);
+        return Math.max(Math.max(...us) - Math.min(...us), Math.max(...vs) - Math.min(...vs), piece.thickness);
+    }
+    if (piece.kind === "lathe") {
+        const rs = piece.profile.map(([r]) => r);
+        const ys = piece.profile.map(([, y]) => y);
+        return Math.max(Math.max(...rs) - Math.min(...rs), Math.max(...ys) - Math.min(...ys));
+    }
+    return Infinity;
+};
+/** The coarse level of a part: what is drawn in the line drawings stays, and so does any 3D piece over `COARSE_MIN` metres; the small detail goes. */
+export const coarsen = (pieces) => pieces.filter((piece) => piece.only !== "mesh" || piece.kind === "lines" || sizeOf(piece) >= COARSE_MIN);

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

@@ -0,0 +1,5 @@
+/**
+ * The real hardware each module descends from, by module id: what a reader can look up. The kit starts from real engineering and goes further where a ship needs it (bolder shapes, new materials, armour, scale,
+ * drives that do not exist yet); each module still looks engineered and has a job.
+ */
+export declare const ANCESTORS: Readonly<Record<string, string>>;

package/dist/model/fleet/ancestors.js

@@ -0,0 +1,47 @@
+// The real hardware each module of the kit descends from: what a reader can look up. Pure: no imports.
+/**
+ * The real hardware each module descends from, by module id: what a reader can look up. The kit starts from real engineering and goes further where a ship needs it (bolder shapes, new materials, armour, scale,
+ * drives that do not exist yet); each module still looks engineered and has a job.
+ */
+export const ANCESTORS = {
+    "engine-fusion-1": "Space Shuttle main engine and Starship Raptor plumbing (feed lines, injector head, gimbal actuators); NERVA's nozzle; Daedalus' fusion nozzle and field coils",
+    "engine-fusion-3": "Starship Super Heavy's engine cluster and its thrust puck; Saturn V's F-1 cluster; Daedalus' first-stage engine",
+    "engine-fusion-4": "Saturn V first stage's four outer engines and its thrust structure",
+    "engine-fusion-7": "Starship Ship's seven-engine base and Saturn V's thrust structure; NASA Mars transfer vehicle studies' engine clusters",
+    "thruster-pod-s": "Apollo service module's reaction-control quads and the ISS's attitude thrusters",
+    "rcs-ring-m": "Space Shuttle's reaction-control jets and Apollo's RCS quad rings",
+    "tank-cryo-12": "Saturn V S-IVB hydrogen tank, Space Shuttle external tank (ring frames, feed lines) and Starship's tank domes",
+    "tank-cryo-24": "Space Shuttle external tank and Saturn V S-II; NASA Mars transfer vehicle studies' long propellant tanks",
+    "tank-slim-18": "Saturn V S-IVB and Falcon 9 tanks",
+    "tank-header-9": "Starship's header tanks and the Space Shuttle's reserve tanks",
+    "tank-spheres-4": "Apollo service module's spherical helium tanks and Orion's service module pressurant spheres",
+    "container-12": "ISO shipping containers, and the ISS's MPLM and cargo pallets",
+    "container-12-cold": "Refrigerated ISO containers; the ISS's cold stowage freezers",
+    "cargo-bay-4": "Container-ship cell guides and twist-lock castings; the ISS's external logistics carriers and Canadarm rails",
+    "habitat-ring-16": "Von Braun's wheel space station, NASA's Nautilus-X centrifuge and the spin habitats of the Mars transfer vehicle studies",
+    "habitat-ring-30": "Von Braun's wheel space station and the Stanford torus study",
+    "habitat-drum-crew": "ISS Destiny and Harmony nodes, and Skylab's workshop",
+    "habitat-drum-large": "ISS Zvezda and the Mars transfer vehicle studies' habitat modules",
+    "farm-drum": "Skylab's and the ISS's plant growth chambers (Veggie, Advanced Plant Habitat); BIOS-3's grow racks",
+    "common-area-m": "ISS Node 1 Unity and the Cupola",
+    "store-drum-m": "ISS Leonardo, the Multi-Purpose Logistics Module",
+    "lab-m": "ISS Columbus and Kibo laboratories; Skylab's workshop",
+    "dome-observation-m": "The ISS Cupola, the seven-window observation dome with its hinged shutters, and the Space Shuttle's overhead windows",
+    "solarium-m": "The ISS Veggie and Advanced Plant Habitat gardens, the Biosphere 2 glass halls, and the O'Neill cylinder studies' farm and park lands",
+    "eva-lock-m": "ISS Quest airlock and the Space Shuttle's airlock",
+    "pod-survey-m": "Orion's service module payload bay and the ISS's Express racks",
+    "pod-medical-m": "ISS's crew health care system and Apollo's medical kits, in a Skylab-sized pod",
+    "deck-nav-m": "Orion's crew module, the Space Shuttle's flight deck and the ISS Cupola",
+    "comms-array-m": "NASA's Deep Space Network dishes, the TDRS satellites and Orion's high-gain antenna",
+    "mast-sensor-40": "Hubble's and JWST's booms, the ISS's Canadarm2 and a Deep Space Network lattice tower",
+    "reactor-fusion": "NASA's Kilopower and NERVA reactors with their shadow shields, and the Mars transfer vehicle studies' reactor and radiator layout; Daedalus' reactor chamber",
+    "radiator-stowed": "ISS's photovoltaic radiators folded for launch, and the Space Shuttle's payload-bay radiators",
+    "radiator-deployed": "ISS's thermal radiator wings on booms; the Mars transfer vehicle studies' large radiators",
+    "node-two": "ISS Node 2 Harmony and the Common Berthing Mechanism",
+    "node-four": "ISS Node 1 Unity and Node 3 Tranquility, with their berthing ports",
+    "truss-m-12": "ISS Integrated Truss Structure segments",
+    "truss-l-24": "ISS Integrated Truss Structure and the Mars transfer vehicle studies' long truss spine",
+    "adapter-m-l": "Saturn V's instrument unit and Spacecraft-LM adapter, and the Space Shuttle's payload adapters",
+    "adapter-l-m": "Saturn V's interstage and Apollo's Spacecraft-LM adapter",
+    "shield-forward": "Daedalus' beryllium dust shield, Orion's heat shield and Apollo's ablative heat shield; the Mars transfer vehicle studies' shadow shield",
+};

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

@@ -0,0 +1,76 @@
+import type { Piece } from "../pieces.ts";
+/**
+ * The four collar classes: S for small craft and service ports, M for the ordinary module spine, L for heavy spines, H for the heaviest.
+ *
+ * @example
+ * ```ts
+ * import type { CollarClass } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const heavy: CollarClass = "L";
+ * console.log(heavy);
+ * ```
+ */
+export type CollarClass = "S" | "M" | "L" | "H";
+/**
+ * What a collar class is, in metres.
+ *
+ * @example
+ * ```ts
+ * import { COLLARS, type CollarSpec } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const medium: CollarSpec = COLLARS.M;
+ * console.log(medium.outer, medium.bore, medium.bolts);
+ * ```
+ */
+export interface CollarSpec {
+    /** Outer diameter of the flange: the diameter of the joint. */
+    outer: number;
+    /** Diameter of the clear port through the middle. */
+    bore: number;
+    /** Bolts on the bolt circle, and latch dogs on the rim. */
+    bolts: number;
+    dogs: number;
+    /** Flange thickness. */
+    thick: number;
+}
+/**
+ * The collar standard: four classes, each twice the one before.
+ *
+ * @example
+ * ```ts
+ * import { COLLARS } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(COLLARS.M.outer, COLLARS.L.bore);
+ * ```
+ */
+export declare const COLLARS: Readonly<Record<CollarClass, CollarSpec>>;
+/**
+ * The collar classes in order of size.
+ *
+ * @example
+ * ```ts
+ * import { COLLAR_CLASSES } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(COLLAR_CLASSES.join(" < "));
+ * ```
+ */
+export declare const COLLAR_CLASSES: readonly ["S", "M", "L", "H"];
+/**
+ * Whether two facing collars mate: the same class, and both there.
+ *
+ * @param a The collar on one module's end, or undefined for none.
+ * @param b The collar on the module it meets.
+ * @returns True when both are there and of one class.
+ * @example
+ * ```ts
+ * import { mates } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(mates("L", "L"), mates("L", "M"));
+ * ```
+ */
+export declare const mates: (a: CollarClass | undefined, b: CollarClass | undefined) => boolean;
+/**
+ * One collar's pieces. `y` is the face (the end of the module) and `facing` is +1 for a collar on a module's top (the face looks up) and -1 for one on its bottom. Nothing stands out past `y`:
+ * the flange sits a little back from the face and the bolt heads fill the space to it, so two collars meet face to face.
+ */
+export declare function collar(cls: CollarClass, y: number, facing: 1 | -1): Piece[];

package/dist/model/fleet/collars.js

@@ -0,0 +1,76 @@
+import { annulus, box, boltRing, disc, hoop, post, ringOf, rod, stamp } from "./detail.js";
+/**
+ * The collar standard: four classes, each twice the one before.
+ *
+ * @example
+ * ```ts
+ * import { COLLARS } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(COLLARS.M.outer, COLLARS.L.bore);
+ * ```
+ */
+export const COLLARS = {
+    S: { outer: 3, bore: 1.4, bolts: 8, dogs: 4, thick: 0.1 },
+    M: { outer: 6, bore: 3, bolts: 16, dogs: 8, thick: 0.14 },
+    L: { outer: 12, bore: 6, bolts: 24, dogs: 12, thick: 0.24 },
+    H: { outer: 24, bore: 12, bolts: 36, dogs: 18, thick: 0.44 },
+};
+/**
+ * The collar classes in order of size.
+ *
+ * @example
+ * ```ts
+ * import { COLLAR_CLASSES } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(COLLAR_CLASSES.join(" < "));
+ * ```
+ */
+export const COLLAR_CLASSES = ["S", "M", "L", "H"];
+/**
+ * Whether two facing collars mate: the same class, and both there.
+ *
+ * @param a The collar on one module's end, or undefined for none.
+ * @param b The collar on the module it meets.
+ * @returns True when both are there and of one class.
+ * @example
+ * ```ts
+ * import { mates } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(mates("L", "L"), mates("L", "M"));
+ * ```
+ */
+export const mates = (a, b) => a !== undefined && a === b;
+/**
+ * One collar's pieces. `y` is the face (the end of the module) and `facing` is +1 for a collar on a module's top (the face looks up) and -1 for one on its bottom. Nothing stands out past `y`:
+ * the flange sits a little back from the face and the bolt heads fill the space to it, so two collars meet face to face.
+ */
+export function collar(cls, y, facing) {
+    const c = COLLARS[cls];
+    const t = c.thick;
+    const R = c.outer / 2;
+    const r = c.bore / 2;
+    const back = (d) => y - facing * d;
+    const lo = Math.min(back(t * 1.5), back(t * 0.5));
+    const out = [annulus("hull-grey", r * 1.12, R, lo, lo + t, 64, { outline: false, body: true })];
+    // the seal: a dark ring round the bore, on the flange's outer face
+    out.push(hoop("black", r * 1.16, back(t * 0.5), t * 0.28, 32, 5));
+    // hazard blocks between the seal and the bolts, on the flange face
+    for (let i = 0; i < c.bolts; i++) {
+        const a0 = (2 * Math.PI * i) / c.bolts;
+        out.push({ kind: "lathe", material: i % 2 ? "black" : "hazard", segs: 3, only: "mesh", profile: [[r * 1.24, back(t * 0.46)], [r * 1.24 + (R - r) * 0.14, back(t * 0.46)]], arc: () => [a0, a0 + (2 * Math.PI) / c.bolts] });
+    }
+    // bolts on the bolt circle
+    out.push(...boltRing(r + (R - r) * 0.62, back(t * 0.5), c.bolts, t * 0.83, facing === -1));
+    // alignment pins, four, between bolts
+    const pin = { kind: "lathe", material: "hull-yellow", segs: 8, only: "mesh", profile: [[t * 0.55, back(t * 0.5)], [t * 0.35, y], [0.001, y]] };
+    out.push(...stamp([pin], ringOf(4, r + (R - r) * 0.34, 0, 45)));
+    // latch dogs on the rim
+    out.push(...stamp([box("panel-dark", [0, lo, R - t], t * 2.6, t * 2.2, t * 1.5)], ringOf(c.dogs, 0, 0)));
+    // the port: a tube down from the bore and a pressure door in it
+    const doorY = back(Math.max(0.6, c.bore * 0.22));
+    out.push(post("hull-grey-dark", [0, 0], r, Math.min(y, doorY), r, Math.max(y, doorY), 24));
+    out.push(disc("hull-grey", [0, 0], r * 0.97, doorY - (facing === 1 ? 0.08 : 0), 0.08, 24));
+    out.push(hoop("hull-grey-dark", r * 0.7, doorY + facing * 0.12, 0.05, 24, 5));
+    out.push(rod("hull-grey", [-r * 0.55, doorY + facing * 0.12, 0], [r * 0.55, doorY + facing * 0.12, 0], 0.05, 6), rod("hull-grey", [0, doorY + facing * 0.12, -r * 0.55], [0, doorY + facing * 0.12, r * 0.55], 0.05, 6));
+    return out;
+}