@adatechnology/game-test-room 0.21.0 → 0.22.0

package/dist/index.js

@@ -1,7 +1,8 @@
 // src/room.ts
 import { createDestruction, JOINT_DEFAULTS, resolveStrings as resolveDestructionStrings } from "@adatechnology/game-destruction";
-import { createAudioEngine, createAudioSink } from "@adatechnology/game-audio";
-import { surfaceOfMaterial } from "@adatechnology/game-contracts";
+import { createAudioEngine, createAudioSink, loadKitSamples } from "@adatechnology/game-audio";
+import { createDestructionRenderer, createDestructionSound, dragSoundKey, impactKey, impactSoundKeys, specFromObject3D } from "@adatechnology/game-destruction-three";
+import { bodyMass, KNOCK_CHEST, knockOf, surfaceOfMaterial } from "@adatechnology/game-contracts";
 
 // src/body-sounds.ts
 import { BODY_FOLEY_BANK } from "@adatechnology/game-audio";
@@ -31,13 +32,14 @@ function blowOfTool(id, category, table = DEFAULT_TOOL_BLOWS) {
 }
 var levelOf = (energyJ) => Math.max(0.5, Math.min(1, 0.5 + energyJ / 800));
 var STRIDE_METRES = { walk: 0.72, run: 1.05 };
+var SLAM_HURT_SPEED = 3.5;
 function createBodySounds(audio) {
   audio?.register(BODY_FOLEY_BANK);
   const played = [];
   const play = (id, position, volume, delay = 0) => {
     played.push(id);
     if (played.length > 64) played.shift();
-    audio?.play(id, { position, volume, ...delay > 0 ? { delay } : {} });
+    audio?.play(id, { position, volume, urgent: true, ...delay > 0 ? { delay } : {} });
   };
   return {
     swing(blow, position, delay = 0) {
@@ -49,6 +51,10 @@ function createBodySounds(audio) {
     },
     jump: (position) => play("jump", position, 0.6),
     land: (surface, speed, position) => play(landSoundId(surface, speed), position, Math.min(1, 0.45 + speed / 8)),
+    slam(speed, position) {
+      play("body_fall", position, Math.min(1, 0.4 + speed / 8));
+      if (speed >= SLAM_HURT_SPEED) play("player_hurt", position, Math.min(1, 0.5 + speed / 12));
+    },
     played
   };
 }
@@ -73,7 +79,6 @@ function createStrideCounter(stride = STRIDE_METRES) {
 }
 
 // src/room.ts
-import { createDestructionRenderer, createDestructionSound, dragSoundKey, impactKey, specFromObject3D } from "@adatechnology/game-destruction-three";
 import { createArsenal, DEFAULT_LOADOUT } from "@adatechnology/game-weapons";
 import { createFilmLcg, createFluids, createItemUse, ITEM_USES, resolveStrings as resolveFluidStrings } from "@adatechnology/game-fluids";
 import { createFilmBridge, createFilmManager, createFluidRenderer } from "@adatechnology/game-fluids-three";
@@ -316,6 +321,38 @@ function createArena(THREE, size, scene, scenery, tapOption) {
   };
 }
 
