@adatechnology/game-floorplan-structure 1.0.5 → 1.1.1

package/dist/index.d.ts

@@ -1,5 +1,6 @@
-import { FloorplanEngine, ViewerLayer } from '@adatechnology/game-floorplan';
-import { MaterialId, JointKind, StructureRole, DestructibleSpec } from '@adatechnology/game-contracts';
+import { FloorplanEngine, ViewerLayer, RoomDef, DoorDef, WindowDef, FloorDef } from '@adatechnology/game-floorplan';
+import { MaterialId, JointKind, StructureRole, SoilProfile, PileSpec, DestructibleSpec, WindExposure } from '@adatechnology/game-contracts';
+import { SoilDef, FrameOptions, WindOptions, SizeStructureOptions } from '@adatechnology/game-destruction';
 
 interface StructurePackOptions {
     /** Litres of the tank by template id or style id. */
@@ -51,6 +52,10 @@ interface StructurePart {
     pitch?: number;
     tent?: string;
     form?: string;
+    /** Rooms a concrete slab covers (the rectangles of the storey it carries); the slab itself is their bounding box. `toDestructibleSpec` cuts the slab into panels over it. */
+    footprint?: Rect[];
+    /** Slab the panel, beam or column was made for (`toDestructibleSpec` with `slabPanels`; a `StructurePart` of `buildStructure` never has it). */
+    slab?: string;
 }
 /** `part` rests on `on` (`GROUND` or another part) through `joint`. `bears: false` ties the two without carrying load. */
 interface Support {
@@ -340,6 +345,84 @@ interface PlanContext {
  */
 declare function buildStructure(source: StructureSource, options?: StructureOptions): Structure;
 
+interface PartsAndSupports {
+    parts: StructurePart[];
+    supports: Support[];
+}
+
+/**
+ * How a concrete slab of a house is cut into panels with beams under their edges, and where pillars are added so that every beam spans a
+ * reasonable distance (design T10-estrutura-real.md §12). Every number is a choice of the design and can be changed per call
+ * (`toDestructibleSpec({ slabPanels: { maxSpan: 4 } })`).
+ */
+interface SlabPanelOptions {
+    /** Longest side of a panel and longest stretch of a beam or bond beam without a support, metres (default 5). */
+    maxSpan: number;
+    /** A cut never leaves a piece narrower than this, metres (default 1.5). */
+    minPanel: number;
+    /** Share of a line of the panel a wall must cover (doors included) for the line to be a room boundary the panel is cut along (default 0.6). */
+    lineCoverage: number;
+    /** A gap in a line of walls up to this wide is a door and counts as wall, metres (default 1.3). */
+    doorGap: number;
+    /** Walls whose lines are this close are one line, metres (default 0.2). */
+    lineTolerance: number;
+    /** A panel with less than this share of its area inside the footprint of the slab is left out (default 0.5). */
+    footprintShare: number;
+    /** Thickness of a panel is its short side over this (default 40: `h = L/40`). */
+    thicknessRatio: number;
+    /** Thinnest floor slab, metres (default 0.10). */
+    floorMinThickness: number;
+    /** Thinnest roof slab, metres (default 0.08). */
+    roofMinThickness: number;
+    /** Depth of a beam is its span over this (default 10: `h = L/10`, a simply supported beam of NBR 6118, and deep enough for the frame to carry the loss of one pillar; continuous beams are L/12). */
+    beamDepthRatio: number;
+    /** Shallowest beam, metres (default 0.25). */
+    beamMinDepth: number;
+    /** Depth of beams and bond beams is rounded up to a multiple of this, metres (default 0.05). */
+    beamStep: number;
+    /** Width of a beam is the thickness of the wall it hides in, or its depth over this when that is wider (default 3). */
+    beamWidthRatio: number;
+    /** Side of the pillars that are added, metres (default 0.20; NBR 6118 13.2.3 asks for 19 cm). */
+    columnSide: number;
+    /**
+     * Most storeys of a building that gets panels (default 8). A tall building is a frame of its own (`buildTower`, the skyscraper presets), and cutting its 40 slabs and
+     * sizing every pillar for the loss of each other one is quadratic: minutes for the 40-storey tower of the plan engine. It keeps its slabs whole, and the steel is not declared.
+     */
+    maxStoreys: number;
+}
+declare const SLAB_PANEL_DEFAULTS: Readonly<SlabPanelOptions>;
+declare const resolveSlabPanels: (options?: boolean | Partial<SlabPanelOptions>) => SlabPanelOptions | undefined;
+
+type Interval = [number, number];
+/**
+ * The span the destruction world measures for a beam from `0` to `length` held at `supports`: twice the farthest any point is from its nearest support
+ * (two supports `g` apart give `g`; a beam hanging `e` past its last support gives `2e`). `at` is where a new support helps the most.
+ */
+declare function beamSpan(length: number, supports: readonly Interval[]): {
+    span: number;
+    at: number;
+    lo: number;
+    hi: number;
+};
+/** Depth of a beam over `span` metres: `span / beamDepthRatio` up to a multiple of `beamStep`, not under `minimum`. */
+declare const beamDepthFor: (span: number, options: SlabPanelOptions, minimum?: number) => number;
+/**
+ * The slabs of concrete cut into panels with beams (`SlabPanelOptions`): see `T10-estrutura-real.md` §12. `input` is the structure as
+ * `toDestructibleSpec` has it (walls with their roles), and the result has the panels, the beams, the pillars they need and the supports re-pointed.
+ */
+declare function applySlabPanels(input: PartsAndSupports, structure: Structure, options: SlabPanelOptions): PartsAndSupports;
+/**
+ * The panels `toDestructibleSpec` makes of the slabs of a structure (named as it names them), for a renderer that draws the floor of each room apart:
+ * `panels` (each with `slab`, the id of the slab it was cut from), `replaced` (those slabs, which the spec no longer has) and the `supports` that touch the panels.
+ */
+declare function slabPanelView(structure: Structure, options: SlabPanelOptions): {
+    panels: StructurePart[];
+    replaced: string[];
+    supports: Support[];
+};
+/** The panels of `slabPanelView`, alone. */
+declare const slabPanelsOf: (structure: Structure, options: SlabPanelOptions) => StructurePart[];
+
 interface DestructibleSpecOptions {
     /** Fraction of its capacity a pillar or bearing wall uses at rest (default 0.65). */
     safety?: number;
@@ -351,6 +434,11 @@ interface DestructibleSpecOptions {
     portico?: boolean;
     /** How finely the walls are split (default `panels`; `coarse` is one part per wall as the Visor de casas 3D builds it). */
     wallDetail?: WallDetail;
+    /**
+     * Cuts the concrete slabs into panels with a beam under each edge, and adds the pillars those beams and the bond beams need (design T10 §12): `true` for
+     * `SLAB_PANEL_DEFAULTS`, options to change them, `false` for the slab as one piece, as the Visor de casas 3D describes it. Default `true`.
+     */
+    slabPanels?: boolean | Partial<SlabPanelOptions>;
     /** Name of the spec (default `house`). */
     name?: string;
     /** Leaves parts out (and what rests on them is dropped from the joints). */
@@ -359,7 +447,40 @@ interface DestructibleSpecOptions {
     sized?: boolean;
     /** Metres the anchored terrain slab reaches beyond the parts (default 6). */
     terrainMargin?: number;
+    /**
+     * Declares the tension steel of the concrete beams, slabs, roofs and stairs of a construction with rebar (`structure.rebar.ratio`), so the destruction
+     * world bends them (`structure.flexure` of game-destruction): `true` for the default ratios (`REBAR_RATIOS`), or ratios per role. When the spec is
+     * sized the steel is sized too (`sizeRebar`: at rest at `safetyOthers`, after the loss of any pillar or bearing wall under `redundancy`). On by
+     * default (a house of concrete is reinforced concrete, with the slab in panels on real beams, `slabPanels`); `false` leaves the concrete plain, as the
+     * Visor de casas 3D describes it.
+     */
+    rebar?: boolean | Partial<Record<'beam' | 'slab' | 'roof' | 'stair', number>>;
+    /**
+     * The ground the house stands on (`DestructibleSpec.soil` of game-contracts: a soil class id such as `clay_stiff`, or a profile of layers). With it
+     * the foundations bear on the soil (game-destruction `soil`): the house settles, and tips over where the soil cannot carry it. A raft foundation
+     * (`raft`, `basement`, `building`) becomes a concrete raft under the footprint (`RAFT_THICKNESS`) instead of the anchored terrain; any other
+     * foundation keeps the terrain and every wall and pillar on it bears on a footing at least `footingWidth` wide. Off by default.
+     */
+    soil?: string | SoilProfile;
+    /** Foundation used with `soil` (default the construction's `foundation.type`). */
+    foundation?: FoundationType;
+    /**
+     * Deep concrete piles under the raft (a piled raft; with `soil` only). `length` omitted: each pile goes down to where it carries its share of the
+     * house with the NBR 6122 safety (`pileLength`). Defaults: diameter 0.4 m, one pile per `PILE_AREA` m² of raft, at least 4, bored.
+     */
+    piles?: true | Partial<PileSpec>;
+    /** Soil classes beyond `SOILS` that `soil` names (the same ones given to the destruction world in `soil.soils`). */
+    soils?: readonly SoilDef[];
 }
+/** Thickness of the raft of a house on the soil, metres (usual 0.20 to 0.30 m). */
+declare const RAFT_THICKNESS = 0.25;
+/** Raft area per pile when the count is not given, m² (a 3 x 3 m grid). */
+declare const PILE_AREA = 9;
+/**
+ * Tension steel ratio a concrete member starts with before sizing, `As / (b d)`: beams 0.8%, slabs and roof slabs 0.25%, stairs 0.4% (inside the
+ * usual ranges of NBR 6118; the minimum for C25 is 0.15%).
+ */
+declare const REBAR_RATIOS: Readonly<Record<'beam' | 'slab' | 'roof' | 'stair', number>>;
 /**
  * The structure as a `DestructibleSpec` in the space of the house (x = u, y = height, z = v; the ground is y = 0), one box per part and a terrain slab
  * that anchors it. Capacities are sized from the loads at rest, as a designer would: a house stands whole, holds the loss of one pillar or bearing wall
@@ -475,6 +596,561 @@ declare const structureLayer: ViewerLayer;
 /** kg/m3 the plan structure weighs its parts with (the table of the Visor de casas 3D; a material outside it weighs like soft wood). */
 declare const DENSITY: Readonly<Record<string, number>>;
 
+/**
+ * Building systems of a multi-storey building, as parts added to a frame spec: the rigid concrete core (shear-wall tube with the stairs and the
+ * elevator shafts inside), the glass curtain wall hung from the slab edges, the flat roof (screed sloped to the drains and a waterproofing
+ * membrane) and the mechanical floor under it (elevator machines, the water tank, chillers). Every number is an option with a real default; see the
+ * design T10-estrutura-real.md §9.
+ */
+/** The frame the systems are added to, in metres: what `buildFrame` was given. */
+interface TowerGeometry {
+    floors: number;
+    /** Clear height of a storey (`buildFrame` `height`). */
+    height: number;
+    /** Slab thickness. */
+    slab: number;
+    spanX: number;
+    spanZ: number;
+    columnSize: number;
+    /** Columns along x and z (`buildFrame` `columnsX`, `columnsZ`; default 3 and 4, as `TOWER_DEFAULTS`). */
+    columnsX?: number;
+    columnsZ?: number;
+    /** Depth of the beams (`buildFrame` `beamHeight`; default 0.6 m, as `TOWER_DEFAULTS`). */
+    beamHeight?: number;
+    /** The top slab is a roof (`roof` id) instead of `slab_<floors-1>`. */
+    roof: boolean;
+}
+interface CoreOptions {
+    /** Centre of the core in plan, object-local `[x, z]` (default `[0, 0]`). */
+    center?: [number, number];
+    /** Thickness of the outer walls of the tube (default 0.35 m: 30 to 60 cm in high-rise cores; at least h/25, NBR 6118 18.5 / EN 1992-1-1 9.6). */
+    wallThickness?: number;
+    /** Thickness of the walls inside it, between the stair and the shafts and between shafts (default 0.2 m). */
+    innerThickness?: number;
+    /** Elevator shafts (default 2), each `shaft` wide along z and `shaftDepth` deep along x. */
+    elevators?: number;
+    shaft?: number;
+    shaftDepth?: number;
+    /** Stair compartment: width along x (two flights of 1.2 m side by side) and length along z (default 2.6 x 4.8 m, NBR 9077). */
+    stairWidth?: number;
+    stairLength?: number;
+    /** Concrete of the walls (default `concrete`). */
+    material?: string;
+    /** Rebar cage of the walls: bars of `diameter` every `spacing` (default 12.5 mm every 0.15 m: about 0.5% of the section, above the 0.2% of EN 1992-1-1 9.6.2). */
+    rebar?: {
+        spacing?: number;
+        diameter?: number;
+    };
+    /** Thickness of the mat foundation under the core when the frame has no raft (default 1.2 m). */
+    matThickness?: number;
+}
+declare const CORE_DEFAULTS: {
+    readonly wallThickness: 0.35;
+    readonly innerThickness: 0.2;
+    readonly elevators: 2;
+    readonly shaft: 2.2;
+    readonly shaftDepth: 2.4;
+    readonly stairWidth: 2.6;
+    readonly stairLength: 4.8;
+    readonly material: "concrete";
+    readonly rebar: {
+        readonly spacing: 0.15;
+        readonly diameter: 0.0125;
+    };
+    readonly matThickness: 1.2;
+};
+/** Outer size of the core in plan, `[x, z]`, from its options: the stair compartment beside the row of shafts. */
+declare const coreSize: (o?: CoreOptions) => [number, number];
+/**
+ * Adds the concrete core: four shear walls per storey forming a tube, the wall between the stair and the shafts and the walls between shafts, each
+ * resting on the one below (continuous from the foundation to the roof) with its rebar cage, the slab of each storey resting on the tube, two
+ * flights and a landing of stairs per storey inside, and an elevator car parked at the bottom of each shaft. Part ids: `core_<f>_<n|s|e|w|stair|shaft_k>`,
+ * `stair_<f>_a|b`, `landing_<f>`, `elevator_<k>`, `core_mat`.
+ */
+declare function addCore(spec: DestructibleSpec, g: TowerGeometry, options?: CoreOptions): DestructibleSpec;
+interface CurtainWallOptions {
+    /** Width of a panel (default 1.5 m). */
+    panel?: number;
+    /** Glass of the panels (default `glass`: annealed or laminated glass that breaks in large shards; `tempered_glass` breaks in small cubes). */
+    material?: string;
+    /** Glass thickness in metres: the two panes of an insulated unit (default 0.012, 6 + 6 mm). */
+    thickness?: number;
+    /** Mass of the aluminium frame per m² of facade (default 10 kg/m²). */
+    frameKgM2?: number;
+    /** Size of the pieces a broken panel falls in (default 0.6 m: a laminated pane breaks in large shards held by the interlayer). */
+    shard?: number;
+    /** Gap from the slab edge to the glass (default 0.1 m). */
+    offset?: number;
+    /** Storeys without glass (the mechanical floor has louvres): default none. */
+    skip?: (floor: number) => boolean;
+}
+declare const CURTAIN_DEFAULTS: {
+    readonly panel: 1.5;
+    readonly material: "glass";
+    readonly thickness: 0.012;
+    readonly frameKgM2: 10;
+    readonly shard: 0.6;
+    readonly offset: 0.1;
+};
+/**
+ * Adds a glass curtain wall around the frame: one panel per bay and storey, floor to floor, hung from the edge of the slab above it (`bolt`, carries
+ * nothing: role none). In a blast the panels shatter into `shard`-sized pieces (`units`) that fall from the facade; a panel whose slab falls goes
+ * with it. Part ids: `glass_<f>_<side>_<k>` with side `n`, `s`, `e`, `w`.
+ */
+declare function addCurtainWall(spec: DestructibleSpec, g: TowerGeometry, options?: CurtainWallOptions): DestructibleSpec;
+interface PunchedFacadeOptions {
+    /** Material of the infill wall (default `brick`: a masonry or block wall between the columns, as the residential towers are built). */
+    material?: string;
+    /** Thickness of the wall in metres (default 0.2). */
+    thickness?: number;
+    /** Width of the window as a share of the clear bay (default 0.6). */
+    window?: number;
+    /** Sill and head of the window above the floor of the storey (default 0.9 and 2.4 m; the head is kept under the beam). */
+    sill?: number;
+    head?: number;
+    /** Glass of the window and its thickness (default `glass`, 12 mm: an insulated unit). */
+    glass?: string;
+    glassThickness?: number;
+    /** Storeys without infill (louvres on a mechanical floor): default none. */
+    skip?: (floor: number) => boolean;
+}
+declare const PUNCHED_DEFAULTS: {
+    readonly material: "brick";
+    readonly thickness: 0.2;
+    readonly window: 0.6;
+    readonly sill: 0.9;
+    readonly head: 2.4;
+    readonly glass: "glass";
+    readonly glassThickness: 0.012;
+};
+/**
+ * Closes the perimeter bays of every storey with an infill wall that has a window in it (the alternative to the curtain wall): a sill wall under the
+ * window, a wall over it and a pier at each side, all resting on the columns of the bay (role partition: they load the columns and carry nothing, as the
+ * walls of `buildFrame`), and the glass in the opening, which rests on the sill and carries nothing. Part ids: `infill_<f>_<side>_<k>_sill|head|pl|pr`,
+ * `glass_<f>_<side>_<k>` with side `n`, `s`, `e`, `w` (the same ids as the curtain wall, so the two exclude each other).
+ */
+declare function addPunchedFacade(spec: DestructibleSpec, g: TowerGeometry, options?: PunchedFacadeOptions): DestructibleSpec;
+interface FlatRoofOptions {
+    /** Slope of the screed to the drains (default 0.01: 1%, the minimum of NBR 9575 for flat roofs). */
+    slope?: number;
+    /** Screed thickness at the drains (default 0.02 m). */
+    screedMin?: number;
+    /** Density of the screed (default 2000 kg/m³, cement and sand). */
+    screedDensity?: number;
+    /** Membrane material and thickness (default `rubber` 1.5 mm: an EPDM sheet). */
+    membrane?: string;
+    membraneThickness?: number;
+    /** Drains (default one per 150 m² of roof, at least 2, on the long centre line). */
+    drains?: number;
+    /** Water standing on the membrane in metres (default 0.005: 5 mm of a storm on its way to the drains); set it in game with `setLiters`. */
+    water?: number;
+}
+declare const FLAT_ROOF_DEFAULTS: {
+    readonly slope: 0.01;
+    readonly screedMin: 0.02;
+    readonly screedDensity: 2000;
+    readonly membrane: "rubber";
+    readonly membraneThickness: 0.0015;
+    readonly water: 0.005;
+    readonly areaPerDrain: 150;
+};
+/**
+ * Turns the top slab into a flat roof: a screed sloped to the drains (its weight from the mean thickness `screedMin + slope * run / 2`), the
+ * waterproofing membrane over it with the rain water on it (`contains` water, running down through a puncture: `outflow` [0, -1, 0], so a shot through
+ * the membrane is a `leak` into the floor below) and the drains (tag `drain`). Screed and membrane load the roof slab (role partition: carried,
+ * carry nothing). Part ids: `roof_screed`, `roof_membrane`, `roof_drain_<k>`.
+ */
+declare function addFlatRoof(spec: DestructibleSpec, g: TowerGeometry, options?: FlatRoofOptions): DestructibleSpec;
+interface MechanicalFloorOptions {
+    /** Elevator machines: one per elevator, over its shaft (default from the core; 2). */
+    elevators?: number;
+    /** Where the shafts are, object-local `[x, z]` of each (default from the core layout). */
+    shafts?: Array<[number, number]>;
+    /** Mass of a traction machine with its frame (default 2500 kg) and of what hangs from it: car, counterweight, rated load (default 1500 + 2000 + 1000 kg). */
+    machineMass?: number;
+    suspendedMass?: number;
+    /** Water tank in litres (default: `occupants` per storey x 200 L a day x 40% stored up high, NBR 5626, plus a fire reserve of 6000 L, NBR 13714). */
+    waterLiters?: number;
+    occupants?: number;
+    fireReserve?: number;
+    /** Chillers on the floor (default 2 of 3500 kg). */
+    chillers?: number;
+    chillerMass?: number;
+    /** Material and wall thickness of the tank (default `plastic` 10 mm: a fibreglass or polyethylene reservoir). */
+    tankMaterial?: string;
+    tankWall?: number;
+    /** Where the tank goes, `[x, z]` (default the middle of the bay at -x, away from the core). */
+    tankAt?: [number, number];
+    /**
+     * Storey the equipment stands on (default the top one, under the roof). On any other storey the part ids end in `_<floor>` (`water_tank_20`,
+     * `chiller_0_20`), so a tower can carry a mechanical floor every few storeys (design T10 §11).
+     */
+    floor?: number;
+}
+declare const MECHANICAL_DEFAULTS: {
+    readonly tankMaterial: "plastic";
+    readonly tankWall: 0.01;
+    readonly machineMass: 2500;
+    readonly suspendedMass: 4500;
+    readonly occupants: 16;
+    readonly litersPerPerson: 200;
+    readonly storedFraction: 0.4;
+    readonly fireReserve: 6000;
+    readonly chillers: 2;
+    readonly chillerMass: 3500;
+};
+/** Litres of the water tank of a building of `storeys` occupied storeys (NBR 5626 consumption, the fire reserve of NBR 13714). */
+declare const towerWater: (storeys: number, o?: Pick<MechanicalFloorOptions, "occupants" | "fireReserve">) => number;
+/**
+ * Makes the top storey the mechanical floor: the elevator machines over the shafts, the water tank (with its water: `contains`, a shot makes it leak)
+ * and the chillers, on the slab under the roof (role partition: their weight goes into the structure). Part ids: `machine_<k>`, `water_tank`,
+ * `chiller_<k>`.
+ */
+declare function addMechanicalFloor(spec: DestructibleSpec, g: TowerGeometry, options?: MechanicalFloorOptions): DestructibleSpec;
+interface DamperOptions {
+    /** Mass of the damper in kg (default: `ratio` of the modal mass of the building, estimated as `modalShare` of its mass). */
+    mass?: number;
+    /** Mass ratio, damper over the modal mass of the building (default 0.01: 0.5 to 2% is the usual range). */
+    ratio?: number;
+    /** Share of the building's mass that is its modal mass in the first mode, tip at 1 (default 0.25, a uniform cantilever). */
+    modalShare?: number;
+    /** Frequency in Hz and damping ratio of the damper (default: tuned by the world to the building, `wind.tuning`). */
+    frequency?: number;
+    damping?: number;
+    /** Where it stands on the mechanical floor, object-local `[x, z]` (default on the beam end beside the column nearest to 35% of the depth at +z, clear of the machines: its weight goes straight to the beam and the column). */
+    at?: [number, number];
+    /** Material of the mass (default `steel`; the real ones are steel or lead-filled blocks and concrete). */
+    material?: string;
+    /** Tallest the block may be, metres (default 2.5: it stands inside the mechanical floor). */
+    maxHeight?: number;
+}
+declare const DAMPER_DEFAULTS: {
+    readonly ratio: 0.01;
+    readonly modalShare: 0.25;
+    readonly material: "steel";
+    readonly maxHeight: 2.5;
+};
+/** Mass in kg of a damper for a structure: `ratio` of `modalShare` of the mass of everything above the foundations (curtain wall, roof and equipment included). */
+declare const damperMass: (spec: DestructibleSpec, o?: Pick<DamperOptions, "ratio" | "modalShare">) => number;
+/**
+ * Adds a tuned mass damper to the mechanical floor: a block of `material` on the slab under the roof (role partition: its mass loads the slab and
+ * goes down to the core and the columns like the machines), with `PartSpec.damper` so the world tunes it to the building and moves it against the
+ * sway (Den Hartog). Part id: `damper`.
+ */
+declare function addTunedMassDamper(spec: DestructibleSpec, g: TowerGeometry, options?: DamperOptions): DestructibleSpec;
+interface TowerMechanicalOptions {
+    /**
+     * Another mechanical floor every this many storeys (design T10 §11): storeys `every`, `2 * every`... below the top one, each with its own
+     * relay water tank for the storeys it serves and its chillers, and without glass. Default none: only the top storey.
+     */
+    every?: number;
+}
+/** Indices of the intermediate mechanical storeys of a tower of `floors` storeys with one every `every` (none below `every / 2` storeys of the top one). */
+declare const mechanicalStoreys: (floors: number, every?: number) => number[];
+interface TowerOptions extends Omit<FrameOptions, 'walls' | 'roof' | 'continuousColumns'> {
+    /** The core (default on); `false` for a frame alone. */
+    core?: CoreOptions | false;
+    /** The curtain wall (default on, without glass on the mechanical floor). */
+    facade?: CurtainWallOptions | false;
+    /** A punched facade (infill walls with windows) instead of the curtain wall: turn the curtain wall off (`facade: false`) when you use it. Default off. */
+    punched?: PunchedFacadeOptions | false;
+    /** The flat roof (default on). */
+    flatRoof?: FlatRoofOptions | false;
+    /** The mechanical floor under the roof (default on). */
+    mechanical?: (MechanicalFloorOptions & TowerMechanicalOptions) | false;
+    /** A tuned mass damper on the mechanical floor (default off: `{}` adds one of 1% of the modal mass). */
+    damper?: DamperOptions | false;
+    /**
+     * The wind the tower is made for (default none: the tower is sized for its weight only). Its `speed`, `terrain`, `class`... size the walls, columns
+     * and core bars for the wind (`sizeStructure({ wind })`), and the fields of `WindExposure` (terrain, class, topography, statistical, drag, damping)
+     * go into `DestructibleSpec.wind`, where the building stands. The world still needs its own `wind` for the wind to blow.
+     */
+    wind?: WindOptions | false;
+    /** Size the structure (`sizeStructure`, default `{}`); `false` keeps the material capacities. */
+    sizing?: SizeStructureOptions | false;
+}
+/** The fields of the wind options that describe the place and the shape of one building (`DestructibleSpec.wind`). */
+declare const windExposureOf: (w: WindOptions) => WindExposure;
+/** Defaults of the frame of a tower: 16 x 24 m on a 8 m grid, 12 storeys of 3 m, 60 cm columns caged with 20 mm bars, 60 cm beams, continuous columns. */
+declare const TOWER_DEFAULTS: {
+    readonly spanX: 16;
+    readonly spanZ: 24;
+    readonly columnsX: 3;
+    readonly columnsZ: 4;
+    readonly floors: 12;
+    readonly height: 3;
+    readonly columnSize: 0.6;
+    readonly beamHeight: 0.6;
+    readonly slabThickness: 0.2;
+    readonly columnCage: {
+        readonly material: "steel";
+        readonly spacing: 0.15;
+        readonly diameter: 0.02;
+    };
+};
+/**
+ * A multi-storey building with real structure: a frame with continuous columns, the concrete core in the bay at +x of the centre, the curtain wall,
+ * the flat roof and the mechanical floor, sized as a designer would. Every system can be turned off or configured.
+ */
+declare function buildTower(options?: TowerOptions): DestructibleSpec;
+
+/**
+ * The skyscraper as a recipe: a few numbers (storeys, bay, core ratio, facade, mechanical floors, damper, wind, soil and piles) that `skyscraperLayout`
+ * turns into the sizes of a `buildTower` and `buildSkyscraper` turns into a destructible spec on deep piles. The typologies that use it
+ * (`game-floorplan-commercial` office tower, `game-floorplan-residential` residential tower) bring their own defaults and the rooms of the plan; the
+ * structure is the same one. Design T10-estrutura-real.md §11.
+ */
+/** Deep foundation of a tower: bored piles under the raft, taken down to firm ground (`pileLength`) by the load each one carries. */
+interface PileDesign {
+    /** Diameter in metres (default 1.2: the bored piles of high-rise foundations are 0.8 to 2.0 m). */
+    diameter?: number;
+    /** Grid pitch as a multiple of the diameter (default 3.5; the usual minimum is 2.5 to 3). */
+    pitch?: number;
+    method?: PileSpec['method'];
+    /** Longest pile in metres (default 60); when the load does not fit, the piles are put closer. */
+    maxLength?: number;
+    /** Fixed length and count (default: from the load and the soil). */
+    length?: number;
+    count?: number;
+}
+declare const PILE_DEFAULTS: {
+    readonly diameter: 1.2;
+    readonly pitch: 3.5;
+    readonly method: "bored";
+    readonly maxLength: 60;
+};
+/**
+ * Most storeys a skyscraper has by default (owner decision 2026-10-25): above about 60 the drift at the top passes H/500, because the engine has no outrigger
+ * or perimeter tube. A default, not a physical constant: `SkyscraperOptions.range` (or a preset with another `range`) raises it.
+ */
+declare const SKYSCRAPER_MAX_STOREYS = 60;
+/** Numbers that describe one typology of skyscraper. Every one is an option of `skyscraperLayout`. */
+interface SkyscraperPreset {
+    /** Storeys: the default and the range the typology accepts (the top storey is the mechanical floor). */
+    storeys: number;
+    range: readonly [number, number];
+    /** Clear height of a storey in metres (the storey pitch is this plus the slab). */
+    height: number;
+    /** Column spacing in metres along x and z. */
+    bay: readonly [number, number];
+    /** Bays along x and z (z always odd: the core stands in the middle bay, between two rows of beams). */
+    bays: readonly [number, number];
+    /** Tallest the tower may be over its narrowest side (default 9: Taipei 101 is 8.3, the Burj Khalifa 8); the bays are widened to keep it. `false` leaves them as given. */
+    slenderness: number | false;
+    /** Target share of the floor plate taken by the concrete core (tube footprint over plate); the number of elevators follows, as far as the bay allows. */
+    coreRatio: number;
+    facade: 'curtain' | 'punched';
+    /** Another mechanical floor every this many storeys; `false` none (only the top one). */
+    mechanicalEvery: number | false;
+    /** Total height in metres from which a tuned mass damper is added on the top mechanical floor; `false` never. */
+    damperAbove: number | false;
+    /** The wind the tower is designed for (`buildTower({ wind })`). */
+    wind: WindOptions | false;
+    /** The ground: a soil class id or a profile of layers; `false` leaves the tower on anchored ground. */
+    soil: string | SoilProfile | false;
+    /** Deep piles under the raft (only with `soil`); `false` leaves a shallow raft. */
+    piles: PileDesign | false;
+    /**
+     * Sizes the lateral system by height (default on): a tower taller than `above` metres whose design drift at the requested storeys is over the limit of
+     * the wind (`driftLimit`, default H/500: NBR 6118 serviceability) gets wider bays, and with them a larger plate and core, in steps of 0.5 m up to `maxBay`
+     * until it passes. `false` keeps the layout as given (and then a 60-storey tower is `drift`).
+     */
+    sizeForWind?: boolean | {
+        above?: number;
+        maxBay?: number;
+    };
+    /** Dead load per m² of floor besides the slab itself, kg/m² (facade, partitions, finishes, equipment), used to size the columns. */
+    superimposed: number;
+}
+/** Defaults of a generic skyscraper: a 40-storey tower on 12 m bays with a curtain wall, a plant floor every 20 storeys, a damper above 150 m, in a city wind, on piles to the sand under soft clay. */
+declare const SKYSCRAPER_DEFAULTS: SkyscraperPreset;
+interface SkyscraperOptions extends Partial<Omit<SkyscraperPreset, 'bay' | 'bays'>> {
+    bay?: number | readonly [number, number];
+    bays?: readonly [number, number];
+    /** Sizes derived from the load and the height unless given: columns, beam depth and slab thickness in metres. */
+    columnSize?: number;
+    beamHeight?: number;
+    slabThickness?: number;
+    /** The core (`false`: a frame alone); `wallThickness` and `elevators` are derived unless given. */
+    core?: CoreOptions | false;
+    curtain?: CurtainWallOptions;
+    punchedFacade?: PunchedFacadeOptions;
+    flatRoof?: FlatRoofOptions | false;
+    mechanical?: (MechanicalFloorOptions & TowerMechanicalOptions) | false;
+    damper?: DamperOptions;
+    sizing?: SizeStructureOptions | false;
+}
+interface SkyscraperLayout {
+    storeys: number;
+    /** Clear height, slab and storey pitch in metres. */
+    height: number;
+    slab: number;
+    pitch: number;
+    /** Height from the ground to the roof. */
+    total: number;
+    bay: [number, number];
+    /** Distance between the outer column axes. */
+    span: [number, number];
+    columnsX: number;
+    columnsZ: number;
+    columnSize: number;
+    beamHeight: number;
+    /** Size of the floor slab, `[x, z]`, centred on the origin of the spec. */
+    plate: [number, number];
+    core: {
+        center: [number, number];
+        size: [number, number];
+        wallThickness: number;
+        elevators: number;
+        stairWidth: number;
+        shaftDepth: number;
+    } | null;
+    /** Footprint of the core over the plate. */
+    coreRatio: number;
+    facade: 'curtain' | 'punched';
+    /** Storeys with plant (the intermediate ones and the top one), ascending. */
+    mechanical: number[];
+    damper: boolean;
+    /** The options `buildTower` is called with. */
+    tower: TowerOptions;
+}
+/**
+ * Resolves the numbers of a skyscraper from a preset and the options. Without `sizeForWind: false`, a tall tower that would drift past H/500 gets wider
+ * bays (so a larger plate and core) until it does not: the way real towers thicken the core and widen the footprint with height. Memoised, because it
+ * builds the tower to measure it.
+ */
+declare function skyscraperLayout(options?: SkyscraperOptions, preset?: SkyscraperPreset): SkyscraperLayout;
+/**
+ * Piles under the raft, by the load: a grid of `pitch` diameters over the raft, each as long as it needs to carry its share of the tower with the
+ * NBR 6122 safety (`pileLength`); when that is longer than `maxLength` the grid is closed up and tried again, down to a pitch of 2.5 diameters.
+ */
+declare function pilesFor(spec: DestructibleSpec, soil: string | SoilProfile, design?: PileDesign): PileSpec;
+/** The tower of a layout: `buildTower` on a raft, then the soil and, with it, the deep piles sized by the load. */
+declare function buildSkyscraper(options?: SkyscraperOptions, preset?: SkyscraperPreset): DestructibleSpec;
+
+/**
+ * The floor plan of a skyscraper at room level, shared by every typology: a central core (stairs, elevator shafts and a service shaft) inside a ring of
+ * corridors, with the four strips of the perimeter left for the typology (office suites, apartments) to fill. The plate and the core come from the
+ * same `SkyscraperLayout` as the structure (`buildSkyscraper`), so a room of the plan stands where the structure has its slab and its core. The plan is in
+ * the space of `game-floorplan` (`u` to the right, `v` to the back, from the front-left corner); the structure is centred (`planToSpace`). Design
+ * T10-estrutura-real.md §11.5.
+ */
+/** `[u0, v0, u1, v1]`. */
+type PlateRect = [number, number, number, number];
+interface PlateOptions {
+    /** Width of the corridors around the core (default 1.8 m). */
+    corridor?: number;
+    /** Width of the elevator lobby beside the shafts (default 3 m). */
+    lobby?: number;
+    /** Narrowest the stair room is made (default 3.4 m): the stairs need more than the tube's clear width. */
+    stairWidth?: number;
+}
+declare const PLATE_DEFAULTS: {
+    readonly corridor: 1.8;
+    readonly lobby: 3;
+    readonly stairWidth: 3.4;
+};
+type StripId = 'south' | 'north' | 'west' | 'east';
+/** One of the four bands of the perimeter, where the typology puts its rooms. */
+interface PlateStrip {
+    id: StripId;
+    /** Side of the building the outer edge is on, as `game-floorplan` names it. */
+    side: 'front' | 'back' | 'left' | 'right';
+    rect: PlateRect;
+    /** The strip runs along `u` (south and north) or along `v` (west and east). */
+    alongU: boolean;
+    /** Length along the perimeter and depth from the outer wall to the circulation, metres. */
+    length: number;
+    depth: number;
+    /** Id (without the storey suffix) of the circulation room the inner edge touches: `corridor_s`, `corridor_n`, `corridor_w` or `lobby`. */
+    circulation: string;
+}
+interface TowerPlate {
+    w: number;
+    d: number;
+    core: PlateRect;
+    stairs: PlateRect;
+    service: PlateRect | null;
+    shafts: PlateRect[];
+    lobby: PlateRect;
+    corridors: {
+        s: PlateRect;
+        n: PlateRect;
+        w: PlateRect;
+    };
+    strips: PlateStrip[];
+}
+/** The plate of a layout: where the core, its rooms, the circulation and the four strips stand. */
+declare function towerPlate(layout: SkyscraperLayout, options?: PlateOptions): TowerPlate;
+/** A point of the plan (`u`, `v`) in the space of the structure (centred on the plate, `x` right, `z` back). */
+declare const planToSpace: (layout: SkyscraperLayout, [u, v]: [number, number]) => [number, number];
+type StoreyKind = 'ground' | 'typical' | 'mechanical';
+/** What kind each storey is: the first is the ground floor, the mechanical ones are the plant floors of the layout, the rest are typical. */
+declare const storeyKinds: (layout: SkyscraperLayout) => StoreyKind[];
+interface StoreyContext {
+    floor: number;
+    kind: StoreyKind;
+    layout: SkyscraperLayout;
+    plate: TowerPlate;
+    /** Floor to floor, metres: the ceiling of the plan floor. */
+    ceiling: number;
+}
+interface StripFill {
+    rooms: RoomDef[];
+    doors: DoorDef[];
+    windows: WindowDef[];
+}
+/** Fills one strip of a storey with rooms. Room ids must be unique in the whole tower: end them with the storey (`_${floor}`). */
+type StripFiller = (strip: PlateStrip, storey: StoreyContext) => StripFill;
+interface TowerPlanOptions extends PlateOptions {
+    /** The perimeter of the typical storeys. */
+    typical: StripFiller;
+    /** The ground floor (default: the typical filler). */
+    ground?: StripFiller;
+    /** The plant floors (default: one plant room per strip, no windows). */
+    mechanical?: StripFiller;
+}
+/** Cuts a strip into `count` equal parts along its length. */
+declare const splitStrip: (strip: PlateStrip, count: number) => PlateRect[];
+/**
+ * Windows on every outside wall of a room of the plate, `spacing` metres apart (at least one a wall); `y0`, `y1` the sill and head (default 0.3 and the
+ * ceiling less 0.5 m, a glass facade).
+ */
+declare function exteriorWindows(id: string, rect: PlateRect, plate: TowerPlate, ceiling: number, o?: {
+    spacing?: number;
+    width?: number;
+    y0?: number;
+    y1?: number;
+}): WindowDef[];
+/** The door from a room of a strip to the circulation it touches. */
+declare const stripDoor: (id: string, strip: PlateStrip, floor: number, width?: number) => DoorDef;
+/**
+ * The storeys of a tower as `FloorDef`s for `TemplateDef.floorsFn`: each has the core and the circulation, the strips filled by the typology for its
+ * kind of storey (ground, typical, plant), `ceiling` the storey pitch of the structure. The template's size must be the plate (`layout.plate`).
+ */
+declare function towerFloors(layout: SkyscraperLayout, plan: TowerPlanOptions): FloorDef[];
+/** The names of the rooms and storeys the plan helpers make (`elevator_lobby`, `plant_room`, `typical_floor`...), for the packs that fill the strips to register with `engine.registerLocale`. */
+declare const towerLocales: {
+    readonly en: {
+        readonly labels: {
+            elevator_lobby: string;
+            service_shaft: string;
+            plant_room: string;
+            mechanical_floor: string;
+            typical_floor: string;
+        };
+    };
+    readonly 'pt-BR': {
+        readonly labels: {
+            elevator_lobby: string;
+            service_shaft: string;
+            plant_room: string;
+            mechanical_floor: string;
+            typical_floor: string;
+        };
+    };
+};
+
 declare const version = "0.1.0";
 
-export { CONSTRUCTIONS, CONSTRUCTION_SYSTEMS, type ChaletOptions, type Chimney, type Construction, type ConstructionBuild, type ConstructionBuilder, type ConstructionSystem, type ConstructionSystemDef, DENSITY, type DestructibleSpecOptions, type FoundationType, GROUND, type Opening, type PartRole, type PlanContext, ROOF_COVERINGS, type Rect, type Roof, type RoofCoveringDef, type RoofPane, type RoofShape, type ShackOptions, type SourceDoor, type SourceWall, type SourceWindow, type Structure, type StructureExtras, type StructureOptions, type StructurePackOptions, type StructurePart, type StructureSource, type Support, type TankPlanOptions, type TankPlatform, type Tent, type WallDetail, type WallMaterials, type WallSpecimenOptions, type WaterTank, type WoodFrameOptions, buildStructure, buildWallSpecimen, campConstruction, chaletConstruction, constructionOfSystem, logCabinConstruction, masonryConstruction, planWaterTank, register, registerConstruction, registerConstructionSystem, registerRoofCovering, shackConstruction, structureLayer, toDestructibleSpec, version, woodFrameConstruction };
+export { CONSTRUCTIONS, CONSTRUCTION_SYSTEMS, CORE_DEFAULTS, CURTAIN_DEFAULTS, type ChaletOptions, type Chimney, type Construction, type ConstructionBuild, type ConstructionBuilder, type ConstructionSystem, type ConstructionSystemDef, type CoreOptions, type CurtainWallOptions, DAMPER_DEFAULTS, DENSITY, type DamperOptions, type DestructibleSpecOptions, FLAT_ROOF_DEFAULTS, type FlatRoofOptions, type FoundationType, GROUND, MECHANICAL_DEFAULTS, type MechanicalFloorOptions, type Opening, PILE_AREA, PILE_DEFAULTS, PLATE_DEFAULTS, PUNCHED_DEFAULTS, type PartRole, type PileDesign, type PlanContext, type PlateOptions, type PlateRect, type PlateStrip, type PunchedFacadeOptions, RAFT_THICKNESS, REBAR_RATIOS, ROOF_COVERINGS, type Rect, type Roof, type RoofCoveringDef, type RoofPane, type RoofShape, SKYSCRAPER_DEFAULTS, SKYSCRAPER_MAX_STOREYS, SLAB_PANEL_DEFAULTS, type ShackOptions, type SkyscraperLayout, type SkyscraperOptions, type SkyscraperPreset, type SlabPanelOptions, type SourceDoor, type SourceWall, type SourceWindow, type StoreyContext, type StoreyKind, type StripFill, type StripFiller, type StripId, type Structure, type StructureExtras, type StructureOptions, type StructurePackOptions, type StructurePart, type StructureSource, type Support, TOWER_DEFAULTS, type TankPlanOptions, type TankPlatform, type Tent, type TowerGeometry, type TowerMechanicalOptions, type TowerOptions, type TowerPlanOptions, type TowerPlate, type WallDetail, type WallMaterials, type WallSpecimenOptions, type WaterTank, type WoodFrameOptions, addCore, addCurtainWall, addFlatRoof, addMechanicalFloor, addPunchedFacade, addTunedMassDamper, applySlabPanels, beamDepthFor, beamSpan, buildSkyscraper, buildStructure, buildTower, buildWallSpecimen, campConstruction, chaletConstruction, constructionOfSystem, coreSize, damperMass, exteriorWindows, logCabinConstruction, masonryConstruction, mechanicalStoreys, pilesFor, planToSpace, planWaterTank, register, registerConstruction, registerConstructionSystem, registerRoofCovering, resolveSlabPanels, shackConstruction, skyscraperLayout, slabPanelView, slabPanelsOf, splitStrip, storeyKinds, stripDoor, structureLayer, toDestructibleSpec, towerFloors, towerLocales, towerPlate, towerWater, version, windExposureOf, woodFrameConstruction };