@adatechnology/game-floorplan 0.1.0 → 0.2.0

package/MIGRATION.md

@@ -331,6 +331,38 @@ The palette recipes per style are data supplied by the packs (`registerPaletteSt
 - Everything the old SDK held in Portuguese (names, labels, reasons, messages) is now a key plus a locale entry (`en`, `pt-BR`). Register more with `engine.registerLocale('xx', table)`.
 - Randomness is drawn from the same named streams as before so seeds reproduce. Those stream names are the only Portuguese left in the code, in each pack's `legacy-seeds.ts` (for example `'fachada'`, `'lote'`, `'c:sala'`, `'estado:protegida'`). Do not translate them: changing a stream name changes every plan generated from an existing seed.
 
+## Rules from the Visor de casas 3D (spec 001, T2.2b)
+
+The team page (PlantasSDK of the Visor de casas 3D, VC3) kept changing the generator after this port was made (86 regions, rules R01-R72). The engine now follows it; with the id
+tables of the four MIGRATION files, the 12 residential and commercial templates give the same rooms, walls, openings, items, state items and lot as the page
+(900 plans recorded in `game-floorplan-post-apocalyptic/tests/fixtures/team-golden/vc3-plans.json`, plus 4500 more checked once). **The old VP-equality claim above no longer holds**:
+plans differ from the earlier port on purpose. The five rural templates are still to come (T2.2f).
+
+| VC3 | Engine | Effect |
+|---|---|---|
+| `RAIO_JOG` 0.24 | option `playerRadius` (default 0.24, `engine.constants.PLAYER_RADIUS`) | walkability grid has 10 cm cells indoors and drops cells closer than the radius to a wall body; furniture may not close the way for that disc (relaxed pass: 0.12) |
+| `PORTA_FOLGA`, `folga` | `DoorDef.clearance`, `TemplateDef.clearance.door` (default 0.12) | door never closer to a corner or junction than this |
+| `JAN_FOLGA` 0.3, R10 | `TemplateDef.clearance.window`; windows are spread over the wall stretch they fall in (one centred, several with equal gaps, never near a corner, junction or door; bathroom windows small and high) | window positions differ from the earlier port |
+| R43 `SEM_JANELA` | `WINDOWLESS_ROOM_TYPES`: any other room with an exterior wall gets a window in its longest free stretch | |
+| `bloqueiaJanela`, `hjan`, `aereo`, `H_AEREO` 2.15 | `blocksWindow(item, window, overheadOff?)`, `FurnitureDef.windowHeight`, `FurnitureDef.overhead` | a wall cabinet and a shower enclosure block a window; a second pass drops the cabinet (`item.overhead = false`) |
+| R30 `FOLGA_CARRO`, `candidatosCarro` | `parking.ts` (`carCandidates`), option `carClearance` (driver 0.8, side 0.6, end 0.6); the item gets `driver` and `carClearance` | the driver door of a parked car opens |
+| `partesUteis` | `usableParts` | inset only where there is a real wall |
+| `corposParedes` | the grid reads the wall bodies | |
+| R07 | `paths.ts`: every ground-floor exterior door gets a paved path to the pedestrian gate or the nearest path (`path_<door id>`, `entrance_path` for the template's `doorTarget`); a building at the street line has `from: null` | |
+| R23 | the yard water tank slot has `chance: 0` (the tank sits on the slab, T2.2e) | |
+| R20 | `mailbox` item on the front wall beside the pedestrian gate | |
+| R64 | `table_lamp` on a nightstand, dresser or console table (stream `abajur:<room legacy key>`) | |
+| R66 | `single_storey_a`: the bathroom opens from the living room, washbasin on the back wall | |
+| state | fortified: at least one window boarded, the barricade must cover the door zone, a mattress search on a fixed grid in tight houses; abandoned: clothes and stains retry until 2 | |
+| hooks for the rural pack | `TemplateDef.noWalls`, `cumulativeCeilings`, `reservations`, `paths`, `place`; `DoorDef.edge`, `model`, `type`, `steps`; `LotConfig.extraZones`; `StyleDef.fenceHeight`; slot `floorFree`; `FurnitureDef.exactOnly` | |
+
+New vocabulary (VC3 names to SDK): door `tipo` is `type` (`porta` is `door`), `degraus` is `steps`, item `aereo` is `overhead`, `hjan` is `windowHeight`, `so` is `exactOnly`.
+
+New API: `registerResultExtension(name, run, { after?, seedKey? })` (output in `result[name]`, runs after the state and before the zoning report, `rng = createRng(seed, seedKey ?? name)`, so a pack can
+reproduce a team stream and the structure pack puts `result.structure` in the plan), `registerFindsProvider(provider)` and `findsFor(query)` (stub for phase 3: `FindsQuery { place, container, state, rng, day?, region?, footprint?, key? }`,
+`FindStack { itemId, count, data? }`), `registerViewerLayer(layer)` (a pack adds a checkbox and a drawing to the 2D viewer; `engine.viewerLayers`). Furniture extension fields live on `FurnitureDef` (the former `ItemDef` of this package,
+renamed so it does not collide with the item catalogue's `ItemDef`).
+
 ## Zoning (new)
 
 Urban zoning is a generic layer in the engine; the zones themselves are content (see the residential and commercial `regions/br`).

package/dist/index.d.ts

@@ -5,60 +5,6 @@ declare function hashString(input: string | number): number;
 /** Independent stream for a `(seed, key)` pair. */
 declare const createRng: (seed: string | number, key: string) => Rng;
 
-/** Tools handed to a style recipe. `jit` and `rng` draw from the style's seeded stream: draw order is part of the contract. */
-interface PaletteDraw {
-    rng: Rng;
-    base: [string, number, number, number];
-    H0: number;
-    H1: number;
-    H2: number;
-    jit(v: number, a: number): number;
-    hsl(h: number, s: number, l: number): Hsl;
-}
-interface PaletteEarly {
-    /** Accent mode: true saturates walls, false puts accents on objects. */
-    wallMode: boolean;
-    /** Maximum wall saturation. */
-    sMax: number;
-    /** Facade, wall, gate, roof, ceiling... in insertion order. */
-    roles: Record<string, Hsl>;
-    /** General floor `[h, s, l]` for room types that do not define their own. */
-    generalFloor: [number, number, number];
-}
-interface PaletteStyleDef {
-    /** Legacy stream suffix; defaults to the style id. */
-    seedKey?: string;
-    /** Facade colour table `[labelKey, h, s, l]`. */
-    facadeColors: [string, number, number, number][];
-    /** Draws up to the room colours (before the room loop). */
-    early(d: PaletteDraw): PaletteEarly;
-    /** Draws the object roles (wood, fabrics, metal, ground colours) after the room loop. */
-    late(d: PaletteDraw, e: PaletteEarly): Record<string, Hsl>;
-}
-interface PaletteContext extends PaletteDraw {
-    style: string;
-    sMax: number;
-    wallMode: boolean;
-    generalFloor: [number, number, number];
-}
-interface PaletteOptions {
-    seed?: number | string;
-    style?: string;
-    state?: string;
-}
-type Palette = {
-    meta: {
-        seed: number | string;
-        style: string;
-        state: string;
-        scheme: string;
-        base: string;
-        accentMode: 'wall' | 'object';
-    };
-} & Record<string, number | object>;
-/** Seeded colour-harmony palette: a facade base colour, a harmony scheme, role colours and contrast rules. */
-declare function palette(o?: PaletteOptions): Palette;
-
 /** Axis-aligned rectangle `[u0, v0, u1, v1]`. `u` runs along the facade, `v` from the street to the back. */
 type Rect = [number, number, number, number];
 type Vec2 = [number, number];
@@ -74,7 +20,7 @@ type ItemColor = {
 } | {
     pick: number[];
 };
-interface ItemDef {
+interface FurnitureDef {
     type: string;
     category: string;
     w: number;
@@ -92,11 +38,19 @@ interface ItemDef {
     /** Keep-out margin around the item (pools). */
     rim: number;
     decor?: boolean;
+    /** Hangs a wall cabinet over the counter (y 1.55 to 2.15 m): it blocks a window unless the fill dropped the cabinet. */
+    overhead?: boolean;
+    /** Effective height that blocks a window when taller than `h` (a shower enclosure is 0.1 m tray plus 1.95 m glass). */
+    windowHeight?: number;
+    /** Plugs into a socket (lamps, appliances). */
+    powered?: boolean;
+    /** Only picked when a slot names its exact type (`=type`), never through its category. */
+    exactOnly?: boolean;
     mount?: Mount;
     equip?: string[];
     color?: ItemColor;
 }
-type ItemInput = Pick<ItemDef, 'type' | 'category' | 'w' | 'd' | 'h'> & Partial<ItemDef>;
+type ItemInput = Pick<FurnitureDef, 'type' | 'category' | 'w' | 'd' | 'h'> & Partial<FurnitureDef>;
 type Anchor = 'wall' | 'corner' | 'center' | 'window' | 'on' | 'inside';
 type Side = 'left' | 'right' | 'front' | 'back' | 'any';
 type FacingRule = 'center' | 'door' | 'target' | 'u+' | 'u-' | 'v+' | 'v-';
@@ -163,6 +117,18 @@ interface DoorDef {
     width: number;
     opensTo?: string;
     steel?: boolean;
+    /** Clear wall from the opening to a corner or junction; defaults to the template's `clearance.door`, else 0.12 m. */
+    clearance?: number;
+    /** Explicit position instead of a wall edge (a tent flap in the middle of the lot). */
+    edge?: {
+        axis: 'u' | 'v';
+        pos: number;
+        a0: number;
+        a1: number;
+    };
+    model?: string;
+    type?: string;
+    steps?: number;
     [extra: string]: Json;
 }
 interface WindowDef {
@@ -206,6 +172,14 @@ interface LotConfig {
         side: string;
     };
     libraries?: Record<string, string>;
+    /** Lot zones over the building area (a camp). */
+    extraZones?: {
+        id: string;
+        type: string;
+        label?: string;
+        parts: Rect[];
+        library?: string;
+    }[];
     yardZones?: {
         id: string;
         type: string;
@@ -246,6 +220,35 @@ interface TemplateDef {
     facadeExtra?: (facade: Json, rng: Rng, w: number, d: number, o: FloorplanOptions) => void;
     building?: (w: number, d: number, o: FloorplanOptions) => Json;
     singleFloor?: boolean;
+    /** Place tag of the building for finds (`house`, `pharmacy`...). */
+    place?: string;
+    /** Building system the structure pack builds (a reference registered there). */
+    construction?: string;
+    /** Region of the content (`br`...), chosen by the pack that registered the template. */
+    region?: string;
+    /** Clear wall around openings: from a door to a corner or junction, and from a window to a corner, junction or door. */
+    clearance?: {
+        door?: number;
+        window?: number;
+    };
+    /** No walls are built (a tent): rooms and openings stay. */
+    noWalls?: boolean;
+    /** Storey heights add up (a mezzanine with a different ceiling) instead of `index * ceiling`. */
+    cumulativeCeilings?: boolean;
+    /** Settings the packs read from the plan (`power`: `grid`, `offgrid` or `tap`; `solar`); it lands in `result.config`. */
+    config?: (o: FloorplanOptions, w: number, d: number) => Json;
+    /** Marks lot areas taken by the building (chimney, tank, tents) as keep-out zones for the lot fill. */
+    reservations?: (plan: Plan) => void;
+    /** Own paths from the doors that sit away from the building edge (tents); replaces the generated ones. */
+    paths?: (plan: Plan, context: {
+        gates: Json[];
+        setback: number;
+        marginLeft: number;
+        marginRight: number;
+        backyard: number;
+        w: number;
+        d: number;
+    }) => Json[];
     /** Sides built against a neighbour (`left` / `right`): exempt from the side setback. */
     partyWalls?: ('left' | 'right')[];
     options?: Json;
@@ -262,6 +265,8 @@ interface StyleDef {
     /** Name of the legacy palette RNG stream (kept so old seeds still reproduce). */
     seedKey?: string;
     height: number;
+    /** Height of a fence boundary (default 2.0 m). */
+    fenceHeight?: number;
     front: BoundaryRule;
     sideYard: BoundaryRule;
     back: BoundaryRule;
@@ -278,7 +283,72 @@ interface StyleDef {
     /** Ground type weights per lot zone type. */
     grounds: Record<string, Weights>;
 }
+interface CarClearance {
+    /** Clear space beside the driver door (m). */
+    driver: number;
+    /** Clear space on the passenger side (m). */
+    side: number;
+    /** Clear space in front of and behind the car (m). */
+    end: number;
+}
+interface ResultExtensionContext {
+    plan: Plan;
+    /** The result built so far: the plan, the items, the state items and the extensions that ran before. */
+    result: Json;
+    seed: number | string;
+    /** Seeded stream of the extension: `createRng(seed, seedKey ?? name)`. */
+    rng: Rng;
+    options: FloorplanOptions;
+}
+type ResultExtensionRun = (context: ResultExtensionContext) => Json;
+interface ResultExtensionOptions {
+    /** Extensions that must run first. */
+    after?: string[];
+    /** Name of the seeded stream; defaults to the extension name. A pack sets the name of the team's own flow to reproduce its seeds. */
+    seedKey?: string;
+}
+interface FindStack {
+    readonly itemId: string;
+    readonly count: number;
+    readonly data?: {
+        readonly ageDays?: number;
+        readonly condition?: number;
+        readonly charge?: number;
+        readonly fill?: number;
+    };
+}
+interface FindsQuery {
+    /** Kind of place (`TemplateDef.place`, a room type, a lot zone type). */
+    place: string;
+    /** Kind of container (a furniture category). */
+    container: string;
+    state: string;
+    rng: Rng;
+    /** Outbreak days; 0 is the normal world. */
+    day?: number;
+    region?: string;
+    /** Footprint of the place in m². */
+    footprint?: number;
+    key?: string;
+}
+/**
+ * Answers what a container holds. Registered by an item pack; the engine only keeps the registry. An array is the answer, even an empty one (an abandoned
+ * cupboard that holds nothing); `null` means this provider does not know the container, and the next provider (or the default of the pack) answers.
+ */
+interface FindsProvider {
+    findsFor(query: FindsQuery): readonly FindStack[] | null;
+}
 interface FloorplanOptions {
+    /** Number of storeys, for templates that accept it. */
+    floors?: number;
+    /** Building system of the structure pack (`masonry`, `wood_frame`, ...). */
+    construction?: string;
+    /** How finely the structure pack splits the walls (`coarse`, `panels`, `units`). */
+    wallDetail?: 'coarse' | 'panels' | 'units';
+    /** Radius of the player body (m, default 0.24): a disc this wide must pass between doors and rooms once the furniture is placed. */
+    playerRadius?: number;
+    /** Space a parked car keeps from walls (default driver 0.8, side 0.6, end 0.6). */
+    carClearance?: Partial<CarClearance>;
     seed?: number | string;
     w?: number;
     d?: number;
@@ -291,6 +361,10 @@ interface FloorplanOptions {
     locale?: string;
     /** Urban zone id or definition to clamp the plan to. */
     zone?: string | ZoneDef;
+    /** Outbreak days for the finds (`FindsQuery.day`); 0 or none is the normal world. */
+    day?: number;
+    /** Region of the world for the finds (`FindsQuery.region`), as the item pack names it. */
+    region?: string;
     [extra: string]: Json;
 }
 interface Room {
@@ -334,6 +408,16 @@ interface Plan {
     facade?: Json;
     openPairs: Record<number, [string, string][]>;
     zoning?: ZoningReport;
+    /** Lot areas the building keeps out of the fill (set by `TemplateDef.reservations`). */
+    reservations: Rect[];
+    /** The options the plan was built with (seed included). */
+    options: FloorplanOptions;
+    /** Result of `TemplateDef.config`. */
+    config?: Json;
+    /** Cache of the wall bodies per storey, filled by the walkability grid. */
+    wallBodies?: Record<number, Rect[]>;
+    playerRadius: number;
+    carClearance: CarClearance;
 }
 interface Slot {
     id: string;
@@ -415,7 +499,7 @@ interface StateContext {
     /** Placement helpers shared with the decor passes. */
     ctx: PlacementContext;
     kit: PlacementKit;
-    catalog: Record<string, ItemDef>;
+    catalog: Record<string, FurnitureDef>;
     wallTopHeights: Record<string, number>;
 }
 interface StatePlugin {
@@ -459,10 +543,13 @@ interface PlacementKit {
     createGrid(plan: Plan, room: Room, ignored?: Set<string> | null): Json;
     clearRect(r: Rect, f: Vec2, clearance: number): Rect;
     pickWeighted(rng: Rng, w: Weights): string;
+    createRng(seed: number | string, key: string): Rng;
+    /** Name of the room in seeded streams: the legacy key when the room id was renamed, else the id. */
+    roomSeedKey(room: Room): string;
     shuffle<T>(a: T[], rng: Rng): T[];
     facingRotation(f: Vec2, type: string): number;
     cutIntervals(intervals: [number, number][], a: number, b: number): [number, number][];
-    blocksWindow(it: ItemDef, j: Json): boolean;
+    blocksWindow(it: FurnitureDef, j: Json, overheadOff?: boolean): boolean;
 }
 interface DecorPassContext {
     plan: Plan;
@@ -471,7 +558,7 @@ interface DecorPassContext {
     rng: Rng;
     ctx: PlacementContext;
     kit: PlacementKit;
-    catalog: Record<string, ItemDef>;
+    catalog: Record<string, FurnitureDef>;
     /** Decor profiles registered per style id. */
     profiles: Record<string, Json>;
 }
@@ -514,8 +601,97 @@ interface FloorplanLocale {
     messages?: Record<string, string>;
     ui?: Record<string, string>;
 }
+interface ViewerLayerContext {
+    /** Canvas 2D context, already in CSS pixels. */
+    g: CanvasRenderingContext2D;
+    plan: Json;
+    /** Storey being drawn (0 when `all`). */
+    floor: number;
+    /** All storeys at once (the lot view). */
+    all: boolean;
+    /** Metres to pixels. */
+    scale: number;
+    X(u: number): number;
+    Z(v: number): number;
+    rect(r: Rect, fill?: string | null, stroke?: string | null, lineWidth?: number): void;
+    /** Tooltip area (metres) with its text. */
+    hit(r: Rect, text: string): void;
+}
+interface ViewerLayerLegendEntry {
+    label: string;
+    color: string;
+    shape: 'filled' | 'hollow' | 'dashed' | 'line';
+}
+/** A layer a pack adds to the 2D viewer (the structure pack draws pillars and beams); the viewer shows a checkbox for it. */
+interface ViewerLayer {
+    id: string;
+    /** Checkbox text, or a key of the `ui` locale table. */
+    label: string;
+    defaultOn?: boolean;
+    draw(context: ViewerLayerContext): void;
+    legend?(plan: Json): ViewerLayerLegendEntry[];
+}
 
-declare function registerItem(def: ItemInput): ItemDef;
+/** Tools handed to a style recipe. `jit` and `rng` draw from the style's seeded stream: draw order is part of the contract. */
+interface PaletteDraw {
+    rng: Rng;
+    base: [string, number, number, number];
+    H0: number;
+    H1: number;
+    H2: number;
+    jit(v: number, a: number): number;
+    hsl(h: number, s: number, l: number): Hsl;
+}
+interface PaletteEarly {
+    /** Accent mode: true saturates walls, false puts accents on objects. */
+    wallMode: boolean;
+    /** Maximum wall saturation. */
+    sMax: number;
+    /** Facade, wall, gate, roof, ceiling... in insertion order. */
+    roles: Record<string, Hsl>;
+    /** General floor `[h, s, l]` for room types that do not define their own. */
+    generalFloor: [number, number, number];
+}
+interface PaletteStyleDef {
+    /** Legacy stream suffix; defaults to the style id. */
+    seedKey?: string;
+    /** Facade colour table `[labelKey, h, s, l]`. */
+    facadeColors: [string, number, number, number][];
+    /** Draws up to the room colours (before the room loop). */
+    early(d: PaletteDraw): PaletteEarly;
+    /** Draws the object roles (wood, fabrics, metal, ground colours) after the room loop. */
+    late(d: PaletteDraw, e: PaletteEarly): Record<string, Hsl>;
+}
+interface PaletteContext extends PaletteDraw {
+    style: string;
+    sMax: number;
+    wallMode: boolean;
+    generalFloor: [number, number, number];
+}
+interface PaletteOptions {
+    seed?: number | string;
+    style?: string;
+    state?: string;
+}
+type Palette = {
+    meta: {
+        seed: number | string;
+        style: string;
+        state: string;
+        scheme: string;
+        base: string;
+        accentMode: 'wall' | 'object';
+    };
+} & Record<string, number | object>;
+/** Seeded colour-harmony palette: a facade base colour, a harmony scheme, role colours and contrast rules. */
+declare function palette(o?: PaletteOptions): Palette;
+
+/** What a container holds, from the first registered provider that answers (`null` passes to the next); none answering means nothing. */
+declare function findsFor(query: FindsQuery): readonly FindStack[];
+/** Like `findsFor`, but `null` when no provider answered, so a pack can fall back to its own default. */
+declare function findsAnswer(query: FindsQuery): readonly FindStack[] | null;
+
+declare function registerItem(def: ItemInput): FurnitureDef;
 declare function registerItems(list: ItemInput[]): void;
 declare function registerLibrary(id: string, library: SlotLibrary): void;
 declare function registerLibraryAlias(alias: string, id: string): void;
@@ -537,6 +713,12 @@ declare function registerState(name: string, plugin: StatePlugin): void;
 /** Default state draw when `options.state` is absent: `{ state: weight }` on its own seeded stream. */
 declare function setStateDistribution(weights: Record<string, number> | null, seedKey?: string): void;
 declare const listStates: () => string[];
+/** Adds a named piece to every result, after the state and before the zoning report; its output lands in `result[name]`. */
+declare function registerResultExtension(name: string, run: ResultExtensionRun, options?: ResultExtensionOptions): void;
+/** Registers who answers what a container holds (the item packs, from phase 3 on). */
+declare function registerFindsProvider(provider: FindsProvider): void;
+/** Adds (or replaces, by id) a layer of the 2D viewer; drawn after the items, before the labels. */
+declare function registerViewerLayer(layer: ViewerLayer): void;
 
 /** Recorded slots (resolved positions) of every storey and of the lot. */
 declare function slots(template: string | TemplateDef, options?: FloorplanOptions): Json[];
@@ -603,6 +785,191 @@ declare function openingZones(u: number, v: number, axis: 'u' | 'v', width: numb
 
 /** Keep-out zone of a window (inside, or outside for the lot). */
 declare function windowZone(j: Json, outside?: boolean): Rect;
+/** `overheadOff`: the counter sits under the window without its wall cabinet. */
+declare function blocksWindow(it: Pick<FurnitureDef, 'window' | 'overhead' | 'windowHeight'> & {
+    h: number;
+}, win: Json, overheadOff?: boolean): boolean;
+
+/** One primitive of a far-away silhouette. Parts are listed in creation order; `parent` is the index of a group part (`-1` is the root). */
+type SilhouettePart = {
+    shape: 'group';
+    parent: number;
+    x: number;
+    y: number;
+    z: number;
+    ry: number;
+} | {
+    shape: 'box';
+    parent: number;
+    x: number;
+    y: number;
+    z: number;
+    width: number;
+    height: number;
+    depth: number;
+    color: number;
+    emissive: boolean;
+    ry: number;
+    rz: number;
+    radius: number;
+} | {
+    shape: 'prism';
+    parent: number;
+    x: number;
+    y: number;
+    z: number;
+    width: number;
+    height: number;
+    depth: number;
+    color: number;
+    ry: number;
+} | {
+    shape: 'cylinder';
+    parent: number;
+    x: number;
+    y: number;
+    z: number;
+    radiusTop: number;
+    radiusBottom: number;
+    height: number;
+    color: number;
+    segments: number;
+} | {
+    shape: 'line';
+    parent: number;
+    points: [number, number, number][];
+    color: number;
+} | {
+    shape: 'sign';
+    parent: number;
+    x: number;
+    y: number;
+    z: number;
+    width: number;
+    height: number;
+    ry: number;
+    text: string;
+    background: string;
+    foreground: string;
+};
+/** A window the renderer draws as an instance (a lit one glows). `ry` is the facing; the size is width by height. */
+type SilhouetteWindow = {
+    x: number;
+    y: number;
+    z: number;
+    ry: number;
+    width: number;
+    height: number;
+    isLit: boolean;
+};
+type Silhouette = {
+    parts: SilhouettePart[];
+    windows: SilhouetteWindow[];
+    /** Footprint on the ground: centre and size, for the LOD plan. */
+    footprint: {
+        x: number;
+        z: number;
+        width: number;
+        depth: number;
+        height: number;
+    };
+};
+type RandomSource = () => number;
+
+/** The page's own seeded generator (mulberry32), so a silhouette drawn from the same seed has the same windows and colours. */
+declare function createSilhouetteRandom(seed: number): RandomSource;
+
+type CityBuildingParams = {
+    x: number;
+    z: number;
+    width: number;
+    depth: number;
+    height: number;
+    color: number;
+    /** Chance of a ground-floor shop on both long faces; omitted means none. */
+    shopChance?: number;
+    /** Chance that a window is lit. */
+    litChance?: number;
+    random?: RandomSource;
+    seed?: number;
+};
+/** City building: block, roof slab, maybe a vent, maybe a shop front, and window instances on the four faces. */
+declare function createCityBuilding(p: CityBuildingParams): Silhouette;
+
+type Seeded = {
+    random?: RandomSource;
+    seed?: number;
+};
+type TwoStoreyParams = Seeded & {
+    x: number;
+    z: number;
+    width: number;
+    depth: number;
+    color: number;
+    roofColor?: number;
+    ry?: number;
+};
+/** Two-storey house with a balcony slab, pitched roof and four windows. */
+declare function createTwoStoreyHouse(p: TwoStoreyParams): Silhouette;
+type SlabHouseParams = Seeded & {
+    x: number;
+    z: number;
+    width: number;
+    depth: number;
+    floors: number;
+    color: number;
+};
+/** Reinforced-concrete slab house of one to three floors, with water tank, side stair and sometimes rebar starters. */
+declare function createSlabHouse(p: SlabHouseParams): Silhouette;
+type ColonialParams = Seeded & {
+    x: number;
+    z: number;
+    width: number;
+    color: number;
+    hasDoor: boolean;
+};
+/** Colonial terrace house: parapet, roof behind it and a row of doors or windows. */
+declare function createColonialHouse(p: ColonialParams): Silhouette;
+type ChaletParams = Seeded & {
+    x: number;
+    z: number;
+    color?: number;
+    ry?: number;
+};
+/** Wooden chalet on a stone base with a steep roof and a chimney. */
+declare function createChalet(p: ChaletParams): Silhouette;
+type CompanyHouseParams = Seeded & {
+    x: number;
+    z: number;
+    color?: number;
+};
+/** Company-town house with a low front fence. */
+declare function createCompanyHouse(p: CompanyHouseParams): Silhouette;
+type StiltHouseParams = Seeded & {
+    x: number;
+    z: number;
+    color?: number;
+};
+/** House on stilts with a ramp-like entry platform. */
+declare function createStiltHouse(p: StiltHouseParams): Silhouette;
+type FarmhouseParams = Seeded & {
+    x: number;
+    z: number;
+};
+/** Farm house with a long covered porch on six posts. */
+declare function createFarmhouse(p: FarmhouseParams): Silhouette;
+type DetachedHouseParams = Seeded & {
+    x: number;
+    z: number;
+    width: number;
+    depth: number;
+    color: number;
+    roofColor?: number;
+    ry?: number;
+    isBoarded?: boolean;
+};
+/** One-storey detached house; boarded windows get two crossed planks each. */
+declare function createDetachedHouse(p: DetachedHouseParams): Silhouette;
 
 declare const version = "0.1.0";
 /**
@@ -634,6 +1001,13 @@ declare const engine: {
     registerState: typeof registerState;
     setStateDistribution: typeof setStateDistribution;
     registerLocale: typeof registerLocale;
+    registerResultExtension: typeof registerResultExtension;
+    registerFindsProvider: typeof registerFindsProvider;
+    findsFor: typeof findsFor;
+    findsAnswer: typeof findsAnswer;
+    registerViewerLayer: typeof registerViewerLayer;
+    viewerLayers: ViewerLayer[];
+    blocksWindow: typeof blocksWindow;
     defineZone: typeof defineZone;
     getZone: (id: string) => ZoneDef | undefined;
     listZones: () => ZoneDef[];
@@ -643,9 +1017,10 @@ declare const engine: {
     translate: typeof translate;
     listLocales: () => string[];
     templates: Record<string, TemplateDef>;
-    catalog: Record<string, ItemDef>;
+    catalog: Record<string, FurnitureDef>;
     libraries: Record<string, SlotLibrary>;
     styles: Record<string, StyleDef>;
+    paletteStyles: Record<string, PaletteStyleDef>;
     createRng: (seed: string | number, key: string) => Rng;
     mulberry32: typeof mulberry32;
     hashString: typeof hashString;
@@ -663,8 +1038,17 @@ declare const engine: {
     constants: {
         WALL_THICKNESS: number;
         DOOR_CLEARANCE: number;
+        PLAYER_RADIUS: number;
+        DOOR_EDGE_CLEARANCE: number;
+        WINDOW_EDGE_CLEARANCE: number;
+        OVERHEAD_TOP: number;
+        CAR_CLEARANCE: {
+            readonly driver: 0.8;
+            readonly side: 0.6;
+            readonly end: 0.6;
+        };
     };
 };
 type FloorplanEngine = typeof engine;
 
-export { type Anchor, type BoundaryRule, type DecorPass, type DecorPassContext, type DoorDef, type FacingRule, type FloorDef, type FloorplanEngine, type FloorplanLocale, type FloorplanOptions, type GateCfg, type GroundOverlayRule, type Hsl, type ItemColor, type ItemDef, type ItemInput, type Json, type LotConfig, type MeshFront, type Mount, type PaletteDraw, type PaletteEarly, type PaletteStyleDef, type PlacedItem, type PlacementContext, type PlacementKit, type Plan, type Rect, type Room, type RoomColorDef, type RoomDef, type Side, type Slot, type SlotDef, type SlotKit, type SlotLibrary, type StateContext, type StatePlugin, type StyleDef, type TemplateDef, type Vec2, type Weights, type WindowDef, type ZoneAdjustment, type ZoneDef, type ZoneViolation, type ZoningReport, checkLot, createRng, defineZone, engine, generate, getZone, hashString, limitsOf, listLocales, listStates, listTemplates, listZones, mulberry32, openingZones, overlaps, palette, registerDecorProfile, registerGroundOverlay, registerItem, registerItems, registerLibrary, registerLibraryAlias, registerLocale, registerPaletteStyle, registerPass, registerPermeableGround, registerRoomColors, registerSeedKeys, registerState, registerStyle, registerTemplate, registerWallTop, setStateDistribution, slotKit, slots, translate, validate, version, windowZone };
+export { type Anchor, type BoundaryRule, type CarClearance, type ChaletParams, type CityBuildingParams, type ColonialParams, type CompanyHouseParams, type DecorPass, type DecorPassContext, type DetachedHouseParams, type DoorDef, type FacingRule, type FarmhouseParams, type FindStack, type FindsProvider, type FindsQuery, type FloorDef, type FloorplanEngine, type FloorplanLocale, type FloorplanOptions, type FurnitureDef, type GateCfg, type GroundOverlayRule, type Hsl, type ItemColor, type ItemInput, type Json, type LotConfig, type MeshFront, type Mount, type PaletteDraw, type PaletteEarly, type PaletteStyleDef, type PlacedItem, type PlacementContext, type PlacementKit, type Plan, type RandomSource, type Rect, type ResultExtensionContext, type ResultExtensionOptions, type ResultExtensionRun, type Room, type RoomColorDef, type RoomDef, type Side, type Silhouette, type SilhouettePart, type SilhouetteWindow, type SlabHouseParams, type Slot, type SlotDef, type SlotKit, type SlotLibrary, type StateContext, type StatePlugin, type StiltHouseParams, type StyleDef, type TemplateDef, type TwoStoreyParams, type Vec2, type ViewerLayer, type ViewerLayerContext, type ViewerLayerLegendEntry, type Weights, type WindowDef, type ZoneAdjustment, type ZoneDef, type ZoneViolation, type ZoningReport, blocksWindow, checkLot, createChalet, createCityBuilding, createColonialHouse, createCompanyHouse, createDetachedHouse, createFarmhouse, createRng, createSilhouetteRandom, createSlabHouse, createStiltHouse, createTwoStoreyHouse, defineZone, engine, findsAnswer, findsFor, generate, getZone, hashString, limitsOf, listLocales, listStates, listTemplates, listZones, mulberry32, openingZones, overlaps, palette, registerDecorProfile, registerFindsProvider, registerGroundOverlay, registerItem, registerItems, registerLibrary, registerLibraryAlias, registerLocale, registerPaletteStyle, registerPass, registerPermeableGround, registerResultExtension, registerRoomColors, registerSeedKeys, registerState, registerStyle, registerTemplate, registerViewerLayer, registerWallTop, setStateDistribution, slotKit, slots, translate, validate, version, windowZone };