@adatechnology/game-test-room 0.28.1 → 0.28.2

package/dist/index.global.js

@@ -51106,6 +51106,8 @@ void main(){
     { id: "shallow_water", water: { liquid: "water", depth: 0.3, drag: 0.65, blowShare: WATER_BLOW_SHARE }, strata: [{ material: "mud", thickness: 0.15 }, { material: "soil", thickness: 1.5 }, { material: "stone", thickness: 0.5 }] }
   ];
   var DEFAULT_BAR_YIELD_JOULES = 24e5;
+  var DEFAULT_BAR_DIAMETER = 0.01;
+  var DEFAULT_BAR_YIELD_PA = 5e8;
   var DEFAULT_PROFILE = "concrete_slab";
   function createRandom(seed) {
     let state = seed | 0;
@@ -51387,6 +51389,7 @@ void main(){
   var RIGID_WIDENING = 2.5;
   var COLLAPSE_DEPTH_SHARE = 0.75;
   var COLLAPSE_SPREAD_BEND = 0.5;
+  var BARS_SHARE_REACH = 0.6;
   var RIM_REACH = 1.45;
   var FLAME_MINIMUM = 200;
   var FLAME_REACH = 0.6;
@@ -51906,19 +51909,95 @@ void main(){
           }
         }
       }
