@adatechnology/game-floorplan-three 0.8.2 → 0.9.0

package/dist/index.global.js

@@ -70,7 +70,7 @@ var GameFloorplanThree = (() => {
     shade: () => shade
   });
 
-  // ../game-shapes/dist/chunk-R4RY23RH.js
+  // ../game-shapes/dist/chunk-IFXQIDSA.js
   function canonicalJson(value) {
     if (value === null) return "null";
     if (typeof value === "number") return Object.is(value, -0) ? "-0" : Number.isFinite(value) ? String(value) : JSON.stringify(String(value));
@@ -1538,6 +1538,107 @@ var GameFloorplanThree = (() => {
     return { positions: positions2, normals, uvs };
   }
 
+  // ../game-contracts/dist/index.js
+  var DEFAULT_COST_ALLOCATION_BYTES = 1024 * 1024;
+  var DEFAULT_IGNITION_RULES = {
+    fillCurve: [
+      [0, 0.6],
+      [0.1, 1],
+      [0.35, 0.6],
+      [0.65, 0.3],
+      [0.9, 0.15],
+      [1, 0.12]
+    ],
+    flameFillInfluence: 0.5,
+    flameDefaults: { incendiary: 0.7, tracer: 0.2 },
+    sparkTarget: { steel: 1, iron: 1, aluminium: 0.25 },
+    sparkMetalDefault: 0.5,
+    sparkFluid: { diesel: 0.15 },
+    fireNear: { radius: 1.5, chancePerSecond: 0.5 }
+  };
+  var resolveIgnitionRules = (rules) => ({
+    ...DEFAULT_IGNITION_RULES,
+    ...rules,
+    flameDefaults: { ...DEFAULT_IGNITION_RULES.flameDefaults, ...rules?.flameDefaults },
+    sparkTarget: { ...DEFAULT_IGNITION_RULES.sparkTarget, ...rules?.sparkTarget },
+    sparkFluid: { ...DEFAULT_IGNITION_RULES.sparkFluid, ...rules?.sparkFluid },
+    fireNear: { ...DEFAULT_IGNITION_RULES.fireNear, ...rules?.fireNear }
+  });
+  var fillFactor = (fill2, curve = DEFAULT_IGNITION_RULES.fillCurve) => {
+    if (curve.length === 0) return 1;
+    const f = Math.min(1, Math.max(0, fill2));
+    if (f <= curve[0][0]) return curve[0][1];
+    for (let i = 1; i < curve.length; i++) {
+      const [x1, y1] = curve[i];
+      const [x0, y0] = curve[i - 1];
+      if (f <= x1) return x1 === x0 ? y1 : y0 + (y1 - y0) * (f - x0) / (x1 - x0);
+    }
+    return curve[curve.length - 1][1];
+  };
+  var sparkTargetFactor = (materialId, metal, rules = DEFAULT_IGNITION_RULES) => !metal ? 0 : rules.sparkTarget[materialId] ?? rules.sparkMetalDefault;
+  var ignitionChance = (hit, target, rules = DEFAULT_IGNITION_RULES) => {
+    const k = fillFactor(target.fill, rules.fillCurve);
+    const spark = (hit.ignition?.spark ?? 0) * target.sparkTarget * (target.fluid === void 0 ? 1 : rules.sparkFluid[target.fluid] ?? 1) * k;
+    const flameBase = hit.ignition?.flame ?? Math.max(hit.incendiary ? rules.flameDefaults.incendiary : 0, hit.tracer ? rules.flameDefaults.tracer : 0);
+    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 KIT_ORIGIN_KEY = "kitOrigin";
+  function markKitOrigin(object2, origin) {
+    const node = object2;
+    node.userData = node.userData ?? {};
+    node.userData[KIT_ORIGIN_KEY] = { ...origin };
+    return object2;
+  }
+  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-shapes-three/dist/index.js
   var UV_BEFORE_NORMAL = /* @__PURE__ */ new Set(["LatheGeometry", "ExtrudeGeometry"]);
   var INDEX_FIRST = /* @__PURE__ */ new Set(["BoxGeometry", "CylinderGeometry", "ConeGeometry", "SphereGeometry", "PlaneGeometry", "CircleGeometry", "RingGeometry", "LatheGeometry", "TorusGeometry"]);
@@ -8997,7 +9098,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const em = w.emitters();
       if (em.length && !IV.efx && K.IVK.effects) {
         const g = h.houseGroup;
-        IV.efx = ik.gfx.createEffects(g, { maxParticles: 1400, seed: 11, document: DOC });
+        IV.efx = ik.gfx.createEffects(g, { maxParticles: 1400, seed: 11, document: DOC, ...K.IVK.effectSink ? { effects: K.IVK.effectSink } : {} });
       }
       if (IV.efx) {
         const alive = IV.efx.stats().alive;
@@ -10614,7 +10715,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         return null;
       }
       const A = AD.plan ? AD : AD.create({ ...o.adapterOptions || {}, GameInteractables: GI, GameInteractablesHousehold: HH, locale: o.locale || cfg.locale, region: o.region, ...cfg.seedKey ? { seedKey: cfg.seedKey } : {} });
-      return { GI, HH, GT, A, gfx: GT.createThreeAdapter(THREE, { document: DOC, Reflector }), items: o.items !== false, effects: o.effects !== false, camera: o.camera || null, onEvent: o.onEvent || null, onSeat: o.onSeat || null };
+      return { GI, HH, GT, A, gfx: GT.createThreeAdapter(THREE, { document: DOC, Reflector }), items: o.items !== false, effects: o.effects !== false, effectSink: o.effectSink || null, camera: o.camera || null, onEvent: o.onEvent || null, onSeat: o.onSeat || null };
     })();
     const VEG = (() => {
       const l = cfg.vegetation || null, G = l && (l.GameVegetation || (l.buildLot ? l : null)), S = l && (l.GameVegetationSpecies || (l.toSpec ? l : null));
@@ -10631,7 +10732,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
 
   // src/lights/room-light.ts
   function installLightsRoomLight(K, shared) {
-    const { THREE, rectsOf: rectsOf2 } = K;
+    const { THREE, rectsOf: rectsOf2, cfg } = K;
     const MAX_LIGHTS = 12, EMPTY = [1e9, 1e9, -1e9, -1e9];
     const LZU = { uRB0: { value: new Float32Array(MAX_LIGHTS * 4) }, uRB1: { value: new Float32Array(MAX_LIGHTS * 4) }, uRB2: { value: new Float32Array(MAX_LIGHTS * 4) }, uRBY: { value: new Float32Array(MAX_LIGHTS * 2) }, uREx: { value: new Float32Array(MAX_LIGHTS * 4) }, uIndK: { value: 0.06 } };
     for (let i = 0; i < MAX_LIGHTS; i++) for (const k of ["uRB0", "uRB1", "uRB2", "uREx"]) LZU[k].value.set(EMPTY, i * 4);
@@ -10670,8 +10771,15 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       o = o || {};
       const scene = o.scene, N = Math.max(1, Math.min(MAX_LIGHTS, o.n || 6)), NS = Math.max(0, Math.min(N, o.shadows != null ? o.shadows : 2)), size = o.shadowSize || 512, MAX_EXTERNAL = o.external != null ? o.external : 2;
       for (const k of Object.keys(shared.mats)) roomLightMask(shared.mats[k]);
+      const budget = o.budget, lease = budget ? budget.lease({ owner: "floorplan.rooms", point: N, shadows: NS }) : null;
+      if (budget && !lease) throw new Error("lighting: the LightBudget has no " + N + " free point slots (" + NS + " with shadow) for the rooms");
+      if (budget) for (const [key, width] of [["uRB0", 4], ["uRB1", 4], ["uRB2", 4], ["uRBY", 2], ["uREx", 4]]) {
+        const next = new Float32Array(budget.sizes.point * width);
+        if (width === 4) for (let i = 0; i < budget.sizes.point; i++) next.set(EMPTY, i * 4);
+        LZU[key].value = next;
+      }
       const PL = [], sig = new Array(N).fill(""), seg = { n: 0 };
-      for (let i = 0; i < N; i++) {
+      if (!lease) for (let i = 0; i < N; i++) {
         const l = new THREE.PointLight(16763008, 0, 8, 1.6);
         l.visible = true;
         l.castShadow = i < NS;
@@ -10687,12 +10795,30 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         if (scene) scene.add(l);
         PL.push(l);
       }
-      const A = { lights: PL, crates: new Array(N).fill(null), n: N, shadows: NS, stats: { rooms: 0, external: 0, shadows: 0, shadowChanged: false }, indirect: (v) => {
+      const slotOf = (i) => lease ? lease.handles[i].slot : i;
+      const put = (i, v) => {
+        if (lease) {
+          lease.handles[i].update(v.color === void 0 || typeof v.color === "number" ? v : { ...v, color: new THREE.Color(v.color).getHex() });
+          return;
+        }
+        const pl = PL[i];
+        if (v.position) pl.position.set(v.position[0], v.position[1], v.position[2]);
+        if (v.color !== void 0) pl.color.set(v.color);
+        if (v.intensity !== void 0) pl.intensity = v.intensity;
+        if (v.distance !== void 0) pl.distance = v.distance;
+        if (v.decay !== void 0) pl.decay = v.decay;
+      };
+      const effects = lease ? effectLights({ budget, ours: lease.handles.map((h) => h.slot) }) : null;
+      const A = { lights: lease ? lease.handles : PL, crates: new Array(N).fill(null), n: N, shadows: NS, stats: { rooms: 0, external: 0, shadows: 0, shadowChanged: false }, indirect: (v) => {
         LZU.uIndK.value = v;
       } };
       const _p = new THREE.Vector3(), _f = new THREE.Vector3();
       const lim = (v, a, b) => Math.max(a, Math.min(b, v));
       A.invalidate = () => {
+        if (lease) {
+          lease.invalidateShadow();
+          return;
+        }
         for (let i = 0; i < NS; i++) PL[i].shadow.needsUpdate = true;
       };
       A.update = function(houses2, focus, op) {
@@ -10800,47 +10926,44 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         A.stats.external = Ne;
         let shadows = 0;
         for (let i = 0; i < N; i++) {
-          const pl = PL[i], g = asg[i], b0 = LZU.uRB0.value, b1 = LZU.uRB1.value, b2 = LZU.uRB2.value, by = LZU.uRBY.value, ex = LZU.uREx.value;
+          const g = asg[i], at = slotOf(i), b0 = LZU.uRB0.value, b1 = LZU.uRB1.value, b2 = LZU.uRB2.value, by = LZU.uRBY.value, ex = LZU.uREx.value;
           A.crates[i] = g ? { k: g.k, rects: g.rects, y: g.y, exterior: !!g.exterior, exclusion: g.exclusion || null, d: g.d } : null;
           if (!g) {
-            pl.intensity = 0;
-            for (const a of [b0, b1, b2, ex]) a.set(EMPTY, i * 4);
-            by.set([0, 0], i * 2);
+            put(i, { intensity: 0 });
+            for (const a of [b0, b1, b2, ex]) a.set(EMPTY, at * 4);
+            by.set([0, 0], at * 2);
             continue;
           }
-          pl.position.set(g.pos[0], g.pos[1], g.pos[2]);
-          pl.color.set(g.color);
-          if (g.exterior) {
-            pl.intensity = g.lumens;
-            pl.distance = g.dist;
-            pl.decay = g.decay;
-          } else {
-            pl.intensity = (7 + g.range * 0.8) * lim(1 + 0.4 * (Math.sqrt(g.n) - 1), 1, 2.2);
-            pl.distance = Math.max(3, g.dm * 1.3 + 0.5);
-            pl.decay = 1.6;
-          }
+          const lamp = g.exterior ? { intensity: g.lumens, distance: g.dist, decay: g.decay } : { intensity: (7 + g.range * 0.8) * lim(1 + 0.4 * (Math.sqrt(g.n) - 1), 1, 2.2), distance: Math.max(3, g.dm * 1.3 + 0.5), decay: 1.6 };
+          put(i, { position: g.pos, color: g.color, ...lamp });
           const rs = g.rects;
-          b0.set(rs[0] || EMPTY, i * 4);
-          b1.set(rs[1] || EMPTY, i * 4);
-          b2.set(rs[2] || EMPTY, i * 4);
-          by.set(g.y, i * 2);
-          ex.set(g.exclusion || EMPTY, i * 4);
+          b0.set(rs[0] || EMPTY, at * 4);
+          b1.set(rs[1] || EMPTY, at * 4);
+          b2.set(rs[2] || EMPTY, at * 4);
+          by.set(g.y, at * 2);
+          ex.set(g.exclusion || EMPTY, at * 4);
           if (i < NS) {
             shadows++;
             const s2 = g.house.group.uuid + "|" + g.k + "|" + g.pos.map((v) => v.toFixed(2)).join(",");
             if (sig[i] !== s2) {
               sig[i] = s2;
-              pl.shadow.needsUpdate = true;
+              if (lease) lease.invalidateShadow(i);
+              else PL[i].shadow.needsUpdate = true;
               seg.n++;
               A.stats.shadowChanged = true;
             }
-            pl.shadow.camera.far = Math.max(4, pl.distance);
+            if (!lease) PL[i].shadow.camera.far = Math.max(4, lamp.distance);
           }
         }
+        if (effects) effects.update(houses2);
         A.stats.shadows = shadows;
         return A.stats;
       };
       A.dispose = () => {
+        if (lease) {
+          lease.release();
+          return;
+        }
         for (const l of PL) {
           if (l.shadow && l.shadow.map) l.shadow.map.dispose();
           l.removeFromParent();
@@ -10848,59 +10971,116 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       };
       return A;
     }
-    Object.assign(K, { MAX_LIGHTS, EMPTY, LZU, roomLightMask, lighting });
-  }
-
-  // ../game-contracts/dist/index.js
-  var DEFAULT_IGNITION_RULES = {
-    fillCurve: [
-      [0, 0.6],
-      [0.1, 1],
-      [0.35, 0.6],
-      [0.65, 0.3],
-      [0.9, 0.15],
-      [1, 0.12]
-    ],
-    flameFillInfluence: 0.5,
-    flameDefaults: { incendiary: 0.7, tracer: 0.2 },
-    sparkTarget: { steel: 1, iron: 1, aluminium: 0.25 },
-    sparkMetalDefault: 0.5,
-    sparkFluid: { diesel: 0.15 },
-    fireNear: { radius: 1.5, chancePerSecond: 0.5 }
-  };
-  var resolveIgnitionRules = (rules) => ({
-    ...DEFAULT_IGNITION_RULES,
-    ...rules,
-    flameDefaults: { ...DEFAULT_IGNITION_RULES.flameDefaults, ...rules?.flameDefaults },
-    sparkTarget: { ...DEFAULT_IGNITION_RULES.sparkTarget, ...rules?.sparkTarget },
-    sparkFluid: { ...DEFAULT_IGNITION_RULES.sparkFluid, ...rules?.sparkFluid },
-    fireNear: { ...DEFAULT_IGNITION_RULES.fireNear, ...rules?.fireNear }
-  });
-  var fillFactor = (fill2, curve = DEFAULT_IGNITION_RULES.fillCurve) => {
-    if (curve.length === 0) return 1;
-    const f = Math.min(1, Math.max(0, fill2));
-    if (f <= curve[0][0]) return curve[0][1];
-    for (let i = 1; i < curve.length; i++) {
-      const [x1, y1] = curve[i];
-      const [x0, y0] = curve[i - 1];
-      if (f <= x1) return x1 === x0 ? y1 : y0 + (y1 - y0) * (f - x0) / (x1 - x0);
+    const effectsByBudget = /* @__PURE__ */ new WeakMap();
+    const OPENING_REACH = 2.5, OPENING_SIDE = 0.6;
+    function effectLights(o) {
+      o = o || {};
+      const budget = o.budget;
+      if (!budget) throw new Error("effectLights: a LightBudget is required");
+      const known = effectsByBudget.get(budget);
+      if (known && !o.ours) return known;
+      const ours = new Set(o.ours || []), size = budget.sizes.point, _p = new THREE.Vector3(), P0 = new THREE.Vector3();
+      for (const [key, width] of [["uRB0", 4], ["uRB1", 4], ["uRB2", 4], ["uRBY", 2], ["uREx", 4]]) {
+        const had = LZU[key].value;
+        if (had.length >= size * width) continue;
+        const next = new Float32Array(size * width);
+        if (width === 4) for (let i = 0; i < size; i++) next.set(EMPTY, i * 4);
+        next.set(had);
+        LZU[key].value = next;
+      }
+      const roomBoxes = (house, M) => {
+        const list2 = [];
+        for (const c of house.r.rooms) {
+          if (c.type === "void") continue;
+          const rs = [];
+          for (const [a, b, c2, d] of rectsOf2(c)) {
+            let x0 = 1e9, z0 = 1e9, x1 = -1e9, z1 = -1e9;
+            for (const [u, v] of [[a, b], [c2, b], [a, d], [c2, d]]) {
+              _p.set(u, 0, v).applyMatrix4(M);
+              x0 = Math.min(x0, _p.x);
+              x1 = Math.max(x1, _p.x);
+              z0 = Math.min(z0, _p.z);
+              z1 = Math.max(z1, _p.z);
+            }
+            rs.push([x0 - 0.08, z0 - 0.08, x1 + 0.08, z1 + 0.08]);
+          }
+          _p.set(0, house.y0(c.floor), 0).applyMatrix4(M);
+          list2.push({ c, rs, y: [_p.y - 0.06, _p.y + (c.ceiling || 2.8) + 0.3] });
+        }
+        return list2;
+      };
+      const boxAt = (boxes, x, y, z) => boxes.find((q) => y >= q.y[0] && y <= q.y[1] && q.rs.some((r) => x >= r[0] && x <= r[2] && z >= r[1] && z <= r[3]));
+      const openingSides = (house, M, boxes, into) => {
+        const open = house.internal && house.internal.doorState || /* @__PURE__ */ new Map();
+        const reach = (list2, isDoor) => {
+          for (const p of list2 || []) {
+            if (isDoor && !(open.has(p.id) ? open.get(p.id) : !!p.open)) continue;
+            const alongU = p.axis === "u", y = house.y0(p.floor) + (isDoor ? 1 : ((p.y0 != null ? p.y0 : 0.9) + (p.y1 != null ? p.y1 : 2)) / 2);
+            const at = (side) => _p.set(alongU ? p.at : p.pos + side, y, alongU ? p.pos + side : p.at).applyMatrix4(M).clone();
+            if (at(0).distanceTo(P0) > OPENING_REACH) continue;
+            for (const side of [-OPENING_SIDE, OPENING_SIDE]) {
+              const w = at(side), hit = boxAt(boxes, w.x, w.y, w.z);
+              if (hit) into.set(hit.c, hit);
+            }
+          }
+        };
+        reach(house.r.doors, true);
+        reach(house.r.windows, false);
+      };
+      const clear = (at) => {
+        for (const key of ["uRB0", "uRB1", "uRB2", "uREx"]) LZU[key].value.set(EMPTY, at * 4);
+        LZU.uRBY.value.set([0, 0], at * 2);
+      };
+      const write = (at, into) => {
+        const rs = [];
+        let lo = 1e9, hi = -1e9;
+        for (const q of into.values()) {
+          rs.push(...q.rs);
+          lo = Math.min(lo, q.y[0]);
+          hi = Math.max(hi, q.y[1]);
+        }
+        while (rs.length > 3) {
+          const r23 = rs.pop(), r1 = rs[rs.length - 1];
+          rs[rs.length - 1] = [Math.min(r1[0], r23[0]), Math.min(r1[1], r23[1]), Math.max(r1[2], r23[2]), Math.max(r1[3], r23[3])];
+        }
+        LZU.uRB0.value.set(rs[0] || EMPTY, at * 4);
+        LZU.uRB1.value.set(rs[1] || EMPTY, at * 4);
+        LZU.uRB2.value.set(rs[2] || EMPTY, at * 4);
+        LZU.uRBY.value.set([lo, hi], at * 2);
+        LZU.uREx.value.set(EMPTY, at * 4);
+      };
+      const A = {
+        /** Once per frame, after the budget's `present`: points the mask of every lit slot that is not the house's at the rooms its light reaches. */
+        update(houses2) {
+          const indoors = cfg.effectLightsIndoors !== false, list2 = (Array.isArray(houses2) ? houses2 : [houses2]).filter(Boolean), cache2 = /* @__PURE__ */ new Map();
+          for (let at = 0; at < size; at++) {
+            if (ours.has(at)) continue;
+            const light = budget.group.children[at];
+            if (!indoors || !light || !light.isPointLight || !(light.intensity > 0) || !light.visible) {
+              clear(at);
+              continue;
+            }
+            const into = /* @__PURE__ */ new Map();
+            P0.set(light.position.x, light.position.y, light.position.z);
+            for (const house of list2) {
+              if (house.group && !house.group.visible) continue;
+              house.house.updateMatrixWorld(true);
+              const M = house.house.matrixWorld;
+              let boxes = cache2.get(house);
+              if (!boxes) cache2.set(house, boxes = roomBoxes(house, M));
+              const here = boxAt(boxes, P0.x, P0.y, P0.z);
+              if (here) into.set(here.c, here);
+              openingSides(house, M, boxes, into);
+            }
+            if (into.size) write(at, into);
+            else clear(at);
+          }
+        }
+      };
+      if (!o.ours) effectsByBudget.set(budget, A);
+      return A;
     }
-    return curve[curve.length - 1][1];
-  };
-  var sparkTargetFactor = (materialId, metal, rules = DEFAULT_IGNITION_RULES) => !metal ? 0 : rules.sparkTarget[materialId] ?? rules.sparkMetalDefault;
-  var ignitionChance = (hit, target, rules = DEFAULT_IGNITION_RULES) => {
-    const k = fillFactor(target.fill, rules.fillCurve);
-    const spark = (hit.ignition?.spark ?? 0) * target.sparkTarget * (target.fluid === void 0 ? 1 : rules.sparkFluid[target.fluid] ?? 1) * k;
-    const flameBase = hit.ignition?.flame ?? Math.max(hit.incendiary ? rules.flameDefaults.incendiary : 0, hit.tracer ? rules.flameDefaults.tracer : 0);
-    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 KIT_ORIGIN_KEY = "kitOrigin";
-  function markKitOrigin(object2, origin) {
-    const node = object2;
-    node.userData = node.userData ?? {};
-    node.userData[KIT_ORIGIN_KEY] = { ...origin };
-    return object2;
+    Object.assign(K, { MAX_LIGHTS, EMPTY, LZU, roomLightMask, lighting, effectLights });
   }
 
   // ../game-destruction/dist/index.js
@@ -13613,6 +13793,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     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 rng2 = createRng(options.seed ?? 1);
     const rnd = () => rng2.next();
     let time = 0;
@@ -14560,7 +14741,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       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()) {
@@ -14575,13 +14756,25 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         }
       }
       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;
     };
@@ -16065,7 +16258,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     };
     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;
@@ -16135,6 +16330,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         updateBound(o);
       },
       remove(id) {
+        impls.get(id)?.impl.dispose?.();
         objects.delete(id);
         impls.delete(id);
       },
@@ -16210,7 +16406,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         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(box3, direction, distance2, options2 = {}) {
@@ -16235,11 +16431,11 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           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 r = implHit(im, { type: "ballistic", point: rh.point, part: rh.part, normal: rh.normal, direction: d, energy: E, caliber, ...extras, ...source !== void 0 ? { source } : {} });
               r.part = rh.part;
               r.point = rh.point;
               r.exitEnergy = r.penetrated ? E * 0.5 : 0;
@@ -16561,12 +16757,27 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       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 at = defs.findIndex((a) => a.id === def.id);
+        if (at >= 0) defs[at] = 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) ?? MATERIALS2.find((x) => x.id === id);
@@ -16593,6 +16804,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       ...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);
@@ -19774,6 +19986,34 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   }
   function installDestructionBreach(K, _shared) {
     const { THREE, fragmentMaterial, invalidate, invalidateShadow } = K;
+    const paintState = { attached: false };
+    const paintQueues = /* @__PURE__ */ new Set();
+    const paintQueue = {
+      id: DEFERRED_QUEUE_ID.BREACH_PAINT,
+      pending: () => {
+        let n = 0;
+        for (const q of paintQueues) n += q.pending();
+        return n;
+      },
+      run(deadline, clock) {
+        let ran = 0;
+        for (const q of [...paintQueues]) {
+          if (q.pending() === 0) continue;
+          if (ran > 0 && clock() >= deadline) break;
+          ran += q.run(deadline, clock);
+        }
+        return ran;
+      },
+      flush() {
+        for (const q of [...paintQueues]) q.flush();
+      },
+      attach() {
+        paintState.attached = true;
+      },
+      detach() {
+        paintState.attached = false;
+      }
+    };
     function createBreachView(opts) {
       const { house, structure } = opts;
       const views = /* @__PURE__ */ new Map();
@@ -20088,8 +20328,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           else s.data = collapseRange(s.it.mesh, s.v0, s.it.v1);
         }
       }
-      function flush(budgetMs = paintBudgetMs) {
+      function flush(budgetMs) {
         if (dirty.size === 0) return 0;
+        if (budgetMs === void 0 && paintState.attached) return dirty.size;
+        budgetMs ?? (budgetMs = paintBudgetMs);
         const deadline = performance.now() + budgetMs;
         for (const view of dirty) {
           dirty.delete(view);
@@ -20100,6 +20342,34 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         invalidateShadow();
         return dirty.size;
       }
+      const queue = {
+        id: DEFERRED_QUEUE_ID.BREACH_PAINT,
+        pending: () => dirty.size,
+        run(deadline, clock) {
+          let ran = 0;
+          for (const view of dirty) {
+            dirty.delete(view);
+            paint(view);
+            ran++;
+            if (clock() >= deadline) break;
+          }
+          if (ran > 0) {
+            invalidate();
+            invalidateShadow();
+          }
+          return ran;
+        },
+        flush() {
+          flush(Infinity);
+        },
+        attach() {
+          paintState.attached = true;
+        },
+        detach() {
+          paintState.attached = false;
+        }
+      };
+      paintQueues.add(queue);
       function dispose(view) {
         dirty.delete(view);
         if (view.units) {
@@ -20134,6 +20404,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
          */
         claim() {
           var _a;
+          paintQueues.add(queue);
           for (const q of opts.spec()?.parts ?? []) {
             if (!q.units) continue;
             const host = hostOf(q.id);
@@ -20186,6 +20457,12 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           dropped.length = 0;
         },
         flush,
+        /** Takes this house's painting out of the renderer's queue (the house goes away); `claim` puts it back. */
+        release() {
+          paintQueues.delete(queue);
+        },
+        /** The painting of this house alone. */
+        deferredQueue: () => queue,
         /** The wall has damage drawn. */
         has(partId) {
           return views.has(partId);
@@ -20200,7 +20477,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         })
       };
     }
-    Object.assign(K, { createBreachView });
+    Object.assign(K, { createBreachView, breachPaintQueue: paintQueue });
   }
 
   // src/destruction/world.ts
@@ -20455,6 +20732,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         if (R && D.id && D.active) R.unbind(D.id);
         if (D.active && D.world.has(D.id)) D.world.remove(D.id);
         D.active = false;
+        breach.release();
       };
       D.follow = (world, id, spec) => {
         D.spec = spec;
@@ -20489,6 +20767,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         return { restore: () => breach.restore(), dispose: () => {
           offFollow();
           breach.restore();
+          breach.release();
         }, update: () => {
           breach.flush();
         } };
@@ -21101,7 +21380,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
 
   // src/build/api.ts
   function buildApi(K, shared) {
-    const { cfg, VERSION: VERSION2, ATLAS, TEX, applyPart, carGroup, carModel, props, TYPES, roomLightMask, lighting, newState, build } = K;
+    const { cfg, VERSION: VERSION2, ATLAS, TEX, applyPart, carGroup, carModel, props, TYPES, roomLightMask, lighting, effectLights, newState, build } = K;
     return {
       version: VERSION2,
       build,
@@ -21116,10 +21395,13 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       },
       roomLightMask,
       lighting,
+      effectLights,
       setNight(n) {
         shared.mats.glass.emissive.set(n ? 9067040 : 0);
         shared.mats.glass.opacity = n ? 0.4 : 0.24;
       },
+      /** The chipped-plaster painting of every house of this renderer as a `DeferredQueue` for a frame budget (id `floorplan.breach-paint`); asking for it changes nothing. */
+      deferredQueue: () => K.breachPaintQueue,
       cars: { model: carModel, group: carGroup, info: (k, seed) => {
         const m = carModel(k, seed);
         return m && { parts: m.parts.length, tris: m.tris, L: m.L, W: m.W, H: m.H };
@@ -21586,6 +21868,14 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     return { off, reset: () => navigator.undoChanges(houseId) };
   }
 
+  // ../game-render-three/dist/index.js
+  var DEFAULT_ANGLE = Math.PI / 3;
+  function isLightBudget(value) {
+    const candidate = value;
+    return typeof candidate === "object" && candidate !== null && typeof candidate.acquire === "function" && typeof candidate.addSource === "function" && typeof candidate.lease === "function" && typeof candidate.present === "function";
+  }
+  var EFFECT_STEP_SECONDS = 1 / 50;
+
   // src/test-area/text.ts
   var TEXT = {
     en: {
@@ -21608,7 +21898,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         hit: { burst_9mm: "9 mm burst", burst_762: "7.62 burst", sledge: "Sledgehammer", c4: "C4", rpg: "RPG warhead" },
         state: { normal: "Normal", fortified: "Fortified", abandoned: "Abandoned" }
       },
-      layers: { roof: "Roof", lot: "Lot (ground, wall, gate)", night: "Night (lit windows and lamps)" },
+      layers: { roof: "Roof", lot: "Lot (ground, wall, gate)", night: "Night (lit windows and lamps)", room_lights: "Room lights (one lamp per lit room, stopped by the walls)" },
       metrics: { houses: "Houses", parts: "Parts", standing: "Standing", broken: "Broken", holes: "Holes", draw_calls: "Draw calls", triangles: "Triangles", lod: "Level of detail (nearest)", floor: "Your floor", doors_open: "Doors open", target: "You aim at", planned: "Planned draw calls" },
       sheet: { kicker: "House", title: "House of the bench", template: "Typology", seed: "Seed", state: "State", floors: "Floors", size: "Size", parts: "Structure parts", look: "You aim at", none: "nothing to use", no_engine: "The page gave no floorplan engine" },
       specimens: {
@@ -21674,7 +21964,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         hit: { burst_9mm: "Rajada de 9 mm", burst_762: "Rajada de 7,62", sledge: "Marreta", c4: "C4", rpg: "Ogiva de RPG" },
         state: { normal: "Normal", fortified: "Fortificada", abandoned: "Abandonada" }
       },
-      layers: { roof: "Telhado", lot: "Lote (ch\xE3o, muro, port\xE3o)", night: "Noite (janelas e l\xE2mpadas acesas)" },
+      layers: { roof: "Telhado", lot: "Lote (ch\xE3o, muro, port\xE3o)", night: "Noite (janelas e l\xE2mpadas acesas)", room_lights: "Luz por c\xF4modo (uma l\xE2mpada por c\xF4modo aceso, barrada pelas paredes)" },
       metrics: { houses: "Casas", parts: "Pe\xE7as", standing: "De p\xE9", broken: "Quebradas", holes: "Furos", draw_calls: "Draw calls", triangles: "Tri\xE2ngulos", lod: "N\xEDvel de detalhe (a mais perto)", floor: "Seu andar", doors_open: "Portas abertas", target: "Voc\xEA mira em", planned: "Draw calls planejados" },
       sheet: { kicker: "Casa", title: "Casa da bancada", template: "Tipologia", seed: "Semente", state: "Estado", floors: "Andares", size: "Tamanho", parts: "Pe\xE7as da estrutura", look: "Voc\xEA mira em", none: "nada para usar", no_engine: "A p\xE1gina n\xE3o deu o motor de plantas" },
       specimens: {
@@ -21971,6 +22261,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     let THREE = null;
     let houseRenderer = null;
     let houseRendererKey = "";
+    let stopPaintQueue;
+    let roomLights = null;
     const placed = [];
     let time = 0;
     let dirty = false;
@@ -21998,20 +22290,29 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const rendererFor = () => {
       const key = `${settings.quality}|${locale}`;
       if (!houseRenderer || houseRendererKey !== key) {
+        stopPaintQueue?.();
+        dropRoomLights();
         houseRenderer?.dispose?.();
         houseRenderer = create3(THREE, {
           locale,
           lod: { interior: 10, hide: 40 },
           breachPaintBudgetMs: 4,
           ...options.house,
+          ...options.house?.interactives ? { interactives: { effectSink: () => host?.effects, ...options.house.interactives } } : {},
           quality: settings.quality,
           ...options.world ? { destruction: options.world } : {},
           ...options.renderer ? { destructionRenderer: options.renderer } : {}
         });
         houseRendererKey = key;
+        const paintQueue = houseRenderer.deferredQueue?.();
+        stopPaintQueue = paintQueue ? host?.defer?.(paintQueue, DEFERRED_PRIORITY[DEFERRED_QUEUE_ID.BREACH_PAINT]) : void 0;
       }
       return houseRenderer;
     };
+    const dropRoomLights = () => {
+      roomLights?.dispose();
+      roomLights = null;
+    };
     const clearHouses = () => {
       for (const p of placed) p.house.dispose();
       placed.length = 0;
@@ -22249,6 +22550,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       }
       if (change.kind === "layer") {
         if (change.id === "roof") showAll();
+        else if (change.id === "room_lights") dropRoomLights();
         else if (placed.length > 0) {
           dirty = true;
           dirtyAt = time;
@@ -22415,7 +22717,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       layers: () => [
         { id: "roof", name: text.layers.roof, default: true },
         { id: "lot", name: text.layers.lot, default: false },
-        { id: "night", name: text.layers.night, default: false }
+        { id: "night", name: text.layers.night, default: false },
+        { id: "room_lights", name: text.layers.room_lights, default: false }
       ],
       metrics: () => [
         { id: "houses_built", name: text.metrics.houses, read: () => placed.length },
@@ -22461,6 +22764,21 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
             updateSheet();
           }
         });
+        const stopEffectLights = lent.onFrame(
+          () => {
+            const budget = lent.lights;
+            if (!isLightBudget(budget) || placed.length === 0 || !houseRenderer) return;
+            const houses2 = placed.map((p) => p.house);
+            if (lent.bench?.layer("room_lights") ?? false) {
+              roomLights ?? (roomLights = houseRenderer.lighting({ scene: lent.scene, n: 3, shadows: 0, budget }));
+              roomLights.update(houses2, cameraWorld(), {});
+              return;
+            }
+            dropRoomLights();
+            houseRenderer.effectLights?.({ budget })?.update(houses2);
+          },
+          { phase: "present", order: 20 }
+        );
         const onKey = (event) => {
           if (event.code === "KeyE" && !event.repeat && placed.length > 0) useNearest();
         };
@@ -22468,9 +22786,13 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         return () => {
           stopChange?.();
           stopFrame();
+          stopEffectLights();
+          dropRoomLights();
           globalThis.removeEventListener?.("keydown", onKey);
           for (const remove of removers.splice(0)) remove();
           clearHouses();
+          stopPaintQueue?.();
+          stopPaintQueue = void 0;
           houseRenderer?.dispose?.();
           houseRenderer = null;
           host = null;