@adatechnology/game-floorplan-structure 1.3.3 → 2.0.1

package/dist/index.d.ts

@@ -1,4 +1,5 @@
-import { FloorplanEngine, ViewerLayer, RoomDef, DoorDef, WindowDef, FloorDef } from '@adatechnology/game-floorplan';
+import { FloorplanEngine, ViewerLayer, RoomDef, DoorDef, WindowDef, FloorDef, PlanAxis } from '@adatechnology/game-floorplan';
+export { LotPath } 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';
 
@@ -256,7 +257,7 @@ interface StructureSource {
         link?: {
             from: number;
             to: number;
-        } | null;
+        } | string | null;
     }[];
     facade: {
         roof?: string;
@@ -313,7 +314,7 @@ interface SourceDoor {
     u: number;
     v: number;
     width: number;
-    side?: string;
+    side?: string | null;
     axis: 'u' | 'v';
     steps?: number;
 }
@@ -1159,6 +1160,254 @@ declare const towerLocales: {
     };
 };
 
+/** A point in the world: `[u, v, y]` (y is the absolute height). */
+type Point3 = [number, number, number];
+/** Something fixed to the inner face of a wall of a room: a socket, a switch, the panel. */
+interface WallFixture {
+    id: string;
+    room: string;
+    floor: number;
+    u: number;
+    v: number;
+    /** Height above the storey floor. */
+    y: number;
+    /** Position along the wall. */
+    c: number;
+    axis: PlanAxis;
+    pos: number;
+    frontU: number;
+    frontV: number;
+}
+interface Outlet extends WallFixture {
+    type: string;
+    voltage: number;
+}
+interface LightSwitch extends WallFixture {
+    door: string;
+    /** On the latch side of the door. */
+    latchSide: boolean;
+    /** Lamp ids it turns on. */
+    controls: string[];
+}
+interface ElectricalPanel extends WallFixture {
+    w: number;
+    h: number;
+    breakers: number;
+}
+interface ElectricMeter {
+    id: string;
+    place: string;
+    u: number;
+    v: number;
+    y: number;
+    side: string;
+    w: number;
+    d: number;
+    h: number;
+}
+/** Pole, drop, meter, descent and the run to the panel; a tap has no meter and a bare connection instead. */
+interface ServiceEntrance {
+    pole: {
+        u: number;
+        v: number;
+        h: number;
+    };
+    drop: Point3[];
+    meter: ElectricMeter | null;
+    descent: Point3[];
+    internalRun: Point3[] | null;
+    tap?: boolean;
+    connection?: {
+        u: number;
+        v: number;
+        y: number;
+    };
+}
+interface Circuit {
+    id: string;
+    room: string;
+    floor: number;
+    outlets: string[];
+    switches: string[];
+    lamps: string[];
+    exposed: boolean;
+    gauge_mm2: number;
+}
+interface Conduit {
+    id: string;
+    circuit: string;
+    from: string;
+    to: string;
+    exposed: boolean;
+    diameter: number;
+    points: Point3[];
+}
+interface OutdoorLamp {
+    id: string;
+    u: number;
+    v: number;
+    y: number;
+    door: string;
+    switch: string | null;
+}
+interface PlumbingPoint {
+    id: string;
+    kind: string;
+    item: string;
+    room: string | null;
+    floor: number;
+    u: number;
+    v: number;
+    y: number;
+    flowLpm: number | undefined;
+    run: string | null;
+}
+interface PlumbingRun {
+    id: string;
+    from: string;
+    /** A point, a room, or `ceiling`. */
+    to: string | null;
+    points: Point3[];
+    diameter: number;
+    exposed: string;
+}
+interface Plumbing {
+    tank: 'water_tank' | null;
+    capacityL: number;
+    points: PlumbingPoint[];
+    visibleRuns: PlumbingRun[];
+}
+interface SolarPanel {
+    id: string;
+    u: number;
+    v: number;
+    w: number;
+    d: number;
+    length: number;
+}
+interface Inverter {
+    id: string;
+    u: number;
+    v: number;
+    y: number;
+    side: string;
+    w: number;
+    d: number;
+    h: number;
+    outdoor: boolean;
+    link: string;
+}
+interface Solar {
+    type: 'slab_rack' | 'roof';
+    orientation: string;
+    north: 'front' | 'back';
+    slopeSide: 'front' | 'back' | null;
+    tilt: number;
+    area: number[];
+    areaM2: number;
+    count: number;
+    floor: number;
+    y: number;
+    panels: SolarPanel[];
+    inverter: Inverter | null;
+}
+/** A door or a window in the wall of an outbuilding. */
+interface OutbuildingOpening {
+    id: string;
+    axis: PlanAxis;
+    pos: number;
+    at: number;
+    u: number;
+    v: number;
+    width: number;
+    side: string;
+    height?: number;
+    exterior?: boolean;
+    y0?: number;
+    y1?: number;
+    /** Swing area of a door. */
+    zone?: Rect;
+}
+interface OutbuildingWall {
+    axis: PlanAxis;
+    u0: number;
+    v0: number;
+    u1: number;
+    v1: number;
+    thickness: number;
+    h: number;
+    side: string;
+}
+interface OutbuildingItem {
+    type: string;
+    category: string;
+    u: number;
+    v: number;
+    w: number;
+    d: number;
+    h: number;
+    ry: number;
+    frontU: number;
+    frontV: number;
+    aabb: Rect;
+}
+interface Outbuilding {
+    id: string;
+    type: 'outbuilding';
+    use: string;
+    floor: number;
+    aabb: Rect;
+    interior: Rect[];
+    ceiling: number;
+    thickness: number;
+    front: [number, number];
+    walls: OutbuildingWall[];
+    doors: OutbuildingOpening[];
+    windows: OutbuildingOpening[];
+    items: OutbuildingItem[];
+}
+
+type EnergyMode = 'grid' | 'tap' | 'offgrid';
+/** What a template says about its energy (a shack taps the grid without a meter, a cabin may run off-grid on solar). */
+interface EnergyConfig {
+    mode: EnergyMode;
+    solar?: boolean;
+}
+interface Electrical {
+    mode: EnergyMode;
+    serviceEntrance: ServiceEntrance | null;
+    panel: ElectricalPanel | null;
+    outlets: Outlet[];
+    switches: LightSwitch[];
+    circuits: Circuit[];
+    conduits: Conduit[];
+    exposed: boolean;
+    outdoorLamps: OutdoorLamp[];
+    source?: 'solar' | 'lamp';
+}
+
+interface GasMeter {
+    id: 'gas.meter';
+    u: number;
+    v: number;
+    y: number;
+    side: string;
+    w: number;
+    d: number;
+    h: number;
+}
+interface Gas {
+    type: 'piped' | 'cylinder';
+    meter: GasMeter | null;
+}
+
+interface Utilities {
+    gas: Gas | null;
+    electrical: Electrical;
+    solar: Solar | null;
+    plumbing: Plumbing;
+}
+
 declare const version = "0.1.0";
 
