@adatechnology/game-floorplan-three 0.9.3 → 0.10.1

package/dist/testing-ikPy2Nxl.d.ts

@@ -1,379 +0,0 @@
-import { DeferredQueue, ModuleScenario, TestableModule } from '@adatechnology/game-contracts';
-import { LightBudget } from '@adatechnology/game-render-three';
-
-/** Texts the house shows to the player (interaction prompts, messages, outbuilding labels), by locale. */
-type Messages = Record<string, string>;
-declare const en: Messages;
-declare const ptBR: Messages;
-declare const locales: Record<string, Messages>;
-type Translate = (key: string, params?: Record<string, string | number>) => string;
-/**
- * Translator for a locale id ('en', 'pt-BR'), or for a partial table that overrides the English one.
- * A missing key falls back to English and then to the key itself.
- */
-declare function createTranslator(locale?: string | Partial<Messages>): Translate;
-
-/** A part of the house a hit can damage (door, window, glass, tank...): the game reads `hp`. */
-interface Damageable {
-    type: string;
-    hp: number;
-    hpMax: number;
-}
-/** What `create(THREE, options)` reads. Everything is optional; the three.js namespace is the first argument. */
-interface HouseRendererOptions {
-    /** Document used to draw the procedural textures on a canvas (default: the page's). */
-    document?: any;
-    /** `'game'` merges more and draws less than `'high'`. */
-    quality?: 'high' | 'game';
-    /** Locale of the texts the house shows (`en`, `pt-BR`) or a table of messages. */
-    locale?: string | Partial<Messages>;
-    /** `@adatechnology/game-props3d` (default: the package's own dependency). */
-    props?: any;
-    /** `THREE.Reflector` (three/examples/jsm/objects/Reflector.js); without it the mirrors use only the environment map. */
-    reflector?: any;
-    /** Cars of the lot and garage: `build(kind, { quality, seed })` -> `{ group, damageable, release() }`. Without it there are no cars. */
-    fleet?: {
-        build(kind: string, options: {
-            quality: string;
-            seed: number;
-        }): any;
-    } | null;
-    /** Car kinds (fleet ids) per lot style (`budget`, `mid`, `high`); replaces the list of a style. */
-    carKinds?: Record<string, string[]>;
-    /** Hit points per damage class (glass, wood, water, metal, masonry, rubber, fuel, gas). */
-    hp?: Record<string, number>;
-    /** Textures from the app that replace the procedural ones. */
-    textures?: Record<string, any>;
-    atlas?: Record<string, any>;
-    /** Materials the game swaps (a material or a function of the default one). */
-    materials?: Record<string, any>;
-    /** The world of `@adatechnology/game-destruction`; the house registers itself in it on first need. */
-    destruction?: any;
-    /** `createDestructionRenderer(THREE, { scene, world })` of `@adatechnology/game-destruction-three`: draws fracture, collapse, fragments, spalls and the rebar cage on the house's meshes. */
-    destructionRenderer?: any;
-    /** The lights of effects (a blast, a fire, a flare) light the room where their point is, and the rooms either side of an open door or window next to it (see `effectLights` and `lighting`). Default true; false keeps them off every house surface. */
-    effectLightsIndoors?: boolean;
-    /** Milliseconds per frame the house may spend repainting damaged walls (chipped plaster, holes); events of one frame are painted together. Default `Infinity` (all of them at the frame's flush); a game loop sets a few ms. */
-    breachPaintBudgetMs?: number;
-    /** The interactables kit, injected: `{ GameInteractables, GameInteractablesHousehold, GameInteractablesThree, adapter (optional), adapterOptions, locale, region, items, effects, effectSink, camera, onEvent, onSeat }`. */
-    interactives?: any;
-    /** The vegetation packages, injected: `{ GameVegetation, GameVegetationSpecies }`. */
-    vegetation?: any;
-    /** Maps an id of the plan to the key its seeded random draws use, to reproduce a scene drawn with other ids (golden tests). */
-    seedKey?: (id: string) => string | null | undefined;
-    /** Distance (m) beyond which the interior (`interior`) and the house (`hide`) are drawn no more, or `false` to switch distance LOD off. */
-    lod?: false | {
-        interior?: number;
-        hide?: number;
-    };
-    drawCallBudget?: number;
-    onChange?: (change: {
-        shadow: boolean;
-    }) => void;
-    onCollider?: (collider: any) => void;
-    onDamage?: (part: any, point: {
-        x: number;
-        y: number;
-        z: number;
-    } | null, type: string) => void;
-    onWreck?: (event: any, house: any) => void;
-    onInteract?: (target: any, action: any) => boolean | void;
-    onLight?: (light: any) => void;
-    onMessage?: (text: string) => void;
-}
-interface BuildOptions {
-    /** `'high'` (default) or `'game'`. */
-    quality?: 'high' | 'game';
-    /** Night: lit windows and room lamps. */
-    night?: boolean;
-    /** Roof cut off and floors above hidden, to look into the plan. */
-    cut?: boolean;
-    /** A state returned by `newState()`: pass the same one to rebuild without closing every door. */
-    state?: any;
-    /** `false`: the app already has ground, street and lawn. */
-    terrain?: boolean;
-    /** `true`: no lot wall, fence or gates (the game has its own). */
-    noPerimeter?: boolean;
-    /** `'meshes'`: one mesh per structural piece instead of one per group and material. */
-    pieces?: 'meshes';
-    drawCallBudget?: number;
-    building?: {
-        floors?: number;
-        floor?: number;
-        unit?: number;
-        showBuilding?: boolean;
-    };
-}
-/** The house the renderer built. The three.js groups are ready to add to a scene. */
-interface House {
-    version: string;
-    r: any;
-    name: string;
-    quality: string;
-    group: any;
-    house: any;
-    groups: Record<string, any>;
-    floors: any[];
-    ceilings: any[];
-    roof: any;
-    lot: any;
-    ground: any;
-    building: any;
-    /** Public colliders: walls, doors, lot walls and gates (aabb) and furniture (obb). */
-    colliders: any[];
-    /** Parts that move or take damage: id -> `{ group, type, opens(t), damageable }`. */
-    parts: Record<string, any>;
-    doors: any[];
-    stairs: any[];
-    labels: any[];
-    /** The real lights the builders asked for (at night) in `list`, and the same grouped by room id in `byRoom`. */
-    lights: {
-        list: any[];
-        byRoom: Record<string, any[]>;
-    };
-    stats: any;
-    structure: any;
-    destruction: any;
-    interactives: any;
-    update(dt: number, time?: number, focus?: {
-        x: number;
-        y: number;
-        z: number;
-    }): void;
-    show(options: {
-        floor?: number;
-        cut?: boolean;
-        lot?: boolean;
-    }): void;
-    target(eye: any, options?: any): any;
-    interact(target: any): any;
-    toggleDoor(id: string): any;
-    toggleLight(room?: string): any;
-    lightOn(room: string): boolean;
-    collide(x: number, z: number, floor: number, options?: any): any;
-    roomAt(floor: number, x: number, z: number): any;
-    setLod(level: number): void;
-    readonly lod: number;
-    damage(id: string, point?: any, type?: string, amount?: number): void;
-    colliderDamage(collider: any, point?: any, type?: string, amount?: number): void;
-    /** The part (door, window, furniture piece...) an object belongs to, found by going up its parents. */
-    partOf(object: any): any | null;
-    /** The first part whose box holds the point (with a tolerance, default 5 cm). */
-    partAt(point: {
-        x: number;
-        y: number;
-        z: number;
-    }, tolerance?: number): any | null;
-    dispose(): void;
-    [extra: string]: any;
-}
-/** What `HouseRenderer.lighting` reads. */
-interface LightingOptions {
-    scene?: any;
-    /** Room lights, 1 to 12 (6). */
-    n?: number;
-    /** How many of them cast shadows (2). */
-    shadows?: number;
-    shadowSize?: number;
-    /** Outside lamps that may take a light (2). */
-    external?: number;
-    /**
-     * The host's LightBudget: the house leases `n` point slots (`shadows` with shadow) for good instead of creating lights, and the room masks are written at the slot of each light (what the shader
-     * indexes by). Without it the lights are created here, which changes every lit material's program key (deprecated, removed in the next major).
-     */
-    budget?: LightBudget;
-}
-/** The renderer `create(THREE, options)` returns. */
-interface HouseRenderer {
-    version: string;
-    build(result: any, options?: BuildOptions): House;
-    newState(): any;
-    types: Record<string, any>;
-    mv: any;
-    applyPart(group: any, t: number): void;
-    materials: Record<string, any>;
-    roomLightMask(material: any): void;
-    lighting(options?: LightingOptions): any;
-    /**
-     * Lets the lights of effects (a blast, a fire, a flare) that hold slots of `budget` light the room their point is in, and the rooms either side of an open door or window next to it.
-     * Call `update(houses)` every frame after the budget's `present`. Works without `lighting()`. Off for every house with `effectLightsIndoors: false`.
-     */
-    effectLights?(options: {
-        budget: any;
-    }): {
-        update(houses: unknown): void;
-    };
-    setNight(night: boolean): void;
-    /** The painting of the damaged walls of every house as a `DeferredQueue` for a shared frame budget; `budget.register` attaches it and `flush()` stops painting from `onFrame`. */
-    deferredQueue?(): DeferredQueue;
-    cars: {
-        model(kind: string, seed?: number): any;
-        group(...args: any[]): any;
-        info(kind: string, seed?: number): any;
-    };
-    dispose(): void;
-}
-
-type AreaText = {
-    group: string;
-    name: string;
-    controls: Record<'package' | 'template' | 'state' | 'seed' | 'quality' | 'lod' | 'houses' | 'budget' | 'floor_view' | 'hit', string>;
-    hints: Record<'template' | 'houses' | 'budget' | 'lod' | 'floor_view' | 'hit', string>;
-    actions: Record<'build' | 'enter' | 'up' | 'down' | 'door' | 'strike' | 'reset' | 'clear', string>;
-    options: {
-        quality: Record<string, string>;
-        lod: Record<string, string>;
-        floor_view: Record<string, string>;
-        hit: Record<string, string>;
-        state: Record<string, string>;
-    };
-    layers: Record<'roof' | 'lot' | 'night' | 'room_lights', string>;
-    metrics: Record<'houses' | 'parts' | 'standing' | 'broken' | 'holes' | 'draw_calls' | 'triangles' | 'lod' | 'floor' | 'doors_open' | 'target' | 'planned', string>;
-    sheet: {
-        kicker: string;
-        title: string;
-        template: string;
-        seed: string;
-        state: string;
-        floors: string;
-        size: string;
-        parts: string;
-        look: string;
-        none: string;
-        no_engine: string;
-    };
-    specimens: Record<string, string>;
-    scenarios: Record<string, string>;
-    steps: Record<'built' | 'no_engine' | 'entered' | 'floor' | 'no_floor' | 'door' | 'no_door' | 'strike' | 'no_aim' | 'cleared' | 'reset' | 'one_pillar_broke' | 'slabs_whole' | 'no_slab_fell' | 'two_slab_fell' | 'two_roof_fell' | 'partition_broke' | 'slab_stayed' | 'glass_hole' | 'glass_broke' | 'walls_whole' | 'tank_hole' | 'tank_leaked' | 'gas_exploded' | 'gas_damaged', string>;
-};
-
-/** What the room hands a scenario (`ScenarioContext` of game-test-room), narrowed to what these use. */
-interface AreaContext {
-    room: any;
-    step(seconds: number): void;
-    expect(condition: boolean, label: string, data?: Record<string, unknown>): void;
-}
-type Vec3 = readonly [number, number, number];
-/** Where the team's page lays its specimens (the arena has 14 m of half width). */
-declare const SPECIMEN_AT: Vec3;
-/**
- * The six structural scenarios of the team's house area (sala-de-testes/area-casas, L3833-3868), same ids and same checks, on the specimens the area builds: destroy a pillar, two pillars, a partition,
- * shoot a window, puncture the water tank, set the gas bottle on fire. The hits are the team's (3 MJ blunt on a pillar, 600 J 9 mm on the glass and the tank, 900 C fire on the bottle). A scenario
- * passes when every check holds; the names of the checks are in `text.steps`.
- */
-declare function createHouseScenarios(text: AreaText, at?: Vec3): Array<ModuleScenario<AreaContext>>;
-
-/** The part of the floorplan engine (`engine` of `@adatechnology/game-floorplan`, with the content packs the page registered) the test area reads. */
-interface FloorplanEngineLike {
-    generate(template: string, options?: {
-        seed?: number;
-        state?: string;
-        floors?: number;
-    }): any;
-    listTemplates(): Array<{
-        id: string;
-        name?: string;
-        floors?: number;
-        floorRange?: number[] | null;
-    }>;
-    listStates(): string[];
-    translate?(namespace: any, key: string, locale?: string, vars?: Record<string, string | number>): string;
-}
-/** A pack of templates the bench lists together (residential, commercial, rural, post-apocalyptic). Ids the engine does not know are left out. */
-interface TemplateGroup {
-    id: string;
-    /** Name by locale (`en`, `pt-BR`); the id when absent. */
-    name?: Record<string, string>;
-    templates: readonly string[];
-}
-/** A small house the area lays out for the structural scenarios: the structure spec of a template, drawn as boxes named by part (the team's HouseArea items). */
-interface SpecimenDef {
-    /** Item id (`house_casa_portico`): the scenarios and the golden name them. */
-    id: string;
-    template: string;
-    seed?: number;
-    state?: string;
-    /** The bearing walls only close: a frame of pillars and beams carries the building. */
-    portico?: boolean;
-    /**
-     * How the structure is sized (`toDestructibleSpec`): `safety` is the share of its capacity a pillar uses at rest, `redundancy` the most it uses after one other pillar is lost.
-     * A slab on four pillars is held by the sum of the four: with `safety` 0.72 and `redundancy` 0.97 it holds one loss (0.96) and falls with two.
-     */
-    sizing?: {
-        safety?: number;
-        redundancy?: number;
-        safetyOthers?: number;
-    };
-    /** Name by locale; the text of the area when absent. */
-    name?: Record<string, string>;
-}
-interface FloorplanTestOptions {
-    locale?: string;
-    /** The engine with the packs registered. Without it the module has no houses to build. */
-    engine?: FloorplanEngineLike;
-    /** The packs the bench lists, in order. Default: every template of the engine in one group. */
-    groups?: readonly TemplateGroup[];
-    /** The states the bench offers (`normal`, `fortified`, `abandoned`). Default: the engine's. */
-    states?: readonly string[];
-    /** The room's destruction world and renderer (`room.world`, `room.renderer`): the houses built here register in them, so every shot, blast and fire of the room reaches the walls. */
-    world?: any;
-    renderer?: any;
-    /** Passed to the house renderer: `fleet`, `reflector`, `interactives`, `vegetation`, `props`, `textures`... */
-    house?: Partial<HouseRendererOptions>;
-    /** Template and seed the bench starts with. */
-    template?: string;
-    seed?: number;
-    /** Specimens of the structural scenarios; default the five of the team's house area, those whose template the engine has. */
-    specimens?: readonly SpecimenDef[];
-    /** Half size of the room's arena (`createTestRoom({ arenaSize })`), 14 by default: where the houses are laid. */
-    arenaSize?: number;
-    /** Where the specimens stand for the scenarios (the team's page: `[-5, 0, -11]`). */
-    specimenAt?: readonly [number, number, number];
-}
-
-declare const FLOORPLAN_AREA_ID = "floorplan_area";
-type Placed = {
-    house: any;
-    plan: any;
-    seed: number;
-    width: number;
-    depth: number;
-};
-/**
- * The houses test area as a `TestableModule`: any typology of the content packs the page registered (residential, commercial, rural, post-apocalyptic) built with game-floorplan-three from a seed, laid
- * in the room, with the player able to walk in (walls and closed doors stop the walk), use the doors (E), go up and down the floors, see the level of detail (manual, by distance, or shared among a row
- * of houses by a draw-call budget), and hit the walls with what the room throws (its tools, or the bench's hit): the houses register in the room's destruction world, so shots, blows, blasts and fire
- * reach the structure and the room's renderer draws the fracture, the brick courses and the collapse. Dust and sparks are the room's own effects: this module draws no particles.
- * Everything that is a pack of content comes in by option: this package knows no game.
- */
-declare function createFloorplanTestModule(options?: FloorplanTestOptions): TestableModule<AreaContext> & {
-    readonly houses: readonly Placed[];
-    build(): void;
-    clear(): void;
-    groups(): readonly TemplateGroup[];
-};
-
-/**
- * The five items of the team's house area (sala-de-testes/area-casas): a frame house, a whole house, a wood-frame house, a log cabin and a tent. The team's frame house is its single-storey house A; here it is the
- * two-storey townhouse, because the ceiling slab of the single-storey plan keeps standing on its bearing partitions when two pillars go (see evidence, T2.6). The frame house is a reinforced concrete frame (T10 §12): the slabs
- * are cut into panels on real beams, the pillars are sized (`sizing`) to carry the load of the ones lost, and the beams to carry the span the lost pillar leaves: one pillar lost and the slab stays,
- * the two ends of a side lost and that side comes down (owner, 2026-10-24: "4 pilares e a sustentação é a soma dos 4"; 2026-10-25: the real structure of the houses).
- */
-declare const DEFAULT_SPECIMENS: readonly SpecimenDef[];
-/** What the area keeps of a built specimen: the structure spec the house draws (what the destruction world is given) and the plan it came from. */
-interface SpecimenSpec {
-    readonly spec: any;
-    readonly plan: any;
-}
-/**
- * The structure spec of a specimen: the engine draws the plan, the house renderer draws the house, and the house describes its structure (`house.structure.spec`) with what the water tank holds and
- * what makes the gas bottle explode. The spec is cached per three.js namespace and specimen; each call hands out a copy.
- */
-declare function specimenSpec(THREE: any, engine: FloorplanEngineLike, def: SpecimenDef, houseOptions?: Partial<HouseRendererOptions>): SpecimenSpec;
-/**
- * One box (or cylinder, sphere) per part, named by the part id and coloured by its material, in the space of the house (the origin at the corner of the plan): what the team's house area draws, so the
- * room binds each mesh to the part of the same name. The anchored terrain slab is left out (the room has a floor).
- */
-declare function buildSpecimenMeshes(THREE: any, spec: any): any;
-
-export { type AreaContext as A, type BuildOptions as B, DEFAULT_SPECIMENS as D, FLOORPLAN_AREA_ID as F, type HouseRendererOptions as H, type LightingOptions as L, type Messages as M, SPECIMEN_AT as S, type TemplateGroup as T, type HouseRenderer as a, type Damageable as b, type FloorplanEngineLike as c, type FloorplanTestOptions as d, type House as e, type SpecimenDef as f, type Translate as g, buildSpecimenMeshes as h, createFloorplanTestModule as i, createHouseScenarios as j, createTranslator as k, en as l, locales as m, ptBR as p, specimenSpec as s };