@adatechnology/game-destruction 0.2.0 → 0.3.1

package/README.md

@@ -80,6 +80,9 @@ makes a through hole, through 5 cm concrete it only cracks and lodges. Grazing h
 | `fire` | `temperature`, `radius`, `duration` | heats towards the flame temperature and ignites at the material's ignition point |
 | `heat` | same | heat without flame (cutting torch, hot plate); melts what it can reach |
 
+Brittle materials that `shatter` (glass, ceramic) take blunt and ballistic damage multiplied by `fragility(ductility, thickness)` (x1 from 2 cm up, to x118
+for 3 mm glass), so a 9 mm shatters a window pane in one shot while a 5 cm block of glass takes several.
+
 `hit(objectId, hit)` finds the part along `direction`; `hitPart` targets a known part; `shoot` and `raycast` work in world space.
 
 ## Fire, melting and leaks
@@ -125,13 +128,20 @@ without any `structure` behave exactly as before.
   horizontal length for walls. A 0.3 m concrete column carries 40 t, a 0.2 m brick wall 8 t per metre, a 0.1 x 0.2 m softwood beam 2 t.
 - **Joints** carry load when `bears` is true (default when both parts have a role). `bears: 'a_on_b'` means part `a` rests on `b`: load flows only
   that way. A `partition` is supported but supports nothing, so breaking it never drops anything.
-- **Overload**: above stress 1 a part takes `(stress - 1) * maxHp * 0.5` damage per second, emits `stress` (once per 0.5 s) and cascades; brittle
+- **Overload**: above stress 1 a part loses `min(0.6, 0.12 + 0.8 * (stress - 1))` of its `maxHp` per second (stress 1.02 gives way in ~7 s, 1.1 in ~5 s,
+  1.5 in ~2 s, anything above 1.7 in ~1.7 s; deterministic), emits `stress` (once per 0.5 s) and cascades; brittle
   parts `crack` from stress 0.8. Metal never fractures, so overloaded steel only reports stress.
 - **Collapse**: a part with no support path to an anchored part falls: it is cut from the supported pieces into its own group (index 1 or more) and
-  one `collapse` event lists the group. Non-structural parts that hang only on collapsed parts fall with them. Make the group its own object with
+  one `collapse` event lists the group, and every part in it that is not already lost gets `PartState.status === 'collapsed'` (kept through
+  `serialize`/`load`, cleared by `reset`; a part that later breaks becomes `broken`). Non-structural parts that hang only on collapsed parts fall with them. Make the group its own object with
   `splitGroup`.
 - `buildFrame({ spanX, spanZ, columnsX, columnsZ, height, floors, walls, roof, columnCapacity, ... })` returns a test structure: columns on
   foundations (`rebar`), beams, a slab per floor, optional brick walls (`mortar`) with a door opening, and a roof that rests (`resting`) on the top beams.
+- `sizeStructure(spec, { safety?, redundancy? })` returns a copy of the spec with `structure.capacity` set from the loads the world itself solves
+  for the intact spec, so every structural part rests at stress `safety` (default 0.65). With `redundancy` (e.g. 0.97) the capacities are also
+  raised where needed so that losing any single `column` keeps every other part at or below that stress: the structure stands with one column
+  gone and, without help, falls with two neighbours gone. Raw material capacities are rarely a sensible design (a 54 t roof on 20 cm columns is
+  already over 1 at rest); size the structure instead of hand-tuning. Parts without `structure` or with role `none` are untouched.
 
 ## Contracts: implement your own or use the default world
 
@@ -182,7 +192,7 @@ world continues with the same events as the original. The loading world must use
 `raycast`, `shoot`, `disassemble`, `workableJoints`, `nearestJoint`, `extinguish`, `setLiters`, `update`, `state`, `part`, `reset`, `on`,
 `register`, `serialize`, `load`, `time`. `state()` and `part()` return live views; do not mutate them.
 
-Also exported: `buildFrame`, `partCapacity`, `checkDestructible`, `checkHit`, `IMPACT_CONTRACT`, `MATERIALS`, `JOINT_DEFAULTS`, `JOINT_BY_MATERIALS`, `inferJoints`, `guessMaterial`, `partVolume`, `partMass`, `partThickness`, the
+Also exported: `buildFrame`, `sizeStructure`, `partCapacity`, `checkDestructible`, `checkHit`, `IMPACT_CONTRACT`, `MATERIALS`, `JOINT_DEFAULTS`, `JOINT_BY_MATERIALS`, `inferJoints`, `guessMaterial`, `partVolume`, `partMass`, `partThickness`, the
 helpers `vec`, `quat`, `quatFromEuler`, `rotateVec`, `toLocal`, `toWorld`, the locale (`locales`, `resolveStrings`, `DestructionStrings`) and all types.
 
 The locale table has `en` and `pt-BR` strings for material names, part statuses, joint kinds, tools, damage types, event labels and fracture styles:

