@adatechnology/game-floorplan-three 0.4.2 → 0.5.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();
@@ -6267,7 +6267,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 +6296,39 @@ 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);
+    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;
-      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));
+      let view = views.get(partId);
+      if (!view) {
+        const items = structure.meshesOf(partId).filter((it) => it.mesh);
+        if (!items.length) return false;
+        view = { mesh: null, saved: null, items, paint: wallColour(items), units: 0, opening: null, chips: [] };
+      }
+      if (change.opening) {
+        if (view.opening) return false;
+        view.opening = { 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();
+      }
       const mesh = new THREE.InstancedMesh(unitGeometry, unitMaterial, Math.max(1, list.length));
-      mesh.name = "breach:" + event.part;
+      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);
@@ -6319,8 +6340,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(partId, view);
       invalidate();
       invalidateShadow();
       return true;
@@ -6334,7 +6357,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 +6593,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 +6650,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 = () => {
@@ -8566,6 +8622,20 @@ 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 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) };
+  }
+}
 var FLOOR_TOUCH = 5e-3;
 var LOOSE = /* @__PURE__ */ new Set(["paper"]);
 var BASE_MATERIAL = {
@@ -8681,6 +8751,7 @@ 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] };
   }
+  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 +8795,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 +8814,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 +8882,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 +8897,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 {