@adatechnology/game-floorplan-three 0.4.2 → 0.6.0

package/dist/index.js

@@ -66,8 +66,8 @@ function createTranslator(locale) {
 var OPEN_ROOM_TYPES = /* @__PURE__ */ new Set(["balcony", "terrace", "veranda", "balcony_gourmet"]);
 var rectsOf = (c) => c.parts && c.parts.length ? c.parts : [[c.u0, c.v0, c.u1, c.v1]];
 var isOpenArea = (c) => OPEN_ROOM_TYPES.has(c.type) || c.outdoor === true;
-function planLod(houses, focus, budget) {
-  const l = houses.map((c) => ({ c, d: c.distance(focus), n0: c.stats.drawCalls, n1: c.stats.drawCallsLOD1, level: 0 })).sort((a, b) => a.d - b.d);
+function planLod(houses2, focus, budget) {
+  const l = houses2.map((c) => ({ c, d: c.distance(focus), n0: c.stats.drawCalls, n1: c.stats.drawCallsLOD1, level: 0 })).sort((a, b) => a.d - b.d);
   let total = l.reduce((s, x) => s + x.n0, 0);
   for (let i = l.length - 1; i >= 0 && total > budget; i--) {
     total -= l[i].n0 - l[i].n1;
@@ -5872,12 +5872,12 @@ function installLightsRoomLight(K, shared) {
     A.invalidate = () => {
       for (let i = 0; i < NS; i++) PL[i].shadow.needsUpdate = true;
     };
-    A.update = function(houses, focus, op) {
+    A.update = function(houses2, focus, op) {
       op = op || {};
-      houses = (Array.isArray(houses) ? houses : [houses]).filter(Boolean);
+      houses2 = (Array.isArray(houses2) ? houses2 : [houses2]).filter(Boolean);
       _f.set(focus.x, focus.y, focus.z);
       const rooms = [], exterior = [];
-      for (const house of houses) {
+      for (const house of houses2) {
         if (house.group && !house.group.visible) continue;
         house.house.updateMatrixWorld(true);
         const M = house.house.matrixWorld, by = /* @__PURE__ */ new Map();
@@ -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;
@@ -6267,7 +6271,12 @@ function installDestructionBreach(K, _shared) {
       }
       return null;
     };
-    function courses(part, units, opening, paint) {
+    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) {
       const [u0, v0, u1, v1] = part.aabb;
       const alongU = u1 - u0 >= v1 - v0;
       const len = alongU ? u1 - u0 : v1 - v0;
@@ -6291,23 +6300,54 @@ function installDestructionBreach(K, _shared) {
           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 = Math.hypot(x - opening.center[0], y - opening.center[1], z - opening.center[2]);
-          if (d < opening.radius) continue;
-          list.push({ x, y, z, sx: alongU ? b - a : thick, sy: rowH, sz: alongU ? thick : b - a, colour: d < opening.radius + 0.25 || paint === null ? edge : paint });
+          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 });
         }
       }
       return list;
     }
-    function open(event) {
-      if (lod !== 0 || views.has(event.part) || !event.opening) return false;
-      const part = structure.byId.get(event.part);
-      const spec = opts.spec()?.parts?.find((q) => q.id === event.part);
-      if (!part || !spec || !spec.units) return false;
-      const items = structure.meshesOf(event.part).filter((it) => it.mesh);
-      if (!items.length) return false;
-      const list = courses(part, spec.units, event.opening, wallColour(items));
+    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 draw2(partId, change) {
+      if (lod !== 0) return false;
+      const hostId = hostOf(partId);
+      if (!hostId || !specOf(partId)?.units) return false;
+      let view = views.get(hostId);
+      if (!view) {
+        const items = structure.meshesOf(hostId).filter((it) => it.mesh);
+        if (!items.length) return false;
+        const parts = [hostId, ...riders(hostId)].filter((id) => structure.byId.get(id) && specOf(id)?.units);
+        view = { mesh: null, saved: null, items, paint: wallColour(items), units: 0, opening: null, chips: new Map(parts.map((id) => [id, []])), openings: /* @__PURE__ */ new Map() };
+      }
+      if (!view.chips.has(partId)) return false;
+      if (change.opening) {
+        if (view.openings.has(partId)) return false;
+        view.openings.set(partId, { center: local(change.opening.center), radius: change.opening.radius });
+        if (partId === hostId) view.opening = view.openings.get(partId);
+      }
+      if (change.chip) view.chips.get(partId).push(local(change.chip));
+      const list = [];
+      for (const [id, chips] of view.chips) list.push(...courses(structure.byId.get(id), specOf(id).units, view.openings.get(id) ?? null, chips, view.paint));
+      if (view.mesh) {
+        view.mesh.removeFromParent();
+        view.mesh.dispose();
+      }
       const mesh = new THREE.InstancedMesh(unitGeometry, unitMaterial, Math.max(1, list.length));
-      mesh.name = "breach:" + event.part;
+      mesh.name = "breach:" + hostId;
       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);
@@ -6319,8 +6359,10 @@ function installDestructionBreach(K, _shared) {
       mesh.castShadow = true;
       mesh.receiveShadow = true;
       house.add(mesh);
-      const saved = items.map((it) => ({ it, v0: it.v0, data: collapseRange(it.mesh, it.v0, it.v1) }));
-      views.set(event.part, { mesh, saved, units: list.length, opening: event.opening });
+      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(hostId, view);
       invalidate();
       invalidateShadow();
       return true;
@@ -6334,7 +6376,11 @@ function installDestructionBreach(K, _shared) {
     return {
       /** Handles a `stage` event of the house's object. Returns true when the wall was redrawn as courses. */
       stage(event) {
-        return event.stage === 2 ? open(event) : false;
+        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. */
+      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). */
       drop(partId) {
@@ -6566,6 +6612,9 @@ function installDestructionWorld(K, shared) {
         case "stage":
           breach.stage(e);
           break;
+        case "chip":
+          breach.chip(e);
+          break;
         case "collapse":
           for (const id of e.parts) {
             breach.drop(id);
@@ -6620,6 +6669,32 @@ function installDestructionWorld(K, shared) {
       if (D.active && D.world.has(D.id)) D.world.remove(D.id);
       D.active = false;
     };
+    D.follow = (world, id, spec) => {
+      D.spec = spec;
+      const offFollow = world.on("*", (e) => {
+        if (e.object !== id) return;
+        switch (e.type) {
+          case "stage":
+            breach.stage(e);
+            break;
+          case "chip":
+            breach.chip(e);
+            break;
+          case "fracture":
+            breach.drop(e.part);
+            break;
+          case "collapse":
+            for (const p of e.parts) breach.drop(p);
+            break;
+          default:
+            break;
+        }
+      });
+      return { restore: () => breach.restore(), dispose: () => {
+        offFollow();
+        breach.restore();
+      } };
+    };
     D.piece = (id) => D.active ? D.world.part(D.id, id) : null;
     D.state = () => D.active ? D.world.state(D.id) : null;
     D.reset = () => {
@@ -8459,6 +8534,7 @@ function createFloorplanTestModule(options = {}) {
   return {
     id: FLOORPLAN_AREA_ID,
     name: text.name,
+    ground: { surface: "lawn" },
     group: text.group,
     get houses() {
       return placed;
@@ -8566,6 +8642,56 @@ 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) {
+  const all = [...drawn.values()];
+  const width = Math.max(...all.map((p) => p.max[0])) - Math.min(...all.map((p) => p.min[0]));
+  for (const part of parts) {
+    if (LOOSE.has(part.material) || part.shape.kind !== "box" || part.rotation) continue;
+    const [x, y, z] = part.shape.size;
+    if (y >= x && y >= z) {
+      if (z < x && x >= 0.6 * width) continue;
+      part.structure = { role: "column" };
+    } 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 = {
@@ -8643,10 +8769,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;
@@ -8681,6 +8809,14 @@ 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]));
   const build = (T3) => {
@@ -8724,7 +8860,7 @@ function furnitureSpec(THREE, type, opts = {}) {
   if (w === void 0 || d === void 0 || h === void 0) throw new Error(`game-floorplan-three: furniture type "${type}" is not in the catalogue, so give w, d and h`);
   const o = opts.options ?? {};
   const seed = Math.round(opts.seed ?? 1);
-  const plain = /shelf|bookcase|rack/.test(type) ? "paper" : "plastic";
+  const plain = SHELVING.test(type) ? "paper" : "plastic";
   const root = { x: seed, z: 0, ry: 0, w, d, h, y: 0, base: 0, palette: o.palette, seed: `furniture_${type}_${seed}` };
   const { K, shared } = renderer.internals;
   const before = K.PARTS.length;
@@ -8743,7 +8879,7 @@ function furnitureSpec(THREE, type, opts = {}) {
         shared.ctx = saved.ctx;
       }
     },
-    { materials: { plain, ...o.materials }, chairs: o.chairs }
+    { materials: { plain, ...o.materials }, chairs: o.chairs, carcass: SHELVING.test(type) }
   );
   const spouts = K.PARTS.slice(before).filter((p) => p.type === "water_tap").map((p) => [p.pos[0] - root.x, p.pos[1], p.pos[2] - root.z]);
   K.PARTS.length = before;
@@ -8811,7 +8947,9 @@ function wallPlan(options) {
 function draw(THREE, plan, options) {
   return create(THREE, { ...options, fleet: null }).build(plan, { quality: "game", terrain: false, noPerimeter: true, pieces: "meshes" });
 }
+var houses = /* @__PURE__ */ new WeakMap();
 function label(house) {
+  houses.set(house.group, house);
   for (const [id, items] of Object.entries(house.destruction.ranges())) {
     for (const item of items) {
       const object = item.isObject3D ? item : item.mesh;
@@ -8824,12 +8962,13 @@ function wallPiece(THREE, options) {
   const plan = wallPlan(options);
   const houseOptions = options.house ?? {};
   const probe = draw(THREE, plan, { ...houseOptions, destruction: void 0, destructionRenderer: void 0 });
-  const spec = probe.structure.spec({ wallDetail: "coarse" });
+  const spec = probe.structure.spec();
   probe.dispose();
   return {
     plan,
     spec,
-    build: (T) => label(draw(T, plan, houseOptions))
+    build: (T) => label(draw(T, plan, houseOptions)),
+    follow: (root, world, objectId) => houses.get(root)?.destruction?.follow?.(world, objectId, spec) ?? null
   };
 }
 export {