@adatechnology/game-test-room 0.19.0 → 0.19.1

package/README.md

@@ -211,9 +211,9 @@ Every frame the room puts `root` at the player's feet turned to where the player
 
 **Pushing furniture.** Against a piece that stands on the floor, with bare hands, a tap on E grabs as ever and holding E fills a ring around the crosshair (longer the heavier). Then W pushes, S pulls, slower with the mass; letting go ends it. Before each step the volume of the piece is swept (`world.sweepBox`) against everything and the arena: at an obstacle the piece and the player stop and the player strains, and a piece too heavy for the player (`RoomOptions.push`, `FurniturePushRules` of game-player) never moves. A piece lower than a table is pushed from above, bent over it. Scripted: `room.push`. Try it: `?scene=push` in the example.
 
-**Opening by hand.** A tap of E on a leaf (a part an `open_*` clip of the item moves: furniture doors, drawers and lids, vehicle doors, hood and trunk) opens it, and E again closes it; looking into what an open leaf opened, E closes that leaf. The player steps up to the handle, the hand goes to the free edge of the leaf (a drawer by its front) and follows it, pulling (the arm bends, the body leans back) or pushing; a door that swings into the player makes the player step back. The leaf swings along the item's own clip at a speed set by its mass, its sweep tested against the world (`world.sweepBox`) and the arena: it stops at what is in its way with a knock. A locked leaf (`room.lockLeaf`) only rattles. Latch, hinge creak, the leaf meeting the frame and the rattle play by material. Holding E still pushes the piece. Scripted: `room.useLeaf`, `room.leafOpening`, `room.leaves`, `room.door`; the numbers are `RoomOptions.doors` (`DoorUseRules` of game-player). A module that moves its own leaves (the doors of a house) asks for the same hand and body with `host.reachFor`. Try it: `?scene=doors` in the example.
+**Opening by hand.** A tap of E on a leaf (a part an `open_*` clip of the item moves: furniture doors, drawers and lids, vehicle doors, hood and trunk) opens it, and E again closes it; looking into what an open leaf opened, E closes that leaf. The player steps up to the handle, the body's hand goes to the free edge of the leaf (a drawer by its front) through the same `reach` as a held tool, in both views, and follows it, pulling (the arm bends, the body leans back) or pushing; a door that swings into the player makes the player step back. The leaf swings along the item's own clip at a speed set by its mass, its sweep tested against the world (`world.sweepBox`) and the arena: it stops at what is in its way with a knock. A locked leaf (`room.lockLeaf`) only rattles. Latch, hinge creak, the leaf meeting the frame and the rattle play by material. Holding E still pushes the piece. Scripted: `room.useLeaf`, `room.leafOpening`, `room.leaves`, `room.door`; the numbers are `RoomOptions.doors` (`DoorUseRules` of game-player). A module that moves its own leaves (the doors of a house) asks for the same hand and body with `host.reachFor`. Try it: `?scene=doors` in the example.
 