package/dist/index.d.ts

@@ -96,6 +96,18 @@ interface DestructionOptions {
     /** Distance at which a burning part heats parts of other objects, in metres (default 0.6). */
     fireSpread?: number;
 }
+interface SizeStructureOptions {
+    /** Stress every structural part has at rest after sizing (`load / capacity`), 0..1 (default 0.65). */
+    safety?: number;
+    /**
+     * Redundancy target: when set, the capacity of a part is raised (never lowered) until losing any single `column` leaves every other
+     * structural part at this stress or below, e.g. 0.97 (an N-1 design: the building stands with one column gone). Omit to skip the check.
+     * Should be above `safety` and, to let the structure fall when a second column goes, below 1.
+     */
+    redundancy?: number;
+    /** Extra or overriding materials, the same list given to `createDestruction`. */
+    materials?: MaterialDef[];
+}
 interface AddOptions {
     /** Object id (default a generated `obj_1`, `obj_2`...). */
     id?: string;
@@ -299,6 +311,15 @@ interface FrameOptions {
  */
 declare const buildFrame: (o?: FrameOptions) => DestructibleSpec;
 
+/**
+ * Sizes the load capacity of a structure the way an engineer would, from the loads the world itself computes. The intact spec goes through the
+ * same load solver `createDestruction` uses, and each structural part (`structure.role` other than `none`) gets `structure.capacity = load / safety`,
+ * so its at-rest stress is exactly `safety`. With `redundancy` set, every `column` is also removed in turn and the capacity of the parts that
+ * would carry more is raised so they stay at or below `redundancy`. Parts without `structure`, with role `none`, or with no support path to an
+ * anchored part are left as they are. The spec is not modified; a copy is returned.
+ */
+declare const sizeStructure: (spec: DestructibleSpec, options?: SizeStructureOptions) => DestructibleSpec;
+
 /** Small vector helpers (arrays of three numbers). Pure functions; they allocate a new array. */
 declare const vec: {
     add: (a: Vec3, b: Vec3) => Vec3;
@@ -366,4 +387,4 @@ declare const checkDestructible: (impl: DestructibleImpl, options?: CheckOptions
     problems: string[];
 };
 
-export { type AddOptions, type CheckOptions, type DestructionLocale, type DestructionOptions, type DestructionSnapshot, type DestructionStrings, type DestructionWorld, type FrameOptions, JOINT_BY_MATERIALS, JOINT_DEFAULTS, MATERIALS, type MaterialDef, type MaterialThermal, type ObjectRuntime, type PartRuntime, buildFrame, checkDestructible, createDestruction, fragility, guessMaterial, inferJoints, locales, partCapacity, partMass, partThickness, partVolume, quat, quatFromEuler, resolveStrings, rotateVec, toLocal, toWorld, vec };
+export { type AddOptions, type CheckOptions, type DestructionLocale, type DestructionOptions, type DestructionSnapshot, type DestructionStrings, type DestructionWorld, type FrameOptions, JOINT_BY_MATERIALS, JOINT_DEFAULTS, MATERIALS, type MaterialDef, type MaterialThermal, type ObjectRuntime, type PartRuntime, type SizeStructureOptions, buildFrame, checkDestructible, createDestruction, fragility, guessMaterial, inferJoints, locales, partCapacity, partMass, partThickness, partVolume, quat, quatFromEuler, resolveStrings, rotateVec, sizeStructure, toLocal, toWorld, vec };

package/dist/index.global.js

@@ -41,6 +41,7 @@ var GameDestruction = (() => {
     quatFromEuler: () => quatFromEuler,
     resolveStrings: () => resolveStrings,
     rotateVec: () => rotateVec,
+    sizeStructure: () => sizeStructure,
     toLocal: () => toLocal,
     toWorld: () => toWorld,
     vec: () => vec
@@ -1461,6 +1462,7 @@ var GameDestruction = (() => {
   var clamp2 = (v, a, b) => Math.max(a, Math.min(b, v));
   var isLost = (p) => p.st.status === "broken" || p.st.status === "melted" || p.st.status === "ashes";
   var clone = (v) => structuredClone(v);
+  var overloadRate = (stress) => Math.min(0.6, 0.12 + 0.8 * (stress - 1));
   var updateBound = (o) => {
     if (!o.parts.length) return;
     const c = [0, 0, 0];
@@ -1771,7 +1773,10 @@ var GameDestruction = (() => {
         for (const g of o.st.groups) {
           const ps = g.map((id) => o.byId.get(id)).filter((p) => !isLost(p) && !o.collapsed.has(p.spec.id));
           if (ps.length === 0 || g.some((id) => o.byId.get(id).anchored) || !ps.some((p) => p.structural)) continue;
-          for (const p of ps) o.collapsed.add(p.spec.id);
+          for (const p of ps) {
+            o.collapsed.add(p.spec.id);
+            p.st.status = "collapsed";
+          }
           emit({ ...base(o, src), type: "collapse", parts: ps.map((p) => p.spec.id), mass: ps.reduce((sum, p) => sum + p.st.mass, 0) });
         }
       }
@@ -2071,7 +2076,7 @@ var GameDestruction = (() => {
       const effM = p.thickness / Math.max(sin, 0.3);
       const thr = mat.penetration * effM * 1e3;
       const penetrated = E > thr;
-      const scale = mat.damageScale?.ballistic ?? 1;
+      const scale = (mat.damageScale?.ballistic ?? 1) * (mat.fracture === "shatter" ? fragility(mat.ductility, p.thickness) : 1);
       const id = p.spec.id;
       if (!penetrated && mat.ricochetDeg && angle < mat.ricochetDeg) {
         const r = vec.sub(d, vec.scale(n, 2 * vec.dot(d, n)));
@@ -2421,7 +2426,7 @@ var GameDestruction = (() => {
               p.rt.stressT = 0.5;
               emit({ ...base(o), type: "stress", part: p.spec.id, stress, load: p.st.load ?? 0 });
             }
-            applyDamage(o, p, (stress - 1) * p.st.maxHp * 0.5 * dt, "blunt", null, null, 5, 3);
+            applyDamage(o, p, overloadRate(stress) * p.st.maxHp * dt, "blunt", null, null, 5, 3);
           } else if (stress > 0.8 && p.mat.ductility < 0.3 && p.rt.stressT <= 0 && p.st.cracks.length < 6) {
             p.rt.stressT = 0.5;
             const { c, q } = partXf(o, p);
@@ -2883,6 +2888,47 @@ var GameDestruction = (() => {
     return { name: "frame", parts, joints, tags: ["structure"] };
   };
 
+  // src/size.ts
+  var sizeStructure = (spec, options = {}) => {
+    const safety = options.safety ?? 0.65;
+    const redundancy = options.redundancy;
+    const loads = (s) => {
+      const w = createDestruction(options.materials ? { materials: options.materials } : {});
+      const id = w.add(s);
+      return new Map(w.state(id).parts.map((p) => [p.id, { load: p.load ?? 0, stress: p.stress ?? 0 }]));
+    };
+    const out = structuredClone(spec);
+    const base = loads(out);
+    const need = /* @__PURE__ */ new Map();
+    for (const p of out.parts) {
+      if (!p.structure || p.structure.role === "none") continue;
+      const b = base.get(p.id);
+      if (!b || b.stress <= 0) continue;
+      need.set(p.id, b.load / safety);
+    }
+    if (redundancy !== void 0) {
+      for (const col of out.parts) {
+        if (col.structure?.role !== "column") continue;
+        const reduced = {
+          ...out,
+          parts: out.parts.filter((p) => p.id !== col.id),
+          joints: (out.joints ?? []).filter((j) => j.a !== col.id && j.b !== col.id)
+        };
+        if (!out.joints) delete reduced.joints;
+        const l = loads(reduced);
+        for (const [id, n] of need) {
+          const r = l.get(id);
+          if (r && r.stress > 0) need.set(id, Math.max(n, r.load / redundancy));
+        }
+      }
+    }
+    for (const p of out.parts) {
+      const n = need.get(p.id);
+      if (n !== void 0) p.structure = { ...p.structure, capacity: n };
+    }
+    return out;
+  };
+
   // src/locale.ts
   var locales = {
     en: {
@@ -2915,7 +2961,7 @@ var GameDestruction = (() => {
         wax: "wax",
         soil: "soil"
       },
-      partStatus: { intact: "intact", damaged: "damaged", broken: "broken", melted: "melted", ashes: "ashes" },
+      partStatus: { intact: "intact", damaged: "damaged", collapsed: "collapsed", broken: "broken", melted: "melted", ashes: "ashes" },
       jointKinds: {
         screw: "screw",
         bolt: "nut and bolt",
@@ -2996,7 +3042,7 @@ var GameDestruction = (() => {
         wax: "cera",
         soil: "terra"
       },
-      partStatus: { intact: "intacto", damaged: "danificado", broken: "quebrado", melted: "derretido", ashes: "cinzas" },
+      partStatus: { intact: "intacto", damaged: "danificado", collapsed: "desabado", broken: "quebrado", melted: "derretido", ashes: "cinzas" },
       jointKinds: {
         screw: "parafuso",
         bolt: "porca e parafuso",