@adatechnology/game-floorplan-three 0.9.3 → 0.10.0

package/dist/{chunk-QUVGWVEC.js → chunk-7XVCZF6H.js}

@@ -778,6 +778,7 @@ function installHouseHelpers(K, shared) {
 // src/house/walls.ts
 function installHouseWalls(K, shared) {
   const { EPS, Y0, boxC, bx, cursor, effectiveHeight, pieceRecord, structurePiece, wallColor } = K;
+  const sh = (color, factor) => K.sh(color, factor);
   function wallBox(alongU, L, a, b, ya, yb, th, cL, cH, mL, mH) {
     if (yb - ya < 1e-4 || b - a < 1e-4) return;
     if (alongU) {
@@ -821,6 +822,7 @@ function installHouseWalls(K, shared) {
   function walls() {
     const R = shared.ctx.r, cut = shared.ctx.cut, nA = R.floors.length, vMin = Math.min(...R.walls.map((w) => w.axis === "u" ? w.v0 : Math.min(w.v0, w.v1)));
     const corners = /* @__PURE__ */ new Map();
+    const looks = /* @__PURE__ */ new Map();
     for (const w of R.walls) {
       const f = w.floor;
       cursor.group = "f" + f;
@@ -830,6 +832,10 @@ function installHouseWalls(K, shared) {
       const hh = cut ? Math.min(h, 1.2) : h, L = alongU ? w.v0 : w.u0, s0 = Math.min(alongU ? w.u0 : w.v0, alongU ? w.u1 : w.v1), s1 = Math.max(alongU ? w.u0 : w.v0, alongU ? w.u1 : w.v1);
       const front = alongU && Math.abs(L - vMin) < 0.05;
       const sideL = sideOf(w.sides[0], front), sideH = sideOf(w.sides[1], front);
+      if (w.id) {
+        const face = sideL.exterior ? sideL : sideH;
+        looks.set(w.id, { mat: face.mat, color: face.color, top: y0 + hh });
+      }
       shared.ctx.colliders.push({ type: "wall", piece: w.id, f, x0: alongU ? s0 : L - th / 2, z0: alongU ? L - th / 2 : s0, x1: alongU ? s1 : L + th / 2, z1: alongU ? L + th / 2 : s1 });
       if (w.type === "railing") {
         const c0 = shared.ctx.colors.metal != null ? shared.ctx.colors.metal : 9080466;
@@ -876,8 +882,27 @@ function installHouseWalls(K, shared) {
       cursor.group = "f" + e.f;
       bx(e.color.mat, e.pu - e.th / 2, e.y0, e.pv - e.th / 2, e.pu + e.th / 2, e.y0 + e.hh, e.pv + e.th / 2, e.color.color);
     }
+    if (shared.ctx.showPillars) wallPillars(looks);
   }
-  Object.assign(K, { wallBox, sideOf, pieceOf, nearestWall, walls });
+  const PILLAR_IN_WALL = /^(wall_column_|column_\d|jamb_column_)/;
+  const wallOf = (pillar, parts) => {
+    const u = (pillar.aabb[0] + pillar.aabb[2]) / 2, v = (pillar.aabb[1] + pillar.aabb[3]) / 2;
+    return parts.find((q) => (q.role === "wall" || q.role === "partition") && q.assembly !== void 0 && q.floor === pillar.floor && u >= q.aabb[0] - 1e-3 && u <= q.aabb[2] + 1e-3 && v >= q.aabb[1] - 1e-3 && v <= q.aabb[3] + 1e-3);
+  };
+  function wallPillars(looks) {
+    const parts = Object.values(shared.ctx.structureIndex);
+    for (const e of parts) {
+      if (e.role !== "column" || !PILLAR_IN_WALL.test(e.id)) continue;
+      const host = wallOf(e, parts);
+      const look = host && looks.get(host.id);
+      if (!host || !look) continue;
+      cursor.group = "f" + e.floor;
+      cursor.pc = structurePiece(host.id);
+      bx(look.mat, e.aabb[0], e.y0, e.aabb[1], e.aabb[2], Math.min(e.y1, look.top), e.aabb[3], sh(look.color != null ? look.color : 15262420, 0.93));
+    }
+    cursor.pc = null;
+  }
+  Object.assign(K, { wallBox, sideOf, pieceOf, nearestWall, walls, wallPillars });
 }
 
 // src/house/doors.ts
@@ -6165,7 +6190,7 @@ function installLightsRoomLight(K, shared) {
 
 // src/destruction/pieces.ts
 import { assemblyPart, getAssembly } from "@adatechnology/game-destruction";
-import { DENSITY, MEMBER_CAGE, toDestructibleSpec } from "@adatechnology/game-floorplan-structure";
+import { DENSITY, MEMBER_CAGE, cageResidualCapacity, toDestructibleSpec } from "@adatechnology/game-floorplan-structure";
 
 // src/destruction/panels.ts
 import { resolveSlabPanels, slabPanelView } from "@adatechnology/game-floorplan-structure";
@@ -6345,7 +6370,8 @@ 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" : ""));
-            const out = def && def.reinforcement && !sp.reinforcement ? { ...sp, reinforcement: { ...def.reinforcement } } : sp;
+            const cage = def && def.reinforcement ? pc.role === "column" && sp.shape.kind === "box" ? { ...def.reinforcement, residualCapacity: cageResidualCapacity(sp.shape.size, def.reinforcement, sp.structure?.capacity) } : { ...def.reinforcement } : null;
+            const out = cage && !sp.reinforcement ? { ...sp, reinforcement: cage } : 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" } };
             }
@@ -6374,6 +6400,7 @@ function collapseRange(mesh, v0, v1) {
   const a = pos.array;
   const u = mesh.userData;
   if (!u._p0) u._p0 = a.slice();
+  if (!u.plainPositions) Object.defineProperty(u, "plainPositions", { value: u._p0, enumerable: false, configurable: true, writable: true });
   const list = u.collapsedRanges ?? (u.collapsedRanges = []);
   if (!list.some((r) => r[0] === v0 && r[1] === v1)) list.push([v0, v1]);
   const saved = a.slice(v0 * 3, v1 * 3);
@@ -6457,10 +6484,11 @@ function installDestructionBreach(K, _shared) {
       const v = house.worldToLocal(tmp.p.set(p[0], p[1], p[2]));
       return [v.x, v.y, v.z];
     };
-    function cells(part, units) {
+    function cells(part, units, mask) {
       const [u0, v0, u1, v1] = part.aabb;
-      const alongU = u1 - u0 >= v1 - v0;
+      const alongU = mask.alongU;
       const len = alongU ? u1 - u0 : v1 - v0;
+      const offset = (alongU ? u0 : v0) - mask.start;
       const [ul, uh] = units.size;
       const rows = Math.max(1, Math.round((part.y1 - part.y0) / uh));
       const rowH = (part.y1 - part.y0) / rows;
@@ -6471,7 +6499,7 @@ function installDestructionBreach(K, _shared) {
         const shift = units.bond === "running" && r & 1 ? w / 2 : 0;
         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 });
+          if (b - a > 1e-3) out.push({ a: offset + a, b: offset + b, y0: part.y0 + r * rowH, y1: part.y0 + (r + 1) * rowH, r, i });
         }
       }
       return out;
@@ -6485,8 +6513,21 @@ function installDestructionBreach(K, _shared) {
       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 part.role === "column" ? wallAround(part) : null;
+    }
+    function wallAround(part) {
+      const cu = (part.aabb[0] + part.aabb[2]) / 2, cv = (part.aabb[1] + part.aabb[3]) / 2;
+      for (const q of structure.parts) {
+        if (q.id === part.id || q.role !== "wall" && q.role !== "partition" || !structure.meshesOf(q.id).some((it) => it.mesh)) continue;
+        const inside = cu >= q.aabb[0] - 1e-3 && cu <= q.aabb[2] + 1e-3 && cv >= q.aabb[1] - 1e-3 && cv <= q.aabb[3] + 1e-3;
+        if (inside && Math.min(q.y1, part.y1) - Math.max(q.y0, part.y0) > 0.5) return q.id;
+      }
       return null;
     }
+    const pillarSpans = (view) => structure.parts.filter((q) => q.role === "column" && wallAround(q) === view.host).map((q) => {
+      const a = (view.mask.alongU ? q.aabb[0] : q.aabb[1]) - view.mask.start, b = (view.mask.alongU ? q.aabb[2] : q.aabb[3]) - view.mask.start;
+      return { a, b, y0: q.y0, y1: q.y1 };
+    });
     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();
@@ -6575,6 +6616,17 @@ function installDestructionBreach(K, _shared) {
       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) };
     }
+    function besidePillars(c, pillars) {
+      let { a, b } = c;
+      for (const k of pillars) {
+        if (c.y1 <= k.y0 || c.y0 >= k.y1 || b <= k.a || a >= k.b) continue;
+        const centre = (a + b) / 2;
+        if (centre > k.a && centre < k.b) return [];
+        if (centre <= k.a) b = Math.min(b, k.a);
+        else a = Math.max(a, k.b);
+      }
+      return b - a > 1e-3 ? [{ ...c, a, b }] : [];
+    }
     const boxDistance = (s, y, a, b, c, d) => Math.hypot(Math.max(a - s, 0, s - b), Math.max(c - y, 0, y - d));
     const ellipseDistance = (s, y, cs, cy, rs, ry) => (Math.hypot((s - cs) / Math.max(rs, 1e-4), (y - cy) / Math.max(ry, 1e-4)) - 1) * Math.min(rs, ry);
     function covered(c, boxes) {
@@ -6597,9 +6649,15 @@ function installDestructionBreach(K, _shared) {
       const discs = [];
       const flakes = [];
       const shown = [];
+      const pillars = pillarSpans(view);
       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), spalls = view.spalls.get(id);
-        const all = cells(part, units2);
+        const own = cells(part, units2, mask);
+        const all = id === view.host ? own.flatMap((c) => besidePillars(c, pillars)) : own;
+        if (view.fallen.has(id)) {
+          holes.push(...all);
+          continue;
+        }
         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 });
@@ -6695,52 +6753,55 @@ function installDestructionBreach(K, _shared) {
       }
       return { center: local(chip.center), along: a, up: u };
     }
+    function newView(hostId) {
+      const items = structure.meshesOf(hostId).filter((it) => it.mesh);
+      if (!items.length) return null;
+      const parts = [hostId, ...riders(hostId)].filter((id) => structure.byId.get(id) && specOf(id)?.units);
+      const mask = maskOf(hostId, parts), core = maskOf(hostId, parts);
+      return {
+        host: hostId,
+        parts,
+        items,
+        mask,
+        core,
+        unitMaterial: unitsMaterial(core),
+        shells: [],
+        saved: null,
+        units: null,
+        gone: 0,
+        pits: 0,
+        bounds: drawnBounds(items),
+        chips: new Map(parts.map((id) => [id, []])),
+        spalls: new Map(parts.map((id) => [id, []])),
+        openings: /* @__PURE__ */ new Map(),
+        flakes: 0,
+        fallen: /* @__PURE__ */ new Set()
+      };
+    }
+    function cut(view) {
+      if (view.saved) return;
+      view.shells = view.items.map((it) => shell(it, view.mask));
+      for (const m of view.shells) m.userData.behind = () => view.units;
+      view.saved = view.items.map((it) => ({ it, v0: it.v0, data: collapseRange(it.mesh, it.v0, it.v1) }));
+    }
     function draw(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);
-        if (!parts.includes(partId)) return false;
-        const mask = maskOf(hostId, parts), core = maskOf(hostId, parts);
-        view = {
-          host: hostId,
-          parts,
-          items,
-          mask,
-          core,
-          unitMaterial: unitsMaterial(core),
-          shells: [],
-          saved: null,
-          units: null,
-          gone: 0,
-          pits: 0,
-          bounds: drawnBounds(items),
-          chips: new Map(parts.map((id) => [id, []])),
-          spalls: new Map(parts.map((id) => [id, []])),
-          openings: /* @__PURE__ */ new Map(),
-          flakes: 0
-        };
-      }
-      if (!view.chips.has(partId)) return false;
+      const view = views.get(hostId) ?? newView(hostId);
+      if (!view || !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 (change.chip) view.chips.get(partId).push(chipBox(change.chip, view.mask.alongU));
+      for (const chip of change.chips ?? []) view.chips.get(partId).push(chipBox(chip, view.mask.alongU));
       if (change.spall) {
         const list = view.spalls.get(partId);
         list.push({ center: local(change.spall.center), radius: change.spall.radius });
         if (list.length > MAX_FLAKES) list.shift();
       }
-      if (!view.saved) {
-        view.shells = view.items.map((it) => shell(it, view.mask));
-        for (const m of view.shells) m.userData.behind = () => view.units;
-        view.saved = view.items.map((it) => ({ it, v0: it.v0, data: collapseRange(it.mesh, it.v0, it.v1) }));
-      }
+      cut(view);
       views.set(hostId, view);
       if (opts.deferPaint && change.spall) dirty.add(view);
       else {
@@ -6851,14 +6912,32 @@ function installDestructionBreach(K, _shared) {
        */
       chip(event) {
         if (event.torn) return false;
-        return draw(event.part, { chip: { center: event.center, size: event.size ?? [0, 0, 0], rotation: event.rotation ?? [0, 0, 0, 1] } });
+        const rotation = event.rotation ?? [0, 0, 0, 1];
+        if (event.units?.length) return draw(event.part, { chips: event.units.map((unit) => ({ center: unit.center, size: unit.size, rotation })) });
+        return draw(event.part, { chip: { center: event.center, size: event.size ?? [0, 0, 0], rotation } });
       },
       /** 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;
+        let host = views.get(partId) ?? [...views.values()].find((view) => view.parts.includes(partId));
+        if (!host && lod === 0 && riders(partId).length > 0) {
+          host = newView(partId);
+          if (host) {
+            cut(host);
+            views.set(partId, host);
+          }
+        }
+        if (!host) return;
+        host.fallen.add(partId);
+        if (host.parts.some((id) => !host.fallen.has(id))) {
+          dirty.delete(host);
+          paint(host);
+          invalidate();
+          invalidateShadow();
+          return;
+        }
+        const v = host;
         dispose(v);
-        views.delete(partId);
+        views.delete(v.host);
         if (v.saved) dropped.push(v);
       },
       /** LOD 0 draws the cut wall; LOD 1 and 2 give the wall its box back. */
@@ -7338,6 +7417,7 @@ function installBuildBuild(K, shared) {
     shared.ctx.noPiece = false;
     cursor.separate = opts.pieces === "meshes";
     cursor.pc = null;
+    shared.ctx.showPillars = opts.pillars !== "hidden";
     shared.ctx.apartment = r.template === "apartment_modern";
     shared.ctx.pa = Math.max(3, Math.min(20, pr.floors != null ? pr.floors : 5));
     shared.ctx.pf = Math.max(1, Math.min(shared.ctx.pa, pr.floor != null ? pr.floor : 3));
@@ -8133,10 +8213,10 @@ function createHouseScenarios(text, at = SPECIMEN_AT) {
         const list = events(room);
         const columns = groundColumns(parts);
         const laj = slabs(parts);
-        const first = columns[0];
-        const mate = columns.slice(1).filter((p) => Math.abs(p.position[0] - first.position[0]) < 0.5).sort((a, b) => Math.abs(b.position[2] - first.position[2]) - Math.abs(a.position[2] - first.position[2]))[0] ?? columns[1];
-        blunt(room, oid, first.id, centre(first.id), 3e6);
-        blunt(room, oid, mate.id, centre(mate.id), 3e6);
+        const first = columns.find((p) => !/^wall_column_/.test(p.id)) ?? columns[0];
+        const mate = columns.filter((p) => p !== first && !/^wall_column_/.test(p.id)).filter((p) => Math.abs(p.position[0] - first.position[0]) < 0.5).sort((a, b) => Math.abs(b.position[2] - first.position[2]) - Math.abs(a.position[2] - first.position[2]))[0] ?? columns[1];
+        const along = columns.filter((p) => /^wall_column_/.test(p.id) && Math.abs(p.position[0] - first.position[0]) < 0.5);
+        for (const p of [first, mate, ...along]) blunt(room, oid, p.id, centre(p.id), 3e6);
         step(90);
         const fell = collapsed(list);
         expect(laj.some((id) => fell.includes(id)), fill(T.two_slab_fell, { n: fell.length }));
@@ -8879,4 +8959,4 @@ export {
   FLOORPLAN_AREA_ID,
   createFloorplanTestModule
 };
-//# sourceMappingURL=chunk-QUVGWVEC.js.map
+//# sourceMappingURL=chunk-7XVCZF6H.js.map