-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, MEMBER_CAGE, 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 };
+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 };

package/dist/index.global.js

@@ -1037,9 +1037,10 @@ var GameFloorplanStructure = (() => {
   }
 
   // src/structure/stairs.ts
+  var isStair = (item) => item.category === "stairs" && typeof item.link === "object" && item.link !== null;
   function flightsOf(items) {
     const flights = /* @__PURE__ */ new Map();
-    for (const item of items.filter((it) => it.category === "stairs" && it.link)) {
+    for (const item of items.filter(isStair)) {
       const key = `${item.link.from}_${item.link.to}`;
       if (!flights.has(key) || item.floor === item.link.from) flights.set(key, item);
     }
@@ -1617,12 +1618,12 @@ var GameFloorplanStructure = (() => {
       const rect = lot.rect;
       const poleU = clamp(gate ? gate.u + 3 : plan.w / 2, rect[0] + 0.5, rect[2] - 0.5);
       const poleV = rect[1] - 0.6;
-      let meter;
+      let placed;
       if (gate) {
         const direction = gate.u - gate.width / 2 - 0.4 >= rect[0] + 0.3 ? -1 : 1;
-        meter = { place: "gate_pillar", u: round22(gate.u + direction * (gate.width / 2 + 0.25)), v: round22(gate.v), y: 1.4, side: "front", ...METER_SIZE };
-      } else meter = { place: "facade", u: round22(door ? door.at + 1.2 : plan.w / 2), v: -0.1, y: 1.4, side: "front", ...METER_SIZE };
-      meter.id = "meter";
+        placed = { place: "gate_pillar", u: round22(gate.u + direction * (gate.width / 2 + 0.25)), v: round22(gate.v), y: 1.4, side: "front", ...METER_SIZE };
+      } else placed = { place: "facade", u: round22(door ? door.at + 1.2 : plan.w / 2), v: -0.1, y: 1.4, side: "front", ...METER_SIZE };
+      const meter = Object.assign(placed, { id: "meter" });
       electrical.serviceEntrance = { pole: { u: round22(poleU), v: round22(poleV), h: 7.5 }, drop: [[round22(poleU), round22(poleV), 6.5], [meter.u, meter.v, 2.6]], meter, descent: [[meter.u, meter.v, 2.6], [meter.u, meter.v, 1.65]], internalRun: null };
     } else if (lot === null || plan.style === "commercial") {
       const front = door ? { u: round22(door.at + 1), v: -0.1 } : { u: round22(plan.w / 2), v: -0.1 };
@@ -1656,7 +1657,8 @@ var GameFloorplanStructure = (() => {
     }
     if (electrical.serviceEntrance && electrical.panel) {
       const entrance = electrical.serviceEntrance;
-      entrance.internalRun = [[entrance.meter.u, entrance.meter.v, 0.1], [electrical.panel.u, electrical.panel.v, heightOf(plan, electrical.panel.floor, electrical.panel.y)]];
+      const meterOf = entrance.meter;
+      entrance.internalRun = [[meterOf.u, meterOf.v, 0.1], [electrical.panel.u, electrical.panel.v, heightOf(plan, electrical.panel.floor, electrical.panel.y)]];
     }
   }
 
@@ -1745,9 +1747,9 @@ var GameFloorplanStructure = (() => {
     placePanel(layout);
     addSwitches(layout);
     addConduits(layout);
-    if (mode === "tap" && electrical.serviceEntrance?.meter) {
-      const entrance = electrical.serviceEntrance;
-      const meter = entrance.meter;
+    const entrance = electrical.serviceEntrance;
+    const meter = entrance?.meter;
+    if (mode === "tap" && entrance && meter) {
       entrance.tap = true;
       entrance.connection = { u: meter.u, v: meter.v, y: 2.6 };
       entrance.meter = null;
@@ -1778,11 +1780,11 @@ var GameFloorplanStructure = (() => {
     };
   }
   function besideStove(context, stove, room, solids, doorZones) {
-    const t = [-stove.frontV, stove.frontU];
+    const t = [-(stove.frontV ?? 1), stove.frontU ?? 0];
     const parts = room.parts.map(inner);
     for (const s of context.rng() < 0.5 ? [1, -1] : [-1, 1]) {
-      const cx = stove.x + t[0] * s * (stove.w / 2 + CYLINDER.w / 2 + 0.03) - stove.frontU * (stove.d - CYLINDER.d) / 2;
-      const cz = stove.z + t[1] * s * (stove.w / 2 + CYLINDER.w / 2 + 0.03) - stove.frontV * (stove.d - CYLINDER.d) / 2;
+      const cx = stove.x + t[0] * s * (stove.w / 2 + CYLINDER.w / 2 + 0.03) - (stove.frontU ?? 0) * (stove.d - CYLINDER.d) / 2;
+      const cz = stove.z + t[1] * s * (stove.w / 2 + CYLINDER.w / 2 + 0.03) - (stove.frontV ?? 1) * (stove.d - CYLINDER.d) / 2;
       const rect = [cx - CYLINDER.w / 2, cz - CYLINDER.d / 2, cx + CYLINDER.w / 2, cz + CYLINDER.d / 2].map(round22);
       const inside = parts.some((q) => rect[0] >= q[0] - 0.011 && rect[2] <= q[2] + 0.011 && rect[1] >= q[1] - 0.011 && rect[3] <= q[3] + 0.011);
       if (inside && !solids.some((o) => overlaps(rect, o, 0.011)) && !doorZones.some((z) => overlaps(rect, z, 0.011))) return { mode: "beside", x: cx, z: cz, rect };
@@ -1838,8 +1840,8 @@ var GameFloorplanStructure = (() => {
       d: CYLINDER.d,
       h: CYLINDER.h,
       y: 0,
-      frontU: -stove.frontU,
-      frontV: -stove.frontV,
+      frontU: -(stove.frontU ?? 0),
+      frontV: -(stove.frontV ?? 1),
       room: stove.room,
       floor: stove.floor,
       outdoor: !!spot.outdoor,
@@ -2099,9 +2101,11 @@ var GameFloorplanStructure = (() => {
     for (const item of items.filter((m) => m.category === "outbuilding")) {
       const rng = context.rngFor(streamOf(item.id));
       const [a0, a1, a2, a3] = item.aabb;
-      const n = [item.frontU, item.frontV];
-      const t = [-item.frontV, item.frontU];
-      const horizontal = Math.abs(item.frontU) === 1;
+      const frontU = item.frontU ?? 0;
+      const frontV = item.frontV ?? 1;
+      const n = [frontU, frontV];
+      const t = [-frontV, frontU];
+      const horizontal = Math.abs(frontU) === 1;
       const cx = (a0 + a2) / 2;
       const cz = (a1 + a3) / 2;
       const depth = horizontal ? a2 - a0 : a3 - a1;
@@ -2338,7 +2342,7 @@ var GameFloorplanStructure = (() => {
   }
   function structureExtension(context) {
     const cache = cacheOf(context.result);
-    const options = { construction: cache.build.construction, extras: cache.build.extras ?? {}, tank: context.result.waterTank ?? null, wallDetail: context.options.wallDetail ?? "panels" };
+    const options = { construction: cache.build.construction, extras: cache.build.extras ?? {}, tank: tankOf(context), wallDetail: context.options.wallDetail ?? "panels" };
     const { roof, ...structure } = buildStructure(context.result, options);
     cache.roof = roof;
     for (const part of structure.parts) {
@@ -2349,6 +2353,7 @@ var GameFloorplanStructure = (() => {
     return structure;
   }
   var COOKING_CYLINDER = { type: "cooking_gas_cylinder", category: "cooking_gas_cylinder", w: 0.36, d: 0.36, h: 0.48 };
+  var tankOf = (context) => context.result.waterTank ?? null;
   function energyOf(context) {
     const energy = context.plan.tpl.energy;
     return typeof energy === "function" ? energy(context.options, context.plan.w, context.plan.d) : void 0;
@@ -2379,10 +2384,11 @@ var GameFloorplanStructure = (() => {
       if (context.result.lot) addOutbuildingPaths(context.result.lot, outbuildings, context.result.items);
       return outbuildings;
     }, { after: ["contents"] });
-    engine.registerResultExtension("utilities", (context) => planUtilities({ plan: context.plan, items: context.result.items, stateItems: context.result.stateItems, tank: context.result.waterTank ?? null, ...energyOf(context) ? { energy: energyOf(context) } : {}, rngFor: (key) => engine.createRng(context.seed, key) }), { after: ["outbuildings", "waterTank"] });
+    engine.registerResultExtension("utilities", (context) => planUtilities({ plan: context.plan, items: context.result.items, stateItems: context.result.stateItems, tank: tankOf(context), ...energyOf(context) ? { energy: energyOf(context) } : {}, rngFor: (key) => engine.createRng(context.seed, key) }), { after: ["outbuildings", "waterTank"] });
   }
 
   // ../game-contracts/dist/index.js
+  var DEFAULT_COST_ALLOCATION_BYTES = 1024 * 1024;
   var DEFAULT_IGNITION_RULES = {
     fillCurve: [
       [0, 0.6],
@@ -2426,6 +2432,54 @@ var GameFloorplanStructure = (() => {
     const flame = flameBase * (1 - rules.flameFillInfluence * (1 - k));
     return 1 - (1 - Math.min(1, Math.max(0, spark))) * (1 - Math.min(1, Math.max(0, flame)));
   };
+  var DEFERRED_QUEUE_ID = {
+    DESTRUCTION_EVENTS: "destruction.events",
+    BREACH_PAINT: "floorplan.breach-paint",
+    AUDIO_VOICES: "audio.voices",
+    VEHICLE_CREASE: "vehicles.crease"
+  };
+  var DEFERRED_PRIORITY = {
+    [DEFERRED_QUEUE_ID.DESTRUCTION_EVENTS]: { priority: 300, phase: "present" },
+    [DEFERRED_QUEUE_ID.BREACH_PAINT]: { priority: 250, phase: "present" },
+    [DEFERRED_QUEUE_ID.AUDIO_VOICES]: { priority: 200, phase: "idle", reserveMs: 1 },
+    [DEFERRED_QUEUE_ID.VEHICLE_CREASE]: { priority: 100, phase: "idle" }
+  };
+  var SURFACE_IDS = ["concrete", "asphalt", "wood", "tile", "dirt", "grass", "gravel", "sand", "metal", "water", "glass", "carpet"];
+  var GAIT_IDS = ["walk", "run"];
+  var LANDING_IDS = ["light", "heavy"];
+  var BODY_SOUND_IDS = [
+    "jump",
+    "cloth_rustle",
+    "body_fall",
+    "fall_damage",
+    "player_hurt",
+    "player_breath_run",
+    "player_death",
+    "bite",
+    "grab",
+    "punch_swing",
+    "punch_hit_body",
+    "punch_hit_face",
+    "punch_hit_object",
+    "kick_swing",
+    "kick_hit",
+    "kick_hit_object",
+    "shove_two_hands",
+    "knife_swing",
+    "knife_stab",
+    "knife_slash",
+    "knife_hit_object",
+    "blunt_swing",
+    "blunt_hit",
+    "blunt_hit_object",
+    "axe_swing",
+    "axe_chop",
+    "axe_hit_object"
+  ];
+  var footstepSoundId = (surface, gait) => `footstep_${surface}_${gait}`;
+  var FOOTSTEP_SOUND_IDS = SURFACE_IDS.flatMap((surface) => GAIT_IDS.map((gait) => footstepSoundId(surface, gait)));
+  var LAND_SOUND_IDS = SURFACE_IDS.flatMap((surface) => LANDING_IDS.map((landing) => `land_${surface}_${landing}`));
+  var BODY_FOLEY_IDS = [...FOOTSTEP_SOUND_IDS, ...LAND_SOUND_IDS, ...BODY_SOUND_IDS];
 
   // ../game-destruction/dist/index.js
   var FIRE_PRIME_C = 300;
@@ -5137,6 +5191,7 @@ var GameFloorplanStructure = (() => {
     const ignitionRules = resolveIgnitionRules(options.ignition);
     const breachBlastFactor = options.breach?.blastFactor ?? BREACH_BLAST_FACTOR;
     const chipEnergy = options.breach?.chipEnergy ?? CHIP_ENERGY;
+    const chainLinkCap = options.chainLinksPerUpdate !== void 0 && options.chainLinksPerUpdate >= 1 ? Math.floor(options.chainLinksPerUpdate) : Infinity;
     const rng = createRng(options.seed ?? 1);
     const rnd = () => rng.next();
     let time = 0;
@@ -5159,7 +5214,13 @@ var GameFloorplanStructure = (() => {
       const typed = listeners.get(e.type);
       if (typed) for (const fn of [...typed]) fn(e);
     };
-    const base = (o, source) => source === void 0 ? { object: o.id, time } : { object: o.id, time, source };
+    let blow;
+    const base = (o, source) => ({
+      object: o.id,
+      time,
+      ...source === void 0 ? {} : { source },
+      ...blow === void 0 ? {} : { blow }
+    });
     const pendingCollapse = /* @__PURE__ */ new Map();
     let runDepth = 0;
     const drainBlasts = () => {
@@ -6084,7 +6145,7 @@ var GameFloorplanStructure = (() => {
       if (disc < 0) return true;
       return -b - Math.sqrt(disc) > maxDist;
     };
-    const raycastInternal = (origin, dir, maxDist, ignore, worldOnly = false) => {
+    const raycastInternal = (origin, dir, maxDist, ignore, worldOnly = false, precise = false) => {
       const d = vec.normalize(dir);
       let best = null;
       for (const o of objects.values()) {
@@ -6099,13 +6160,25 @@ var GameFloorplanStructure = (() => {
         }
       }
       for (const im of worldOnly ? [] : impls.values()) {
+        let boxHit = null;
         for (const ps of im.impl.describe().parts) {
           if (ignore?.has(`${im.impl.id}\0${ps.id}`)) continue;
           const ov = im.poses.get(ps.id);
           const r = rayPartRaw(im.position, im.rotation, ps, ov?.q ?? quatFromEuler(...ps.rotation ?? [0, 0, 0]), origin, d, ov?.pos);
-          if (!r || r.t0 < 0 || r.t0 > maxDist) continue;
-          if (!best || r.t0 < best.distance) best = { object: im.impl.id, part: ps.id, point: vec.madd(origin, d, r.t0), normal: r.n, distance: r.t0, pathLen: r.t1 - r.t0 };
+          if (!r || r.t1 < 0 || r.t0 > maxDist) continue;
+          if (r.t0 < 0) {
+            if (precise && im.impl.surfaceRay) boxHit = boxHit ?? { object: im.impl.id, part: ps.id, point: origin, normal: r.n, distance: 0, pathLen: r.t1 };
+            continue;
+          }
+          if (!boxHit || r.t0 < boxHit.distance) boxHit = { object: im.impl.id, part: ps.id, point: vec.madd(origin, d, r.t0), normal: r.n, distance: r.t0, pathLen: r.t1 - r.t0 };
         }
+        if (!boxHit) continue;
+        if (precise && im.impl.surfaceRay) {
+          const far = best ? Math.min(maxDist, best.distance) : maxDist;
+          const implId = im.impl.id;
+          const s = im.impl.surfaceRay({ origin, direction: d, maxDistance: far, ...ignore ? { ignored: (part) => ignore.has(`${implId}\0${part}`) } : {} });
+          if (s && (!best || s.distance < best.distance)) best = { object: implId, part: s.part, point: s.point, normal: s.normal, distance: s.distance, pathLen: s.pathLen };
+        } else if (!best || boxHit.distance < best.distance) best = boxHit;
       }
       return best;
     };
@@ -7292,7 +7365,17 @@ var GameFloorplanStructure = (() => {
       res.events = cur.slice(start);
       return res;
     };
-    const doHit = (o, hit, only) => {
+    const withBlow = (type, fn) => () => {
+      const outer = blow;
+      blow = type;
+      try {
+        return fn();
+      } finally {
+        blow = outer;
+      }
+    };
+    const doHit = (o, hit, only) => withBlow(hit.type, () => resolveHit(o, hit, only))();
+    const resolveHit = (o, hit, only) => {
       let point = hit.point;
       let dir = hit.direction;
       if (hit.space === "local") {
@@ -7589,7 +7672,9 @@ var GameFloorplanStructure = (() => {
     };
     const detonatePrimed = (until) => {
       const end = time;
-      for (let next = nextPrimed(until); next; next = nextPrimed(until)) {
+      let fired = 0;
+      for (let next = nextPrimed(until); next && fired < chainLinkCap; next = nextPrimed(until)) {
+        fired++;
         primed.delete(next.p);
         time = Math.max(0, Math.min(end, next.p.rt.chainDue));
         next.p.rt.chainDue = void 0;
@@ -7659,6 +7744,7 @@ var GameFloorplanStructure = (() => {
         updateBound(o);
       },
       remove(id) {
+        impls.get(id)?.impl.dispose?.();
         objects.delete(id);
         impls.delete(id);
       },
@@ -7728,13 +7814,51 @@ var GameFloorplanStructure = (() => {
       blastProbe() {
         return { ...blastProbe };
       },
+      blastReach(point, target, options2 = {}) {
+        const L = vec.distance(point, target);
+        if (L < 1e-4) return 1;
+        const shelter = { ...SHELTER_DEFAULTS, ...options2.shelter };
+        const ignore = new Set(options2.ignore ?? []);
+        const d = vec.scale(vec.sub(target, point), 1 / L);
+        let t = 1;
+        for (const o of objects.values()) {
+          if (ignore.has(o.id) || raySphereMiss(point, d, toWorld(o.st.position, o.st.rotation, o.bc), o.br, L)) continue;
+          for (const p of o.parts) {
+            if (isLost(p) || p.st.stripped) continue;
+            const r = rayPart(o, p, point, d);
+            if (!r) continue;
+            const t0 = Math.max(r.t0, 0);
+            const path = Math.min(r.t1, L) - t0;
+            if (path < shelter.minPath) continue;
+            if (p.st.opening && insideOpening(o, p, toLocal(o.st.position, o.st.rotation, vec.madd(point, d, t0 + path / 2)))) continue;
+            t *= Math.exp(-(p.mat.hpPerKg * p.mat.density * path * (p.mat.damageScale?.shelter ?? 1)) / shelter.k);
+            if (t < 1e-4) return 0;
+          }
+        }
+        for (const im of impls.values()) {
+          if (ignore.has(im.impl.id)) continue;
+          for (const ps of im.impl.describe().parts) {
+            const mat = materials.get(ps.material);
+            if (!mat) continue;
+            const ov = im.poses.get(ps.id);
+            const r = rayPartRaw(im.position, im.rotation, ps, ov?.q ?? quatFromEuler(...ps.rotation ?? [0, 0, 0]), point, d, ov?.pos);
+            if (!r || r.t1 < 0 || r.t0 > L) continue;
+            let path = Math.min(r.t1, L) - Math.max(r.t0, 0);
+            if (ps.thickness !== void 0 && ps.thickness > 0) path = Math.min(path, 2 * ps.thickness);
+            else if (path < shelter.minPath) continue;
+            t *= Math.exp(-(mat.hpPerKg * mat.density * path * (mat.damageScale?.shelter ?? 1)) / shelter.k);
+            if (t < 1e-4) return 0;
+          }
+        }
+        return t;
+      },
       explode(point, energy, radius, source, blast) {
         blastProbe.partsTested = 0;
         blastProbe.partsNear = 0;
         return withCollapses(run(() => blastWorld(point, energy, radius, source, blast)));
       },
       raycast(origin, direction, maxDistance = Infinity) {
-        const r = raycastInternal(origin, direction, maxDistance);
+        const r = raycastInternal(origin, direction, maxDistance, void 0, false, true);
         return r ? { object: r.object, part: r.part, point: r.point, normal: r.normal, distance: r.distance } : null;
       },
       sweepBox(box2, direction, distance2, options2 = {}) {
@@ -7752,21 +7876,23 @@ var GameFloorplanStructure = (() => {
       },
       shoot(origin, direction, energy, caliber, source, round3) {
         const extras = typeof round3 === "number" ? { piercing: round3 } : round3 ?? {};
-        return withCollapses(run(() => {
+        return withCollapses(run(withBlow("ballistic", () => {
           const results = [];
           const d = vec.normalize(direction);
           const ignore = /* @__PURE__ */ new Set();
           let org = origin;
           let E = energy;
           for (let i = 0; i < 4 && E > 0; i++) {
-            const rh = raycastInternal(org, d, Infinity, ignore);
+            const rh = raycastInternal(org, d, Infinity, ignore, false, true);
             if (!rh) break;
             const im = impls.get(rh.object);
             if (im) {
-              const r = implHit(im, { type: "ballistic", point: rh.point, direction: d, energy: E, caliber, ...extras, ...source !== void 0 ? { source } : {} });
+              const scaled = extras.penetration && E < energy ? { ...extras, penetration: Object.fromEntries(Object.entries(extras.penetration).map(([k, mm]) => [k, mm * (E / energy)])) } : extras;
+              const r = implHit(im, { type: "ballistic", point: rh.point, part: rh.part, normal: rh.normal, direction: d, energy: E, caliber, ...scaled, ...source !== void 0 ? { source } : {} });
               r.part = rh.part;
               r.point = rh.point;
-              r.exitEnergy = r.penetrated ? E * 0.5 : 0;
+              const left = r.events.find((e) => e.type === "hole" && e.energyLeft !== void 0);
+              r.exitEnergy = r.penetrated ? left?.energyLeft ?? E * 0.5 : 0;
               results.push(r);
               ignore.add(`${im.impl.id}\0${rh.part}`);
               if (!r.penetrated) break;
@@ -7785,7 +7911,7 @@ var GameFloorplanStructure = (() => {
             E = out.exitEnergy;
           }
           return results;
-        }));
+        })));
       },
       disassemble(objectId, jointId, tool, dt) {
         const im = impls.get(objectId);
@@ -8085,12 +8211,27 @@ var GameFloorplanStructure = (() => {
       breach: { area: 0.1 }
     }
   ];
+  var SHIPPED = structuredClone(assemblies_default);
   var ASSEMBLIES = assemblies_default;
-  var getAssembly = (id) => ASSEMBLIES.find((a) => a.id === id);
+  var assembliesOver = (defs) => {
+    const get = (id) => defs.find((a) => a.id === id);
+    return {
+      list: () => defs,
+      get,
+      register(def) {
+        const at2 = defs.findIndex((a) => a.id === def.id);
+        if (at2 >= 0) defs[at2] = def;
+        else defs.push(def);
+      },
+      part: (assemblyId, options) => buildAssemblyPart(get(assemblyId), assemblyId, options)
+    };
+  };
+  var defaultSet;
+  var defaultAssemblies = () => defaultSet ?? (defaultSet = assembliesOver(ASSEMBLIES));
+  var getAssembly = (id) => defaultAssemblies().get(id);
   var faceCount = (layer) => layer.faces === "both" ? 2 : 1;
   var assemblyDepth = (def) => def.depth ?? def.core.thickness + (def.layers ?? []).reduce((sum, l) => sum + l.thickness * faceCount(l), 0);
-  var assemblyPart = (assemblyId, options) => {
-    const def = getAssembly(assemblyId);
+  var buildAssemblyPart = (def, assemblyId, options) => {
     if (!def) throw new Error(`unknown assembly "${assemblyId}"`);
     const densityOf2 = (id) => {
       const m = options.materials?.get(id) ?? MATERIALS.find((x) => x.id === id);
@@ -8117,6 +8258,7 @@ var GameFloorplanStructure = (() => {
       ...options.extra
     };
   };
+  var assemblyPart = (assemblyId, options) => defaultAssemblies().part(assemblyId, options);
   var buildFrame = (o = {}) => {
     const spanX = o.spanX ?? 8, spanZ = o.spanZ ?? 8;
     const nx = Math.max(2, o.columnsX ?? 3), nz = Math.max(2, o.columnsZ ?? 3);