-**First-person arms and strikes.** An avatar may carry `firstPerson` (arms drawn in the camera's space; the room shows them only in the first person, updates them every frame after the modules' frame hooks and hands them where the tool in the hands asks the hands to be) and `strike(clipId)`. The hand targets come from the module that places the tool (`host.setHandTargets(source)`, `HandTargets` of `@adatechnology/game-contracts`: world-space poses of the right and left hand plus the grip closure and the size of the hands), else from the carried item, else null; the stance is `hold` when there are targets, else `handStances[toolId]` (default `{ fists: 'fists' }`) or `relaxed`. A melee strike (`fists`, `shove`, Shift+V kick) no longer lands at the click: the room calls `avatar.strike(strikeClips[toolId])` (default `{ fists: 'punch_right', shove: 'shove_two_hands', kick: 'front_kick' }`), which plays the clip on the arms and on the body and answers the seconds to its impact, writes a `strike` line to the log, and calls the existing `meleeUse` at that second with the aim read again. The left click with bare hands (`hand`, the default tool) punches too (E or the right button grab). Punches alternate hands, right first (`punchHand`: `alternate`, `left`, `right`; `punchTools`, default `['hand', 'fists']`): the room calls `strike(clip, { hand })` and logs the hand, as the kick does with `kickLeg` and `{ leg }`. A **strike combo** is an ability the page gives (`strikeCombo`, such as `PUNCH_COMBO` of `game-characters-people`: jab, cross, hook, uppercut): while it is on (N, its button, `setStrikeCombo(true)`, `strikeComboOn`) each blow of its tools plays its next step (`{ clip, hand }`) and a pause longer than its `reset` starts it over; off, the tools strike as usual. The strike line carries `combo` and `step`. A tool without a clip, or an avatar that answers null, keeps the instant blow; a strike pending blocks the same tool. `toRoomAvatar(createPlayerAvatar(THREE))` already gives all of it (`firstPerson: false` for no arms).
+**Hands and strikes.** The body is the only set of arms, in both views: the room hands its hands where the tool in them asks them to be (`reach`, every frame after the modules' frame hooks) and an avatar may answer `strike(clipId)`. The hand targets come from the module that places the tool (`host.setHandTargets(source)`, `HandTargets` of `@adatechnology/game-contracts`: world-space poses of the right and left hand plus the grip closure and the size of the hands), else from the carried item, else null; the stance is `hold` when there are targets, else `handStances[toolId]` (default `{ fists: 'fists' }`) or `relaxed`. A melee strike (`fists`, `shove`, Shift+V kick) no longer lands at the click: the room calls `avatar.strike(strikeClips[toolId])` (default `{ fists: 'punch_right', shove: 'shove_two_hands', kick: 'front_kick' }`), which plays the clip on the body (in both views) and answers the seconds to its impact, writes a `strike` line to the log, and calls the existing `meleeUse` at that second with the aim read again. The left click with bare hands (`hand`, the default tool) punches too (E or the right button grab). Punches alternate hands, right first (`punchHand`: `alternate`, `left`, `right`; `punchTools`, default `['hand', 'fists']`): the room calls `strike(clip, { hand })` and logs the hand, as the kick does with `kickLeg` and `{ leg }`. A **strike combo** is an ability the page gives (`strikeCombo`, such as `PUNCH_COMBO` of `game-characters-people`: jab, cross, hook, uppercut): while it is on (N, its button, `setStrikeCombo(true)`, `strikeComboOn`) each blow of its tools plays its next step (`{ clip, hand }`) and a pause longer than its `reset` starts it over; off, the tools strike as usual. The strike line carries `combo` and `step`. A tool without a clip, or an avatar that answers null, keeps the instant blow; a strike pending blocks the same tool. `toRoomAvatar(createPlayerAvatar(THREE))` already gives all of it .
 
 `room.setCameraMode('first' | 'third')` (option `cameraMode`, property `cameraMode`, event `room.on('camera', fn)`; every change is a `camera` action in the log). V toggles it when a body is set. In `first` the body is hidden; in `third` it is shown, the camera stands over the shoulder, and a carried item rides `avatar.hand('R')` instead of the camera frame. Option `thirdPerson` changes the view; the defaults are the team game's shoulder camera (`zombiada-modo-livre.html`, `cameraUpdate`, line 76546): `back` 3.8 m, `side` 0.9 m to the right, `up` 1.95 m (`crouchUp` 1.4 m), `lift` 0.1 m, three probe rays (`probes` 0 and +-0.2 m) that pull the camera in `margin` 0.3 m short of a wall (never closer than `minDistance` 0.2 m) and let it out at `recover` 4 per second.
 

package/dist/index.d.ts

@@ -430,7 +430,7 @@ interface RoomAvatar {
     /** Hides the head and neck from `camera` while the view is `first` (shadows, mirrors and other cameras keep seeing them). */
     setView?(mode: CameraMode, camera: THREE_NS.Object3D | null): void;
     /**
-     * Plays the strike `clipId` (on the body and on the arms) and answers the seconds until its impact, or null when this avatar has no such clip. The room then waits that long
+     * Plays the strike `clipId` (on the body, in both views) and answers the seconds until its impact, or null when this avatar has no such clip. The room then waits that long
      * before the blow lands (`strikeClips`); an avatar without `strike`, or one that answers null, gets the blow at the click.
      */
     strike?(clipId: string, options?: {

package/dist/index.global.js

@@ -3150,6 +3150,7 @@ var GameTestRoom = (() => {
   var CHIP_ENERGY = 200;
   var CHIP_SPLASH = 0.5;
   var CRATER_SPENT = 0.6;
+  var EDGE_REACH = 1.5;
   var BAR_BOW = 0.08;
   var BULLET_JOINT_SPAN = 0.3;
   var CUT_SLICE = 1;
@@ -4523,6 +4524,9 @@ var GameTestRoom = (() => {
           const lo = cell.center[a] - cell.size[a] / 2 + w / 2, hi = cell.center[a] + cell.size[a] / 2 - w / 2;
           size[a] = w;
           center[a] = clamp2(lp[a], lo, hi);
+          const [from, to] = tornToEdge({ p, cell, a, b: a === u ? v : u, at: lp[a], crater: [center[a] - w / 2, center[a] + w / 2], reach: w * EDGE_REACH, gone: (k) => worn[k] === -1 });
+          size[a] = to - from;
+          center[a] = (from + to) / 2;
         }
         const taken2 = (cut2[i] ?? 0) + size[u] * size[v];
         if (taken2 >= cell.size[u] * cell.size[v] * CRATER_SPENT) {
@@ -4560,6 +4564,19 @@ var GameTestRoom = (() => {
         collapseCheck(o, src);
       }
     };
+    const tornToEdge = (o) => {
+      const { p, cell, a, b, at: at3, crater: crater2, reach, gone } = o;
+      const half = p.dims[a] / 2;
+      const lo = cell.center[a] - cell.size[a] / 2, hi = cell.center[a] + cell.size[a] / 2;
+      const free = (side, sign) => {
+        if (sign > 0 ? side >= half - 1e-6 : side <= -half + 1e-6) return sign > 0 || a !== planeAxes(p.thin)[1];
+        const probe = side + sign * 1e-3;
+        return gridOf(p).some((c, k) => gone(k) && Math.abs(probe - c.center[a]) <= c.size[a] / 2 && Math.abs(cell.center[b] - c.center[b]) <= c.size[b] / 2);
+      };
+      if (at3 - lo <= reach && free(lo, -1)) return [lo, Math.max(crater2[1], lo)];
+      if (hi - at3 <= reach && free(hi, 1)) return [Math.min(crater2[0], hi), hi];
+      return crater2;
+    };
     const craterAcross = (energy) => clamp2(0.03 + 12e-4 * Math.sqrt(Math.max(0, energy)), 0.03, 0.14);
     const craterFragments = (o, p, cell, dir, speed, mass, tag) => {
       const { c, q } = partXf(o, p);
@@ -7524,7 +7541,7 @@ var GameTestRoom = (() => {
     const registry = createSoundRegistry(options.banks);
     const voices = createVoiceManager({ ...options.groups ? { groups: options.groups } : {}, ...options.maxVoices === void 0 ? {} : { maxVoices: options.maxVoices } });
     const engineRandom = createRng2(seed);
-    const shared = createNoiseStore(engineRandom);
+    const shared2 = createNoiseStore(engineRandom);
     const busSettings = /* @__PURE__ */ new Map();
     const busNodes = /* @__PURE__ */ new Map();
     const meters = /* @__PURE__ */ new Map();
@@ -7563,7 +7580,7 @@ var GameTestRoom = (() => {
       if (!created) return null;
       context = created;
       chain = buildChain(created, mix, engineRandom);
-      if (mix.noise.create === "eager") noiseBuffer(shared, created, mix.noise.seconds);
+      if (mix.noise.create === "eager") noiseBuffer(shared2, created, mix.noise.seconds);
       for (const [bus, setting] of Object.entries(mix.buses ?? {})) {
         busSettings.set(bus, { ...setting, ...busSettings.get(bus) });
       }
@@ -7682,8 +7699,8 @@ var GameTestRoom = (() => {
     const loopHost = {
       ready,
       output: outputFor,
-      prepareNoise: () => context && prepareNoise(shared, context, mix.noise.seconds),
-      noise: () => noiseBuffer(shared, context, mix.noise.seconds),
+      prepareNoise: () => context && prepareNoise(shared2, context, mix.noise.seconds),
+      noise: () => noiseBuffer(shared2, context, mix.noise.seconds),
       register: (loop) => void loops.add(loop),
       unregister: (loop) => void loops.delete(loop)
     };
@@ -7691,7 +7708,7 @@ var GameTestRoom = (() => {
       registry,
       register: (bank) => registry.register(bank),
       plan: (id, playOptions = {}) => planWith(id, playOptions, createRng2(playOptions.seed ?? seed)),
-      play: (id, playOptions = {}) => playWith(id, playOptions, randomFor(playOptions), shared),
+      play: (id, playOptions = {}) => playWith(id, playOptions, randomFor(playOptions), shared2),
       playPlan(plan, playOptions = {}) {
         const audio = ready();
         if (!audio) return null;
@@ -7699,13 +7716,13 @@ var GameTestRoom = (() => {
         const recipe = { id: plan.id, bus: plan.bus, layers: [], sources: [], priority: plan.priority, ...plan.group ? { group: plan.group } : {} };
         const voiceId = plan.silent ? void 0 : admit(recipe, plan.level, plan.distance);
         if (voiceId === null) return null;
-        if (planUsesNoise(plan)) prepareNoise(shared, audio, mix.noise.seconds);
-        return start(plan, shared, voiceId, playOptions.delay);
+        if (planUsesNoise(plan)) prepareNoise(shared2, audio, mix.noise.seconds);
+        return start(plan, shared2, voiceId, playOptions.delay);
       },
       loop: (id, loopOptions = {}) => createLoopHandle(registry.loop(id), loopHost, loopOptions.volume),
       channel(channelOptions) {
         const random = channelOptions.random ?? (channelOptions.seed === void 0 ? engineRandom : createRng2(channelOptions.seed));
-        const store = channelOptions.ownNoise ? createNoiseStore(random) : shared;
+        const store = channelOptions.ownNoise ? createNoiseStore(random) : shared2;
         return {
           random,
           play: (id, playOptions = {}) => playWith(id, playOptions, random, store),
@@ -7727,7 +7744,7 @@ var GameTestRoom = (() => {
         if (!context || !chain) return;
         const old = chain;
         chain = buildChain(context, mix, engineRandom);
-        if (mix.noise.seconds !== previous.noise.seconds) shared.reset();
+        if (mix.noise.seconds !== previous.noise.seconds) shared2.reset();
         for (const node of busNodes.values()) {
           node.disconnect();
           node.connect(chain.master);
@@ -7746,7 +7763,7 @@ var GameTestRoom = (() => {
       warmUp() {
         const audio = ready();
         if (!audio) return false;
-        noiseBuffer(shared, audio, mix.noise.seconds);
+        noiseBuffer(shared2, audio, mix.noise.seconds);
         return true;
       },
       level(bus) {
@@ -7781,7 +7798,7 @@ var GameTestRoom = (() => {
         chain = null;
         busNodes.clear();
         meters.clear();
-        shared.reset();
+        shared2.reset();
       }
     };
   }
@@ -12588,12 +12605,12 @@ var GameTestRoom = (() => {
     }
     function drawing(entry, action) {
       const context = engine.context;
-      const shared = context.random;
+      const shared2 = context.random;
       if (entry.random) context.random = entry.random;
       try {
         action();
       } finally {
-        context.random = shared;
+        context.random = shared2;
       }
     }
     return {
@@ -40280,6 +40297,81 @@ void main(){
     return root;
   }
 
+  // ../game-shapes-three/dist/index.js
+  var isTexture = (v) => !!v && typeof v === "object" && v.isTexture === true;
+  function texturesOf(material, out) {
+    for (const value of Object.values(material)) if (isTexture(value)) out.add(value);
+    const uniforms = material.uniforms;
+    if (uniforms) {
+      for (const u of Object.values(uniforms)) if (isTexture(u?.value)) out.add(u.value);
+    }
+  }
+  function collect(roots) {
+    const geometries = /* @__PURE__ */ new Set();
+    const materials = /* @__PURE__ */ new Set();
+    const textures = /* @__PURE__ */ new Set();
+    const skeletons = /* @__PURE__ */ new Set();
+    for (const root of roots) {
+      root.traverse((object) => {
+        const o = object;
+        if (o.geometry && typeof o.geometry.dispose === "function") geometries.add(o.geometry);
+        if (o.skeleton && typeof o.skeleton.dispose === "function") skeletons.add(o.skeleton);
+        const list = Array.isArray(o.material) ? o.material : o.material ? [o.material] : [];
+        for (const m of list) {
+          if (!m || typeof m.dispose !== "function") continue;
+          materials.add(m);
+          texturesOf(m, textures);
+        }
+      });
+    }
+    return { geometries, materials, textures, skeletons };
+  }
+  var marked = /* @__PURE__ */ new WeakSet();
+  var shared = (r) => r.userData?.shared === true || marked.has(r);
+  function releaseObject3D(roots, options = {}) {
+    const list = Array.isArray(roots) ? roots : [roots];
+    const report = { geometries: 0, materials: 0, textures: 0 };
+    if (list.length === 0) return report;
+    const found = collect(list);
+    const keepRoots = options.keep === void 0 ? [] : Array.isArray(options.keep) ? options.keep : [options.keep];
+    const releasing = new Set(list);
+    for (const keep of keepRoots) {
+      const walk = (o) => {
+        if (releasing.has(o)) return;
+        const owner = o;
+        if (owner.geometry) found.geometries.delete(owner.geometry);
+        if (owner.skeleton) found.skeletons.delete(owner.skeleton);
+        const mats = Array.isArray(owner.material) ? owner.material : owner.material ? [owner.material] : [];
+        for (const m of mats) {
+          if (!m) continue;
+          found.materials.delete(m);
+          const t = /* @__PURE__ */ new Set();
+          texturesOf(m, t);
+          for (const x of t) found.textures.delete(x);
+        }
+        for (const c of o.children) walk(c);
+      };
+      walk(keep);
+    }
+    for (const g of found.geometries) {
+      if (shared(g)) continue;
+      g.dispose();
+      report.geometries++;
+    }
+    for (const m of found.materials) {
+      if (shared(m)) continue;
+      m.dispose();
+      report.materials++;
+    }
+    for (const t of found.textures) {
+      if (shared(t)) continue;
+      t.dispose();
+      report.textures++;
+    }
+    for (const s of found.skeletons) s.dispose();
+    return report;
+  }
+
   // src/segment-box.ts
   var segmentTouchesBox = (from, to, min2, max2) => {
     let near = 0;
@@ -40320,9 +40412,13 @@ void main(){
     const projectiles = [];
     const meshes = [];
     const up = new THREE.Vector3(0, 1, 0);
+    const drop = (objects) => {
+      for (const object of objects) object.removeFromParent();
+      releaseObject3D(objects, { keep: scene2 });
+    };
     const clear = () => {
       projectiles.length = 0;
-      for (const mesh2 of meshes) mesh2.removeFromParent();
+      drop(meshes);
       meshes.length = 0;
     };
     const addMesh = (geometry, color, metalness, at3) => {
@@ -40346,13 +40442,12 @@ void main(){
     };
     const remove = (projectile) => {
       for (const extra of projectile.attached ?? []) {
-        extra.removeFromParent();
         const extraAt = meshes.indexOf(extra);
         if (extraAt >= 0) meshes.splice(extraAt, 1);
       }
-      projectile.mesh.removeFromParent();
       const meshAt = meshes.indexOf(projectile.mesh);
       if (meshAt >= 0) meshes.splice(meshAt, 1);
+      drop([...projectile.attached ?? [], projectile.mesh]);
       const at3 = projectiles.indexOf(projectile);
       if (at3 >= 0) projectiles.splice(at3, 1);
     };
@@ -47207,6 +47302,23 @@ ${SURFACE_GLSL}`).replace("#include <color_fragment>", "#include <color_fragment
       }
       return m;
     };
+    let releaseBatch = null;
+    const dropTree = (root) => {
+      if (!root) return;
+      if (releaseBatch) releaseBatch.push(root);
+      else releaseObject3D(root, { keep: scene2 });
+    };
+    const releasingTogether = (fn) => {
+      if (releaseBatch) return fn();
+      releaseBatch = [];
+      try {
+        fn();
+      } finally {
+        const roots = releaseBatch;
+        releaseBatch = null;
+        releaseObject3D(roots, { keep: scene2 });
+      }
+    };
     const removeEntry = (id) => {
       const e = entries.get(id);
       if (!e) return;
@@ -47223,7 +47335,10 @@ ${SURFACE_GLSL}`).replace("#include <color_fragment>", "#include <color_fragment
       e.follower?.dispose?.();
       if (world.has(id)) world.remove(id);
       e.so.root.removeFromParent();
+      const inner = wrapped.get(e.so.root);
       letGo(e.so.root);
+      dropTree(e.so.root);
+      dropTree(inner);
       entries.delete(id);
       doors.forget(id);
       rendererPieces.delete(id);
@@ -47239,12 +47354,14 @@ ${SURFACE_GLSL}`).replace("#include <color_fragment>", "#include <color_fragment
         }
         if (world.has(id)) world.remove(id);
         p?.root.removeFromParent();
+        dropTree(p?.root);
         rendererPieces.delete(id);
         splitOf.delete(id);
       }
       loose.length = 0;
     };
-    const clearEverything = () => {
+    const clearEverything = () => releasingTogether(clearEverythingNow);
+    const clearEverythingNow = () => {
       if (heldEntry || heldPiece) releaseHeld();
       useItemPlayer = null;
       playing.length = 0;
@@ -47293,8 +47410,10 @@ ${SURFACE_GLSL}`).replace("#include <color_fragment>", "#include <color_fragment
       seating.release();
       pushByKey = false;
       push.end();
-      clearEverything();
-      for (const id of [...entries.keys()]) removeEntry(id);
+      releasingTogether(() => {
+        clearEverythingNow();
+        for (const id of [...entries.keys()]) removeEntry(id);
+      });
       renderer.reset();
       for (const listener of [...resetListeners]) listener();
       tools.clear();
@@ -47447,11 +47566,11 @@ ${SURFACE_GLSL}`).replace("#include <color_fragment>", "#include <color_fragment
     };
     const reachAvatar = () => {
       const doorHand = doors.handTargets();
-      const targets = push.active ? null : heldPiece ? twistHand : handSource?.() ?? null;
+      const targets = push.active ? null : doorHand ?? (heldPiece ? twistHand : handSource?.() ?? null);
       lastHand = {
         stance: push.active || doorHand ? "hold" : handStances[toolId] ?? (targets ? "hold" : "relaxed"),
         triggerFinger: targets?.fingers?.index ?? null,
-        targets: push.handTargets() ?? doorHand ?? targets
+        targets: push.handTargets() ?? targets
       };
       if (!avatar?.reach) return;
       avatar.reach(targets, { camera: camera2, keepOutside: { contact: (origin, direction, maxDistance) => rayWorld(origin, direction, maxDistance)?.distance ?? null } });