@adatechnology/game-floorplan-structure 2.0.1 → 2.1.0

package/README.md

@@ -14,6 +14,24 @@ plan.structure.supports // what each part rests on, down to 'ground'
 
 A free-standing wall: `buildStructure(plan, { roof: false })` leaves the roof out, so a plan with one exterior wall stands as a house wall does (on the strip footing, with the bond beam on it). `wallPiece` of `game-floorplan-three` builds and draws such a wall; every wall of a scene or a game is made that way.
 
+Structural validation: `validateStructure(structure, { doors, wallDetail })` checks a structure as a structural engineer would sign it and returns typed
+violations (`{ code, part, message }`, codes in `STRUCTURAL_VIOLATION`): load paths (`FLOATING_PART`, `PILLAR_NOT_GROUNDED`), reinforced concrete by
+NBR 6118 (`CONCRETE_BELOW_MIN_SECTION`: pillars of 19 cm and 360 cm², beams 12 cm wide and L/10 deep between point supports; `UNREINFORCED_CONCRETE`;
+`BEAM_ON_WEAK_MASONRY`) and, in masonry, confined masonry: `MISSING_GROUND_BEAM`, `WALL_END_WITHOUT_PILLAR`, `CORNER_WITHOUT_PILLAR`,
+`WALL_JUNCTION_WITHOUT_PILLAR`, `WALL_SPAN_WITHOUT_PILLAR` (more than `MAX_PILLAR_SPACING`, 4 m), `PILLAR_DOES_NOT_REACH_BOND_BEAM`, `MISSING_BOND_BEAM`,
+`OPENING_WITHOUT_LINTEL`, `OPENING_WITHOUT_SILL`, `UNBONDED_MASONRY`, `MISSING_PLASTER`. `validateSpec(spec)` checks a spec built straight (towers,
+skyscrapers) for load paths and sections; `countViolations` tallies them. Every typology of the floorplan packages runs through it in its
+`tests/construction.test.ts`:
+
+```ts
+const plan = engine.generate('townhouse', { seed: 7 })
+validateStructure(plan.structure, { doors: plan.doors }) // [] : nothing a structural engineer would refuse
+```
+
+A masonry house stands on reinforced concrete ground beams (`ground_beam_*`, viga baldrame, `GROUND_BEAM_DEPTH` deep, buried, anchored in the spec;
+`groundBeams: false` leaves them out), with concrete pillars from the floor to the bond beam, a lintel over every opening (h = L/10, the wide doors on
+jamb pillars) and a sill beam (`_sillbeam_`, `SILL_BEAM_DEPTH`) under every window.
+
 Tall buildings: `buildTower()` builds a frame with continuous columns, a concrete core with stairs and elevator shafts, a glass curtain wall, a flat
 roof with its membrane and the mechanical floor (`addCore`, `addCurtainWall`, `addFlatRoof`, `addMechanicalFloor` add each one to any frame spec).
 Wind: `buildTower({ wind: { speed, terrain }, damper: true })` sizes the tower for the wind and adds a tuned mass damper (`addTunedMassDamper`, `DAMPER_DEFAULTS`)

package/dist/index.d.ts

