@johnmorrisdotca/uchusen-rockets 0.9.0 → 0.11.0

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

@@ -0,0 +1,445 @@
+import type { MaterialName } from "../materials.ts";
+import { type Frame, type Lathe, type Lines, type Piece, type Plate, type Vec3 } from "../pieces.ts";
+/** A seeded random number generator: the same text gives the same numbers, so the same description gives the same bytes. */
+export type Rng = () => number;
+/** @param seed Any text. @returns A function giving numbers from 0 up to (not including) 1, always the same ones for the same seed. */
+export declare function rng(seed: string): Rng;
+type Extra = Partial<Omit<Plate, "kind" | "material" | "frame" | "outline" | "thickness">>;
+type LatheExtra = Partial<Omit<Lathe, "kind" | "material" | "profile">>;
+/** The tangent frame at a point of a cylinder: u along the circle, v up, w outwards. A plate lying in it lies on the surface. */
+export declare function patch(r: number, az: number, y: number): Frame;
+/** The sag of a flat piece `wide` across on a cylinder of radius `r`: how far its edges stand off the surface. */
+export declare const sagOf: (r: number, wide: number) => number;
+/** A raised rectangle lying on a cylinder, `wide` along the circle and `tall` up it, `raise` metres proud of the surface. */
+export declare function panel(material: MaterialName, r: number, az: number, y: number, wide: number, tall: number, raise: number, extra?: Extra): Plate;
+/** A box standing on a plane: centre of its base at `at`, turned `yaw` degrees about Y; `wide` along its u, `deep` along its v, `tall` up. */
+export declare function box(material: MaterialName, at: Vec3, wide: number, deep: number, tall: number, yaw?: number, extra?: Extra): Plate;
+/** A round rod (a prism with `sides` faces) from a to b: a pipe, a boom, a cable, a strut. */
+export declare function rod(material: MaterialName, a: Vec3, b: Vec3, radius: number, sides?: number, extra?: Extra): Plate;
+/** A flat-sided beam from a to b, `wide` by `deep`. */
+export declare function beam(material: MaterialName, a: Vec3, b: Vec3, wide: number, deep: number, extra?: Extra): Plate;
+/** A cone or bowl on any axis, built from a few stacked prisms, `radii` from the `a` end to the `b` end: a dish, a horn, a sensor head. */
+export declare function horn(material: MaterialName, a: Vec3, b: Vec3, radii: readonly number[], sides?: number, extra?: Extra): Plate[];
+/** A vertical lathe, simple: a straight tube or taper at an offset, from y0 to y1. */
+export declare const post: (material: MaterialName, at: readonly [number, number], r0: number, y0: number, r1: number, y1: number, segs?: number, extra?: LatheExtra) => Lathe;
+/** A vertical disc (a lid, a plate, a pad) at height y, closed on both faces. */
+export declare const disc: (material: MaterialName, at: readonly [number, number], r: number, y: number, thick: number, segs?: number, extra?: LatheExtra) => Lathe;
+/** A ring of rectangular section round the axis: inside radius `r0`, outside `r1`, from y0 to y1. */
+export declare const annulus: (material: MaterialName, r0: number, r1: number, y0: number, y1: number, segs?: number, extra?: LatheExtra) => Lathe;
+/** A round tube bent into a ring (a torus) of major radius `major` and tube radius `minor`, at height y: a cable ring, a field coil, a hoop. */
+export declare function hoop(material: MaterialName, major: number, y: number, minor: number, segs?: number, sides?: number, extra?: LatheExtra): Lathe;
+/** Lines in the drawing only: seams, so the line looks read the same as the mesh. */
+export declare const seams: (weight: Lines["weight"], paths: readonly (readonly Vec3[])[]) => Lines;
+export interface Pose {
+    at: Vec3;
+    /** Degrees about Y, from +Z towards +X. */
+    yaw?: number;
+}
+/** Pieces moved to a pose: turned about Y, then moved. A lathe keeps its axis (vertical): its offset, arc and lean turn with it. Everything the kit draws goes through this, and so does a ship's assembly. */
+export declare function place(pieces: readonly Piece[], pose: Pose): Piece[];
+/** One template put at many poses. The way to repeat bolts, windows, tiles, nozzles, containers: the template is written once and every copy is merged into the part's mesh. */
+export declare const stamp: (template: readonly Piece[], poses: readonly Pose[]) => Piece[];
+/** `count` poses evenly round a circle of radius `r` at height `y`, the first at `start` degrees, each turned to face outwards. */
+export declare function ringOf(count: number, r: number, y: number, start?: number): Pose[];
+/**
+ * A colour scheme: the panel colours of a module. One maker, so every module takes one of a few.
+ *
+ * @example
+ * ```ts
+ * import { LIVERY, type Livery } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const scheme: Livery = LIVERY.science;
+ * console.log(scheme.main, scheme.mainWorn);
+ * ```
+ */
+export interface Livery {
+    /** The main hull colour, its worn twin, a second colour for blocks, its worn twin, an accent, and the dark structural colour. */
+    main: MaterialName;
+    mainWorn: MaterialName;
+    block: MaterialName;
+    blockWorn: MaterialName;
+    accent: MaterialName;
+    dark: MaterialName;
+    /** The colour of the structure under the panels. */
+    under: MaterialName;
+    /** The foil on the hardware that wears it: silver by default, gold kapton for the industrial and foil schemes. */
+    foil?: MaterialName;
+}
+/**
+ * The fleet's liveries. Every one is mostly white thermal blanket, with a few rigid panels in light grey or white, foil on the hardware that wears it, and orange only on small removable access panels (blue on the command scheme): colour is
+ * small and functional, as on the ISS, JWST and Orion's service module.
+ *
+ * @example
+ * ```ts
+ * import { LIVERY } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(LIVERY.industrial.main, LIVERY.command.block);
+ * ```
+ */
+export declare const LIVERY: {
+    readonly industrial: {
+        readonly main: "blanket";
+        readonly mainWorn: "blanket-worn";
+        readonly block: "hull-white";
+        readonly blockWorn: "hull-white-worn";
+        readonly accent: "hull-orange";
+        readonly dark: "panel-dark";
+        readonly under: "hull-grey";
+        readonly foil: "kapton";
+    };
+    readonly science: {
+        readonly main: "blanket";
+        readonly mainWorn: "blanket-worn";
+        readonly block: "hull-white";
+        readonly blockWorn: "hull-white-worn";
+        readonly accent: "hull-orange";
+        readonly dark: "panel-dark";
+        readonly under: "hull-grey";
+        readonly foil: "foil";
+    };
+    readonly command: {
+        readonly main: "blanket";
+        readonly mainWorn: "blanket-worn";
+        readonly block: "hull-grey";
+        readonly blockWorn: "hull-grey-dark";
+        readonly accent: "hull-blue";
+        readonly dark: "panel-dark";
+        readonly under: "hull-grey";
+        readonly foil: "foil";
+    };
+    readonly foil: {
+        readonly main: "blanket";
+        readonly mainWorn: "blanket-worn";
+        readonly block: "kapton";
+        readonly blockWorn: "foil";
+        readonly accent: "hull-orange";
+        readonly dark: "panel-dark";
+        readonly under: "hull-grey";
+        readonly foil: "kapton";
+    };
+    readonly transport: {
+        readonly main: "blanket";
+        readonly mainWorn: "blanket-worn";
+        readonly block: "hull-white";
+        readonly blockWorn: "hull-white-worn";
+        readonly accent: "hull-orange";
+        readonly dark: "panel-dark";
+        readonly under: "hull-grey";
+        readonly foil: "foil";
+    };
+};
+/**
+ * The name of a livery in `LIVERY`.
+ *
+ * @example
+ * ```ts
+ * import type { LiveryName } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const name: LiveryName = "command";
+ * console.log(name);
+ * ```
+ */
+export type LiveryName = keyof typeof LIVERY;
+export interface PanelOptions {
+    r: number;
+    y0: number;
+    y1: number;
+    /** The part of the circle covered, in radians; left out: all of it. */
+    az?: readonly [number, number];
+    livery: Livery;
+    seed: string;
+    /** Average panel size, metres. */
+    wide?: number;
+    tall?: number;
+    /** Metres standing proud of the hull. */
+    raise?: number;
+    /** The share of cells left bare, so the dark structure shows through. */
+    bare?: number;
+    /** Places to leave bare for hardware that stands on the hull (hatches, vents, ladders, cable channels): the middle's azimuth in radians, its height, and its size in metres along the surface. */
+    clear?: readonly {
+        az: number;
+        y: number;
+        wide: number;
+        tall: number;
+    }[];
+}
+/** Hexagonal bolt heads on a frame's face, as flat hexes standing `lift` metres off it: the rows of fixings on a panel's frame. */
+export declare function bolts(f: Frame, spots: readonly (readonly [number, number])[], size: number, lift: number, material?: MaterialName): Plate[];
+/** A grab handle: two stanchions and a round bar, standing `lift` off a frame's face, `length` long along u, centred at (a, b). */
+export declare function grabHandle(f: Frame, a: number, b: number, length: number, lift: number): Piece[];
+/** A quilted thermal blanket on a cylinder: a raised skin of pillows with a crease where two meet, so light and shadow run across it. */
+export declare function blanketPanel(material: MaterialName, r: number, az: number, y: number, wide: number, tall: number, raise: number): Plate;
+/** A rigid panel with a raised frame round a sunk field, and bolts in the frame's corners (and along it when it is big): plating, an access panel, a louvre. */
+export declare function framedPanel(frame: MaterialName, field: MaterialName, r: number, az: number, y: number, wide: number, tall: number, raise: number, bolted?: boolean): Piece[];
+/**
+ * A window in a hull of radius `r` at azimuth `az` and height `y`: a framed port with a raised frame and bolts, a pane that reflects the sky (and glows when the engines are lit), mullions across it every metre or so and a lit sill strip under it.
+ * Glass reads as glass: a dark reflective pane held in a frame, never a flat coloured slab.
+ */
+export declare function glazing(r: number, az: number, y: number, wide: number, tall: number, raise?: number, pane?: MaterialName): Piece[];
+/**
+ * Crinkled foil on a cylinder: a skin of flat triangles with each corner pushed in or out a little, so every facet takes the light on its own, as the multi-layer insulation of Hubble, JWST and the lunar module does. `cell` is the size of a facet's cell,
+ * `crumple` how far a corner can be pushed.
+ *
+ * @param material `foil` (silver) or `kapton` (gold), or any material.
+ * @param r Radius of the surface under it.
+ * @param y0 Bottom of the band.
+ * @param y1 Top of the band.
+ * @param a0 First azimuth, radians.
+ * @param a1 Last azimuth, radians.
+ * @param seed Any text: the same text gives the same crinkles.
+ * @param cell Size of a facet's cell, metres.
+ * @param crumple How far a corner is pushed in or out, metres.
+ * @returns The pieces: a few plates, each holding a few hundred facets.
+ */
+export declare function foilBand(material: MaterialName, r: number, y0: number, y1: number, a0: number, a1: number, seed: string, cell?: number, crumple?: number): Plate[];
+/**
+ * Plating: rows of panels with a gap between, each a quilted thermal blanket (most of them: the hull reads as white blanket), a rigid panel with a raised frame, bolts and sometimes a grab handle, a patch of crinkled foil, a louvre, or, rarely, a small
+ * orange access panel standing on a blanket. Some are worn, some bare, and a seam line for each row and column is in the drawing. The skin of every hull.
+ */
+export declare function hullPanels(o: PanelOptions): Piece[];
+export interface HatchOptions {
+    r: number;
+    az: number;
+    y: number;
+    /** Side of the square door, metres. */
+    size?: number;
+    /** A round hatch with a handwheel (a pressure door) instead of a square access panel. */
+    round?: boolean;
+}
+/** An access hatch: a raised frame, a door in its own colour with hinges, a latch or a handwheel, a warning stripe and a lamp. */
+export declare function hatch(o: HatchOptions): Piece[];
+export interface ConduitOptions {
+    r: number;
+    az: number;
+    y0: number;
+    y1: number;
+    /** How many pipes run side by side. */
+    count?: number;
+    /** Pipe radius, metres. */
+    pipe?: number;
+    material?: MaterialName;
+    seed: string;
+}
+/** A conduit run up a hull: pipes in a bundle held off the surface by clamps, each leaving the structure through a gland and an elbow at the bottom and going back in at the top, with a flange joint half way. Pipes come in the colours pipes come in: stainless, white, grey and a coloured one. */
+export declare function conduitRun(o: ConduitOptions): Piece[];
+/** A ring of pipe round a hull at height y: a coolant or cable ring, with a clamp and a valve. */
+export declare function pipeRing(material: MaterialName, r: number, y: number, pipe?: number, segs?: number): Piece[];
+/** A cable tray up a hull: a channel with cables lying in it. */
+export declare function cableTray(r: number, az: number, y0: number, y1: number, width?: number, seed?: string): Piece[];
+/** A louvred vent: a frame with slats. */
+export declare function vent(r: number, az: number, y: number, wide?: number, tall?: number, slats?: number): Piece[];
+/** A ladder up a hull: two rails and rungs. */
+export declare function ladder(r: number, az: number, y0: number, y1: number, width?: number): Piece[];
+/** A hazard stripe: alternating blocks of warning yellow and black round a hull between two heights. */
+export declare function hazardBand(r: number, y0: number, y1: number, blocks?: number, az?: readonly [number, number]): Piece[];
+/** Digits in seven bars on a hull: the module's number, in our own simple figures. `size` is the height of a digit in metres. */
+export declare function stencil(digits: string, r: number, az: number, y: number, size: number, material?: MaterialName): Piece[];
+/** A ring of bolt heads (hexagons) on a flat face, at radius `r`, standing from height `y` up (`down` false) or down (`down` true). */
+export declare function boltRing(r: number, y: number, count: number, size: number, down?: boolean, material?: MaterialName): Piece[];
+export interface Lamp {
+    at: Vec3;
+    /** `amber` (work), `blue` (docking), `red` (warning), `port` (the red navigation light), `starboard` (the green one), `strobe` (a white flash) or `flood` (a floodlight's lens). All of them light up with the engines ("Engines: Lit"). */
+    colour: "amber" | "blue" | "red" | "port" | "starboard" | "strobe" | "flood";
+    size?: number;
+}
+/** Lamps: small domes in a bright colour. They glow when the viewer's engines are lit. */
+export declare function lamps(list: readonly Lamp[]): Piece[];
+/** A navigation light on a hull of radius `r` at azimuth `az` (radians) and height `y`: a housing, a stalk and a lens, red (`port`) or green (`starboard`), or a white `strobe`. Lit with the engines. */
+export declare function navLight(colour: "port" | "starboard" | "strobe", r: number, az: number, y: number, size?: number): Piece[];
+/** A floodlight on a hull of radius `r` at azimuth `az` and height `y`, aimed along the hull by `tilt` (radians, up positive): a bracket, a round housing with cooling fins and a bright lens. Lit with the engines. */
+export declare function floodlight(r: number, az: number, y: number, tilt?: number): Piece[];
+/**
+ * How a separation joint is made: how many latch hooks and umbilical plates it has. Set on a ship's place (`separation`) or a module's options.
+ *
+ * @example
+ * ```ts
+ * import { shipPieces, type SeparationOptions } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const joint: SeparationOptions = { latches: 8, umbilicals: 2 };
+ * console.log(shipPieces([{ module: "tank-cryo-12" }, { module: "tank-cryo-12", separation: joint }], { detail: 0.3 }).length > 0);
+ * ```
+ */
+export interface SeparationOptions {
+    /** Latch hooks round the joint (default 12). */
+    latches?: number;
+    /** Umbilical plates (default 4). */
+    umbilicals?: number;
+}
+/**
+ * A separation joint at a module boundary: where a ship is planned to come apart in flight. A split collar ring with a groove between its halves, hooked latches round it, pyrotechnic bolt caps, umbilical plates with their
+ * sockets and strobes, and a hazard stencil along the cut. Place it at the height `y` where two modules meet, on a hull of radius `r` (a collar's outer radius).
+ *
+ * @param r Radius of the joint's ring, metres.
+ * @param y Height of the joint plane.
+ * @param options How many latches and umbilical plates.
+ * @returns The pieces: mesh only, apart from the groove's seam line.
+ */
+export declare function separationJoint(r: number, y: number, options?: SeparationOptions): Piece[];
+export type AntennaKind = "whip" | "dish" | "yagi" | "phased" | "omni" | "horn";
+/** An antenna on a base point, pointing along `dir` (a unit direction; up is [0, 1, 0]): a whip, a dish on a pole, a boom with elements, a phased panel, a ball or a horn. `size` is its length or width in metres. */
+export declare function antenna(kind: AntennaKind, base: Vec3, dir: Vec3, size: number, seed?: string): Piece[];
+export interface RadiatorOptions {
+    /** The wing stands from the hull at radius `r0` and goes out `reach` metres, `height` tall, in the plane of the spine and azimuth `az`. */
+    r0: number;
+    az: number;
+    y: number;
+    reach: number;
+    height: number;
+    seed: string;
+    /** Folded against the hull in a box (stowed), or spread out (deployed). */
+    stowed?: boolean;
+    /** Number of panels. */
+    panels?: number;
+}
+/** A radiator wing, stowed or deployed. Deployed: a boom out from the hull, hinged panels along it with coolant pipes in them and a manifold. Stowed: the same panels folded into a closed box with latches. */
+export declare function radiator(o: RadiatorOptions): Piece[];
+/** A shield or heat-shield dome: tiles in a mosaic on a cone or a dome (`profile` is [radius, y] going up), with a ring of seam line at each step, radial seams, and a band of fixings at the rim. */
+export declare function tileShield(profile: readonly (readonly [number, number])[], seed: string, segs?: number, radial?: number): Piece[];
+export interface GreebleOptions {
+    r: number;
+    y0: number;
+    y1: number;
+    az: readonly [number, number];
+    /** How many in all, before the module's detail level. */
+    count: number;
+    seed: string;
+    livery: Livery;
+}
+/** Small machinery scattered over a patch of hull: junction boxes, valve wheels, sensor posts, pump housings, bollards, in sizes from a hand to a person. */
+export declare function greebles(o: GreebleOptions): Piece[];
+/** A sphere, for the elbow where two pipes meet: round whichever way they run. */
+export declare const ball: (material: MaterialName, at: Vec3, radius: number) => Lathe;
+export type PipeEnd = "flange" | "cap" | "bulkhead" | "valve";
+export interface PipeOptions {
+    /** Sides of the tube: 12 reads as round. */
+    sides?: number;
+    /** A flange every this many metres along a run, and at each end. */
+    flangeEvery?: number;
+    /** A clamp bracket every this many metres. */
+    bracketEvery?: number;
+    /** The way the structure is from the pipe, as a unit vector: brackets stand off the structure on a leg that way. Left out: no legs. */
+    support?: Vec3;
+    /** Material of the flanges and brackets. */
+    fittings?: MaterialName;
+    /** How a run ends, at its first and its last point. A `flange` is bolted to a mating flange on a short stub, a `cap` is a bolted blind flange, a `bulkhead` is a gland where the pipe goes through the structure (a pad, a boot and a bolt circle) and a `valve` is a valve body with its handwheel. Default: both ends flanged. */
+    ends?: readonly [PipeEnd, PipeEnd];
+    /** The radius of a bend, in pipe radii: the corner is rounded to it. 0 gives a sharp corner with a round elbow. Default 3. */
+    bend?: number;
+    /** A colour-coding band round the pipe at each joint: teal for coolant, copper for power. */
+    band?: MaterialName;
+}
+/**
+ * A pipe along a path: a round tube for each straight run, corners rounded to a real bend (a chain of short tubes with a round joint at each, `bend` pipe radii of curve), bolted flange joints at an interval, clamp brackets with stand-off
+ * posts, and a proper end for each run: a flange bolted to a mating flange, a blind cap, a gland through the structure or a valve. Never a bare end, never a square bar: the tube has twelve sides by default.
+ *
+ * @param points The path, in metres: two or more points.
+ * @param radius The pipe's radius.
+ * @param material The pipe's material: `pipe-steel` for stainless, `coolant` for a coolant or feed line, `copper` for a power or coil line.
+ * @param options Sides, spacing of flanges and brackets, the way the structure is, the fittings' material, the ends, the bend and a colour-coding band.
+ * @returns The pieces.
+ */
+export declare function pipeRun(points: readonly Vec3[], radius: number, material: MaterialName, options?: PipeOptions): Piece[];
+/**
+ * An I-beam from a to b: a web between two flanges. `up` is the way the web stands; `height` and `width` are the section's, `t` the plate thickness.
+ *
+ * @param material The beam's material.
+ * @param a The start.
+ * @param b The end.
+ * @param up The direction the web stands, a unit vector not along the beam.
+ * @param height The section's height.
+ * @param width The flange width.
+ * @param t The plate thickness.
+ * @returns Three plates: the web and the two flanges.
+ */
+export declare function iBeam(material: MaterialName, a: Vec3, b: Vec3, up: Vec3, height: number, width: number, t?: number): Plate[];
+/** A channel from a to b: a web with a flange at each edge on one side, the open side towards -`up`'s side axis. */
+export declare function channel(material: MaterialName, a: Vec3, b: Vec3, up: Vec3, height: number, width: number, t?: number): Plate[];
+/** A round strut: a tube with a collar at each end, for a brace. */
+export declare function strut(material: MaterialName, a: Vec3, b: Vec3, radius: number, sides?: number): Plate[];
+/**
+ * An armoured porthole in a hull of radius `r` at azimuth `az` and height `y`: a heavy frame ring with a bolt circle, a thick reflective pane in a retaining lip, and a burn shutter on a hinge arm. `open` swings the shutter back
+ * flat against the hull beside the port (the pane glows when the engines are lit); `closed` shuts it over the pane, with four latch dogs, a handwheel and a hazard stripe for the burn.
+ *
+ * @param r Radius of the hull.
+ * @param az Azimuth, radians.
+ * @param y Height.
+ * @param size Outer radius of the frame in metres (default 0.5).
+ * @param shutter `open` or `closed`.
+ * @returns The pieces.
+ */
+export declare function porthole(r: number, az: number, y: number, size?: number, shutter?: "open" | "closed"): Piece[];
+/**
+ * An armoured observation dome on a base ring at `base` (the middle of the ring, at its foot), a descendant of the ISS Cupola: a base ring with lamps, a reflective glass dome with six meridian ribs, two latitude hoops and an oculus
+ * on top, and six armoured petals that either lie open round the base (`open`, the dome shows its glass and glows when the engines are lit) or close over the glass (`closed`, as in a burn or a storm).
+ *
+ * @param base The middle of the ring's foot, in metres.
+ * @param radius Radius of the dome at its foot.
+ * @param shutters `open` or `closed`.
+ * @returns The pieces.
+ */
+export declare function observationDome(base: Vec3, radius: number, shutters?: "open" | "closed"): Piece[];
+/**
+ * The name of a room in `ROOMS`.
+ *
+ * @example
+ * ```ts
+ * import { ROOMS, type RoomKind } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const kind: RoomKind = "garden";
+ * console.log(ROOMS[kind].name);
+ * ```
+ */
+export type RoomKind = "cabin" | "mess" | "gym" | "garden" | "lounge" | "medical" | "shelter" | "recreation" | "school" | "plaza";
+/**
+ * One room: its id, the name a cutaway labels it with, its job, and its size in metres.
+ *
+ * @example
+ * ```ts
+ * import { ROOMS, type RoomSpec } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const mess: RoomSpec = ROOMS.mess;
+ * console.log(mess.name, mess.size);
+ * ```
+ */
+export interface RoomSpec {
+    id: RoomKind;
+    /** The name a cutaway labels it with. */
+    name: string;
+    /** What it is for, in a line. */
+    job: string;
+    /** Floor size in metres: width, depth, and the height of the room. */
+    size: readonly [number, number, number];
+}
+/**
+ * The rooms people need, named, each with a job and a size in metres: a cabin, a mess, a gym, a garden, an observation lounge, medical, a storm shelter, a recreation room, a school and a plaza. A ship places them in a cutaway
+ * with `room`.
+ *
+ * @example
+ * ```ts
+ * import { ROOMS } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(Object.values(ROOMS).map((room) => room.name).join(", "));
+ * ```
+ */
+export declare const ROOMS: Readonly<Record<RoomKind, RoomSpec>>;
+/**
+ * One of the rooms in `ROOMS`, furnished, standing on its floor at the origin (the middle of its floor), ready to `place` in a cutaway. Plain boxes and rods in the fleet's materials: nothing is bare.
+ *
+ * @param kind Which room.
+ * @param seed Any text, so two of the same room differ a little.
+ * @returns The pieces.
+ */
+export declare function room(kind: RoomKind, seed?: string): Piece[];
+/** 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;
+export {};