-      if (collapsed) emitDeform(x, z, reach);
-      if (collapsed && profile.drop !== void 0) {
-        for (let row = row0; row <= row1; row++) {
-          for (let column = column0; column <= column1; column++) {
-            const index = row * stride + column;
-            if (barBend[index] >= COLLAPSE_SPREAD_BEND && dug[index] < limit + profile.drop) {
-              dug[index] = limit + profile.drop;
-              touchVertex(column, row);
-            }
+      if (collapsed) giveWay({ x, z, reach, profile });
+      return collapsed;
+    }
+    function giveWay(spec) {
+      const { x, z, reach, profile } = spec;
+      emitDeform(x, z, reach);
+      if (profile.drop === void 0) return;
+      const limit = maxDepthOfProfile(profile);
+      const column0 = clampIndex(Math.floor((x - reach - x0) / cellSize), columns);
+      const column1 = clampIndex(Math.ceil((x + reach - x0) / cellSize), columns);
+      const row0 = clampIndex(Math.floor((z - reach - z0) / cellSize), rows);
+      const row1 = clampIndex(Math.ceil((z + reach - z0) / cellSize), rows);
+      for (let row = row0; row <= row1; row++) {
+        for (let column = column0; column <= column1; column++) {
+          const index = row * stride + column;
+          if (barBend[index] >= COLLAPSE_SPREAD_BEND && dug[index] < limit + profile.drop) {
+            dug[index] = limit + profile.drop;
+            touchVertex(column, row);
           }
         }
       }
-      return collapsed;
+    }
+    function barsOf(profile) {
+      const bars = profile.strata.find((stratum) => stratum.reinforcement);
+      if (!bars?.reinforcement) return null;
+      let cover = bars.reinforcement.cover;
+      for (const stratum of profile.strata) {
+        if (stratum === bars) break;
+        cover += stratum.thickness;
+      }
+      return { stratum: bars, cover };
+    }
+    function bearAll(loads) {
+      const bends = /* @__PURE__ */ new Map();
+      const touched2 = [];
+      for (const load of loads) {
+        const spread2 = spreadLoad(load, bends);
+        if (spread2) touched2.push({ load, ...spread2 });
+      }
+      let opened = false;
+      for (const [index, bend] of bends) {
+        if (barBend[index] >= bend) continue;
+        barBend[index] = bend;
+        const column = index % stride;
+        const row = (index - column) / stride;
+        touchVertex(column, row);
+        const profile = profileList[profileIndex[index]];
+        const limit = maxDepthOfProfile(profile);
+        if (bend >= 1 && profile.drop !== void 0 && dug[index] >= limit * COLLAPSE_DEPTH_SHARE && dug[index] < limit + profile.drop) {
+          dug[index] = limit + profile.drop;
+          opened = true;
+        }
+      }
+      if (opened) for (const { load, reach, profile } of touched2) giveWay({ x: load.x, z: load.z, reach, profile });
+      return opened;
+    }
+    function spreadLoad(load, bends) {
+      if (!contains(load.x, load.z) || load.newtons <= 0) return null;
+      const profile = profileList[profileIndex[vertexOf(load.x, load.z).index]];
+      const bars = barsOf(profile);
+      if (!bars) return null;
+      const reinforcement = bars.stratum.reinforcement;
+      const moment = (reinforcement.yieldPa ?? DEFAULT_BAR_YIELD_PA) * (reinforcement.diameter ?? DEFAULT_BAR_DIAMETER) ** 3 / 6;
+      const holds2 = 8 * moment / reinforcement.spacing;
+      const footprint = load.radius * Math.SQRT2 + cellSize;
+      const reach = Math.max(footprint, BARS_SHARE_REACH);
+      const column0 = clampIndex(Math.floor((load.x - reach - x0) / cellSize), columns);
+      const column1 = clampIndex(Math.ceil((load.x + reach - x0) / cellSize), columns);
+      const row0 = clampIndex(Math.floor((load.z - reach - z0) / cellSize), rows);
+      const row1 = clampIndex(Math.ceil((load.z + reach - z0) / cellSize), rows);
+      const bare = [];
+      let under = 0;
+      let onBars = 0;
+      for (let row = row0; row <= row1; row++) {
+        for (let column = column0; column <= column1; column++) {
+          const distance4 = Math.hypot(x0 + column * cellSize - load.x, z0 + row * cellSize - load.z);
+          if (distance4 >= reach) continue;
+          const index = row * stride + column;
+          const isBare = dug[index] >= bars.cover;
+          if (isBare) bare.push(index);
+          if (distance4 >= footprint) continue;
+          under++;
+          if (isBare) onBars++;
+        }
+      }
+      if (onBars === 0) return null;
+      const bend = load.newtons * (onBars / under) / holds2;
+      for (const index of bare) bends.set(index, (bends.get(index) ?? 0) + bend);
+      return { reach, profile };
     }
     const maxDepthOfProfile = (profile) => maxDepthOf[indexOfProfile.get(profile.id)];
     function rebarShowing(profile, depth) {
@@ -52193,6 +52272,7 @@ void main(){
       strike,
       burn,
       applyHit,
+      bear: bearAll,
       onDeform(listener) {
         deformListeners.add(listener);
         return () => deformListeners.delete(listener);
@@ -53652,6 +53732,7 @@ ${SURFACE_GLSL}`).replace("#include <color_fragment>", "#include <color_fragment
       "act.throw": "Threw {name} at {speed} m/s",
       "ground.name": "Ground",
       "act.landing": "{name} landed at {speed} m/s: {energy} J",
+      "act.ground_gave_way": "the bare bars could not hold the weight on them: the slab gave way",
       "act.player_land": "You landed at {speed} m/s",
       "act.bench_failed": "{name} failed: {error}",
       "loading.working": "Working\u2026",
@@ -54021,6 +54102,7 @@ ${SURFACE_GLSL}`).replace("#include <color_fragment>", "#include <color_fragment
       "act.throw": "Arremessou {name} a {speed} m/s",
       "ground.name": "Ch\xE3o",
       "act.landing": "{name} caiu a {speed} m/s: {energy} J",
+      "act.ground_gave_way": "os vergalh\xF5es expostos n\xE3o aguentaram o peso: a laje cedeu",
       "act.player_land": "Voc\xEA aterrissou a {speed} m/s",
       "act.bench_failed": "{name} falhou: {error}",
       "loading.working": "Trabalhando\u2026",
@@ -55541,6 +55623,11 @@ ${SURFACE_GLSL}`).replace("#include <color_fragment>", "#include <color_fragment
   var TERRAIN_CELL = 0.1;
   var GROUND_SPLASH_MAX_LITRES = 3;
   var WATER_ENTRY_SPEED = 1.5;
+  var LOAD_EVERY = 0.2;
+  var RESTING_GAP = 0.06;
+  var PLAYER_FOOTPRINT = 0.25;
+  var RESTING_SPEED = 0.3;
+  var GRAVITY_EARTH = 9.81;
   var TERRAIN_MAX_CELLS = 1e3;
   var GROUND_BURST_MAX = 28;
   var GROUND_BURST_PER_METRE = 30;
@@ -57981,6 +58068,30 @@ ${SURFACE_GLSL}`).replace("#include <color_fragment>", "#include <color_fragment
       for (const p of loose) floatPiece(p, dt);
     };
     const footprints = createFootprints(terrain);
+    let loadClock = 0;
+    const restingLoad = (piece) => {
+      if (piece.held || Math.hypot(piece.velocity[0], piece.velocity[1], piece.velocity[2]) > RESTING_SPEED) return null;
+      const box2 = tmpBox.setFromObject(piece.root);
+      const centre = box2.getCenter(tmpV2);
+      return { x: centre.x, z: centre.z, radius: Math.max(piece.halfExtents[0], piece.halfExtents[2]), newtons: piece.mass * GRAVITY_EARTH };
+    };
+    const updateLoads = (dt) => {
+      loadClock += dt;
+      if (loadClock < LOAD_EVERY) return;
+      loadClock = 0;
+      const loads = [];
+      const [px, py, pz] = player.position;
+      if (py - terrain.heightAt(px, pz) <= RESTING_GAP) loads.push({ x: px, z: pz, radius: PLAYER_FOOTPRINT, newtons: playerMass * GRAVITY_EARTH });
+      for (const e of entries2.values()) {
+        const load = e.piece ? restingLoad(e.piece) : null;
+        if (load) loads.push(load);
+      }
+      for (const p of loose) {
+        const load = restingLoad(p);
+        if (load) loads.push(load);
+      }
+      if (loads.length > 0 && terrain.bear(loads)) action("ground_gave_way", t("act.ground_gave_way"));
+    };
     const prevVy = /* @__PURE__ */ new Map();
     const tmpBox = new THREE.Box3();
     const onKey = (code, down, e) => {
@@ -58279,6 +58390,7 @@ ${SURFACE_GLSL}`).replace("#include <color_fragment>", "#include <color_fragment
       vfx.update(dt);
       updateImpacts();
       updateWater(dt);
+      updateLoads(dt);
       if (player.position[1] <= terrain.footAt(player.position[0], player.position[2]) + 0.15) footprints.update(player.position[0], player.position[2]);
       fluidView.update(dt);
       filmBridge.update(dt);