@adatechnology/game-test-room 0.1.2 → 0.2.0

package/dist/index.global.js

@@ -1646,6 +1646,7 @@ var GameTestRoom = (() => {
   var clamp2 = (v, a, b) => Math.max(a, Math.min(b, v));
   var isLost = (p) => p.st.status === "broken" || p.st.status === "melted" || p.st.status === "ashes";
   var clone = (v) => structuredClone(v);
+  var overloadRate = (stress) => Math.min(0.6, 0.12 + 0.8 * (stress - 1));
   var updateBound = (o) => {
     if (!o.parts.length) return;
     const c = [0, 0, 0];
@@ -1956,7 +1957,10 @@ var GameTestRoom = (() => {
         for (const g of o.st.groups) {
           const ps = g.map((id) => o.byId.get(id)).filter((p) => !isLost(p) && !o.collapsed.has(p.spec.id));
           if (ps.length === 0 || g.some((id) => o.byId.get(id).anchored) || !ps.some((p) => p.structural)) continue;
-          for (const p of ps) o.collapsed.add(p.spec.id);
+          for (const p of ps) {
+            o.collapsed.add(p.spec.id);
+            p.st.status = "collapsed";
+          }
           emit({ ...base(o, src), type: "collapse", parts: ps.map((p) => p.spec.id), mass: ps.reduce((sum, p) => sum + p.st.mass, 0) });
         }
       }
@@ -2256,7 +2260,7 @@ var GameTestRoom = (() => {
       const effM = p.thickness / Math.max(sin, 0.3);
       const thr = mat.penetration * effM * 1e3;
       const penetrated = E > thr;
-      const scale2 = mat.damageScale?.ballistic ?? 1;
+      const scale2 = (mat.damageScale?.ballistic ?? 1) * (mat.fracture === "shatter" ? fragility(mat.ductility, p.thickness) : 1);
       const id = p.spec.id;
       if (!penetrated && mat.ricochetDeg && angle < mat.ricochetDeg) {
         const r = vec.sub(d, vec.scale(n, 2 * vec.dot(d, n)));
@@ -2606,7 +2610,7 @@ var GameTestRoom = (() => {
               p.rt.stressT = 0.5;
               emit({ ...base(o), type: "stress", part: p.spec.id, stress, load: p.st.load ?? 0 });
             }
-            applyDamage(o, p, (stress - 1) * p.st.maxHp * 0.5 * dt, "blunt", null, null, 5, 3);
+            applyDamage(o, p, overloadRate(stress) * p.st.maxHp * dt, "blunt", null, null, 5, 3);
           } else if (stress > 0.8 && p.mat.ductility < 0.3 && p.rt.stressT <= 0 && p.st.cracks.length < 6) {
             p.rt.stressT = 0.5;
             const { c, q } = partXf(o, p);
@@ -3096,7 +3100,7 @@ var GameTestRoom = (() => {
         wax: "wax",
         soil: "soil"
       },
-      partStatus: { intact: "intact", damaged: "damaged", broken: "broken", melted: "melted", ashes: "ashes" },
+      partStatus: { intact: "intact", damaged: "damaged", collapsed: "collapsed", broken: "broken", melted: "melted", ashes: "ashes" },
       jointKinds: {
         screw: "screw",
         bolt: "nut and bolt",
@@ -3177,7 +3181,7 @@ var GameTestRoom = (() => {
         wax: "cera",
         soil: "terra"
       },
-      partStatus: { intact: "intacto", damaged: "danificado", broken: "quebrado", melted: "derretido", ashes: "cinzas" },
+      partStatus: { intact: "intacto", damaged: "danificado", collapsed: "desabado", broken: "quebrado", melted: "derretido", ashes: "cinzas" },
       jointKinds: {
         screw: "parafuso",
         bolt: "porca e parafuso",
@@ -4472,6 +4476,8 @@ void main() {
       __publicField(this, "b");
       __publicField(this, "m4");
       __publicField(this, "box");
+      __publicField(this, "t");
+      __publicField(this, "lbox");
       __publicField(this, "decalCount", 0);
       __publicField(this, "tints", /* @__PURE__ */ new WeakMap());
       this.kit = new DecalKit(THREE);
@@ -4479,9 +4485,22 @@ void main() {
       this.b = tmpV(THREE);
       this.m4 = new THREE.Matrix4();
       this.box = new THREE.Box3();
+      this.t = tmpV(THREE);
+      this.lbox = new THREE.Box3();
     }
-    makeMeshVis(mesh, home) {
-      return {
+    /**
+     * @param range vertex range `[v0, v1)` of a merged mesh this part is drawn by (see `MeshRange`); `hosts` caches the shared state per mesh for one `bind`.
+     */
+    makeMeshVis(mesh, home, range, hosts) {
+      let host = null;
+      if (range) {
+        host = hosts?.get(mesh) ?? null;
+        if (!host) {
+          host = { mesh, origGeometry: mesh.geometry, origMaterial: mesh.material, ownGeo: false, work: null, ownMat: false, sharers: [] };
+          hosts?.set(mesh, host);
+        }
+      }
+      const mv = {
         mesh,
         home,
         origGeometry: mesh.geometry,
@@ -4498,31 +4517,72 @@ void main() {
         decals: [],
         meltApplied: 0,
         bottomY: 0,
-        moved: false
+        moved: false,
+        host,
+        range: range ? [range[0], range[1]] : null,
+        merged: host && range ? { host, range: [range[0], range[1]] } : null,
+        loose: false,
+        collapsed: false,
+        hidden: false,
+        touched: false,
+        charK: 0,
+        charHex: 0,
+        glowHex: 0,
+        glowK: 0
       };
+      host?.sharers.push(mv);
+      return mv;
     }
     vertexCount(mv) {
+      if (mv.range) return mv.range[1] - mv.range[0];
       return mv.mesh.geometry.getAttribute(POS_ATTR)?.count ?? 0;
     }
+    /** Is the part drawn? (A ranged part shares its mesh, so `mesh.visible` says nothing about it.) */
+    shown(mv) {
+      return mv.host ? !mv.hidden : mv.mesh.visible;
+    }
+    /** Box of the part's vertices in the space of its mesh (the whole geometry for a plain mesh). */
+    localBox(mv, out) {
+      out.makeEmpty();
+      if (!mv.host || !mv.range) {
+        const geo = mv.mesh.geometry;
+        if (!geo.boundingBox) geo.computeBoundingBox();
+        return geo.boundingBox ? out.copy(geo.boundingBox) : out;
+      }
+      const arr = mv.host.work ?? positionAttr(mv.mesh.geometry)?.array;
+      if (!arr) return out;
+      for (let i = mv.range[0] * 3; i < mv.range[1] * 3; i += 3) out.expandByPoint(this.t.set(arr[i], arr[i + 1], arr[i + 2]));
+      return out;
+    }
+    /** Box of the part in world space. */
+    worldBox(mv, out) {
+      if (!mv.host) return out.setFromObject(mv.mesh);
+      this.localBox(mv, out);
+      mv.mesh.updateWorldMatrix(true, false);
+      return out.isEmpty() ? out : out.applyMatrix4(mv.mesh.matrixWorld);
+    }
     /**
      * Average vertex colour of a mesh whose material uses `vertexColors` (computed once per mesh, from its original geometry), else null. Fragments
      * and debris of such a mesh multiply it by `material.color`; without it they come out white.
      */
     vertexTint(mv) {
-      if (this.tints.has(mv.mesh)) return this.tints.get(mv.mesh) ?? null;
+      if (this.tints.has(mv)) return this.tints.get(mv) ?? null;
       let tint = null;
       const used = materialsOf(mv.origMaterial).some((m) => m.vertexColors === true);
       const attr = used ? mv.origGeometry.getAttribute("color") : void 0;
       if (attr && attr.count > 0 && attr.itemSize >= 3) {
+        const from = mv.merged ? mv.merged.range[0] : 0;
+        const to = mv.merged ? Math.min(attr.count, mv.merged.range[1]) : attr.count;
         let r = 0, g = 0, b = 0;
-        for (let i = 0; i < attr.count; i++) {
+        for (let i = from; i < to; i++) {
           r += attr.getX(i);
           g += attr.getY(i);
           b += attr.getZ(i);
         }
-        tint = new this.THREE.Color(r / attr.count, g / attr.count, b / attr.count);
+        const n = Math.max(1, to - from);
+        tint = new this.THREE.Color(r / n, g / n, b / n);
       }
-      this.tints.set(mv.mesh, tint);
+      this.tints.set(mv, tint);
       return tint;
     }
     /** Colour of the original material (before any char) times the vertex tint, `0xRRGGBB`, or -1. */
@@ -4546,6 +4606,7 @@ void main() {
     }
     /** Clone the geometry (vertex edits); false when its positions cannot be edited. */
     ownGeometry(mv) {
+      if (mv.host) return this.ownHostGeometry(mv.host);
       if (mv.ownGeo) return true;
       const pos = positionAttr(mv.mesh.geometry);
       if (!pos) return false;
@@ -4555,6 +4616,16 @@ void main() {
       mv.work = new Float32Array(positionAttr(g).array);
       return true;
     }
+    ownHostGeometry(host) {
+      if (host.ownGeo) return true;
+      const pos = positionAttr(host.mesh.geometry);
+      if (!pos) return false;
+      host.ownGeo = true;
+      const g = host.mesh.geometry.clone();
+      host.mesh.geometry = g;
+      host.work = new Float32Array(positionAttr(g).array);
+      return true;
+    }
     // ------------------------------------------------------------------------------------------------------------------------------------
     // Dents
     // ------------------------------------------------------------------------------------------------------------------------------------
@@ -4572,10 +4643,15 @@ void main() {
       const r = dent.radius / s;
       const depth = dent.depth / s;
       const geo = mesh.geometry;
-      if (!geo.boundingBox) geo.computeBoundingBox();
-      if (geo.boundingBox && geo.boundingBox.distanceToPoint(lp) > r) return false;
+      let bb;
+      if (mv.host) bb = this.localBox(mv, this.lbox);
+      else {
+        if (!geo.boundingBox) geo.computeBoundingBox();
+        bb = geo.boundingBox;
+      }
+      if (bb && !bb.isEmpty() && bb.distanceToPoint(lp) > r) return false;
       if (!this.ownGeometry(mv)) return false;
-      const work = mv.work;
+      const work = mv.host ? mv.host.work : mv.work;
       const pos = positionAttr(mesh.geometry);
       const r2 = r * r;
       let touched = false;
@@ -4585,7 +4661,9 @@ void main() {
       const nx = ln.x;
       const ny = ln.y;
       const nz = ln.z;
-      for (let i = 0; i < work.length; i += 3) {
+      const from = mv.range ? mv.range[0] * 3 : 0;
+      const to = mv.range ? mv.range[1] * 3 : work.length;
+      for (let i = from; i < to; i += 3) {
         const dx = work[i] - px;
         const dy = work[i + 1] - py;
         const dz = work[i + 2] - pz;
@@ -4599,11 +4677,16 @@ void main() {
         touched = true;
       }
       if (!touched) return false;
+      mv.touched = true;
       this.writePositions(mv, pos);
       return true;
     }
     /** Copy `work` (dents) into the geometry, adding the melt sag when the mesh is melting. */
     writePositions(mv, pos) {
+      if (mv.host) {
+        this.rebuildHost(mv.host);
+        return;
+      }
       const work = mv.work;
       const arr = pos.array;
       const melt = mv.meltApplied;
@@ -4717,6 +4800,12 @@ void main() {
       pv.charApplied = char;
       const target = new this.THREE.Color(charColor);
       for (const mv of pv.meshes) {
+        if (mv.host) {
+          mv.charK = clamp3(char, 0, 1);
+          mv.charHex = charColor;
+          this.paint(mv);
+          continue;
+        }
         this.ownMaterial(mv);
         const mats = materialsOf(mv.mesh.material);
         mats.forEach((m, i) => {
@@ -4734,6 +4823,12 @@ void main() {
       pv.glowApplied = key;
       const intensity = hex === 0 ? 0 : clamp3(0.35 + (temperatureC - 450) / 900, 0, 1.4);
       for (const mv of pv.meshes) {
+        if (mv.host) {
+          mv.glowHex = hex;
+          mv.glowK = intensity;
+          this.paint(mv);
+          continue;
+        }
         this.ownMaterial(mv);
         for (const m of materialsOf(mv.mesh.material)) {
           const e = m.emissive;
@@ -4754,6 +4849,12 @@ void main() {
       pv.meltApplied = m;
       for (const mv of pv.meshes) {
         const mesh = mv.mesh;
+        if (mv.host) {
+          mv.meltApplied = m;
+          mv.touched = true;
+          if (!(this.lowQuality && this.vertexCount(mv) > 2e4) && this.ownGeometry(mv)) this.rebuildHost(mv.host);
+          continue;
+        }
         if (mv.meltApplied === 0 && m > 0) {
           mesh.updateWorldMatrix(true, false);
           mv.bottomY = this.box.setFromObject(mesh).min.y;
@@ -4784,10 +4885,270 @@ void main() {
     // ------------------------------------------------------------------------------------------------------------------------------------
     hide(pv, reason) {
       pv.gone = reason;
-      for (const mv of pv.meshes) mv.mesh.visible = false;
+      for (const mv of pv.meshes) {
+        if (!mv.host || mv.loose) {
+          mv.mesh.visible = false;
+          mv.hidden = true;
+          continue;
+        }
+        mv.hidden = true;
+        for (const d of mv.decals) d.obj.visible = false;
+        this.collapse(mv);
+      }
+    }
+    // ------------------------------------------------------------------------------------------------------------------------------------
+    // Parts drawn by a vertex range of a merged mesh
+    // ------------------------------------------------------------------------------------------------------------------------------------
+    /** Collapse the part's vertices in the merged mesh to one point (its triangles become degenerate and vanish). */
+    collapse(mv) {
+      if (!mv.merged || !this.ownHostGeometry(mv.merged.host)) return;
+      mv.collapsed = true;
+      mv.touched = true;
+      this.rebuildHost(mv.merged.host);
+    }
+    /** Write `work` into the geometry again with the melt of ranged parts and the collapsed ranges applied. */
+    rebuildHost(host) {
+      const geo = host.mesh.geometry;
+      const pos = positionAttr(geo);
+      const work = host.work;
+      if (!pos || !work) return;
+      const arr = pos.array;
+      arr.set(work);
+      for (const s of host.sharers) {
+        if (s.merged && s.merged.host === host) {
+          if (s.collapsed) this.collapseRange(arr, s.merged.range);
+          else if (s.meltApplied > 0 && !s.loose) this.meltRange(arr, work, s.merged.range, s.meltApplied);
+        } else if (s.host === host && s.range && s.meltApplied > 0) this.meltRange(arr, work, s.range, s.meltApplied);
+      }
+      pos.needsUpdate = true;
+      geo.computeVertexNormals();
+      geo.boundingBox = null;
+      geo.boundingSphere = null;
+    }
+    collapseRange(arr, range) {
+      const x = arr[range[0] * 3];
+      const y = arr[range[0] * 3 + 1];
+      const z = arr[range[0] * 3 + 2];
+      for (let i = range[0] * 3; i < range[1] * 3; i += 3) {
+        arr[i] = x;
+        arr[i + 1] = y;
+        arr[i + 2] = z;
+      }
+    }
+    /** Melt of one range: shorter in Y (down to 25 %) with the bottom fixed, a bit wider around its centre, with the same noise as a whole mesh. */
+    meltRange(arr, work, range, melt) {
+      let minY = Infinity;
+      let maxY = -Infinity;
+      let cx = 0;
+      let cz = 0;
+      const n = Math.max(1, range[1] - range[0]);
+      for (let i = range[0] * 3; i < range[1] * 3; i += 3) {
+        minY = Math.min(minY, work[i + 1]);
+        maxY = Math.max(maxY, work[i + 1]);
+        cx += work[i];
+        cz += work[i + 2];
+      }
+      cx /= n;
+      cz /= n;
+      const h = Math.max(1e-4, maxY - minY);
+      const sy = lerp(1, 0.25, melt);
+      const sxz = 1 + 0.18 * melt;
+      for (let i = range[0] * 3, v = 0; i < range[1] * 3; i += 3, v++) {
+        const noise = (Math.imul(v + 1, 2654435761) >>> 0) % 1e3 / 1e3;
+        arr[i] = cx + (work[i] - cx) * sxz;
+        arr[i + 2] = cz + (work[i + 2] - cz) * sxz;
+        arr[i + 1] = Math.max(minY, minY + (work[i + 1] - minY) * sy - noise * melt * h * 0.04);
+      }
+    }
+    /** The colour attribute of the host's current geometry (created white when there is none) with vertex colours switched on in its material. */
+    ensureColors(host) {
+      if (!this.ownHostGeometry(host)) return null;
+      const geo = host.mesh.geometry;
+      let attr = geo.getAttribute("color");
+      if (!attr) {
+        const n = geo.getAttribute(POS_ATTR).count;
+        attr = new this.THREE.BufferAttribute(new Float32Array(n * 3).fill(1), 3);
+        geo.setAttribute("color", attr);
+      }
+      if (!host.ownMat) {
+        host.ownMat = true;
+        const src = materialsOf(host.mesh.material);
+        const cloned = src.map((m) => m.clone());
+        host.mesh.material = Array.isArray(host.mesh.material) ? cloned : cloned[0];
+      }
+      for (const m of materialsOf(host.mesh.material)) {
+        if (m.vertexColors !== true) {
+          ;
+          m.vertexColors = true;
+          m.needsUpdate = true;
+        }
+      }
+      return attr;
+    }
+    /** Colour of the part's vertices from the original colours, its char and its heat. Only the part's range is written. */
+    paint(mv) {
+      if (!mv.host || !mv.range || !mv.merged) return;
+      const idle = mv.charK <= 0 && mv.glowK <= 0;
+      if (idle && !mv.touched) return;
+      const attr = this.ensureColors(mv.host);
+      if (!attr) return;
+      const size = attr.itemSize;
+      const arr = attr.array;
+      const orig = mv.merged.host.origGeometry.getAttribute("color");
+      const oSize = orig?.itemSize ?? 3;
+      const oArr = orig?.array;
+      const shift = mv.merged.range[0] - mv.range[0];
+      const ch = new this.THREE.Color(mv.charHex);
+      const heat = new this.THREE.Color(mv.glowHex);
+      const k = clamp3(mv.charK, 0, 1);
+      const gk = clamp3(mv.glowK, 0, 1);
+      const boost = 1 + Math.max(0, mv.glowK - 1);
+      for (let i = mv.range[0]; i < mv.range[1]; i++) {
+        const o = (i + shift) * oSize;
+        let r = oArr ? oArr[o] : 1;
+        let g = oArr ? oArr[o + 1] : 1;
+        let b = oArr ? oArr[o + 2] : 1;
+        if (k > 0) {
+          r = lerp(r, ch.r, k);
+          g = lerp(g, ch.g, k);
+          b = lerp(b, ch.b, k);
+        }
+        if (gk > 0) {
+          r = lerp(r, heat.r * boost, gk);
+          g = lerp(g, heat.g * boost, gk);
+          b = lerp(b, heat.b * boost, gk);
+        }
+        arr[i * size] = r;
+        arr[i * size + 1] = g;
+        arr[i * size + 2] = b;
+      }
+      mv.touched = true;
+      attr.needsUpdate = true;
+    }
+    /**
+     * Move a ranged part to a mesh of its own: the faces whose vertices all lie in its range are copied (with the current dents and colours) into a
+     * new mesh that takes the merged mesh's transform and material, then attached to `group`; the range is collapsed in the merged mesh. Decals
+     * go with it.
+     */
+    extract(mv, group) {
+      if (!mv.host || !mv.range || !mv.merged || mv.loose) return;
+      const host = mv.host;
+      const [v0, v1] = mv.range;
+      const src = host.mesh.geometry;
+      const geo = new this.THREE.BufferGeometry();
+      const count = v1 - v0;
+      for (const name of Object.keys(src.attributes)) {
+        const a = src.getAttribute(name);
+        if (a.isInterleavedBufferAttribute) continue;
+        const size = a.itemSize;
+        const from = (name === POS_ATTR ? host.work : null) ?? a.array;
+        const slice = from.slice(v0 * size, v1 * size);
+        const Ctor = a.array.constructor;
+        geo.setAttribute(name, new this.THREE.BufferAttribute(new Ctor(slice), size, a.normalized));
+      }
+      const index = src.getIndex();
+      if (index) {
+        const out = [];
+        for (let i = 0; i + 2 < index.count; i += 3) {
+          const a = index.getX(i);
+          const b = index.getX(i + 1);
+          const c = index.getX(i + 2);
+          if (a >= v0 && a < v1 && b >= v0 && b < v1 && c >= v0 && c < v1) out.push(a - v0, b - v0, c - v0);
+        }
+        geo.setIndex(count > 65535 ? new this.THREE.Uint32BufferAttribute(out, 1) : new this.THREE.Uint16BufferAttribute(out, 1));
+      }
+      const mats = materialsOf(host.mesh.material).map((m) => m.clone());
+      const loose = new this.THREE.Mesh(geo, mats[0]);
+      loose.name = `${host.mesh.name || "mesh"}:${v0}-${v1}`;
+      loose.castShadow = host.mesh.castShadow;
+      loose.receiveShadow = host.mesh.receiveShadow;
+      loose.renderOrder = host.mesh.renderOrder;
+      loose.frustumCulled = host.mesh.frustumCulled;
+      loose.layers.mask = host.mesh.layers.mask;
+      loose.position.copy(host.mesh.position);
+      loose.quaternion.copy(host.mesh.quaternion);
+      loose.scale.copy(host.mesh.scale);
+      const parent = host.mesh.parent;
+      if (parent) parent.add(loose);
+      loose.updateMatrixWorld(true);
+      this.collapse(mv);
+      for (const d of mv.decals) {
+        d.obj.visible = true;
+        loose.add(d.obj);
+      }
+      const lp = positionAttr(geo);
+      const lh = {
+        mesh: loose,
+        origGeometry: geo,
+        origMaterial: loose.material,
+        ownGeo: true,
+        work: new Float32Array(lp.array),
+        ownMat: true,
+        sharers: [mv]
+      };
+      mv.host = lh;
+      mv.range = [0, count];
+      mv.mesh = loose;
+      mv.loose = true;
+      mv.moved = true;
+      group.attach(loose);
+      for (const m of materialsOf(loose.material)) m.needsUpdate = true;
+    }
+    restoreRanged(mv) {
+      const merged = mv.merged;
+      const host = merged.host;
+      for (const d of mv.decals) this.disposeDecal(d);
+      mv.decals.length = 0;
+      if (mv.loose) {
+        const loose = mv.mesh;
+        loose.parent?.remove(loose);
+        loose.geometry.dispose();
+        for (const m of materialsOf(loose.material)) m.dispose();
+        mv.host = host;
+        mv.range = [merged.range[0], merged.range[1]];
+        mv.mesh = host.mesh;
+        mv.loose = false;
+        mv.moved = false;
+      }
+      mv.collapsed = false;
+      mv.hidden = false;
+      mv.meltApplied = 0;
+      mv.charK = 0;
+      mv.glowK = 0;
+      mv.touched = false;
+      if (!host.ownGeo) return;
+      const work = host.work;
+      const op = positionAttr(host.origGeometry);
+      const [v0, v1] = merged.range;
+      if (op) work.set(op.array.subarray(v0 * 3, v1 * 3), v0 * 3);
+      const attr = host.mesh.geometry.getAttribute("color");
+      if (attr) {
+        const orig = host.origGeometry.getAttribute("color");
+        const size = attr.itemSize;
+        const a = attr.array;
+        for (let i = v0; i < v1; i++) {
+          for (let c = 0; c < 3; c++) a[i * size + c] = orig ? orig.array[i * orig.itemSize + c] : 1;
+        }
+        attr.needsUpdate = true;
+      }
+      if (host.sharers.every((s) => !s.touched)) {
+        host.mesh.geometry.dispose();
+        host.mesh.geometry = host.origGeometry;
+        host.work = null;
+        host.ownGeo = false;
+        if (host.ownMat) {
+          for (const m of materialsOf(host.mesh.material)) m.dispose();
+          host.mesh.material = host.origMaterial;
+          host.ownMat = false;
+        }
+      } else this.rebuildHost(host);
     }
     /** Bring one mesh back to how it was when it was bound. */
     restoreMesh(mv) {
+      if (mv.merged) {
+        this.restoreRanged(mv);
+        return;
+      }
       const mesh = mv.mesh;
       for (const d of mv.decals) this.disposeDecal(d);
       mv.decals.length = 0;
@@ -4885,6 +5246,10 @@ void main() {
   function materialsOf2(m) {
     return Array.isArray(m) ? m : [m];
   }
+  function isMeshRange(v) {
+    const r = v;
+    return !!r.mesh && Array.isArray(r.range);
+  }
   function createDestructionRenderer(THREE, options) {
     return new Renderer(THREE, options);
   }
@@ -4978,12 +5343,23 @@ void main() {
       const partIds = new Set((state?.parts ?? []).map((p) => p.id));
       const byPart = /* @__PURE__ */ new Map();
       const taken = /* @__PURE__ */ new Set();
+      const put = (pid, e) => {
+        const l = byPart.get(pid);
+        if (l) l.push(e);
+        else byPart.set(pid, [e]);
+      };
       const add2 = (pid, m) => {
         if (taken.has(m)) return;
         taken.add(m);
-        const l = byPart.get(pid);
-        if (l) l.push(m);
-        else byPart.set(pid, [m]);
+        put(pid, { mesh: m });
+      };
+      const addRange = (pid, r) => {
+        const n = r.mesh.geometry.getAttribute("position")?.count ?? 0;
+        const [v0, v1] = r.range;
+        if (!Number.isInteger(v0) || !Number.isInteger(v1) || v0 < 0 || v1 <= v0 || v1 > n) {
+          throw new Error(`game-destruction-three: invalid vertex range [${v0}, ${v1}) for part "${pid}" (the mesh has ${n} vertices)`);
+        }
+        put(pid, { mesh: r.mesh, range: [v0, v1] });
       };
       const meshesIn = (o) => {
         const out = [];
@@ -4994,7 +5370,10 @@ void main() {
       };
       if (options.parts) {
         for (const [pid, v] of Object.entries(options.parts)) {
-          for (const o of Array.isArray(v) ? v : [v]) for (const m of meshesIn(o)) add2(pid, m);
+          for (const o of Array.isArray(v) ? v : [v]) {
+            if (isMeshRange(o)) addRange(pid, o);
+            else for (const m of meshesIn(o)) add2(pid, m);
+          }
         }
       } else {
         const leftovers = [];
@@ -5007,14 +5386,15 @@ void main() {
         if (leftovers.length) this.matchByBox(objectId, root, leftovers, add2);
       }
       const bound = { id: objectId, root, sync: options.syncTransform !== false, parts: /* @__PURE__ */ new Map(), lastPos: null, lastQuat: null, piece: null, isSplit: false };
-      for (const pid of partIds) bound.parts.set(pid, this.makePartVis(objectId, pid, state?.parts.find((p) => p.id === pid)?.material ?? "", byPart.get(pid) ?? []));
+      const hosts = /* @__PURE__ */ new Map();
+      for (const pid of partIds) bound.parts.set(pid, this.makePartVis(objectId, pid, state?.parts.find((p) => p.id === pid)?.material ?? "", byPart.get(pid) ?? [], hosts));
       for (const [pid, meshes] of byPart) {
-        if (!bound.parts.has(pid)) bound.parts.set(pid, this.makePartVis(objectId, pid, this.world.part(objectId, pid)?.material ?? "", meshes));
+        if (!bound.parts.has(pid)) bound.parts.set(pid, this.makePartVis(objectId, pid, this.world.part(objectId, pid)?.material ?? "", meshes, hosts));
       }
       this.bounds.set(objectId, bound);
     }
-    makePartVis(home, id, material, meshes) {
-      return { id, home, material, meshes: meshes.map((m) => this.visuals.makeMeshVis(m, home)), charApplied: 0, glowApplied: 0, meltApplied: 0, gone: "none" };
+    makePartVis(home, id, material, meshes, hosts) {
+      return { id, home, material, meshes: meshes.map((m) => this.visuals.makeMeshVis(m.mesh, home, m.range, hosts)), charApplied: 0, glowApplied: 0, meltApplied: 0, gone: "none" };
     }
     /** Match unlabelled meshes to the part whose shape contains the centre of the mesh's bounding box. */
     matchByBox(objectId, root, meshes, add2) {
@@ -5074,11 +5454,13 @@ void main() {
       const inv = root.matrixWorld.clone().invert();
       const total = new this.THREE.Box3();
       const m4 = new this.THREE.Matrix4();
-      for (const m of meshes) {
-        const g = m.geometry;
-        if (!g.boundingBox) g.computeBoundingBox();
-        if (!g.boundingBox || g.boundingBox.isEmpty()) continue;
-        total.union(g.boundingBox.clone().applyMatrix4(m4.multiplyMatrices(inv, m.matrixWorld)));
+      const lb = new this.THREE.Box3();
+      for (const mv of meshes) {
+        const m = mv.mesh;
+        m.updateWorldMatrix(true, false);
+        this.visuals.localBox(mv, lb);
+        if (lb.isEmpty()) continue;
+        total.union(lb.clone().applyMatrix4(m4.multiplyMatrices(inv, m.matrixWorld)));
       }
       if (total.isEmpty()) return { half: [0.25, 0.25, 0.25], center: new this.THREE.Vector3() };
       const size = total.getSize(new this.THREE.Vector3());
@@ -5086,7 +5468,7 @@ void main() {
     }
     meshesOf(b) {
       const out = [];
-      for (const pv of b.parts.values()) if (pv.gone === "none") for (const mv of pv.meshes) out.push(mv.mesh);
+      for (const pv of b.parts.values()) if (pv.gone === "none") for (const mv of pv.meshes) out.push(mv);
       return out;
     }
     massOf(objectId) {
@@ -5217,6 +5599,9 @@ void main() {
         case "detach":
           this.onDetach(ev);
           break;
+        case "collapse":
+          this.splitLoose(ev.object);
+          break;
         case "disassemble_progress": {
           const k = `unscrew:${ev.joint}`;
           if (this.time - (this.throttles.get(k) ?? -1) > 0.25) {
@@ -5335,8 +5720,8 @@ void main() {
       let best = null;
       let bd = Infinity;
       for (const mv of pv.meshes) {
-        if (!mv.mesh.visible) continue;
-        const d = this.box.setFromObject(mv.mesh).distanceToPoint(p);
+        if (!this.visuals.shown(mv)) continue;
+        const d = this.visuals.worldBox(mv, this.box).distanceToPoint(p);
         if (d < bd) {
           bd = d;
           best = mv;
@@ -5356,7 +5741,7 @@ void main() {
       const wp = new this.THREE.Vector3(ev.worldPoint[0], ev.worldPoint[1], ev.worldPoint[2]);
       const wn = this.worldDir(b, ev.dent.normal);
       for (const mv of pv.meshes) {
-        if (!mv.mesh.visible) continue;
+        if (!this.visuals.shown(mv)) continue;
         this.visuals.applyDent(mv, wp, wn, ev.dent);
       }
       if (def?.tags?.includes("metal")) this.particles.burst("sparks", ev.worldPoint, [wn.x, wn.y, wn.z], 4 + Math.min(8, ev.dent.depth * 150), 3.2);
@@ -5447,16 +5832,20 @@ void main() {
     }
     onDetach(ev) {
       this.sound("detach", this.rootPoint(ev.object), 0.5);
+      this.splitLoose(ev.object);
+    }
+    /** Turn every loose group of the object (a detach, a collapse) into a piece of its own. */
+    splitLoose(objectId) {
       if (!this.autoSplit) return;
-      const b = this.bounds.get(ev.object);
+      const b = this.bounds.get(objectId);
       if (!b) return;
-      const st = this.world.state(ev.object);
+      const st = this.world.state(objectId);
       if (!st || st.groups.length < 2) return;
       const loose = st.groups.length - 1;
       for (let i = 0; i < loose; i++) {
         let newId;
         try {
-          newId = this.world.splitGroup(ev.object, 1);
+          newId = this.world.splitGroup(objectId, 1);
         } catch {
           break;
         }
@@ -5467,7 +5856,7 @@ void main() {
         const { half, center } = this.measure(b.root, this.meshesOf(b));
         old.halfExtents = half;
         this.pieceSys.setCenter(old, center);
-        old.mass = Math.max(0.05, this.massOf(ev.object));
+        old.mass = Math.max(0.05, this.massOf(objectId));
         old.sleeping = false;
       }
     }
@@ -5489,8 +5878,11 @@ void main() {
         from.parts.delete(p.id);
         nb.parts.set(p.id, pv);
         for (const mv of pv.meshes) {
-          group.attach(mv.mesh);
-          mv.moved = true;
+          if (mv.host && !mv.loose) this.visuals.extract(mv, group);
+          else {
+            group.attach(mv.mesh);
+            mv.moved = true;
+          }
         }
       }
       this.bounds.set(newId, nb);
@@ -5606,7 +5998,7 @@ void main() {
     }
     onGone(objectId, pv, reason, def) {
       const bb = new this.THREE.Box3();
-      for (const mv of pv.meshes) bb.union(this.box.setFromObject(mv.mesh));
+      for (const mv of pv.meshes) bb.union(this.visuals.worldBox(mv, this.box));
       this.visuals.hide(pv, reason);
       if (bb.isEmpty()) return;
       const c = bb.getCenter(new this.THREE.Vector3());
@@ -5623,7 +6015,7 @@ void main() {
       const bb = this.box;
       bb.makeEmpty();
       const tmp = new this.THREE.Box3();
-      for (const mv of pv.meshes) if (mv.mesh.visible) bb.union(tmp.setFromObject(mv.mesh));
+      for (const mv of pv.meshes) if (this.visuals.shown(mv)) bb.union(this.visuals.worldBox(mv, tmp));
       let cx = f.point[0];
       let cy = f.point[1];
       let cz = f.point[2];
@@ -10850,6 +11242,9 @@ void main() {
       "ui.quality.medium": "medium",
       "ui.quality.high": "high",
       "ui.equip": "Equip as a tool",
+      "ui.search_items": "Search items (all groups)",
+      "ui.search_tests": "Search tests",
+      "ui.no_results": "Nothing found",
       "ui.objects": "{n} objects",
       "ui.tests": "Tests",
       "ui.run_all": "Run all",
@@ -10885,8 +11280,8 @@ void main() {
       "sc.concrete_stops_bullet.check": "9 mm into 40 cm of concrete: went through: {through}, {dents}, {holes}, {cracks}, block {hp} hp (expected: stopped, wall behind untouched)",
       "sc.hammer_dents_drum": "Hammer dents a steel drum",
       "sc.hammer_dents_drum.check": "Hammer on the drum: {swings} swing(s), {dents} dent(s), first {depth} mm deep, body {hp} hp (expected: dented, not broken)",
-      "sc.glass_shatters": "Glass pane shatters after a few 9 mm shots",
-      "sc.glass_shatters.check": "Glass pane: broken after {shots} shot(s) into {n} shards (expected: broken, at least 4 shards)",
+      "sc.glass_shatters": "Glass pane shatters on the first 9 mm shot",
+      "sc.glass_shatters.check": "Glass pane: broken after {shots} shot(s) into {n} shards (expected: broken on the first shot, at least 4 shards)",
       "sc.shotgun_splinters_crate": "Shotgun splinters a wooden crate",
       "sc.shotgun_splinters_crate.check": "12 ga on the crate: {shots} shot(s), {splinters} board(s) splintered, {holes} holes (expected: at least one splintered)",
       "sc.kick_chair_leg": "A kick takes a chair leg off",
@@ -11139,6 +11534,9 @@ void main() {
       "ui.quality.medium": "m\xE9dia",
       "ui.quality.high": "alta",
       "ui.equip": "Equipar como ferramenta",
+      "ui.search_items": "Buscar item (todas as abas)",
+      "ui.search_tests": "Buscar teste",
+      "ui.no_results": "Nada encontrado",
       "ui.objects": "{n} objetos",
       "ui.tests": "Testes",
       "ui.run_all": "Rodar todos",
@@ -11174,8 +11572,8 @@ void main() {
       "sc.concrete_stops_bullet.check": "9 mm em 40 cm de concreto: atravessou: {through}, {dents}, {holes}, {cracks}, bloco com {hp} hp (esperado: parou, parede atr\xE1s intacta)",
       "sc.hammer_dents_drum": "Martelo amassa um tambor de a\xE7o",
       "sc.hammer_dents_drum.check": "Martelo no tambor: {swings} golpe(s), {dents} amassado(s), o primeiro com {depth} mm, corpo com {hp} hp (esperado: amassado, sem quebrar)",
-      "sc.glass_shatters": "Vidro estilha\xE7a depois de alguns tiros de 9 mm",
-      "sc.glass_shatters.check": "Vidro: quebrou depois de {shots} tiro(s) em {n} cacos (esperado: quebrado, pelo menos 4 cacos)",
+      "sc.glass_shatters": "Vidro estilha\xE7a no primeiro tiro de 9 mm",
+      "sc.glass_shatters.check": "Vidro: quebrou depois de {shots} tiro(s) em {n} cacos (esperado: quebrado no primeiro tiro, pelo menos 4 cacos)",
       "sc.shotgun_splinters_crate": "Escopeta lasca um caixote de madeira",
       "sc.shotgun_splinters_crate.check": "Calibre 12 no caixote: {shots} tiro(s), {splinters} t\xE1bua(s) lascada(s), {holes} furos (esperado: pelo menos uma lascada)",
       "sc.kick_chair_leg": "Um chute solta a perna da cadeira",
@@ -12617,7 +13015,7 @@ void main() {
         step(0.5);
         const fr = room.log.entries({ type: "fracture", objectId: id }).find((e) => e.part === "pane");
         const n = Number(fr?.data?.fragments ?? 0);
-        expect(part(room, id, "pane")?.status === "broken" && n >= 4, t("sc.glass_shatters.check", { shots, n }), { shots, fragments: n });
+        expect(part(room, id, "pane")?.status === "broken" && shots === 1 && n >= 4, t("sc.glass_shatters.check", { shots, n }), { shots, fragments: n });
       }),
       sc("shotgun_splinters_crate", ({ room, step, expect }) => {
         const id = at(room, "wooden_crate", 0, -4);
@@ -12876,7 +13274,11 @@ void main() {
   var CSS = `
 .tr-root{position:absolute;inset:0;pointer-events:none;font:12px/1.35 system-ui,-apple-system,"Segoe UI",Roboto,sans-serif;color:#e8eaee;overflow:hidden}
 .tr-root *{box-sizing:border-box}
-.tr-root button,.tr-root select,.tr-root label{pointer-events:auto}
+.tr-root button,.tr-root select,.tr-root label,.tr-root input{pointer-events:auto}
+.tr-search{width:100%;margin:0 0 6px;padding:5px 8px;border-radius:5px;border:1px solid #3a404c;background:#0f1116;color:#e8eaee;font:inherit}
+.tr-search::placeholder{color:#7d8594}
+.tr-item small{color:#7d8594;margin-left:4px}
+.tr-empty{color:#9aa3b2;padding:4px 2px;grid-column:1/-1}
 .tr-cross{position:absolute;left:50%;top:50%;width:18px;height:18px;margin:-9px 0 0 -9px}
 .tr-cross:before,.tr-cross:after{content:"";position:absolute;background:#fff;opacity:.85;box-shadow:0 0 2px #000}
 .tr-cross:before{left:8px;top:0;width:2px;height:18px}.tr-cross:after{top:8px;left:0;height:2px;width:18px}
@@ -12927,6 +13329,7 @@ void main() {
 .tr-summary{margin-top:6px;color:#9aa3b2}
 @media (max-width:980px){.tr-left,.tr-right{display:none}.tr-root.open .tr-left,.tr-root.open .tr-right{display:flex}.tr-toggle{display:block;pointer-events:auto}.tr-root.open .tr-toggle{right:min(310px,34vw)}.tr-left{width:min(400px,46vw)}.tr-help{display:none}}
 `;
+  var fold = (text) => text.normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase();
   var mk = (tag, cls, text) => {
     const e = document.createElement(tag);
     if (cls) e.className = cls;
@@ -13066,15 +13469,27 @@ void main() {
     const tests = mk("div", "tr-panel tr-tests");
     right.append(cat, anim, tests);
     cat.appendChild(mk("h3", void 0, t("ui.catalog")));
+    const itemSearch = mk("input", "tr-search");
+    itemSearch.type = "search";
+    itemSearch.placeholder = t("ui.search_items");
     const tabs = mk("div", "tr-tabs");
     const items = mk("div", "tr-items");
-    cat.append(tabs, items);
+    cat.append(itemSearch, tabs, items);
     let activeGroup = "";
+    const visibleItems = () => {
+      const term = fold(itemSearch.value.trim());
+      if (!term) return (o.groups().get(activeGroup) ?? []).map((item) => ({ item, group: activeGroup }));
+      return [...o.groups()].flatMap(([group, list2]) => list2.filter((item) => fold(`${item.name} ${item.id} ${group}`).includes(term)).map((item) => ({ item, group })));
+    };
     const renderItems = () => {
       items.textContent = "";
-      for (const it of o.groups().get(activeGroup) ?? []) {
+      const searching = itemSearch.value.trim() !== "";
+      const found = visibleItems();
+      if (!found.length) items.appendChild(mk("div", "tr-empty", t("ui.no_results")));
+      for (const { item: it, group } of found) {
         const wrap = mk("div", "tr-item");
         const b = mk("button", "tr-btn", it.name);
+        if (searching) b.appendChild(mk("small", void 0, group));
         b.type = "button";
         b.title = it.note ?? it.name;
         b.onclick = () => o.onSpawn(it.id);
@@ -13105,6 +13520,8 @@ void main() {
       renderItems();
     };
     renderTabs();
+    itemSearch.oninput = renderItems;
+    for (const box2 of [itemSearch]) box2.addEventListener("keydown", (e) => e.stopPropagation());
     const controls = mk("div", "tr-row");
     const ctl = (label, fn) => {
       const b = mk("button", "tr-btn", label);
@@ -13146,8 +13563,16 @@ void main() {
     const runAll = mk("button", "tr-btn", t("ui.run_all"));
     runAll.type = "button";
     const summary = mk("div", "tr-summary");
+    const testSearch = mk("input", "tr-search");
+    testSearch.type = "search";
+    testSearch.placeholder = t("ui.search_tests");
+    testSearch.addEventListener("keydown", (e) => e.stopPropagation());
     const list = mk("div", "list");
-    tests.append(runAll, summary, list);
+    tests.append(runAll, summary, testSearch, list);
+    testSearch.oninput = () => {
+      const term = fold(testSearch.value.trim());
+      for (const b of scBtns.values()) b.style.display = !term || fold(b.textContent ?? "").includes(term) ? "" : "none";
+    };
     const scBtns = /* @__PURE__ */ new Map();
     let busy = false;
     const mark = (rep) => {
@@ -13346,6 +13771,11 @@ void main() {
         renderTabs();
         renderScenarios();
       },
+      showGroup(group) {
+        activeGroup = group;
+        itemSearch.value = "";
+        renderTabs();
+      },
       togglePanels,
       dispose() {
         offLog();
@@ -13416,7 +13846,13 @@ void main() {
       const p = world.part(arena.table.id, arena.table.topPart);
       return !!p && p.status !== "broken" && p.status !== "melted" && p.status !== "ashes";
     };
-    const groundAt = (x, z) => x > arena.table.minX && x < arena.table.maxX && z > arena.table.minZ && z < arena.table.maxZ && tableOk() ? arena.table.top : 0;
+    const restingTops = [];
+    const restingTopAt = (x, z) => {
+      let top = 0;
+      for (const c of restingTops) if (x > c.minX && x < c.maxX && z > c.minZ && z < c.maxZ && world.has(c.objectId)) top = Math.max(top, c.top);
+      return top;
+    };
+    const groundAt = (x, z) => Math.max(x > arena.table.minX && x < arena.table.maxX && z > arena.table.minZ && z < arena.table.maxZ && tableOk() ? arena.table.top : 0, restingTopAt(x, z));
     const ownFluids = !options.fluids;
     const fluids = options.fluids ?? createFluids({ seed: 1, locale, liquids: options.liquids, groundAt });
     const pristineFluids = ownFluids ? fluids.serialize() : null;
@@ -13549,16 +13985,16 @@ void main() {
     const puncture = (ev) => {
       const e = entryOf(ev.object);
       if (!e?.containerId || e.fluidPart !== ev.part) return;
-      const host = hostOf(e);
-      host.root.updateMatrixWorld(true);
-      tmpM.copy(host.root.matrixWorld).invert();
+      const host2 = hostOf(e);
+      host2.root.updateMatrixWorld(true);
+      tmpM.copy(host2.root.matrixWorld).invert();
       const local = tmpV2.set(ev.point[0], ev.point[1], ev.point[2]).applyMatrix4(tmpM);
       local.x -= e.fluidOffset[0];
       local.y -= e.fluidOffset[1];
       local.z -= e.fluidOffset[2];
-      host.root.getWorldQuaternion(tmpQ).invert();
+      host2.root.getWorldQuaternion(tmpQ).invert();
       const n = tmpV22.set(ev.direction[0], ev.direction[1], ev.direction[2]).applyQuaternion(tmpQ);
-      const part = world.part(host.objectId, ev.part);
+      const part = world.part(host2.objectId, ev.part);
       const hole = part?.holes[part.holes.length - 1];
       fluids.puncture(e.containerId, [local.x, local.y, local.z], [n.x, n.y, n.z], hole?.diameter ?? 9e-3);
     };
@@ -13764,6 +14200,7 @@ void main() {
     };
     const clear = () => {
       clearEverything();
+      restingTops.length = 0;
       pending = [];
       action("clear", t("act.clear"));
     };
@@ -13983,6 +14420,7 @@ void main() {
         }
       });
       player.kick(recoil[0], recoil[1]);
+      emitHost({ type: "shot", weapon: toolId, shots: shots.length, recoil });
       const f = first;
       const d = f ? num(f.distance, 1) : "";
       let text;
@@ -14222,7 +14660,8 @@ void main() {
       if (cat === "hand") return;
       const res = tool.trigger([aimO[0], aimO[1], aimO[2]], [aimD[0], aimD[1], aimD[2]], dt, held, "player");
       if (res.status === "empty") {
-        if (!tool.reloading && tool.reserve > 0) tool.reload();
+        emitHost({ type: "empty", weapon: toolId });
+        if (!tool.reloading && tool.reserve > 0) startReload();
         say(t(tool.reloading ? "hud.reloading" : "hud.empty"));
         return;
       }
@@ -14274,6 +14713,7 @@ void main() {
       progress = null;
       action("tool", t("act.tool", { weapon: toolName(id) }), { data: { weapon: id } });
       fire("tool", id);
+      emitHost({ type: "tool", weapon: id });
     };
     const cycleTool = (dir) => {
       if (!loadout.length) return;
@@ -14501,7 +14941,7 @@ void main() {
         case "KeyR":
           if (heldPiece) heldYaw += Math.PI / 8;
           else {
-            tool.reload();
+            startReload();
             say(t("hud.reloading"));
           }
           break;
@@ -14599,10 +15039,10 @@ void main() {
     const syncContainers = (sdt) => {
       for (const e of entries.values()) {
         if (!e.containerId) continue;
-        const host = hostOf(e);
-        host.root.updateMatrixWorld(true);
-        const q = host.root.getWorldQuaternion(tmpQ);
-        const p = tmpV2.set(e.fluidOffset[0], e.fluidOffset[1], e.fluidOffset[2]).applyMatrix4(host.root.matrixWorld);
+        const host2 = hostOf(e);
+        host2.root.updateMatrixWorld(true);
+        const q = host2.root.getWorldQuaternion(tmpQ);
+        const p = tmpV2.set(e.fluidOffset[0], e.fluidOffset[1], e.fluidOffset[2]).applyMatrix4(host2.root.matrixWorld);
         const vel = sdt > 0 ? [(p.x - e.last[0]) / sdt, (p.y - e.last[1]) / sdt, (p.z - e.last[2]) / sdt] : void 0;
         e.last = [p.x, p.y, p.z];
         fluids.setTransform(e.containerId, [p.x, p.y, p.z], [q.x, q.y, q.z, q.w], vel);
@@ -14613,9 +15053,9 @@ void main() {
         if (!e.containerId || !e.fluidPart) continue;
         const c = fluids.container(e.containerId);
         if (!c) continue;
-        const host = hostOf(e);
-        const part = world.part(host.objectId, e.fluidPart);
-        if (part && part.liters !== void 0 && Math.abs(part.liters - c.liters) > 1e-4) world.setLiters(host.objectId, e.fluidPart, c.liters);
+        const host2 = hostOf(e);
+        const part = world.part(host2.objectId, e.fluidPart);
+        if (part && part.liters !== void 0 && Math.abs(part.liters - c.liters) > 1e-4) world.setLiters(host2.objectId, e.fluidPart, c.liters);
       }
     };
     let paused = false;
@@ -14646,6 +15086,9 @@ void main() {
       updateImpacts();
       fluidView.update(dt);
       for (const s of tools.values()) s.update(dt);
+      if (reloadingSeen && !tool.reloading) emitHost({ type: "reload", weapon: toolId, phase: "end" });
+      reloadingSeen = tool.reloading;
+      for (const update2 of frameListeners) update2(dt);
       for (const tr of tracers) {
         if (tr.life > 0) {
           tr.life -= dt;
@@ -14787,6 +15230,36 @@ void main() {
     const moduleCheck = (ok, text, data, itemId) => {
       log.add({ channel: "check", type: ok ? "pass" : "fail", text: `${ok ? "\u2713" : "\u2717"} ${text}`, itemId, data: { ok, ...data } });
     };
+    const modules = /* @__PURE__ */ new Map();
+    const detachers = [];
+    const hostListeners = /* @__PURE__ */ new Set();
+    const frameListeners = /* @__PURE__ */ new Set();
+    let reloadingSeen = false;
+    function emitHost(event) {
+      for (const listener of hostListeners) listener(event);
+    }
+    function startReload() {
+      if (tool.reload()) emitHost({ type: "reload", weapon: toolId, phase: "start" });
+    }
+    const host = {
+      THREE,
+      scene,
+      camera,
+      locale,
+      groundAt,
+      tool: () => ({ weapon: toolId, category: tool.def.category, ammo: tool.ammo, capacity: tool.capacity, reserve: tool.reserve, reloading: tool.reloading }),
+      on(listener) {
+        hostListeners.add(listener);
+        return () => hostListeners.delete(listener);
+      },
+      onFrame(update2) {
+        frameListeners.add(update2);
+        return () => frameListeners.delete(update2);
+      },
+      log(text, data) {
+        action("module_note", text, { data });
+      }
+    };
     const loadModule = (mod) => {
       const report = { module: mod.id, items: [], scenarios: [], ok: true, problems: [] };
       const fail = (problem) => {
@@ -14851,6 +15324,8 @@ void main() {
         report.scenarios.push(sc.id);
       }
       action("module", t("act.module_loaded", { name: mod.name, items: report.items.length, scenarios: report.scenarios.length, result: t(report.ok ? "mod.all_ok" : "mod.some_failed") }), { data: { module: mod.id, items: report.items, scenarios: report.scenarios, ok: report.ok } });
+      modules.set(mod.id, mod);
+      if (mod.attach) detachers.push(mod.attach(host));
       ui?.refresh();
       return report;
     };
@@ -14906,6 +15381,37 @@ void main() {
       }
       return report;
     };
+    const layArea = (layout) => {
+      const holders = layout.placements.filter((p) => p.surface);
+      const rest = layout.placements.filter((p) => !p.surface);
+      const placed = [...holders, ...rest].map((p) => {
+        const so = spawn(p.item, p.position, p.rotationY ?? 0);
+        if (p.surface) {
+          const [hx, hz] = p.surface.halfSize;
+          restingTops.push({ objectId: so.objectId, minX: p.position[0] - hx, maxX: p.position[0] + hx, minZ: p.position[2] - hz, maxZ: p.position[2] + hz, top: p.surface.height });
+        }
+        return { so, asleep: p.asleep === true };
+      });
+      for (const { so, asleep } of placed) {
+        const piece = asleep ? rendererPieces.get(so.objectId) : void 0;
+        if (piece) piece.sleeping = true;
+      }
+      if (layout.view) room.look(layout.view.eye, layout.view.target);
+      return placed.map(({ so }) => so);
+    };
+    const openArea = (area) => {
+      clear();
+      const mod = [...modules.values()].find((m) => m.id === area || m.group === area);
+      const label = mod?.group ?? S.groups[area] ?? area;
+      ui?.showGroup(label);
+      const layout = mod?.area?.(locale);
+      if (layout) return layArea(layout);
+      const items = catalog.filter((item) => item.group === label);
+      const front = items.filter((item) => item.movable !== false);
+      const back = items.filter((item) => item.movable === false);
+      const row = (list, gap, z) => list.map((item, index) => spawn(item.id, [(index - (list.length - 1) / 2) * gap, 0, z], 0));
+      return [...row(front, 1.6, 1.5), ...row(back, 4.5, -4)];
+    };
     const room = {
       world,
       renderer,
@@ -14985,10 +15491,12 @@ void main() {
         fastForward = on;
       },
       equip,
+      openArea,
       loadModule,
       animations: animationsOf,
       playAnimation,
       dispose() {
+        for (const detach of detachers.splice(0)) detach();
         cancelAnimationFrame?.(raf);
         window.removeEventListener("resize", onResize);
         player.dispose();
@@ -15078,6 +15586,7 @@ void main() {
     if (options.initial) {
       for (const [i, id] of options.initial.entries()) spawn(id, [(i - (options.initial.length - 1) / 2) * 1.3, 0, 0.5]);
     }
+    if (options.area) openArea(options.area);
     return room;
   }
   function structuredCloneSpec(spec) {