@@ -38,8 +38,10 @@ interface StructurePart {
     unit?: true;
     /** Distance between repeated members (joists, ceiling joists). */
     spacing?: number;
-    /** `plate` (timber top plate) or `bond_beam` (masonry bond beam). */
-    beamKind?: 'plate' | 'bond_beam';
+    /** `plate` (timber top plate), `bond_beam` (masonry bond beam) or `ground_beam` (the masonry ground beam, viga baldrame, buried under a ground-floor wall). */
+    beamKind?: 'plate' | 'bond_beam' | 'ground_beam';
+    /** An exterior wall (it carries the bond beam and the pillars of confined masonry). */
+    exterior?: true;
     steps?: number;
     door?: string;
     /** Slab that is the roof (flat roof). */
@@ -329,6 +331,17 @@ interface StructureOptions {
     wallDetail?: WallDetail;
     /** `false`: no roof (a free-standing wall, a garden wall). Default `true`. */
     roof?: boolean;
+    /**
+     * Concrete pillars along the exterior masonry walls besides the corner ones (at the free ends and door jambs, beside the windows, where walls meet and at
+     * most every `spacing` metres, default `WALL_PILLAR_SPACING`). `false`: only the corner pillars. Default `true`.
+     */
+    wallPillars?: boolean | {
+        spacing?: number;
+    };
+    /** A reinforced concrete ground beam (viga baldrame) under each ground-floor wall of a masonry house on strip footings (`GROUND_BEAM_DEPTH` deep). Default `true`. */
+    groundBeams?: boolean;
+    /** The sections the Visor de casas 3D drew below the NBR 6118 minimum (16 cm balcony pillars), for the team's golden only. Default `false`. */
+    visorSections?: boolean;
 }
 /** What a construction builder and the tank get to see: the generated plan, its seed and the template. */
 interface PlanContext {
@@ -348,6 +361,9 @@ interface PlanContext {
  */
 declare function buildStructure(source: StructureSource, options?: StructureOptions): Structure;
 
+/** Depth of the sill beam under a window of a masonry wall, metres (a contraverga is usually 10 cm). */
+declare const SILL_BEAM_DEPTH = 0.1;
+
 interface PartsAndSupports {
     parts: StructurePart[];
     supports: Support[];
@@ -490,6 +506,16 @@ declare const MEMBER_CAGE: {
     diameter: number;
     unit: number;
 };
+/**
+ * What the bare cage of a concrete pillar still carries once its concrete is blown off, as the share of the pillar's `capacity` (kg) the destruction
+ * world keeps for it (`reinforcement.residualCapacity`): its perimeter bars (at most `spacing` apart, at least two a face) by the steel's crushing
+ * strength, halved for buckling between the stirrups. A pillar under a light bond beam keeps standing on its cage; a loaded one still gives way.
+ */
+declare function cageResidualCapacity(size: readonly number[], reinforcement: {
+    material: string;
+    spacing: number;
+    diameter: number;
+}, capacity: number | undefined): 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
@@ -497,38 +523,6 @@ declare const MEMBER_CAGE: {
  */
 declare function toDestructibleSpec(structure: Structure, options?: DestructibleSpecOptions): DestructibleSpec;
 
-interface WallSpecimenOptions {
-    /** Wall assembly of `game-destruction` (`brick_wall_plastered`, `concrete_block_wall`, `reinforced_concrete`, `drywall`, `wood_frame_wall`, `log_wall`, `sheet_metal_shack`...). */
-    assembly: string;
-    /** Width and height in metres (the test area uses 2.4 x 2.1). */
-    w: number;
-    h: number;
-    opening?: 'door' | 'window' | null;
-    /** Default `panels`: piers, lintel with its 0.2 m bearing, sill, plaster and rebar; `units` also lays the bricks, blocks or concrete panels one by one. */
-    detail?: WallDetail;
-}
-/**
- * A test wall as its assembly builds it, standing on a plinth: in `panels` the piers beside the opening, the lintel over it (reinforced concrete bearing 0.2 m on
- * the piers; a header in timber walls), the sill under a window and the wall above; with the plaster coat and the rebar of the assembly. The mass is the
- * assembly's for the whole w x h, whatever the detail.
- */
-declare function buildWallSpecimen(options: WallSpecimenOptions): DestructibleSpec;
-
-type Rng = () => number;
-interface TankPlanOptions {
-    /** Litres by template id or style id (default: budget 500, mid 1000, mansion 3000, any other 2000). */
-    capacities?: Record<string, number>;
-    /** Where the tank goes; default: on the slab of a flat roof, else on a raised platform (the attic one time in eight). */
-    location?: (source: StructureSource, rng: Rng) => WaterTank['place'];
-    /** A template with its own tank (a trestle for the rural water) answers here instead. */
-    custom?: (source: StructureSource, rng: Rng) => WaterTank | null;
-}
-/**
- * The water tank of a house: on the roof slab, in the attic, or on a platform that rises out of the roof, never in the yard. Null for a plan without
- * a lot (an apartment) or a commercial building, and when no room has space.
- */
-declare function planWaterTank(source: StructureSource, rng: Rng, options?: TankPlanOptions): WaterTank | null;
-
 /** What a wall system is made of and how its parts are tied. Timber systems sit on joists, carry the roof on timber plates and have wooden porch posts. */
 interface ConstructionSystemDef {
     /** Wall assembly of `game-destruction` (`registerAssembly`) the detailed wall is built from. Empty: no walls (a tent). */
@@ -567,6 +561,130 @@ declare const CONSTRUCTIONS: Map<string, ConstructionBuilder>;
 /** Registers how a template's building is made: `TemplateDef.construction` names it. A template without one gets the masonry default. */
 declare function registerConstruction(id: string, builder: ConstructionBuilder): void;
 
+/**
+ * Most a masonry wall runs between two of its concrete pillars, metres. Confined masonry (alvenaria confinada / de vedação with a concrete frame) puts a pillar
+ * every 3 to 5 m, at the corners, where walls meet and beside the openings; 4 m is the middle of that range.
+ */
+declare const WALL_PILLAR_SPACING = 4;
+/** Side of a wall pillar, metres: 0.2 x 0.2 m, as the corner pillars (NBR 6118 asks at least 19 cm for a pillar). */
+declare const WALL_PILLAR_SIDE = 0.2;
+/**
+ * Centres of the pillars of a stretch: at each end (inside the stretch, flush with it), at the walls that meet it, and in between so that no span passes
+ * `spacing`. A short pier still gets one at each end (a door jamb beside a corner keeps its own pillar; `addWallPillars` drops the one a pillar already
+ * stands near); one too short for two gets one in its middle, and one too short for a pillar none.
+ */
+declare function pillarStations(from: number, to: number, junctions: readonly number[], spacing: number): number[];
+
+/** Depth of the ground beam (viga baldrame) under a ground-floor masonry wall, metres: the usual 15 x 30 cm, as wide as the wall. */
+declare const GROUND_BEAM_DEPTH = 0.3;
+
+type Rng = () => number;
+/** Side of the concrete pillars of a raised tank slab, metres: NBR 6118 asks at least 19 cm. */
+declare const TANK_PILLAR_SIDE = 0.2;
+interface TankPlanOptions {
+    /** Litres by template id or style id (default: budget 500, mid 1000, mansion 3000, any other 2000). */
+    capacities?: Record<string, number>;
+    /** Where the tank goes; default: on the slab of a flat roof, else on a raised platform (the attic one time in eight). */
+    location?: (source: StructureSource, rng: Rng) => WaterTank['place'];
+    /** A template with its own tank (a trestle for the rural water) answers here instead. */
+    custom?: (source: StructureSource, rng: Rng) => WaterTank | null;
+    /** Side of the platform's concrete pillars (default `TANK_PILLAR_SIDE`; the Visor de casas 3D drew 0.12 m). */
+    pillarSide?: number;
+}
+/**
+ * The water tank of a house: on the roof slab, in the attic, or on a platform that rises out of the roof, never in the yard. Null for a plan without
+ * a lot (an apartment) or a commercial building, and when no room has space.
+ */
+declare function planWaterTank(source: StructureSource, rng: Rng, options?: TankPlanOptions): WaterTank | null;
+
+/** Stable codes of what `validateStructure` and `validateSpec` find wrong in a construction. */
+declare const STRUCTURAL_VIOLATION: {
+    /** A pillar with no load path to the ground, or that starts above what it rests on. */
+    readonly PILLAR_NOT_GROUNDED: "PILLAR_NOT_GROUNDED";
+    /** A pillar of a masonry wall that stops short of the bond beam, or that the bond beam does not rest on. */
+    readonly PILLAR_DOES_NOT_REACH_BOND_BEAM: "PILLAR_DOES_NOT_REACH_BOND_BEAM";
+    /** A masonry wall that runs more than `MAX_PILLAR_SPACING` between two of its pillars. */
+    readonly WALL_SPAN_WITHOUT_PILLAR: "WALL_SPAN_WITHOUT_PILLAR";
+    /** A free end of a masonry wall (a door jamb, the end of a garden wall) with no pillar. */
+    readonly WALL_END_WITHOUT_PILLAR: "WALL_END_WITHOUT_PILLAR";
+    /** Two masonry walls meet at a corner with no pillar there. */
+    readonly CORNER_WITHOUT_PILLAR: "CORNER_WITHOUT_PILLAR";
+    /** Another wall meets a masonry wall inside its length (a T) with no pillar there. */
+    readonly WALL_JUNCTION_WITHOUT_PILLAR: "WALL_JUNCTION_WITHOUT_PILLAR";
+    /** A window or door in a masonry wall with no lintel (verga) over it. */
+    readonly OPENING_WITHOUT_LINTEL: "OPENING_WITHOUT_LINTEL";
+    /** A window in a masonry wall with no sill beam (contraverga) under it. */
+    readonly OPENING_WITHOUT_SILL: "OPENING_WITHOUT_SILL";
+    /** An exterior masonry wall with no bond beam (cinta de amarração) on top. */
+    readonly MISSING_BOND_BEAM: "MISSING_BOND_BEAM";
+    /** A ground-floor masonry wall standing on the soil with no ground beam (viga baldrame) or foundation under it. */
+    readonly MISSING_GROUND_BEAM: "MISSING_GROUND_BEAM";
+    /** A part with no load path down to the ground. */
+    readonly FLOATING_PART: "FLOATING_PART";
+    /** A concrete beam longer than a lintel that rests on masonry alone (no pillar, beam or slab carries it). */
+    readonly BEAM_ON_WEAK_MASONRY: "BEAM_ON_WEAK_MASONRY";
+    /** A concrete pillar or beam below the NBR 6118 minimum section, or a beam between point supports shallower than a tenth of its span. */
+    readonly CONCRETE_BELOW_MIN_SECTION: "CONCRETE_BELOW_MIN_SECTION";
+    /** A concrete pillar or beam with no steel (the construction has no rebar). */
+    readonly UNREINFORCED_CONCRETE: "UNREINFORCED_CONCRETE";
+    /** A brick or block wall laid in stack bond: the vertical joints line up and the wall splits along them. */
+    readonly UNBONDED_MASONRY: "UNBONDED_MASONRY";
+    /** A plastered brick wall without plaster on both faces. */
+    readonly MISSING_PLASTER: "MISSING_PLASTER";
+};
+type StructuralViolationCode = (typeof STRUCTURAL_VIOLATION)[keyof typeof STRUCTURAL_VIOLATION];
+/** One thing a construction gets wrong: the code, the part (or opening) it is about and the rule it breaks, in words. */
+interface StructuralViolation {
+    readonly code: StructuralViolationCode;
+    readonly part: string;
+    readonly message: string;
+}
+/** Most metres a masonry wall runs between two pillars (confined masonry: 3 to 4 m; `WALL_PILLAR_SPACING` is 4). */
+declare const MAX_PILLAR_SPACING = 4;
+/** NBR 6118 13.2.3: no side of a pillar under 19 cm, and at least 360 cm² of section. */
+declare const MIN_PILLAR_SIDE = 0.19;
+declare const MIN_PILLAR_AREA = 0.036;
+/** NBR 6118 13.2.2: a beam at least 12 cm wide. */
+declare const MIN_BEAM_WIDTH = 0.12;
+/** A beam between point supports is at least a tenth of its span deep (pre-sizing of reinforced concrete beams, h = L/10). */
+declare const BEAM_DEPTH_RATIO = 10;
+/** A concrete beam that only masonry carries may be a lintel up to this span; a longer one needs pillars. */
+declare const MAX_LINTEL_ON_MASONRY = 3;
+
+interface ValidateStructureOptions {
+    /** Detail the walls are built in for play (default `panels`, as the houses are): the lintels and sill beams of the windows come from it. */
+    wallDetail?: WallDetail;
+    /** The doors of the plan (`plan.doors`): each door gap in a masonry wall needs a lintel. Without them only the windows are checked. */
+    doors?: readonly SourceDoor[];
+}
+/**
+ * What a structure gets wrong as a real building: load paths (every part down to the ground, every pillar on what carries it), reinforced concrete (NBR
+ * 6118 sections, steel, beam depth) and, in masonry, confined masonry (ground beam, pillars at ends, corners, junctions and every 4 m up to the bond beam,
+ * lintels and sill beams, bonded and plastered bricks). An empty list is a structure that a structural engineer would sign.
+ */
+declare function validateStructure(structure: Structure, options?: ValidateStructureOptions): StructuralViolation[];
+/** What a destructible spec built straight as one (towers, skyscrapers) gets wrong: load paths and concrete sections. */
+declare function validateSpec(spec: DestructibleSpec): StructuralViolation[];
+/** The violations counted by code (for reports and tests). */
+declare function countViolations(violations: readonly StructuralViolation[]): Partial<Record<keyof typeof STRUCTURAL_VIOLATION, number>>;
+
+interface WallSpecimenOptions {
+    /** Wall assembly of `game-destruction` (`brick_wall_plastered`, `concrete_block_wall`, `reinforced_concrete`, `drywall`, `wood_frame_wall`, `log_wall`, `sheet_metal_shack`...). */
+    assembly: string;
+    /** Width and height in metres (the test area uses 2.4 x 2.1). */
+    w: number;
+    h: number;
+    opening?: 'door' | 'window' | null;
+    /** Default `panels`: piers, lintel with its 0.2 m bearing, sill, plaster and rebar; `units` also lays the bricks, blocks or concrete panels one by one. */
+    detail?: WallDetail;
+}
+/**
+ * A test wall as its assembly builds it, standing on a plinth: in `panels` the piers beside the opening, the lintel over it (reinforced concrete bearing 0.2 m on
+ * the piers; a header in timber walls), the sill under a window and the wall above; with the plaster coat and the rebar of the assembly. The mass is the
+ * assembly's for the whole w x h, whatever the detail.
+ */
+declare function buildWallSpecimen(options: WallSpecimenOptions): DestructibleSpec;
+
 /** Masonry house of the engine's own templates: brick with plaster, concrete frame, tiles by facade; a unit in a building gets a flat slab roof. */
 declare function masonryConstruction(source: StructureSource): Construction;
 interface WoodFrameOptions {
@@ -1410,4 +1528,4 @@ interface Utilities {
 
 declare const version = "0.1.0";
 
-export { CONSTRUCTIONS, CONSTRUCTION_SYSTEMS, CORE_DEFAULTS, CURTAIN_DEFAULTS, type ChaletOptions, type Chimney, type Circuit, type Conduit, type Construction, type ConstructionBuild, type ConstructionBuilder, type ConstructionSystem, type ConstructionSystemDef, type CoreOptions, type CurtainWallOptions, DAMPER_DEFAULTS, DENSITY, type DamperOptions, type DestructibleSpecOptions, type ElectricMeter, type Electrical, type ElectricalPanel, type EnergyConfig, type EnergyMode, FLAT_ROOF_DEFAULTS, type FlatRoofOptions, type FoundationType, GROUND, type Gas, type GasMeter, type Inverter, type LightSwitch, MECHANICAL_DEFAULTS, MEMBER_CAGE, type MechanicalFloorOptions, type Opening, type Outbuilding, type OutbuildingItem, type OutbuildingOpening, type OutbuildingWall, type OutdoorLamp, type Outlet, PILE_AREA, PILE_DEFAULTS, PLATE_DEFAULTS, PUNCHED_DEFAULTS, type PartRole, type PileDesign, type PlanContext, type PlateOptions, type PlateRect, type PlateStrip, type Plumbing, type PlumbingPoint, type PlumbingRun, type Point3, 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 ServiceEntrance, type ShackOptions, type SkyscraperLayout, type SkyscraperOptions, type SkyscraperPreset, type SlabPanelOptions, type Solar, type SolarPanel, 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 Utilities, type WallDetail, type WallFixture, 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 };
+export { BEAM_DEPTH_RATIO, CONSTRUCTIONS, CONSTRUCTION_SYSTEMS, CORE_DEFAULTS, CURTAIN_DEFAULTS, type ChaletOptions, type Chimney, type Circuit, type Conduit, type Construction, type ConstructionBuild, type ConstructionBuilder, type ConstructionSystem, type ConstructionSystemDef, type CoreOptions, type CurtainWallOptions, DAMPER_DEFAULTS, DENSITY, type DamperOptions, type DestructibleSpecOptions, type ElectricMeter, type Electrical, type ElectricalPanel, type EnergyConfig, type EnergyMode, FLAT_ROOF_DEFAULTS, type FlatRoofOptions, type FoundationType, GROUND, GROUND_BEAM_DEPTH, type Gas, type GasMeter, type Inverter, type LightSwitch, MAX_LINTEL_ON_MASONRY, MAX_PILLAR_SPACING, MECHANICAL_DEFAULTS, MEMBER_CAGE, MIN_BEAM_WIDTH, MIN_PILLAR_AREA, MIN_PILLAR_SIDE, type MechanicalFloorOptions, type Opening, type Outbuilding, type OutbuildingItem, type OutbuildingOpening, type OutbuildingWall, type OutdoorLamp, type Outlet, PILE_AREA, PILE_DEFAULTS, PLATE_DEFAULTS, PUNCHED_DEFAULTS, type PartRole, type PileDesign, type PlanContext, type PlateOptions, type PlateRect, type PlateStrip, type Plumbing, type PlumbingPoint, type PlumbingRun, type Point3, type PunchedFacadeOptions, RAFT_THICKNESS, REBAR_RATIOS, ROOF_COVERINGS, type Rect, type Roof, type RoofCoveringDef, type RoofPane, type RoofShape, SILL_BEAM_DEPTH, SKYSCRAPER_DEFAULTS, SKYSCRAPER_MAX_STOREYS, SLAB_PANEL_DEFAULTS, STRUCTURAL_VIOLATION, type ServiceEntrance, type ShackOptions, type SkyscraperLayout, type SkyscraperOptions, type SkyscraperPreset, type SlabPanelOptions, type Solar, type SolarPanel, type SourceDoor, type SourceWall, type SourceWindow, type StoreyContext, type StoreyKind, type StripFill, type StripFiller, type StripId, type StructuralViolation, type StructuralViolationCode, type Structure, type StructureExtras, type StructureOptions, type StructurePackOptions, type StructurePart, type StructureSource, type Support, TANK_PILLAR_SIDE, TOWER_DEFAULTS, type TankPlanOptions, type TankPlatform, type Tent, type TowerGeometry, type TowerMechanicalOptions, type TowerOptions, type TowerPlanOptions, type TowerPlate, type Utilities, type ValidateStructureOptions, WALL_PILLAR_SIDE, WALL_PILLAR_SPACING, type WallDetail, type WallFixture, type WallMaterials, type WallSpecimenOptions, type WaterTank, type WoodFrameOptions, addCore, addCurtainWall, addFlatRoof, addMechanicalFloor, addPunchedFacade, addTunedMassDamper, applySlabPanels, beamDepthFor, beamSpan, buildSkyscraper, buildStructure, buildTower, buildWallSpecimen, cageResidualCapacity, campConstruction, chaletConstruction, constructionOfSystem, coreSize, countViolations, damperMass, exteriorWindows, logCabinConstruction, masonryConstruction, mechanicalStoreys, pilesFor, pillarStations, planToSpace, planWaterTank, register, registerConstruction, registerConstructionSystem, registerRoofCovering, resolveSlabPanels, shackConstruction, skyscraperLayout, slabPanelView, slabPanelsOf, splitStrip, storeyKinds, stripDoor, structureLayer, toDestructibleSpec, towerFloors, towerLocales, towerPlate, towerWater, validateSpec, validateStructure, version, windExposureOf, woodFrameConstruction };