@adatechnology/game-floorplan-three 0.5.0 → 0.7.0

package/dist/index.js

@@ -6030,7 +6030,7 @@ function installLightsRoomLight(K, shared) {
 
 // src/destruction/pieces.ts
 import { assemblyPart, getAssembly } from "@adatechnology/game-destruction";
-import { DENSITY, toDestructibleSpec } from "@adatechnology/game-floorplan-structure";
+import { DENSITY, MEMBER_CAGE, toDestructibleSpec } from "@adatechnology/game-floorplan-structure";
 
 // src/destruction/panels.ts
 import { resolveSlabPanels, slabPanelView } from "@adatechnology/game-floorplan-structure";
@@ -6210,7 +6210,11 @@ function installDestructionPieces(K, shared) {
           if (!pc || pc.unit) return sp;
           if (pc.role !== "wall" && pc.role !== "partition") {
             const def = getAssembly(pc.assembly || (pc.material === "concrete" && ["slab", "beam", "column", "stair"].includes(pc.role) ? "reinforced_concrete" : ""));
-            return def && def.reinforcement && !sp.reinforcement ? { ...sp, reinforcement: { ...def.reinforcement } } : sp;
+            const out = def && def.reinforcement && !sp.reinforcement ? { ...sp, reinforcement: { ...def.reinforcement } } : sp;
+            if (out.reinforcement && !out.units && pc.material === "concrete" && (pc.role === "beam" || pc.role === "column") && sp.shape.kind === "box") {
+              return { ...out, units: { size: [MEMBER_CAGE.unit, MEMBER_CAGE.unit, Math.min(...sp.shape.size)], bond: "stack", mortar: "concrete" } };
+            }
+            return out;
           }
           if (!pc.assembly) return sp;
           const [u0, v0, u1, v1] = pc.aabb, alongU = u1 - u0 >= v1 - v0;
@@ -6247,6 +6251,19 @@ function restoreRange(mesh, v0, saved) {
   pos.array.set(saved, v0 * 3);
   pos.needsUpdate = true;
 }
+function noise2(x, y, cell) {
+  const h = (i2, j2) => {
+    const s = Math.sin(i2 * 127.1 + j2 * 311.7) * 43758.5453;
+    return s - Math.floor(s);
+  };
+  const fx = x / cell, fy = y / cell, i = Math.floor(fx), j = Math.floor(fy), u = fx - i, v = fy - j;
+  const su = u * u * (3 - 2 * u), sv = v * v * (3 - 2 * v);
+  return (h(i, j) * (1 - su) + h(i + 1, j) * su) * (1 - sv) + (h(i, j + 1) * (1 - su) + h(i + 1, j + 1) * su) * sv;
+}
+var MASK_TEXEL = 0.02;
+var SPALL_MIN = 0.025;
+var SPALL_RAGGED = 0.045;
+var COVER = 0.015;
 function installDestructionBreach(K, _shared) {
   const { THREE, fragmentMaterial, invalidate, invalidateShadow } = K;
   function createBreachView(opts) {
@@ -6256,94 +6273,198 @@ function installDestructionBreach(K, _shared) {
     const unitMaterial = new THREE.MeshLambertMaterial({ color: 16777215 });
     const unitGeometry = new THREE.BoxGeometry(1, 1, 1);
     const tmp = { m: new THREE.Matrix4(), q: new THREE.Quaternion(), p: new THREE.Vector3(), s: new THREE.Vector3(), c: new THREE.Color() };
-    const wallColour = (items) => {
-      for (const it of items) {
-        if (!it.mesh) continue;
-        const c = it.mesh.geometry.attributes.color;
-        if (!c) continue;
-        const a = c.array;
-        tmp.c.setRGB(a[it.v0 * 3], a[it.v0 * 3 + 1], a[it.v0 * 3 + 2]);
-        return tmp.c.getHex();
-      }
-      return null;
-    };
     const local = (p) => {
       house.updateMatrixWorld(true);
       const v = house.worldToLocal(tmp.p.set(p[0], p[1], p[2]));
       return [v.x, v.y, v.z];
     };
-    function courses(part, units, opening, chips, paint) {
+    function cells(part, units) {
       const [u0, v0, u1, v1] = part.aabb;
       const alongU = u1 - u0 >= v1 - v0;
       const len = alongU ? u1 - u0 : v1 - v0;
-      const thick = alongU ? v1 - v0 : u1 - u0;
       const [ul, uh] = units.size;
       const rows = Math.max(1, Math.round((part.y1 - part.y0) / uh));
       const rowH = (part.y1 - part.y0) / rows;
       const per = Math.max(1, Math.round(len / ul));
       const w = len / per;
-      const edge = fragmentMaterial(part.material).color.getHex();
-      const list = [];
+      const out = [];
       for (let r = 0; r < rows; r++) {
         const shift = units.bond === "running" && r & 1 ? w / 2 : 0;
-        const cells = per + (shift ? 1 : 0);
-        for (let i = 0; i < cells; i++) {
-          let a = i * w - shift, b = a + w;
-          a = Math.max(0, a);
-          b = Math.min(len, b);
-          if (b - a < 1e-3) continue;
-          const mid = (a + b) / 2;
-          const x = alongU ? u0 + mid : (u0 + u1) / 2;
-          const z = alongU ? (v0 + v1) / 2 : v0 + mid;
-          const y = part.y0 + (r + 0.5) * rowH;
-          const d = opening ? Math.hypot(x - opening.center[0], y - opening.center[1], z - opening.center[2]) : Infinity;
-          if (opening && d < opening.radius) continue;
-          const gone = (c) => Math.abs(c[1] - y) <= rowH / 2 && (alongU ? c[0] >= u0 + a && c[0] <= u0 + b : c[2] >= v0 + a && c[2] <= v0 + b);
-          if (chips.some(gone)) continue;
-          const near = opening && d < opening.radius + 0.25 || chips.some((c) => Math.hypot(c[0] - x, c[1] - y, c[2] - z) < 0.15);
-          list.push({ x, y, z, sx: alongU ? b - a : thick, sy: rowH, sz: alongU ? thick : b - a, colour: near || paint === null ? edge : paint });
+        for (let i = 0; i < per + (shift ? 1 : 0); i++) {
+          const a = Math.max(0, i * w - shift), b = Math.min(len, i * w - shift + w);
+          if (b - a > 1e-3) out.push({ a, b, y0: part.y0 + r * rowH, y1: part.y0 + (r + 1) * rowH, r, i });
         }
       }
-      return list;
+      return out;
+    }
+    const specOf = (id) => opts.spec()?.parts?.find((q) => q.id === id);
+    const same = (a, b) => a.every((x, k) => Math.abs(x - b[k]) < 1e-3);
+    function hostOf(partId) {
+      if (structure.meshesOf(partId).some((it) => it.mesh)) return partId;
+      const part = structure.byId.get(partId);
+      if (!part) return null;
+      for (const q of structure.parts) {
+        if (q.id !== partId && same(q.aabb, part.aabb) && Math.abs(q.y1 - part.y0) < 0.01 && structure.meshesOf(q.id).some((it) => it.mesh)) return q.id;
+      }
+      return null;
+    }
+    const riders = (hostId) => structure.parts.filter((q) => q.id !== hostId && specOf(q.id)?.units && hostOf(q.id) === hostId && !structure.meshesOf(q.id).some((it) => it.mesh)).map((q) => q.id);
+    function shell(it, mask) {
+      const g0 = it.mesh.geometry, g = new THREE.BufferGeometry();
+      const src = it.mesh.userData._p0 || g0.attributes.position.array;
+      for (const [name, attr] of Object.entries(g0.attributes)) {
+        const k = attr.itemSize;
+        g.setAttribute(name, new THREE.BufferAttribute((name === "position" ? src : attr.array).slice(it.v0 * k, it.v1 * k), k));
+      }
+      if (g0.index) {
+        const ix = g0.index.array.slice(it.i0, it.i1);
+        for (let k = 0; k < ix.length; k++) ix[k] -= it.v0;
+        g.setIndex(new THREE.BufferAttribute(ix, 1));
+      }
+      g.computeBoundingBox();
+      g.computeBoundingSphere();
+      const base = it.mesh.material;
+      const material = base.clone();
+      const toHouse = { value: new THREE.Matrix4() };
+      material.onBeforeCompile = (sh) => {
+        base.onBeforeCompile?.(sh);
+        sh.uniforms.uToHouse = toHouse;
+        sh.uniforms.uMask = { value: mask.texture };
+        sh.uniforms.uMaskRect = { value: mask.rect };
+        sh.uniforms.uMaskAlongX = { value: mask.alongU ? 1 : 0 };
+        sh.vertexShader = sh.vertexShader.replace("void main() {", "uniform mat4 uToHouse;\nvarying vec3 vHousePos;\nvoid main() {").replace("#include <begin_vertex>", "#include <begin_vertex>\nvHousePos = (uToHouse * vec4(transformed, 1.0)).xyz;");
+        sh.fragmentShader = sh.fragmentShader.replace("void main() {", "uniform sampler2D uMask;\nuniform vec4 uMaskRect;\nuniform float uMaskAlongX;\nvarying vec3 vHousePos;\nvoid main() {\n  vec2 mUv = vec2(((uMaskAlongX > 0.5 ? vHousePos.x : vHousePos.z) - uMaskRect.x) / uMaskRect.z, (vHousePos.y - uMaskRect.y) / uMaskRect.w);\n  if (mUv.x >= 0.0 && mUv.x <= 1.0 && mUv.y >= 0.0 && mUv.y <= 1.0 && texture2D(uMask, mUv).r > 0.5) discard;");
+      };
+      material.customProgramCacheKey = () => "breachMask" + (base.customProgramCacheKey?.() ?? "");
+      const mesh = new THREE.Mesh(g, material);
+      mesh.name = "breach-shell";
+      mesh.userData.breachMask = mask;
+      mesh.position.copy(it.mesh.position);
+      mesh.quaternion.copy(it.mesh.quaternion);
+      mesh.scale.copy(it.mesh.scale);
+      mesh.castShadow = it.mesh.castShadow;
+      mesh.receiveShadow = it.mesh.receiveShadow;
+      mesh.renderOrder = it.mesh.renderOrder;
+      mesh.onBeforeRender = () => {
+        house.updateMatrixWorld();
+        toHouse.value.copy(house.matrixWorld).invert().multiply(mesh.matrixWorld);
+      };
+      it.mesh.parent.add(mesh);
+      mesh.updateMatrixWorld(true);
+      toHouse.value.copy(house.matrixWorld).invert().multiply(mesh.matrixWorld);
+      return mesh;
+    }
+    function maskOf(hostId, parts) {
+      const host = structure.byId.get(hostId);
+      const [u0, v0, u1, v1] = host.aabb;
+      const alongU = u1 - u0 >= v1 - v0;
+      const y0 = Math.min(...parts.map((id) => structure.byId.get(id).y0)), y1 = Math.max(...parts.map((id) => structure.byId.get(id).y1));
+      const len = alongU ? u1 - u0 : v1 - v0;
+      const w = Math.max(2, Math.min(2048, Math.ceil(len / MASK_TEXEL))), h = Math.max(2, Math.min(1024, Math.ceil((y1 - y0) / MASK_TEXEL)));
+      const data = new Uint8Array(w * h);
+      const texture = new THREE.DataTexture(data, w, h, THREE.RedFormat);
+      texture.magFilter = THREE.LinearFilter;
+      texture.minFilter = THREE.LinearFilter;
+      texture.needsUpdate = true;
+      return { data, texture, w, h, alongU, start: alongU ? u0 : v0, len, y0, height: y1 - y0, rect: new THREE.Vector4(alongU ? u0 : v0, y0, len, y1 - y0) };
+    }
+    const boxDistance = (s, y, a, b, c, d) => Math.hypot(Math.max(a - s, 0, s - b), Math.max(c - y, 0, y - d));
+    function paint(view) {
+      const { mask } = view;
+      const along = (p) => (mask.alongU ? p[0] : p[2]) - mask.start;
+      const holes = [];
+      const discs = [];
+      const shown = [];
+      for (const id of view.parts) {
+        const part = structure.byId.get(id), units2 = specOf(id).units, chips = view.chips.get(id), opening = view.openings.get(id);
+        const all = cells(part, units2);
+        const thick = mask.alongU ? part.aabb[3] - part.aabb[1] : part.aabb[2] - part.aabb[0];
+        const mid = mask.alongU ? (part.aabb[1] + part.aabb[3]) / 2 : (part.aabb[0] + part.aabb[2]) / 2;
+        if (opening) discs.push({ s: along(opening.center), y: opening.center[1], r: opening.radius });
+        const gone = (c) => chips.some((p) => p[1] >= c.y0 && p[1] <= c.y1 && along(p) >= c.a && along(p) <= c.b) || opening && Math.hypot((c.a + c.b) / 2 - along(opening.center), (c.y0 + c.y1) / 2 - opening.center[1]) < opening.radius;
+        const kept = [];
+        for (const c of all) (gone(c) ? holes : kept).push(c);
+        for (const c of kept) shown.push({ c, part, units: units2, thick, mid });
+      }
+      const reach = SPALL_MIN + SPALL_RAGGED;
+      mask.data.fill(0);
+      const stamp = (s0, s1, y0, y1, inside) => {
+        const i0 = Math.max(0, Math.floor((s0 - reach) / mask.len * mask.w)), i1 = Math.min(mask.w - 1, Math.ceil((s1 + reach) / mask.len * mask.w));
+        const j0 = Math.max(0, Math.floor((y0 - reach - mask.y0) / mask.height * mask.h)), j1 = Math.min(mask.h - 1, Math.ceil((y1 + reach - mask.y0) / mask.height * mask.h));
+        for (let j = j0; j <= j1; j++) {
+          const y = mask.y0 + (j + 0.5) / mask.h * mask.height;
+          for (let i = i0; i <= i1; i++) {
+            const s = (i + 0.5) / mask.w * mask.len;
+            const edge = SPALL_MIN + SPALL_RAGGED * (0.6 * noise2(s, y, 0.03) + 0.4 * noise2(s + 7.3, y - 3.1, 0.011));
+            if (inside(s, y) <= edge) mask.data[j * mask.w + i] = 255;
+          }
+        }
+      };
+      for (const c of holes) stamp(c.a, c.b, c.y0, c.y1, (s, y) => boxDistance(s, y, c.a, c.b, c.y0, c.y1));
+      for (const d of discs) stamp(d.s - d.r, d.s + d.r, d.y - d.r, d.y + d.r, (s, y) => Math.max(0, Math.hypot(s - d.s, y - d.y) - d.r));
+      mask.texture.needsUpdate = true;
+      const near = (c) => holes.some((h) => boxDistance((c.a + c.b) / 2, (c.y0 + c.y1) / 2, h.a - (c.b - c.a) / 2, h.b + (c.b - c.a) / 2, h.y0 - (c.y1 - c.y0) / 2, h.y1 + (c.y1 - c.y0) / 2) <= reach) || discs.some((d) => boxDistance(d.s, d.y, c.a, c.b, c.y0, c.y1) <= d.r + reach);
+      const list = [];
+      const tone = (hex, k) => tmp.c.setHex(hex).multiplyScalar(k).getHex();
+      for (const { c, part, units: units2, thick, mid } of shown) {
+        if (!near(c)) continue;
+        const centre = mask.start + (c.a + c.b) / 2, y = (c.y0 + c.y1) / 2, len = c.b - c.a, h = c.y1 - c.y0;
+        const at = (s, dy, d, colour) => list.push({ x: mask.alongU ? centre : mid, y, z: mask.alongU ? mid : centre, sx: mask.alongU ? s : d, sy: dy, sz: mask.alongU ? d : s, colour });
+        const base = fragmentMaterial(part.material).color.getHex();
+        const n = noise2(centre * 3.1, y * 2.7, 0.07);
+        if (units2.mortar === "concrete") {
+          at(len, h, thick - 2 * COVER - 0.03 * n, tone(base, 0.86 + 0.2 * n));
+        } else {
+          at(len, h, thick - 2 * COVER - 0.012, 10327948);
+          at(len - 0.012, h - 0.012, thick - 2 * COVER, tone(base, 0.8 + 0.35 * n));
+        }
+      }
+      if (view.units) {
+        view.units.removeFromParent();
+        view.units.dispose();
+      }
+      const units = new THREE.InstancedMesh(unitGeometry, unitMaterial, Math.max(1, list.length));
+      units.name = "breach:" + view.host;
+      list.forEach((u, i) => {
+        tmp.m.compose(tmp.p.set(u.x, u.y, u.z), tmp.q.identity(), tmp.s.set(u.sx, u.sy, u.sz));
+        units.setMatrixAt(i, tmp.m);
+        units.setColorAt(i, tmp.c.setHex(u.colour));
+      });
+      units.count = list.length;
+      units.instanceMatrix.needsUpdate = true;
+      if (units.instanceColor) units.instanceColor.needsUpdate = true;
+      units.castShadow = true;
+      units.receiveShadow = true;
+      units.visible = lod === 0;
+      house.add(units);
+      view.units = units;
+      view.gone = holes.length;
     }
     function draw2(partId, change) {
       if (lod !== 0) return false;
-      const part = structure.byId.get(partId);
-      const spec = opts.spec()?.parts?.find((q) => q.id === partId);
-      if (!part || !spec || !spec.units) return false;
-      let view = views.get(partId);
+      const hostId = hostOf(partId);
+      if (!hostId || !specOf(partId)?.units) return false;
+      let view = views.get(hostId);
       if (!view) {
-        const items = structure.meshesOf(partId).filter((it) => it.mesh);
+        const items = structure.meshesOf(hostId).filter((it) => it.mesh);
         if (!items.length) return false;
-        view = { mesh: null, saved: null, items, paint: wallColour(items), units: 0, opening: null, chips: [] };
+        const parts = [hostId, ...riders(hostId)].filter((id) => structure.byId.get(id) && specOf(id)?.units);
+        if (!parts.includes(partId)) return false;
+        const mask = maskOf(hostId, parts);
+        view = { host: hostId, parts, items, mask, shells: [], saved: null, units: null, gone: 0, chips: new Map(parts.map((id) => [id, []])), openings: /* @__PURE__ */ new Map() };
       }
+      if (!view.chips.has(partId)) return false;
       if (change.opening) {
-        if (view.opening) return false;
-        view.opening = { center: local(change.opening.center), radius: change.opening.radius };
+        if (view.openings.has(partId)) return false;
+        view.openings.set(partId, { center: local(change.opening.center), radius: change.opening.radius });
       }
-      if (change.chip) view.chips.push(local(change.chip));
-      const list = courses(part, spec.units, view.opening, view.chips, view.paint);
-      if (view.mesh) {
-        view.mesh.removeFromParent();
-        view.mesh.dispose();
+      if (change.chip) view.chips.get(partId).push(local(change.chip));
+      if (!view.saved) {
+        view.shells = view.items.map((it) => shell(it, view.mask));
+        view.saved = view.items.map((it) => ({ it, v0: it.v0, data: collapseRange(it.mesh, it.v0, it.v1) }));
       }
-      const mesh = new THREE.InstancedMesh(unitGeometry, unitMaterial, Math.max(1, list.length));
-      mesh.name = "breach:" + partId;
-      list.forEach((u, i) => {
-        tmp.m.compose(tmp.p.set(u.x, u.y, u.z), tmp.q.identity(), tmp.s.set(u.sx, u.sy, u.sz));
-        mesh.setMatrixAt(i, tmp.m);
-        mesh.setColorAt(i, tmp.c.setHex(u.colour));
-      });
-      mesh.count = list.length;
-      mesh.instanceMatrix.needsUpdate = true;
-      if (mesh.instanceColor) mesh.instanceColor.needsUpdate = true;
-      mesh.castShadow = true;
-      mesh.receiveShadow = true;
-      house.add(mesh);
-      if (!view.saved) view.saved = view.items.map((it) => ({ it, v0: it.v0, data: collapseRange(it.mesh, it.v0, it.v1) }));
-      view.mesh = mesh;
-      view.units = list.length;
-      views.set(partId, view);
+      paint(view);
+      views.set(hostId, view);
       invalidate();
       invalidateShadow();
       return true;
@@ -6354,30 +6475,40 @@ function installDestructionBreach(K, _shared) {
         else s.data = collapseRange(s.it.mesh, s.v0, s.it.v1);
       }
     }
+    function dispose(view) {
+      view.units.removeFromParent();
+      view.units.dispose();
+      for (const m of view.shells) {
+        m.removeFromParent();
+        m.geometry.dispose();
+        m.material.dispose();
+      }
+      view.mask.texture.dispose();
+    }
     return {
-      /** Handles a `stage` event of the house's object. Returns true when the wall was redrawn as courses. */
+      /** Handles a `stage` event of the house's object. Returns true when the wall was cut. */
       stage(event) {
         return event.stage === 2 && !!event.opening ? draw2(event.part, { opening: event.opening }) : false;
       },
-      /** Handles a `chip` event: the unit that came out leaves a gap in the courses. Returns true when the wall was redrawn. */
+      /** Handles a `chip` event: the unit that came out leaves a hole in the wall where it was. Returns true when the wall was cut. */
       chip(event) {
         return draw2(event.part, { chip: event.center });
       },
-      /** The part broke or fell: the courses go (the plain range stays collapsed, the renderer hides the part). */
+      /** The part broke or fell: its damage goes (the plain range stays collapsed, the renderer hides the part). */
       drop(partId) {
         const v = views.get(partId);
         if (!v) return;
-        v.mesh.removeFromParent();
-        v.mesh.dispose();
+        dispose(v);
         views.delete(partId);
       },
-      /** LOD 0 draws the courses; LOD 1 and 2 give the wall its box back. */
+      /** LOD 0 draws the cut wall; LOD 1 and 2 give the wall its box back. */
       setLod(level) {
         const was = lod;
         lod = level;
         if (was === 0 === (level === 0)) return;
         for (const v of views.values()) {
-          v.mesh.visible = level === 0;
+          v.units.visible = level === 0;
+          for (const m of v.shells) m.visible = level === 0;
           plain(v, level !== 0);
         }
         invalidate();
@@ -6386,17 +6517,21 @@ function installDestructionBreach(K, _shared) {
       /** Everything back to what it was (after `world.reset`). */
       restore() {
         for (const v of views.values()) {
-          v.mesh.removeFromParent();
-          v.mesh.dispose();
+          dispose(v);
           if (lod === 0) plain(v, true);
         }
         views.clear();
       },
-      /** The wall's opening, if it has courses. */
+      /** The wall has damage drawn. */
       has(partId) {
         return views.has(partId);
       },
-      statistics: () => ({ walls: views.size, units: [...views.values()].reduce((n, v) => n + v.units, 0) })
+      /** Walls with damage drawn, units out of them, and units laid bare at the edge of the cuts. */
+      statistics: () => ({
+        walls: views.size,
+        gone: [...views.values()].reduce((n, v) => n + v.gone, 0),
+        units: [...views.values()].reduce((n, v) => n + v.units.count, 0)
+      })
     };
   }
   Object.assign(K, { createBreachView });
@@ -8515,6 +8650,7 @@ function createFloorplanTestModule(options = {}) {
   return {
     id: FLOORPLAN_AREA_ID,
     name: text.name,
+    ground: { surface: "lawn" },
     group: text.group,
     get houses() {
       return placed;
@@ -8622,6 +8758,9 @@ import { inferJoints } from "@adatechnology/game-destruction";
 import { markKitOrigin as markKitOrigin2 } from "@adatechnology/game-contracts";
 import { residentialItems } from "@adatechnology/game-floorplan-residential";
 var WOOD_THIN = 0.035;
+var BOARD_TOP_THICK = 0.07;
+var BOARD_TOP_WIDTH = 0.5;
+var BOARD_WIDTH = 0.16;
 var SHELF_SPAN = 1.5;
 var SHELVING = /shelf|bookcase|rack/;
 function carcass(parts, drawn) {
@@ -8636,6 +8775,39 @@ function carcass(parts, drawn) {
     } else if (y <= x && y <= z) part.structure = { role: "beam", maxSpan: SHELF_SPAN * Math.max(x, z) };
   }
 }
+function splitTopsIntoBoards(drawn, materialOf, carcassed) {
+  const tops = /* @__PURE__ */ new Map();
+  if (carcassed) return tops;
+  for (let i = drawn.length - 1; i >= 0; i--) {
+    const p = drawn[i];
+    if (p.key !== "wood" || materialOf.wood !== "wood_hard" || p.shape.kind !== "box" || p.rotation) continue;
+    const [sx, sy, sz] = p.shape.size;
+    const across = sx < sz ? 0 : 2;
+    const width = Math.min(sx, sz);
+    if (sy < WOOD_THIN || sy > BOARD_TOP_THICK || sy >= width || width < BOARD_TOP_WIDTH) continue;
+    const count = Math.round(width / BOARD_WIDTH);
+    const boards = [];
+    for (let b = 0; b < count; b++) {
+      const size = [sx, sy, sz];
+      size[across] = width / count;
+      const position = [...p.position];
+      position[across] += (b + 0.5) * size[across] - width / 2;
+      const min = [...p.min];
+      const max = [...p.max];
+      min[across] = position[across] - size[across] / 2;
+      max[across] = position[across] + size[across] / 2;
+      boards.push({ ...p, id: `${p.id}_b${b}`, shape: { kind: "box", size }, position, min, max, color: shadeBoard(p.color, b) });
+    }
+    drawn.splice(i, 1, ...boards);
+    tops.set(p.id, boards);
+  }
+  return tops;
+}
+function shadeBoard(color, board) {
+  const k = [1, 0.94, 1.05, 0.97, 1.03][board % 5];
+  const channel = (shift) => Math.min(255, Math.round((color >> shift & 255) * k)) << shift;
+  return channel(16) | channel(8) | channel(0);
+}
 var FLOOR_TOUCH = 5e-3;
 var LOOSE = /* @__PURE__ */ new Set(["paper"]);
 var BASE_MATERIAL = {
@@ -8713,10 +8885,12 @@ function recordSpec(THREE, name, root, run, opts) {
   };
   run(A);
   if (!drawn.length) throw new Error(`game-floorplan-three: the builder of "${name}" drew no box or cylinder`);
+  const boardsOf = splitTopsIntoBoards(drawn, materialOf, Boolean(opts.carcass));
   const parts = drawn.map((p) => {
     const thin = Math.min(...p.shape.kind === "box" ? p.shape.size : p.shape.kind === "cylinder" ? [p.shape.radius * 2, p.shape.height] : [p.shape.radius * 2]);
     let material = materialOf[p.key] ?? "plastic";
-    if (p.key === "wood" && material === "wood_hard" && thin < WOOD_THIN) material = "wood_soft";
+    if (p.key === "wood" && material === "wood_hard" && opts.carcass && !opts.materials?.wood) material = "mdf";
+    else if (p.key === "wood" && material === "wood_hard" && thin < WOOD_THIN) material = "wood_soft";
     const part = { id: p.id, material, shape: p.shape, position: p.position };
     if (p.rotation) part.rotation = p.rotation;
     if (!LOOSE.has(material) && p.min[1] <= FLOOR_TOUCH) part.anchored = true;
@@ -8751,6 +8925,13 @@ function recordSpec(THREE, name, root, run, opts) {
     if (area < 0.6 * footprint || p.max[1] < 0.2) continue;
     if (!top || p.max[1] > top.y + 1e-6) top = { part: p.id, y: p.max[1] };
   }
+  for (const boards of boardsOf.values()) {
+    if (top && boards[0].max[1] <= top.y - 1e-6) continue;
+    const mid = boards[boards.length >> 1];
+    const min = [Math.min(...boards.map((b) => b.min[0])), Math.min(...boards.map((b) => b.min[2]))];
+    const max = [Math.max(...boards.map((b) => b.max[0])), Math.max(...boards.map((b) => b.max[2]))];
+    if ((max[0] - min[0]) * (max[1] - min[1]) >= 0.6 * footprint && mid.max[1] >= 0.2) top = { part: mid.id, y: mid.max[1], parts: boards.map((b) => b.id) };
+  }
   if (opts.carcass) carcass(parts, byId);
   const spec = { name, parts, joints, tags: ["furniture"] };
   const colors = new Map(drawn.map((p) => [p.id, p.color]));