+// src/hand-sounds.ts
+import { LEAF_FOLEY_SETS } from "@adatechnology/game-audio";
+function pickupClassOf(def) {
+  if (!def) return "plastic";
+  const tags = def.tags ?? [];
+  if (def.id === "paper") return "paper";
+  if (tags.includes("metal")) return "metal";
+  if (tags.includes("glass") || tags.includes("ceramic")) return "glass";
+  if (tags.includes("plastic") || tags.includes("rubber")) return "plastic";
+  if (tags.includes("wood")) return "wood";
+  if (tags.includes("fabric")) return "fabric";
+  if (tags.includes("plant")) return "food";
+  return "plastic";
+}
+var pickupSoundOf = (sounds, def) => `item_pickup_${sounds?.handling ?? pickupClassOf(def)}`;
+function leafFoleyOf(sounds, part, impactKey2, slides2) {
+  const named = sounds?.leaves?.[part] ?? sounds?.leaves?.["*"];
+  const set = named ? LEAF_FOLEY_SETS[named] : void 0;
+  if (set) return set;
+  if (slides2) return LEAF_FOLEY_SETS.drawer;
+  return /metal|glass/.test(impactKey2) ? LEAF_FOLEY_SETS.metal_door : LEAF_FOLEY_SETS.wood_door;
+}
+var openSoundOf = (sounds, def) => sounds?.open ?? (pickupClassOf(def) === "metal" ? "can_open" : "bottle_open");
+var USE_SOUNDS = {
+  drink: "drink_gulp",
+  sip: "drink_gulp",
+  chug: "drink_gulp",
+  eat: "eat_chew"
+};
+var USE_SOUND_EVERY = 0.55;
+var useSoundOf = (sounds, useId) => sounds?.uses?.[useId] ?? USE_SOUNDS[useId];
+
 // src/bench.ts
 var snap = (control, value) => {
   const clamped = Math.min(control.max, Math.max(control.min, value));
@@ -765,7 +802,7 @@ function createExplosives(context) {
     if (!detonation.cone) told(results);
     if (detonation.energy > 0) {
       const isPlayed = context.effects.explosion(detonation.explosive, detonation.point, { direction: detonation.direction }) !== null;
-      renderer.explode(detonation.point, detonation.energy, reach, { visual: !isPlayed, report: results });
+      renderer.explode(detonation.point, detonation.energy, reach, { visual: !isPlayed, report: results, effect: detonation.explosive });
     }
     if (detonation.stunSeconds !== void 0) renderer.emit("flash", detonation.point, [0, 1, 0], 1, 1);
     const onPlayer = blastEffect(detonation, toArray(camera.position));
@@ -2088,6 +2125,8 @@ function createNarrator(c) {
 }
 
 // src/player.ts
+import { stepKnock } from "@adatechnology/game-contracts";
+var SLAM_MIN_SPEED = 1.5;
 var LANDING_MIN_SPEED = 1;
 var EYE = 1.7;
 var PLAYER_RADIUS = 0.3;
@@ -2105,6 +2144,9 @@ var GRAVITY = 13;
 var FLOOR_CLIMB_SPEED = 3;
 var FLOOR_FALL_SPEED = 6;
 var LOOK = 22e-4;
+var LYING_EYE = 0.3;
+var LYING_PITCH = 1.05;
+var LYING_ROLL = 0.35;
 function createPlayer(THREE, o) {
   const cam = o.camera;
   let yaw = 0;
@@ -2142,10 +2184,15 @@ function createPlayer(THREE, o) {
     const reach = (gap > 0 ? FLOOR_CLIMB_SPEED : FLOOR_FALL_SPEED) * dt;
     floorLevel += Math.max(-reach, Math.min(reach, gap));
   };
+  let knocked = null;
+  let rollSide = 1;
   const apply = () => {
-    euler.set(pitch, yaw, 0, "YXZ");
+    const lying = knocked?.lying ?? 0;
+    const fallen = lying * lying * (3 - 2 * lying);
+    euler.set(pitch + (LYING_PITCH - pitch) * fallen, yaw, LYING_ROLL * rollSide * fallen, "YXZ");
     cam.quaternion.setFromEuler(euler);
-    cam.position.set(px.x, eye + floorLevel + y - CROUCH_DROP * crouch - bend, px.z);
+    const standing = eye - CROUCH_DROP * crouch - bend;
+    cam.position.set(px.x, floorLevel + y + standing + (LYING_EYE - standing) * fallen, px.z);
     cam.updateMatrixWorld(true);
   };
   apply();
@@ -2320,6 +2367,41 @@ function createPlayer(THREE, o) {
   window.addEventListener("keyup", onKeyUp);
   window.addEventListener("blur", onBlur);
   window.addEventListener("beforeunload", onBeforeUnload);
+  const stepKnocked = (dt) => {
+    const k = knocked;
+    if (!k) return;
+    const floor = Math.max(floorHere(), o.footing?.(px.x, px.z, PLAYER_RADIUS * FOOT, y).floor ?? -Infinity);
+    floorUnder = floor;
+    const at = { x: px.x, y, z: px.z };
+    const fromY = y;
+    const fallSpeed = Math.max(0, -k.velocity[1]);
+    const done = stepKnock(k, at, dt, () => floor, true);
+    const wantX = at.x - px.x;
+    const wantZ = at.z - px.z;
+    const fromX = px.x;
+    const fromZ = px.z;
+    const vx = k.velocity[0];
+    const vz = k.velocity[2];
+    move(wantX, wantZ);
+    const stoppedX = Math.abs(wantX) > 1e-6 && Math.abs(px.x - fromX) < Math.abs(wantX) * 0.5;
+    const stoppedZ = Math.abs(wantZ) > 1e-6 && Math.abs(px.z - fromZ) < Math.abs(wantZ) * 0.5;
+    if (stoppedX) k.velocity[0] = 0;
+    if (stoppedZ) k.velocity[2] = 0;
+    const into = Math.hypot(stoppedX ? vx : 0, stoppedZ ? vz : 0);
+    if (into >= SLAM_MIN_SPEED) o.onSlam?.({ against: "obstacle", speed: into, direction: [stoppedX ? vx / into : 0, 0, stoppedZ ? vz / into : 0] });
+    y = at.y;
+    if (fromY > floor && y <= floor) {
+      const speed = Math.max(fallSpeed, (fromY - y) / Math.max(dt, 1e-6));
+      if (k.down && speed >= SLAM_MIN_SPEED * 0.5) o.onSlam?.({ against: "ground", speed: Math.hypot(speed, Math.hypot(vx, vz) * 0.5), direction: [0, -1, 0] });
+      else if (speed >= LANDING_MIN_SPEED) o.onFeet?.({ type: "land", speed });
+    }
+    vy = 0;
+    walked = dt > 0 ? Math.hypot(px.x - fromX, px.z - fromZ) / dt : 0;
+    running = false;
+    if (done) knocked = null;
+    followFloor(dt);
+    apply();
+  };
   return {
     get walkIntent() {
       return walkKeys();
@@ -2375,7 +2457,28 @@ function createPlayer(THREE, o) {
       return isCrouched();
     },
     keys,
+    knock(next) {
+      if (seated) return;
+      if (knocked) {
+        knocked.velocity = [knocked.velocity[0] + next.velocity[0], knocked.velocity[1] + next.velocity[1], knocked.velocity[2] + next.velocity[2]];
+        knocked.airborne || (knocked.airborne = next.airborne);
+        knocked.down || (knocked.down = next.down);
+      } else knocked = { ...next, velocity: [...next.velocity] };
+      if (next.down) {
+        const right = Math.cos(yaw) * next.velocity[0] - Math.sin(yaw) * next.velocity[2];
+        rollSide = right >= 0 ? -1 : 1;
+        crouchLatched = false;
+      }
+      if (knocked.airborne) vy = Math.max(vy, knocked.velocity[1]);
+    },
+    get knocked() {
+      return knocked;
+    },
     update(dt) {
+      if (knocked) {
+        stepKnocked(dt);
+        return;
+      }
       if (crouchPress) crouchPress.held += dt;
       const crouched = isCrouched();
       crouch += ((crouched ? 1 : 0) - crouch) * Math.min(1, dt * CROUCH_RATE);
@@ -2415,6 +2518,7 @@ function createPlayer(THREE, o) {
       apply();
     },
     setPose(position, yw, pt) {
+      knocked = null;
       px.x = position[0];
       px.z = position[2];
       floorLevel = floorHere();
@@ -2426,6 +2530,7 @@ function createPlayer(THREE, o) {
       apply();
     },
     look(position, target) {
+      knocked = null;
       px.x = position[0];
       px.z = position[2];
       floorLevel = floorHere();
@@ -2782,6 +2887,8 @@ var TURN_RATE = 8;
 var MAX_WALK_SECONDS = 1.5;
 var APPROACH_SPEED2 = 3;
 var FLOOR_GAP = 0.03;
+var LEAF_SLAM_VOLUME = 0.85;
+var shutVolume = (massKg) => Math.min(1, 0.3 + massKg * 0.03);
 var key = (objectId, part) => `${objectId}\0${part}`;
 var slides = (clip, part) => {
   const last = clip.keys[clip.keys.length - 1]?.parts?.[part];
@@ -3027,7 +3134,7 @@ function createRoomDoors(options) {
     using = { objectId, leaf, obj, grip, pull, phase: control.phase, progress: 0, walked: 0, there: goal === null };
     const at = obj.localToWorld(grip.clone());
     if (goal === null) {
-      options.sound("leaf_rattle", [at.x, at.y, at.z], 0.6);
+      options.sound(options.leafFoley?.(objectId, leaf.part, slides(leaf.clip, leaf.part))?.locked ?? "leaf_rattle", [at.x, at.y, at.z], 0.6);
       event("locked", using);
     } else event("reach", using);
     return true;
@@ -3112,17 +3219,27 @@ function createRoomDoors(options) {
       const at = u.obj.localToWorld(tmp.copy(u.grip));
       const point = [at.x, at.y, at.z];
       const slide = slides(u.leaf.clip, u.leaf.part);
-      const shut = options.impactKey(u.objectId, u.leaf.part).replace("impact_", "leaf_shut_");
+      const foley = options.leafFoley?.(u.objectId, u.leaf.part, slide) ?? null;
+      const own = (moment) => options.leafSound?.(u.objectId, u.leaf.part, moment);
+      const shut = own("shut") ?? options.impactKey(u.objectId, u.leaf.part).replace("impact_", "leaf_shut_");
       if (wasPhase === "reach" && s.phase !== "reach") {
-        if (slide) options.sound("leaf_slide", point, 0.5);
-        else {
+        const opening = foley ? void 0 : own("open");
+        if (foley) {
+          if (was < 0.02) options.sound(foley.open, point, 0.5);
+          if (foley.turn) options.sound(foley.turn, point, 0.35);
+        } else if (slide) options.sound("leaf_slide", point, 0.5);
+        else if (opening) {
+          if (was < 0.02) options.sound(opening, point, 0.5);
+        } else {
           if (was < 0.02) options.sound("leaf_latch", point, 0.5);
           options.sound(/metal|glass/.test(shut) ? "leaf_creak_metal" : "leaf_creak_wood", point, 0.35);
         }
       }
       if (s.arrived) {
         if (s.opening <= 0) {
-          options.sound(slide ? "leaf_slide" : shut, point, Math.min(1, 0.3 + massOf(u.objectId, u.leaf.part) * 0.03));
+          const volume = shutVolume(massOf(u.objectId, u.leaf.part));
+          if (foley) options.sound(foley.slam && volume >= LEAF_SLAM_VOLUME ? foley.slam : foley.close, point, volume);
+          else options.sound(slide ? "leaf_slide" : shut, point, volume);
           event("closed", u);
         } else event("opened", u);
       }
@@ -3393,6 +3510,10 @@ var en = {
     "loading.open_area": "Opening {area}\u2026",
     "loading.spawn": "Building {name}\u2026",
     "act.loosened": "{name} was heavy but free: the blast moved it",
+    "act.knocked_down": "The blast threw the player off their feet at {speed} m/s ({reach}% got through the cover)",
+    "act.player_slammed": "The player was thrown into {what} at {speed} m/s",
+    "act.player_fell": "The player hit the floor at {speed} m/s",
+    "act.player_shoved": "The blast pushed the player at {speed} m/s ({reach}% got through the cover)",
     "act.came_apart": "{name} came apart: what stayed is loose and falls",
     "act.shoved": "{name} stands free: the shots moved it",
     "act.impact": "{name} hit {where} at {speed} m/s: {energy} J of blunt damage",
@@ -3751,6 +3872,10 @@ var ptBR = {
     "loading.open_area": "Abrindo {area}\u2026",
     "loading.spawn": "Montando {name}\u2026",
     "act.loosened": "{name} \xE9 pesado mas estava solto: a explos\xE3o o moveu",
+    "act.knocked_down": "A explos\xE3o derrubou o jogador a {speed} m/s ({reach}% passou pela cobertura)",
+    "act.player_slammed": "O jogador foi arremessado contra {what} a {speed} m/s",
+    "act.player_fell": "O jogador bateu no ch\xE3o a {speed} m/s",
+    "act.player_shoved": "A explos\xE3o empurrou o jogador a {speed} m/s ({reach}% passou pela cobertura)",
     "act.came_apart": "{name} se desmontou: o que ficou est\xE1 solto e cai",
     "act.shoved": "{name} estava solto no ch\xE3o: os tiros o moveram",
     "act.impact": "{name} bateu em {where} a {speed} m/s: {energy} J de dano de impacto",
@@ -4576,9 +4701,16 @@ function createUi(o) {
       nodes.delete(oldest.value);
       logBody.firstElementChild?.remove();
     }
-    if (autoscroll) logBody.scrollTop = logBody.scrollHeight;
+    if (autoscroll) isScrollDue = true;
   }
+  let isScrollDue = false;
+  const scrollToEnd = () => {
+    if (!isScrollDue) return;
+    isScrollDue = false;
+    logBody.scrollTop = logBody.scrollHeight;
+  };
   const flushLog = () => {
+    scrollToEnd();
     if (pendingAdds.length === 0 && pendingUpdates.size === 0) return;
     if (!isLogVisible()) {
       isLogStale = true;
@@ -4971,6 +5103,134 @@ function createUi(o) {
   return api;
 }
 
+// src/module-views.ts
+var FRAME_PX = 3;
+function createModuleViews(THREE, gl) {
+  const entries = [];
+  let mainCamera = null;
+  const overlay = new THREE.Scene();
+  const ortho = new THREE.OrthographicCamera(-0.5, 0.5, 0.5, -0.5, 0, 2);
+  ortho.position.z = 1;
+  const plane = new THREE.PlaneGeometry(1, 1);
+  const roundedMask = (rounded, aspect) => {
+    if (!rounded || typeof document === "undefined") return null;
+    const canvas = document.createElement("canvas");
+    canvas.width = 256;
+    canvas.height = Math.max(16, Math.round(256 / aspect));
+    const g = canvas.getContext("2d");
+    if (!g) return null;
+    const r = Math.min(canvas.width, canvas.height) * Math.min(0.5, rounded);
+    g.fillStyle = "#000";
+    g.fillRect(0, 0, canvas.width, canvas.height);
+    g.fillStyle = "#fff";
+    g.beginPath();
+    g.roundRect(0, 0, canvas.width, canvas.height, r);
+    g.fill();
+    const texture = new THREE.CanvasTexture(canvas);
+    texture.colorSpace = THREE.NoColorSpace;
+    return texture;
+  };
+  const size = () => {
+    if (typeof gl.getSize !== "function") return { w: 960, h: 600 };
+    const v = new THREE.Vector2();
+    gl.getSize(v);
+    return { w: v.x, h: v.y };
+  };
+  const take = (entry) => {
+    const i = entries.indexOf(entry);
+    if (i < 0) return;
+    entries.splice(i, 1);
+    overlay.remove(entry.quad, entry.frame);
+    entry.target.dispose();
+    entry.quad.material.dispose();
+    entry.frame.material.dispose();
+    entry.alpha?.dispose();
+  };
+  return {
+    add(view) {
+      const { w, h } = size();
+      const scale = view.resolution ?? 0.5;
+      const pr = typeof gl.getPixelRatio === "function" ? gl.getPixelRatio() : 1;
+      const target = new THREE.WebGLRenderTarget(Math.max(16, Math.round(w * view.rect.width * pr * scale)), Math.max(16, Math.round(h * view.rect.height * pr * scale)), { samples: 2 });
+      target.texture.colorSpace = THREE.LinearSRGBColorSpace;
+      const alpha = roundedMask(view.rounded ?? 0, w * view.rect.width / Math.max(1, h * view.rect.height));
+      const quad = new THREE.Mesh(plane, new THREE.MeshBasicMaterial({ map: target.texture, side: THREE.DoubleSide, depthTest: false, depthWrite: false, ...alpha ? { alphaMap: alpha, transparent: true } : {} }));
+      const frame = new THREE.Mesh(plane, new THREE.MeshBasicMaterial({ color: 723982, side: THREE.DoubleSide, depthTest: false, depthWrite: false, ...alpha ? { alphaMap: alpha, transparent: true } : {} }));
+      quad.renderOrder = 1;
+      frame.visible = quad.visible = false;
+      overlay.add(frame, quad);
+      const entry = { view, target, quad, frame, alpha };
+      entries.push(entry);
+      return () => take(entry);
+    },
+    setMain(camera) {
+      mainCamera = camera;
+    },
+    main(fallback) {
+      if (!mainCamera) return fallback;
+      const persp = mainCamera;
+      const back = fallback;
+      if (persp.isPerspectiveCamera && back.isPerspectiveCamera && persp.aspect !== back.aspect) {
+        persp.aspect = back.aspect;
+        persp.updateProjectionMatrix();
+      }
+      return mainCamera;
+    },
+    render(scene) {
+      if (!entries.length) return;
+      const { w, h } = size();
+      const autoClear = gl.autoClear;
+      const shadows = gl.shadowMap.autoUpdate;
+      gl.shadowMap.autoUpdate = false;
+      for (const entry of entries) {
+        const cam = entry.view.camera;
+        const aspect = w * entry.view.rect.width / Math.max(1, h * entry.view.rect.height);
+        if (cam.isPerspectiveCamera && Math.abs(cam.aspect - aspect) > 1e-3) {
+          cam.aspect = aspect;
+          cam.updateProjectionMatrix();
+        }
+        gl.setRenderTarget(entry.target);
+        gl.clear();
+        gl.render(scene, cam);
+      }
+      gl.setRenderTarget(null);
+      gl.autoClear = false;
+      gl.setScissorTest(true);
+      for (const entry of entries) {
+        const r = entry.view.rect;
+        const x = r.x * w;
+        const y = (1 - r.y - r.height) * h;
+        const vw = r.width * w;
+        const vh = r.height * h;
+        for (const mesh of [entry.frame, entry.quad]) mesh.visible = false;
+        entry.frame.visible = true;
+        gl.setViewport(x - FRAME_PX, y - FRAME_PX, vw + 2 * FRAME_PX, vh + 2 * FRAME_PX);
+        gl.setScissor(x - FRAME_PX, y - FRAME_PX, vw + 2 * FRAME_PX, vh + 2 * FRAME_PX);
+        gl.render(overlay, ortho);
+        entry.frame.visible = false;
+        entry.quad.visible = true;
+        entry.quad.scale.x = entry.view.mirror ? -1 : 1;
+        gl.setViewport(x, y, vw, vh);
+        gl.setScissor(x, y, vw, vh);
+        gl.render(overlay, ortho);
+        entry.quad.visible = false;
+      }
+      gl.setScissorTest(false);
+      gl.setViewport(0, 0, w, h);
+      gl.autoClear = autoClear;
+      gl.shadowMap.autoUpdate = shadows;
+    },
+    get count() {
+      return entries.length;
+    },
+    dispose() {
+      for (const entry of [...entries]) take(entry);
+      plane.dispose();
+      mainCamera = null;
+    }
+  };
+}
+
 // src/room.ts
 var FIXED_DT = 1 / 60;
 var EXPLOSIVE_EFFECT_IDS = ["m67", "molotov", "pipe_bomb", "m79_40mm", "m72_66mm", "at4_84mm", "dynamite", "c4", "claymore"];
@@ -4999,6 +5259,12 @@ var CAP_RISE = 0.03;
 var MAX_STRIDE_SPEED = 10;
 var v3 = (v) => [v.x, v.y, v.z];
 var dist3 = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]);
+var vehicleLeafKey = (spec, part, moment) => {
+  const tags = spec.parts.find((p) => p.id === part)?.tags ?? [];
+  const leaf = tags.includes("hood") ? "hood" : tags.includes("lid") || tags.includes("trunk") ? "trunk" : "door";
+  return `vehicle_${leaf}_${moment}`;
+};
+var MARK_EVENTS = /* @__PURE__ */ new Set(["dent", "hole", "crack", "chip", "stage", "fracture"]);
 function createTestRoom(options) {
   const THREE = options.THREE;
   const locale = options.locale ?? "en";
@@ -5045,6 +5311,7 @@ function createTestRoom(options) {
   };
   const onResize = () => resize();
   window.addEventListener("resize", onResize);
+  const moduleViews = createModuleViews(THREE, gl);
   const arenaSize = options.arenaSize ?? 14;
   const arena = createArena(THREE, arenaSize, scene, options.scenery, options.tap);
   scene.add(arena.group);
@@ -5104,10 +5371,23 @@ function createTestRoom(options) {
   const ownAudio = options.audio === void 0;
   const audio = options.audio === false ? null : options.audio ?? createAudioEngine({ deferredStart: {} });
   const destructionSound = audio ? createDestructionSound(audio) : null;
+  if (audio && options.samplesBaseUrl !== null) {
+    void loadKitSamples(audio, { baseUrl: options.samplesBaseUrl ?? "./sfx/" }).then((bank) => {
+      if (!bank || typeof window === "undefined") return;
+      const preload = () => {
+        window.removeEventListener("keydown", preload, true);
+        window.removeEventListener("pointerdown", preload, true);
+        void audio.loadSamples(["latch", "creak_wood", "shut_wood", "rattle", "grab_hard", "grab_soft"]).catch(() => void 0);
+      };
+      window.addEventListener("keydown", preload, true);
+      window.addEventListener("pointerdown", preload, true);
+    });
+  }
   const bodySounds = createBodySounds(audio);
-  const playSound = (key2, point, volume) => {
-    destructionSound?.onSound(key2, point, volume);
-    options.onSound?.(key2, point, volume);
+  const playSound = (key2, point, volume, detail) => {
+    destructionSound?.onSound(key2, point, volume, detail);
+    if (detail) options.onSound?.(key2, point, volume, detail);
+    else options.onSound?.(key2, point, volume);
   };
   const lights = createLightBudget(THREE, scene, { ...ROOM_LIGHT_SIZES, ...options.lightSizes });
   const warmup = createProgramWarmup(THREE);
@@ -5177,7 +5457,7 @@ function createTestRoom(options) {
     const size = Math.min(GROUND_BURST_MAX, Math.ceil(result.radius * GROUND_BURST_PER_METRE));
     renderer.emit(material.debris === "clods" ? "dust" : material.debris, result.point, [0, 1, 0], Math.max(2, size), Math.min(4, 1 + result.radius * 4));
     if (result.radius > GROUND_DUST_RADIUS) renderer.emit("dust", result.point, [0, 1, 0], size, 1.4);
-    playSound(impactKey(def), result.point, Math.min(1, 0.25 + result.radius));
+    playSound(impactKey(def), result.point, Math.min(1, 0.25 + result.radius), impactSoundKeys(material.id, def));
   };
   terrain.onDeform((region) => renderer.wakeRegion(region.x, region.z, region.radius));
   const groundImpl = createTerrainImpl(terrain, { id: GROUND_ID, name: t("ground.name"), onBlow: showGroundBlow });
@@ -5405,6 +5685,7 @@ function createTestRoom(options) {
     floorAt: terrain.heightAt,
     start: arena.playerStart,
     crouchKeys: options.crouch?.keys,
+    onSlam: (event) => slamPlayer(event),
     onFeet: (event) => {
       const at = player.position;
       if (event.type === "jump") bodySounds.jump(at);
@@ -5484,7 +5765,11 @@ function createTestRoom(options) {
       return piece;
     },
     dragSound: (objectId, point, volume) => playSound(dragSoundKey(world.materials.get(heaviestMaterial(objectId) ?? "")), point, volume),
-    hitSound: (objectId, point) => playSound(impactKey(world.materials.get(heaviestMaterial(objectId) ?? "")), point, 0.5),
+    hitSound: (objectId, point) => {
+      const material = heaviestMaterial(objectId) ?? "";
+      const def = world.materials.get(material);
+      playSound(impactKey(def), point, 0.5, impactSoundKeys(material, def, "blunt"));
+    },
     onEvent: (ev) => {
       const vars = { name: ev.name, kg: num(ev.massKg, 0) };
       action(`push_${ev.type}`, t(`act.push_${ev.type}`, vars), { objectId: ev.objectId, itemId: entryOf(ev.objectId)?.so.itemId, data: { massKg: Math.round(ev.massKg * 10) / 10 } });
@@ -5574,7 +5859,13 @@ function createTestRoom(options) {
     isLocked: (objectId, part) => lockedLeaves.has(`${objectId}\0*`) || lockedLeaves.has(`${objectId}\0${part}`),
     nameOf,
     impactKey: (objectId, part) => impactKey(world.materials.get(world.part(objectId, part)?.material ?? heaviestMaterial(objectId) ?? "")),
+    leafSound: (objectId, part, moment) => {
+      const spec = specs.get(objectId);
+      return spec?.tags?.includes("vehicle") ? vehicleLeafKey(spec, part, moment) : void 0;
+    },
     sound: playSound,
+    // a vehicle's doors, hood and lid have their own sounds in the vehicle bank (game-vehicles-three), not those of the house
+    leafFoley: (objectId, part, slides2) => specs.get(objectId)?.tags?.includes("vehicle") ? null : leafFoleyOf(entryOf(objectId)?.item?.sounds, part, impactKey(world.materials.get(world.part(objectId, part)?.material ?? heaviestMaterial(objectId) ?? "")), slides2),
     onEvent: (ev) => {
       const vars = { name: ev.name, percent: Math.round(ev.opening * 100) };
       action(`door_${ev.type}`, t(`act.door_${ev.type}`, vars), { objectId: ev.objectId, itemId: entryOf(ev.objectId)?.so.itemId, part: ev.part, data: { opening: Math.round(ev.opening * 1e3) / 1e3, ...ev.by ? { by: ev.by } : {} } });
@@ -5983,6 +6274,37 @@ function createTestRoom(options) {
   let avatar = null;
   let cameraMode = options.cameraMode ?? "first";
   let crouchForced = false;
+  let downForced = false;
+  const playerMass = options.playerMass ?? bodyMass(1.75);
+  const SLAM_REACH = PLAYER_RADIUS + 0.35;
+  const SLAM_SHOULDER = 1.3;
+  const slamPlayer = (event) => {
+    const [x, feet, z] = player.position;
+    const energy = 0.5 * playerMass * event.speed * event.speed;
+    let hit = null;
+    if (event.against === "obstacle") {
+      const from = [x, feet + ((player.knocked?.lying ?? 0) > 0.5 ? 0.3 : SLAM_SHOULDER), z];
+      hit = rayWorld(from, event.direction, SLAM_REACH);
+      if (hit) world.hitPart(hit.object, hit.part, { type: "blunt", point: hit.point, direction: event.direction, energy, radius: 0.2, ...hit.normal ? { normal: hit.normal } : {} });
+    }
+    bodySounds.slam(event.speed, [x, feet + 0.5, z]);
+    action("player_slammed", t(event.against === "obstacle" ? "act.player_slammed" : "act.player_fell", { speed: num(event.speed, 1), what: hit ? nameOf(hit.object) : "" }), {
+      ...hit ? { objectId: hit.object, part: hit.part } : {},
+      data: { against: event.against, speed: event.speed, energy, ...hit ? { object: hit.object, part: hit.part } : {} }
+    });
+  };
+  const knockPlayer = (event) => {
+    if (seating.seat) return;
+    const feet = [player.x, player.feet, player.z];
+    const reach = world.blastReach(event.point, [feet[0], feet[1] + KNOCK_CHEST, feet[2]], event.source ? { ignore: [event.source] } : {});
+    const knock = knockOf({ point: event.point, energy: event.energy, radius: event.radius, reach }, feet, playerMass, options.blastShove);
+    if (!knock) return;
+    player.knock(knock);
+    const speed = Math.hypot(knock.velocity[0], knock.velocity[1], knock.velocity[2]);
+    action(knock.down ? "player_knocked_down" : "player_shoved", t(knock.down ? "act.knocked_down" : "act.player_shoved", { speed: num(speed, 1), reach: num(reach * 100, 0) }), {
+      data: { speed, reach, down: knock.down, source: event.source }
+    });
+  };
   const avatarState = { speed: 0, running: false, crouch: false, down: false, armed: false, pitch: 0 };
   let feetPrev = null;
   let armedForced = null;
@@ -6038,6 +6360,7 @@ function createTestRoom(options) {
     feetPrev = [x, z];
     avatarState.running = !player.crouching && (player.keys.has("ShiftLeft") || player.keys.has("ShiftRight"));
     avatarState.crouch = crouchForced || player.crouching || push.isBent;
+    avatarState.down = downForced || Boolean(player.knocked?.down || (player.knocked?.lying ?? 0) > 0.5);
     avatarState.armed = armedForced ?? tool.def.action.kind === "firearm";
     avatarState.pitch = player.pitch;
     avatarState.holding = heldPiece !== null;
@@ -6110,14 +6433,18 @@ function createTestRoom(options) {
     if (!avatar?.reach) return;
     avatar.reach(targets, { camera, keepOutside: { contact: (origin, direction, maxDistance) => rayWorld(origin, direction, maxDistance)?.distance ?? null } });
   };
+  const thirdEuler = new THREE.Euler(0, 0, 0, "YXZ");
   const applyThirdView = () => {
     if (!thirdActive()) return () => void 0;
     const home = camera.position.clone();
+    const turn = camera.quaternion.clone();
     const pose = thirdPose(0);
     camera.position.set(pose.position[0], pose.position[1], pose.position[2]);
+    if (player.knocked) camera.quaternion.setFromEuler(thirdEuler.set(player.pitch, player.yaw, 0, "YXZ"));
     camera.updateMatrixWorld(true);
     return () => {
       camera.position.copy(home);
+      camera.quaternion.copy(turn);
       camera.updateMatrixWorld(true);
     };
   };
@@ -6499,7 +6826,13 @@ function createTestRoom(options) {
       action("melee", t("act.melee.miss", { weapon: w }), { data: { weapon: id } });
       return;
     }
-    world.hitPart(r.object, r.part, { ...useToHit(u, r.point, r.normal), source: "player" });
+    const hit = useToHit(u, r.point, r.normal);
+    const result = world.hitPart(r.object, r.part, { ...hit, source: "player" });
+    if (!result.events.some((e) => MARK_EVENTS.has(e.type))) {
+      const material = world.part(r.object, r.part)?.material ?? heaviestMaterial(r.object) ?? "";
+      const def = world.materials.get(material);
+      playSound(impactKey(def), r.point, Math.min(0.8, 0.25 + u.energy / 400), impactSoundKeys(material, def, hit.type));
+    }
     const blow = blowOfTool(id, toolDef(id)?.category ?? "");
     if (blow) bodySounds.hit(blow, blowTarget(r), r.point, u.energy);
     pushPiece(r.object, u.direction, 2 * u.energy / 6, r.point);
@@ -6857,7 +7190,9 @@ function createTestRoom(options) {
     heldYaw = 0;
     heldTilt = 0;
     heldVel[0] = heldVel[1] = heldVel[2] = 0;
+    playSound(pickupSoundOf(heldEntry?.item?.sounds, world.materials.get(heaviestMaterial(r.object) ?? "")), r.point, Math.min(1, 0.45 + kg * 0.1));
     action("grab", t("act.grab", { name: heldName, kg: num(kg, 1) }), { objectId: r.object, itemId: entryOf(r.object)?.so.itemId, data: { massKg: Math.round(kg * 10) / 10 } });
+    playSound(impactKey(world.materials.get(heaviestMaterial(r.object) ?? "")).replace("impact_", "grab_"), v3(piece.root.getWorldPosition(tmpV)), 0.8);
     fire("grab", { held: true, objectId: r.object });
     return true;
   };
@@ -6870,6 +7205,7 @@ function createTestRoom(options) {
     releaseHeld();
     piece.velocity = [0, 0, 0];
     renderer.impulse(id, [aimD[0] * speed * piece.mass, (aimD[1] * speed + 1.2) * piece.mass, aimD[2] * speed * piece.mass]);
+    playSound("item_throw", [piece.root.position.x, piece.root.position.y, piece.root.position.z], Math.min(1, 0.3 + speed * 0.04));
     action("throw", t("act.throw", { name, speed: num(speed, 1) }), { objectId: id, itemId: entryOf(id)?.so.itemId, data: { speedMs: speed, massKg: piece.mass } });
     fire("throw", { objectId: id, speed });
     return true;
@@ -6981,6 +7317,7 @@ function createTestRoom(options) {
     e.opened = true;
     if (e.containerId) fluids.open(e.containerId);
     seal.open?.(wrapped.get(e.so.root) ?? e.so.root);
+    playSound(openSoundOf(e.item?.sounds, world.materials.get(heaviestMaterial(e.so.objectId) ?? "")), v3(e.so.root.getWorldPosition(tmpV)), 0.7);
     const tool2 = opener.tool ? catalogMap.get(opener.tool)?.name ?? (arsenal.weapons.has(opener.tool) ? toolName(opener.tool) : opener.tool) : void 0;
     action("open_seal", tool2 ? t("act.open_with", { name: e.name, tool: tool2 }) : t("act.open_by_hand", { name: e.name }), { objectId: e.so.objectId, itemId: e.so.itemId, data: { tool: opener.tool ?? "hand" } });
     return true;
@@ -7029,17 +7366,28 @@ function createTestRoom(options) {
     if (consuming && c.closed) fluids.open(e.containerId);
     useItemPlayer = createItemUse(fluids, e.containerId, def);
     useItemName = def.id;
+    useSoundIn = 0;
     if (eating) useLiters = c.liters;
     action("use_item", t("act.use_item", { name: e.name, use: S.text[`use.${def.id}`] ?? def.id }), { objectId: e.so.objectId, itemId: e.so.itemId, data: { use: def.id } });
     return true;
   };
   let useLiters = null;
+  let useSoundIn = 0;
   const updateItemUse = (dt) => {
     if (!useItemPlayer) return;
     const e = heldEntry;
     const c = e?.containerId ? fluids.container(e.containerId) : void 0;
     const before = c?.liters;
     useItemPlayer.update(dt);
+    const useSound = e && useLiters !== null ? useSoundOf(e.item?.sounds, useItemName) : void 0;
+    if (useSound && e) {
+      useSoundIn -= dt;
+      const now = e.containerId ? fluids.container(e.containerId)?.liters : void 0;
+      if (useSoundIn <= 0 && before !== void 0 && now !== void 0 && now < before) {
+        playSound(useSound, v3(e.so.root.getWorldPosition(tmpV)), 0.6);
+        useSoundIn = USE_SOUND_EVERY;
+      }
+    }
     const seal = e?.item?.seal;
     twisting = null;
     if (e && seal?.openUse === useItemName && !e.opened) {
@@ -7249,7 +7597,9 @@ function createTestRoom(options) {
     if (!loadout.includes(weaponId)) loadout.push(weaponId);
     setTool(weaponId);
   };
+  let hudAimHit;
   const inspectTarget = () => {
+    if (hudAimHit !== void 0) return hudAimHit;
     aim();
     return rayWorld(aimO, aimD, 14);
   };
@@ -7434,6 +7784,7 @@ function createTestRoom(options) {
     }
     syncLiters();
     renderer.update(dt);
+    destructionSound?.update(dt);
     for (const e of entries.values()) e.follower?.update?.();
     terrainView.sync(camera.position);
     showGroundFire(dt);
@@ -7490,12 +7841,12 @@ function createTestRoom(options) {
   const updatePresent = (dt) => {
     reachAvatar();
     if (progress && simTime - progress.at > 0.25) progress = null;
+    ui?.flushLog();
     hudAcc += dt;
     if (hudAcc >= 0.1 && ui) {
       hudAcc = 0;
       ui.hud(hudState());
     }
-    ui?.flushLog();
     metricsAcc += dt;
     if (metricsAcc >= METRICS_INTERVAL_S && ui) {
       metricsAcc = 0;
@@ -7503,6 +7854,14 @@ function createTestRoom(options) {
     }
   };
   const hudState = () => {
+    hudAimHit = inspectTarget();
+    try {
+      return readHudState();
+    } finally {
+      hudAimHit = void 0;
+    }
+  };
+  const readHudState = () => {
     const page = Math.floor(toolIndex / 10);
     const slots = loadout.slice(page * 10, page * 10 + 10).map((id) => arsenal.name(id));
     const ammo = tool.def.action.kind === "firearm" ? `${tool.ammo}/${tool.capacity}${tool.reserve ? ` \xB7 ${tool.reserve}` : ""}` : tool.def.action.kind === "hand" ? "" : tool.def.action.kind === "melee" || tool.def.action.kind === "tool" ? "" : `${num(tool.ammo, 0)}`;
@@ -7693,6 +8052,7 @@ function createTestRoom(options) {
   const environment = options.environment ?? createEnvironmentBus();
   const audioSink = audio ? createAudioSink(audio) : void 0;
   function emitHost(event) {
+    if (event.type === "explosion") knockPlayer(event);
     for (const listener of hostListeners) listener(event);
   }
   function flushEvents(id, state, recoil) {
@@ -7752,7 +8112,10 @@ function createTestRoom(options) {
     lights,
     pools,
     loading,
+    addView: (view) => moduleViews.add(view),
+    setViewCamera: (view) => moduleViews.setMain(view ?? null),
     ...options.blastShove ? { blastShove: options.blastShove } : {},
+    blastReach: (point, target, ignore) => world.blastReach(point, target, ignore ? { ignore } : {}),
     tool: () => ({
       weapon: toolId,
       category: tool.def.category,
@@ -7927,6 +8290,7 @@ function createTestRoom(options) {
         impl: ti.impl,
         animations: ti.animations,
         seats: ti.seats,
+        sounds: ti.sounds,
         thumbnail: ti.thumbnail,
         thumbnailCredit: ti.thumbnailCredit
       };
@@ -8313,7 +8677,10 @@ function createTestRoom(options) {
         crouchForced = state.crouch;
         avatarState.crouch = state.crouch || player.crouching;
       }
-      if (state.down !== void 0) avatarState.down = state.down;
+      if (state.down !== void 0) {
+        downForced = state.down;
+        avatarState.down = state.down || Boolean(player.knocked?.down);
+      }
       if (state.armed !== void 0) armedForced = state.armed;
     },
     avatarState: () => ({ ...avatarState }),
@@ -8334,6 +8701,9 @@ function createTestRoom(options) {
     get playerPosition() {
       return player.position;
     },
+    get playerKnock() {
+      return player.knocked;
+    },
     sit: (objectId, seatId) => seating.sit(objectId, seatId),
     stand: () => seating.stand(),
     get seat() {
@@ -8357,6 +8727,7 @@ function createTestRoom(options) {
       if (ownAudio) audio?.dispose();
       for (const detach of detachers.values()) detach();
       detachers.clear();
+      moduleViews.dispose();
       for (const store of benches.values()) store.dispose();
       benches.clear();
       stopLoop?.();
@@ -8519,7 +8890,8 @@ function createTestRoom(options) {
         for (const batcher of batchers.values()) batcher.update();
         const restoreCamera = room.applyCamera();
         graphics?.beforeRender(camera);
-        gl.render(scene, debugView ?? camera);
+        gl.render(scene, debugView ?? moduleViews.main(camera));
+        moduleViews.render(scene);
         graphics?.afterRender();
         restoreCamera();
         pacer.submitted();