@adatechnology/game-test-room 0.3.0 → 0.5.0

package/dist/index.js

@@ -249,6 +249,15 @@ var en = {
     "act.heat.air": "{weapon}: nothing in range",
     "act.throw.grenade": "{weapon}: thrown, fuse {fuse} s",
     "act.throw.molotov": "{weapon}: thrown, breaks on impact",
+    "act.launch": "{weapon}: launched, arms after {arm} m",
+    "act.place": "{weapon}: charge set down, waits for {triggers}",
+    "act.tripwire": "{weapon}: {who} crossed the trip wire",
+    "act.dud": "{weapon}: hit before arming ({distance} m), did not explode",
+    "act.backblast": "{weapon}: blast behind the tube, {radius} m, {n} objects in the cone, {player} on the shooter",
+    "act.blast_player": "{weapon}: you are in the {zone} zone, {distance} m away (stun {stun} s)",
+    "hud.no_charges": "No charge set down waits for the remote detonator",
+    "blast.zone.lethal": "lethal",
+    "blast.zone.injury": "injury",
     "act.explode": "{weapon}: exploded, {energy} J within {radius} m, {n} objects in range",
     "act.molotov_fire": "{weapon}: fire on the ground, radius {radius} m for {seconds} s",
     "act.tool.none": "{weapon}: nothing in reach",
@@ -274,6 +283,15 @@ var en = {
     "hud.reloading": "Reloading...",
     "hud.empty": "Empty",
     "hud.no_fuel": "Out of fuel",
+    "hud.fault": "Jammed ({fault}): press X to clear",
+    "hud.safe": "Safety on: press B",
+    "hud.clearing": "Clearing the jam...",
+    "hud.safety_on": "Safety on",
+    "hud.safety_off": "Safety off",
+    "fault.misfire": "misfire",
+    "fault.stovepipe": "stovepipe",
+    "fault.double_feed": "double feed",
+    "fault.failure_to_extract": "failure to extract",
     "hud.nothing_to_grab": "Nothing to grab here",
     "hud.cannot_grab": "{name} cannot be picked up",
     "hud.too_heavy": "{name} is too heavy ({kg} kg)",
@@ -284,7 +302,7 @@ var en = {
     "hud.throw": "throw",
     "hud.tilt": "tilt (hold)",
     "hud.equip": "equip {weapon}",
-    "ui.help": "Click: look \xB7 WASD: walk \xB7 Shift: run \xB7 Space: jump \xB7 1-0 / wheel: tool \xB7 LMB: use \xB7 E: grab/drop \xB7 G or RMB: throw \xB7 Tab: panels \xB7 Esc: free the mouse",
+    "ui.help": "Click: look \xB7 WASD: walk \xB7 Shift: run \xB7 Space: jump \xB7 1-0 / wheel: tool \xB7 LMB: use \xB7 E: grab/drop \xB7 G or RMB: throw \xB7 R: reload \xB7 Q: fire mode \xB7 X: clear a jam \xB7 B: safety \xB7 Y: detonate charges set down \xB7 Tab: panels \xB7 Esc: free the mouse",
     "ui.log": "Behaviour log",
     "ui.filter.action": "actions",
     "ui.filter.event": "events",
@@ -556,6 +574,15 @@ var ptBR = {
     "act.heat.air": "{weapon}: nada ao alcance",
     "act.throw.grenade": "{weapon}: arremessada, pavio de {fuse} s",
     "act.throw.molotov": "{weapon}: arremessado, quebra no impacto",
+    "act.launch": "{weapon}: disparado, arma depois de {arm} m",
+    "act.place": "{weapon}: carga posta, espera {triggers}",
+    "act.tripwire": "{weapon}: {who} cruzou o fio",
+    "act.dud": "{weapon}: bateu antes de armar ({distance} m), n\xE3o explodiu",
+    "act.backblast": "{weapon}: sopro atr\xE1s do tubo, {radius} m, {n} objetos no cone, {player} no atirador",
+    "act.blast_player": "{weapon}: voc\xEA est\xE1 na zona {zone}, a {distance} m (atordoado {stun} s)",
+    "hud.no_charges": "Nenhuma carga posta espera o detonador",
+    "blast.zone.lethal": "letal",
+    "blast.zone.injury": "de ferimento",
     "act.explode": "{weapon}: explodiu, {energy} J em {radius} m, {n} objetos ao alcance",
     "act.molotov_fire": "{weapon}: fogo no ch\xE3o, raio de {radius} m por {seconds} s",
     "act.tool.none": "{weapon}: nada ao alcance",
@@ -581,6 +608,15 @@ var ptBR = {
     "hud.reloading": "Recarregando...",
     "hud.empty": "Sem muni\xE7\xE3o",
     "hud.no_fuel": "Sem combust\xEDvel",
+    "hud.fault": "Travou ({fault}): aperte X para destravar",
+    "hud.safe": "Trava ligada: aperte B",
+    "hud.clearing": "Destravando...",
+    "hud.safety_on": "Trava ligada",
+    "hud.safety_off": "Trava desligada",
+    "fault.misfire": "nega",
+    "fault.stovepipe": "chamin\xE9",
+    "fault.double_feed": "dupla alimenta\xE7\xE3o",
+    "fault.failure_to_extract": "falha de extra\xE7\xE3o",
     "hud.nothing_to_grab": "Nada para pegar aqui",
     "hud.cannot_grab": "{name} n\xE3o d\xE1 para pegar",
     "hud.too_heavy": "{name} \xE9 pesado demais ({kg} kg)",
@@ -591,7 +627,7 @@ var ptBR = {
     "hud.throw": "arremessar",
     "hud.tilt": "inclinar (segurar)",
     "hud.equip": "equipar {weapon}",
-    "ui.help": "Clique: olhar \xB7 WASD: andar \xB7 Shift: correr \xB7 Espa\xE7o: pular \xB7 1-0 / roda: ferramenta \xB7 bot\xE3o esquerdo: usar \xB7 E: pegar/soltar \xB7 G ou bot\xE3o direito: arremessar \xB7 Tab: pain\xE9is \xB7 Esc: soltar o mouse",
+    "ui.help": "Clique: olhar \xB7 WASD: andar \xB7 Shift: correr \xB7 Espa\xE7o: pular \xB7 1-0 / roda: ferramenta \xB7 bot\xE3o esquerdo: usar \xB7 E: pegar/soltar \xB7 G ou bot\xE3o direito: arremessar \xB7 R: recarregar \xB7 Q: modo de tiro \xB7 X: destravar \xB7 B: trava \xB7 Y: detonar cargas postas \xB7 Tab: pain\xE9is \xB7 Esc: soltar o mouse",
     "ui.log": "Registro de comportamento",
     "ui.filter.action": "a\xE7\xF5es",
     "ui.filter.event": "eventos",
@@ -1300,6 +1336,354 @@ function createBenchStore(module, locale, onListenerError) {
   return store;
 }
 
+// src/explosives.ts
+import { backblastEffect, blastEffect, createExplosiveBody, tripwireSegment } from "@adatechnology/game-weapons";
+
+// src/segment-box.ts
+var segmentTouchesBox = (from, to, min, max) => {
+  let near = 0;
+  let far = 1;
+  for (let axis = 0; axis < 3; axis++) {
+    const start = from[axis];
+    const delta = to[axis] - start;
+    const low = min[axis];
+    const high = max[axis];
+    if (Math.abs(delta) < 1e-12) {
+      if (start < low || start > high) return false;
+      continue;
+    }
+    const entering = (low - start) / delta;
+    const leaving = (high - start) / delta;
+    near = Math.max(near, Math.min(entering, leaving));
+    far = Math.min(far, Math.max(entering, leaving));
+    if (near > far) return false;
+  }
+  return true;
+};
+
+// src/explosives.ts
+var CONE_BLAST_RADIUS = 0.5;
+var toArray = (vector) => [vector.x, vector.y, vector.z];
+function createExplosives(context) {
+  const { THREE, scene, camera, world, renderer, arsenal, translate, format, action } = context;
+  const projectiles = [];
+  const meshes = [];
+  const up = new THREE.Vector3(0, 1, 0);
+  const clear = () => {
+    projectiles.length = 0;
+    for (const mesh of meshes) mesh.removeFromParent();
+    meshes.length = 0;
+  };
+  const addMesh = (geometry, color, metalness, at) => {
+    const mesh = new THREE.Mesh(geometry, new THREE.MeshStandardMaterial({ color, roughness: 0.6, metalness }));
+    mesh.castShadow = true;
+    mesh.position.set(at[0], at[1], at[2]);
+    scene.add(mesh);
+    meshes.push(mesh);
+    return mesh;
+  };
+  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);
+    const at = projectiles.indexOf(projectile);
+    if (at >= 0) projectiles.splice(at, 1);
+  };
+  const throwUse = (use) => {
+    const isMolotov = !!use.fire;
+    const isRocket = use.trigger === "impact" && (use.armDistance ?? 0) > 0;
+    const geometry = isRocket ? new THREE.CylinderGeometry(0.04, 0.04, 0.5, 8) : isMolotov ? new THREE.CylinderGeometry(0.035, 0.04, 0.2, 8) : new THREE.SphereGeometry(0.045, 8, 6);
+    const mesh = addMesh(geometry, isMolotov ? 3897915 : isRocket ? 7041116 : 4936480, isMolotov ? 0 : 0.4, use.origin);
+    projectiles.push({
+      mesh,
+      pos: new THREE.Vector3(use.origin[0], use.origin[1], use.origin[2]),
+      vel: new THREE.Vector3(use.velocity[0], use.velocity[1], use.velocity[2]),
+      weapon: context.toolId(),
+      fuse: use.fuse,
+      burstOnImpact: isMolotov && use.fuse <= 0,
+      energy: use.energy,
+      radius: use.radius,
+      fire: use.fire,
+      age: 0,
+      ...use.explosive !== void 0 ? { body: createExplosiveBody(use, arsenal.explosives, arsenal.rules.explosives), aligned: isRocket } : {}
+    });
+    const key = isRocket ? "act.launch" : isMolotov ? "act.throw.molotov" : "act.throw.grenade";
+    action(isRocket ? "launch_projectile" : "throw_projectile", translate(key, { weapon: context.toolName(), fuse: format(use.fuse, 1), arm: format(use.armDistance ?? 0, 0) }), {
+      data: { weapon: context.toolId(), fuse: use.fuse, explosive: use.explosive }
+    });
+  };
+  const placementPoint = (use) => {
+    const hit = context.withoutHeld(() => world.raycast(use.origin, use.direction, 3));
+    if (hit) return [hit.point[0] + hit.normal[0] * 0.03, hit.point[1] + hit.normal[1] * 0.03, hit.point[2] + hit.normal[2] * 0.03];
+    const x = use.origin[0] + use.direction[0] * 2;
+    const z = use.origin[2] + use.direction[2] * 2;
+    return [x, context.groundAt(x, z) + 0.03, z];
+  };
+  const markerAt = (at) => {
+    const marker = new THREE.Group();
+    marker.name = "charge_marker";
+    const stake = new THREE.Mesh(new THREE.CylinderGeometry(0.01, 0.01, 0.4, 6), new THREE.MeshStandardMaterial({ color: 9136957, roughness: 0.8 }));
+    stake.position.y = 0.2;
+    const flag = new THREE.Mesh(new THREE.ConeGeometry(0.06, 0.12, 4), new THREE.MeshStandardMaterial({ color: 16738816, emissive: 16724736, emissiveIntensity: 0.4 }));
+    flag.position.y = 0.46;
+    marker.add(stake, flag);
+    marker.position.set(at[0] + 0.12, at[1] - 0.03, at[2]);
+    scene.add(marker);
+    meshes.push(marker);
+    return marker;
+  };
+  const wireLine = (from, to) => {
+    const geometry = new THREE.BufferGeometry().setFromPoints([new THREE.Vector3(...from), new THREE.Vector3(...to)]);
+    const line = new THREE.Line(geometry, new THREE.LineBasicMaterial({ color: 15262920 }));
+    line.name = "charge_wire";
+    scene.add(line);
+    meshes.push(line);
+    return line;
+  };
+  const touching = (wire) => context.bodies().filter((body) => segmentTouchesBox(wire.from, wire.to, toArray(body.box.min), toArray(body.box.max))).map((body) => body.id);
+  const placeUse = (use) => {
+    const at = placementPoint(use);
+    const placed = { ...use, origin: at };
+    const body = createExplosiveBody(placed, arsenal.explosives, arsenal.rules.explosives);
+    if (!body) return;
+    const mesh = addMesh(new THREE.BoxGeometry(0.18, 0.06, 0.1), use.explosive === "claymore" ? 5597999 : 12757112, 0.1, at);
+    mesh.rotation.y = Math.atan2(use.direction[0], use.direction[2]);
+    const attached = [markerAt(at)];
+    const segment = tripwireSegment(placed);
+    const projectile = { mesh, pos: new THREE.Vector3(at[0], at[1], at[2]), vel: new THREE.Vector3(), weapon: context.toolId(), fuse: 0, burstOnImpact: false, energy: use.energy, radius: use.radius, age: 0, body, placed: true, attached };
+    if (segment) {
+      const wire = { from: segment.from, to: segment.to, letThrough: /* @__PURE__ */ new Set() };
+      for (const id of touching(wire)) wire.letThrough.add(id);
+      attached.push(wireLine(segment.from, segment.to));
+      projectile.wire = wire;
+    }
+    projectiles.push(projectile);
+    action("place_charge", translate("act.place", { weapon: context.toolName(), triggers: use.triggers.join("/") || "-" }), { data: { weapon: context.toolId(), explosive: use.explosive, triggers: [...use.triggers], point: at, ...segment ? { wire: segment } : {} } });
+  };
+  const backblastUse = (use) => {
+    renderer.emit("smoke", use.origin, use.direction, 14, use.radius);
+    let reached = 0;
+    for (const object of context.objects()) if (backblastEffect(use, toArray(object.position)) > 0) reached++;
+    const onPlayer = backblastEffect(use, toArray(camera.position));
+    action("backblast", translate("act.backblast", { weapon: context.toolName(), radius: format(use.radius, 0), n: reached, player: format(onPlayer, 2) }), {
+      data: { weapon: context.toolId(), radius: use.radius, halfAngleDeg: use.halfAngleDeg, objects: reached, onPlayer }
+    });
+  };
+  const surfaceProbe = (from, to) => {
+    const dx = to[0] - from[0];
+    const dy = to[1] - from[1];
+    const dz = to[2] - from[2];
+    const length = Math.hypot(dx, dy, dz);
+    if (length < 1e-6) return null;
+    const direction = [dx / length, dy / length, dz / length];
+    const ray = context.withoutHeld(() => world.raycast(from, direction, length + 0.03));
+    let best = ray && ray.distance <= length + 0.03 ? { point: ray.point, normal: ray.normal, ground: ray.normal[1] > 0.7, at: ray.distance } : null;
+    const floor = context.groundAt(to[0], to[2]) + 0.045;
+    if (to[1] < floor) {
+      const point = [to[0], floor, to[2]];
+      const at = Math.hypot(point[0] - from[0], point[1] - from[1], point[2] - from[2]);
+      if (!best || at < best.at) best = { point, normal: [0, 1, 0], ground: true, at };
+    }
+    return best ? { point: best.point, normal: best.normal, ground: best.ground } : null;
+  };
+  const mostExposedPoint = (box2, detonation) => {
+    const { min, max } = box2;
+    const candidates = [toArray(box2.getCenter(new THREE.Vector3())), toArray(box2.clampPoint(new THREE.Vector3(...detonation.point), new THREE.Vector3()))];
+    for (const x of [min.x, max.x]) for (const y of [min.y, max.y]) for (const z of [min.z, max.z]) candidates.push([x, y, z]);
+    let best;
+    for (const point of candidates) {
+      const effect = blastEffect(detonation, point);
+      if (effect.zone !== "none" && (!best || effect.falloff > best.falloff)) best = { point, falloff: effect.falloff };
+    }
+    return best?.point;
+  };
+  const coneBlast = (detonation) => {
+    let reached = 0;
+    for (const object of context.objects()) {
+      const box2 = new THREE.Box3().setFromObject(object);
+      if (box2.isEmpty()) box2.expandByPoint(object.position);
+      const at = mostExposedPoint(box2, detonation);
+      if (!at) continue;
+      reached += world.explode(at, detonation.energy * blastEffect(detonation, at).falloff, CONE_BLAST_RADIUS, "player").length;
+    }
+    return reached;
+  };
+  const detonate = (projectile, detonation) => {
+    const weaponName = context.toolName(projectile.weapon);
+    const reach = Math.max(detonation.injuryRadius, detonation.lethalRadius);
+    const reached = detonation.energy <= 0 ? 0 : detonation.cone ? coneBlast(detonation) : world.explode(detonation.point, detonation.energy, reach, "player").length;
+    if (detonation.energy > 0) renderer.explode(detonation.point, detonation.energy, reach);
+    if (detonation.stunSeconds !== void 0) renderer.emit("flash", detonation.point, [0, 1, 0], 1, 1);
+    const onPlayer = blastEffect(detonation, toArray(camera.position));
+    action("explode", translate("act.explode", { weapon: weaponName, energy: format(detonation.energy, 0), radius: format(reach, 1), n: reached }), {
+      data: { weapon: projectile.weapon, explosive: detonation.explosive, cause: detonation.cause, energyJ: detonation.energy, radius: reach, point: detonation.point, player: onPlayer.zone, stunSeconds: onPlayer.stunSeconds }
+    });
+    if (onPlayer.zone !== "none") {
+      action("blast_player", translate("act.blast_player", { weapon: weaponName, zone: translate(`blast.zone.${onPlayer.zone}`), distance: format(onPlayer.distance, 1), stun: format(onPlayer.stunSeconds, 1) }), { data: { ...onPlayer } });
+    }
+    context.emitHost({ type: "explosion", source: projectile.weapon, point: detonation.point, energy: detonation.energy, radius: reach, cause: detonation.cause });
+    if (detonation.fire) context.startFire(projectile.weapon, detonation.point, detonation.fire, detonation.cause === "impact");
+  };
+  const detonateBare = (projectile, isImpact) => {
+    detonate(projectile, {
+      explosive: projectile.weapon,
+      cause: isImpact ? "impact" : "timer",
+      point: toArray(projectile.pos),
+      direction: [0, 1, 0],
+      at: projectile.age,
+      energy: projectile.energy,
+      lethalRadius: 0,
+      injuryRadius: projectile.radius,
+      noise: 0,
+      destructionLevel: 0,
+      ...projectile.fire ? { fire: projectile.fire } : {}
+    });
+  };
+  const detonateCharges = () => {
+    let count = 0;
+    for (const projectile of [...projectiles]) {
+      if (!projectile.placed || !projectile.body) continue;
+      const event = projectile.body.trigger("remote");
+      if (event?.type !== "detonate") continue;
+      detonate(projectile, event.detonation);
+      remove(projectile);
+      count++;
+    }
+    if (count === 0) context.say(translate("hud.no_charges"));
+    return count;
+  };
+  const stepBody = (projectile, body, dt) => {
+    const events = body.step(dt, surfaceProbe);
+    projectile.pos.set(body.position[0], body.position[1], body.position[2]);
+    projectile.mesh.position.copy(projectile.pos);
+    if (projectile.aligned && body.velocity[0] ** 2 + body.velocity[1] ** 2 + body.velocity[2] ** 2 > 1e-6) {
+      projectile.mesh.quaternion.setFromUnitVectors(up, new THREE.Vector3(body.velocity[0], body.velocity[1], body.velocity[2]).normalize());
+    } else if (!projectile.placed) projectile.mesh.rotation.x += dt * 8;
+    for (const event of events) {
+      if (event.type === "dud") action("dud", translate("act.dud", { weapon: context.toolName(projectile.weapon), distance: format(body.travelled, 1) }), { data: { weapon: projectile.weapon, point: event.point } });
+      else if (event.type === "detonate") detonate(projectile, event.detonation);
+    }
+  };
+  const flyBare = (projectile, dt) => {
+    const { gravity } = arsenal.rules.explosives;
+    let isBurst = false;
+    projectile.vel.y -= gravity * dt;
+    const speed = projectile.vel.length();
+    const step = speed * dt;
+    if (step > 1e-6) {
+      const direction = [projectile.vel.x / speed, projectile.vel.y / speed, projectile.vel.z / speed];
+      const hit = context.withoutHeld(() => world.raycast(toArray(projectile.pos), direction, step + 0.05));
+      if (hit && hit.distance <= step + 0.04) {
+        projectile.pos.set(hit.point[0] - direction[0] * 0.03, hit.point[1] - direction[1] * 0.03, hit.point[2] - direction[2] * 0.03);
+        if (projectile.burstOnImpact) isBurst = true;
+        else {
+          const normal = hit.normal;
+          const normalSpeed = projectile.vel.x * normal[0] + projectile.vel.y * normal[1] + projectile.vel.z * normal[2];
+          projectile.vel.x = (projectile.vel.x - 2 * normalSpeed * normal[0]) * 0.35;
+          projectile.vel.y = (projectile.vel.y - 2 * normalSpeed * normal[1]) * 0.35;
+          projectile.vel.z = (projectile.vel.z - 2 * normalSpeed * normal[2]) * 0.35;
+        }
+      } else projectile.pos.addScaledVector(projectile.vel, dt);
+    }
+    const ground = context.groundAt(projectile.pos.x, projectile.pos.z) + 0.045;
+    if (projectile.pos.y < ground) {
+      projectile.pos.y = ground;
+      if (projectile.burstOnImpact) isBurst = true;
+      else {
+        projectile.vel.y = Math.abs(projectile.vel.y) * 0.35;
+        projectile.vel.x *= 0.7;
+        projectile.vel.z *= 0.7;
+      }
+    }
+    return isBurst;
+  };
+  const checkWire = (projectile, body) => {
+    const wire = projectile.wire;
+    if (!wire) return;
+    const crossing = touching(wire);
+    for (const id of [...wire.letThrough]) if (!crossing.includes(id)) wire.letThrough.delete(id);
+    const crosser = crossing.find((id) => !wire.letThrough.has(id));
+    if (crosser === void 0) return;
+    const event = body.trigger("wire");
+    if (event?.type !== "detonate") return;
+    action("tripwire", translate("act.tripwire", { weapon: context.toolName(projectile.weapon), who: crosser }), { data: { weapon: projectile.weapon, body: crosser } });
+    detonate(projectile, event.detonation);
+  };
+  const update = (dt) => {
+    for (let index = projectiles.length - 1; index >= 0; index--) {
+      const projectile = projectiles[index];
+      if (!projectile) continue;
+      projectile.age += dt;
+      if (projectile.body) {
+        if (projectile.wire && !projectile.body.done) checkWire(projectile, projectile.body);
+        stepBody(projectile, projectile.body, dt);
+        if (projectile.body.done || !projectile.placed && projectile.age > 60) remove(projectile);
+        continue;
+      }
+      const isBurst = flyBare(projectile, dt);
+      projectile.mesh.position.copy(projectile.pos);
+      projectile.mesh.rotation.x += dt * 8;
+      projectile.fuse -= dt;
+      if (isBurst || !projectile.burstOnImpact && projectile.fuse <= 0 || projectile.age > 30) {
+        detonateBare(projectile, isBurst);
+        remove(projectile);
+      }
+    }
+  };
+  return { throwUse, placeUse, backblastUse, detonateCharges, update, clear };
+}
+
+// src/host-events.ts
+var NO_RECOIL = [0, 0];
+var durationOf = (phase, id) => phase?.id === id ? { duration: Math.round((phase.end - phase.start) * 1e6) / 1e6 } : {};
+var toHostEvent = (weapon, event, options = {}) => {
+  const { recoil = NO_RECOIL, phase } = options;
+  switch (event.type) {
+    case "draw":
+      return event.phase === "start" ? { type: "tool", weapon, ...durationOf(phase, "draw") } : null;
+    // a launcher spends a round and throws one projectile: the weapon counts none because it is a throw, a host counts the one that leaves
+    case "shot":
+      return { type: "shot", weapon, shots: Math.max(1, event.shots), recoil, rounds: event.rounds, mode: event.mode, ...event.suppressed ? { suppressed: true } : {} };
+    case "misfire":
+      return { type: "misfire", weapon };
+    case "reload":
+      return { type: "reload", weapon, phase: event.phase, ...event.phase === "start" ? { kind: event.kind, ...durationOf(phase, "reload") } : {} };
+    case "reload_stage":
+      return { type: "stage", weapon, stage: event.stage };
+    case "feed":
+      return { type: "feed", weapon };
+    case "cycle":
+      return { type: "cycle", weapon, phase: event.phase, ...event.phase === "start" ? durationOf(phase, "cycle") : {} };
+    case "empty":
+      return { type: "empty", weapon };
+    case "mode":
+      return { type: "mode", weapon, mode: event.mode };
+    case "fault":
+      return { type: "fault", weapon, fault: event.fault };
+    case "clear":
+      return { type: "clear", weapon, fault: event.fault, phase: event.phase, ...event.phase === "start" ? durationOf(phase, "clear") : {} };
+    case "safety":
+      return { type: "safety", weapon, on: event.on };
+    case "cook":
+      return { type: "cook", weapon, phase: event.phase, fuse: event.fuse };
+    case "attachment":
+      return { type: "attachment", weapon, action: event.action, attachment: event.id, mount: event.mount, ...event.action === "break" ? {} : durationOf(phase, "fit") };
+    case "toggle":
+      return { type: "toggle", weapon, attachment: event.id, on: event.on };
+    case "stock":
+      return { type: "stock", weapon, state: event.state, kind: event.kind, ...durationOf(phase, "stock") };
+    case "underbarrel":
+      return { type: "underbarrel", weapon, on: event.on, ...durationOf(phase, "switch") };
+    default:
+      return null;
+  }
+};
+
 // src/log.ts
 var MAX_ENTRIES = 5e3;
 var pad = (n, w = 2) => String(n).padStart(w, "0");
@@ -1991,7 +2375,7 @@ function createNarrator(c) {
 
 // src/player.ts
 var EYE = 1.7;
-var RADIUS = 0.3;
+var PLAYER_RADIUS = 0.3;
 var WALK = 3.4;
 var RUN = 6.2;
 var JUMP = 4.6;
@@ -2016,8 +2400,8 @@ function createPlayer(THREE, o) {
   };
   apply();
   const blocked = (x, z) => {
-    if (Math.abs(x) > o.limit - RADIUS || Math.abs(z) > o.limit - RADIUS) return true;
-    for (const c of o.colliders) if (x > c[0] - RADIUS && x < c[2] + RADIUS && z > c[1] - RADIUS && z < c[3] + RADIUS) return true;
+    if (Math.abs(x) > o.limit - PLAYER_RADIUS || Math.abs(z) > o.limit - PLAYER_RADIUS) return true;
+    for (const c of o.colliders) if (x > c[0] - PLAYER_RADIUS && x < c[2] + PLAYER_RADIUS && z > c[1] - PLAYER_RADIUS && z < c[3] + PLAYER_RADIUS) return true;
     return false;
   };
   const move = (dx, dz) => {
@@ -2239,6 +2623,7 @@ function makeScenarios(t, num, _locale = "en") {
     sc("steel_through_hole", ({ room, step, expect }) => {
       const id = at(room, "steel_sheet", 0, -4);
       room.setTool("pistol_9mm");
+      room.waitUntilReady();
       look(room, [0, 1.1, -1.5], [0, 1.1, -4]);
       room.use();
       step(0.2);
@@ -2253,6 +2638,7 @@ function makeScenarios(t, num, _locale = "en") {
     sc("concrete_stops_bullet", ({ room, step, expect }) => {
       const id = at(room, "concrete_block", 0, -4);
       room.setTool("pistol_9mm");
+      room.waitUntilReady();
       look(room, [0, 0.5, -1.5], [0, 0.2, -3.8]);
       room.use();
       step(0.2);
@@ -2268,6 +2654,7 @@ function makeScenarios(t, num, _locale = "en") {
     sc("hammer_dents_drum", ({ room, step, expect }) => {
       const id = at(room, "steel_drum", 0, -4);
       room.setTool("hammer");
+      room.waitUntilReady();
       look(room, [0, 0.6, -3.35], [0, 0.5, -4]);
       let swings = 0;
       for (; swings < 8 && (part(room, id, "drum_body")?.dents.length ?? 0) === 0; swings++) {
@@ -2284,6 +2671,7 @@ function makeScenarios(t, num, _locale = "en") {
     sc("glass_shatters", ({ room, step, expect }) => {
       const id = at(room, "glass_pane", 0, -4);
       room.setTool("pistol_9mm");
+      room.waitUntilReady();
       look(room, [0, 1.3, -1.5], [0, 1.05, -4]);
       let shots = 0;
       for (; shots < 10 && part(room, id, "pane")?.status !== "broken"; shots++) {
@@ -2298,6 +2686,7 @@ function makeScenarios(t, num, _locale = "en") {
     sc("shotgun_splinters_crate", ({ room, step, expect }) => {
       const id = at(room, "wooden_crate", 0, -4);
       room.setTool("shotgun_pump_12");
+      room.waitUntilReady();
       look(room, [0, 0.6, -1.8], [0, 0.25, -3.77]);
       let shots = 0;
       const splinters = () => room.log.entries({ type: "fracture", objectId: id }).filter((e) => e.data?.style === "splinter").length;
@@ -2331,6 +2720,7 @@ function makeScenarios(t, num, _locale = "en") {
       const id = at(room, "chair", 0, -4);
       const before = room.renderer.pieces().length;
       room.setTool("kick");
+      room.waitUntilReady();
       let kicks = 0;
       for (; kicks < 8 && room.renderer.pieces().length <= before && part(room, id, "leg_1"); kicks++) {
         const st = room.world.state(id);
@@ -2347,6 +2737,7 @@ function makeScenarios(t, num, _locale = "en") {
     sc("screwdriver_shelf_board", ({ room, step, expect }) => {
       const id = at(room, "shelf", 0, -4);
       room.setTool("screwdriver");
+      room.waitUntilReady();
       look(room, [0, 0.8, -3.5], [0, 0.75, -3.86]);
       const t0 = room.log.entries().length ? room.log.entries().slice(-1)[0].t : 0;
       room.use(5);
@@ -2360,6 +2751,7 @@ function makeScenarios(t, num, _locale = "en") {
     sc("wrong_tool_refused", ({ room, expect }) => {
       const id = at(room, "steel_sheet", 0, -4);
       room.setTool("screwdriver");
+      room.waitUntilReady();
       look(room, [0.2, 1.05, -3.6], [0.34, 1, -4]);
       room.use(0.5);
       const refused = count(room, "tool_refused");
@@ -2369,6 +2761,7 @@ function makeScenarios(t, num, _locale = "en") {
     sc("lighter_burns_crate", ({ room, step, expect }) => {
       const id = at(room, "wooden_crate", 0, -4);
       room.setTool("lighter");
+      room.waitUntilReady();
       look(room, [0, 0.3, -3.65], [0, 0.25, -3.76]);
       room.use(5);
       const lit = anyBurning(room, id);
@@ -2391,6 +2784,7 @@ function makeScenarios(t, num, _locale = "en") {
       const melt0 = part(room, drum2, "drum_body")?.melt ?? 0;
       expect(melt0 === 0 && peak < 1450, t("sc.torch_melts_steel.wood", { peak: num(peak, 0), melt: num(melt0 * 100, 0), crate: yn(anyBurning(room, crate2)) }), { peak });
       room.setTool("cutting_torch");
+      room.waitUntilReady();
       look(room, [-0.15, 0.55, -3.55], [-0.15, 0.5, -3.72]);
       room.use(20);
       const p = part(room, drum2, "drum_body");
@@ -2399,6 +2793,7 @@ function makeScenarios(t, num, _locale = "en") {
     sc("bucket_melts_drips", ({ room, step, expect }) => {
       const id = at(room, "plastic_bucket", 0, -4);
       room.setTool("flamethrower");
+      room.waitUntilReady();
       look(room, [0, 0.5, -2.4], [0, 0.15, -4]);
       room.use(2.5);
       step(10);
@@ -2473,6 +2868,7 @@ function makeScenarios(t, num, _locale = "en") {
     sc("jerrycan_leaks_fuel", ({ room, step, expect }) => {
       const id = at(room, "jerrycan", 0, -3.5);
       room.setTool("pistol_9mm");
+      room.waitUntilReady();
       look(room, [0, 0.4, -1.5], [0, 0.12, -3.43]);
       room.use();
       step(1.5);
@@ -2487,6 +2883,7 @@ function makeScenarios(t, num, _locale = "en") {
       const id = at(room, "jerrycan", 0, -3.5);
       const crate2 = at(room, "wooden_crate", 0.9, -3.2);
       room.setTool("pistol_9mm");
+      room.waitUntilReady();
       look(room, [0, 0.4, -1.5], [0, 0.12, -3.43]);
       room.use();
       step(6);
@@ -2494,6 +2891,7 @@ function makeScenarios(t, num, _locale = "en") {
       expect(!!stain, t("sc.fuel_stain_burns.stain", { stain: yn(!!stain) }));
       if (!stain) return;
       room.setTool("lighter");
+      room.waitUntilReady();
       look(room, [stain.center[0], 0.1, stain.center[2] + 0.06], [stain.center[0], 0, stain.center[2]]);
       room.use(1);
       step(4);
@@ -2529,6 +2927,7 @@ function makeScenarios(t, num, _locale = "en") {
       const before = anyBurning(room, id);
       expect(before, t("sc.extinguisher_puts_out_fire.burning", { burning: yn(before) }));
       room.setTool("extinguisher");
+      room.waitUntilReady();
       look(room, [0, 0.9, -2.2], [0, 0.25, -4]);
       room.use(2.5);
       step(1);
@@ -3397,10 +3796,14 @@ function createTestRoom(options) {
   const tools = /* @__PURE__ */ new Map();
   let toolIndex = Math.max(0, loadout.indexOf("hand"));
   let toolId = loadout[toolIndex] ?? "hand";
+  const toolSettings = {};
+  let fuseLength;
+  const SETTING_IDS = { condition: "condition", ammoQuality: "ammo_quality", fuseLength: "fuse_length" };
   const toolState = (id) => {
     let s = tools.get(id);
     if (!s) {
-      s = arsenal.create(id, { seed: 7, reserve: 999 });
+      s = arsenal.create(id, { seed: 7, reserve: 999, ...toolSettings });
+      s.setFuseLength(fuseLength);
       s.refill();
       tools.set(id, s);
     }
@@ -3501,6 +3904,7 @@ function createTestRoom(options) {
     for (const ev of batch) {
       if (ev.type === "leak") puncture(ev);
       else if (ev.type === "ignite") igniteNear(ev.point, 0.9);
+      else if (ev.type === "explode") emitHost({ type: "explosion", source: ev.object, point: ev.point, energy: ev.energy, radius: ev.radius, cause: "part" });
       fire("event", ev);
       options.onEvent?.(ev);
     }
@@ -3521,7 +3925,7 @@ function createTestRoom(options) {
       },
       primaryUp: () => {
         useHeld = false;
-        tool.release();
+        releaseTrigger();
       },
       secondary: () => {
         if (heldEntry) throwHeld();
@@ -3678,8 +4082,7 @@ function createTestRoom(options) {
     if (heldEntry || heldPiece) releaseHeld();
     useItemPlayer = null;
     playing.length = 0;
-    projectiles.length = 0;
-    clearProjectileMeshes();
+    explosives.clear();
     fireZones.length = 0;
     burningStains.length = 0;
     for (const id of [...entries.keys()]) if (!entries.get(id)?.arena) removeEntry(id);
@@ -3915,7 +4318,6 @@ function createTestRoom(options) {
       }
     });
     player.kick(recoil[0], recoil[1]);
-    emitHost({ type: "shot", weapon: toolId, shots: shots.length, recoil, rounds: shots.filter((s) => s.pellet === 0).length, mode: tool.mode });
     const f = first;
     const d = f ? num(f.distance, 1) : "";
     let text;
@@ -4063,100 +4465,46 @@ function createTestRoom(options) {
       1
     );
   };
-  const projectiles = [];
-  const projMeshes = [];
-  const clearProjectileMeshes = () => {
-    for (const m of projMeshes) m.removeFromParent();
-    projMeshes.length = 0;
-  };
-  const throwUse = (u) => {
-    const w = toolName();
-    const molotov = !!u.fire;
-    const mesh = new THREE.Mesh(
-      molotov ? new THREE.CylinderGeometry(0.035, 0.04, 0.2, 8) : new THREE.SphereGeometry(0.045, 8, 6),
-      new THREE.MeshStandardMaterial({ color: molotov ? 3897915 : 4936480, roughness: 0.6, metalness: molotov ? 0 : 0.4 })
-    );
-    mesh.castShadow = true;
-    mesh.position.set(u.origin[0], u.origin[1], u.origin[2]);
-    scene.add(mesh);
-    projMeshes.push(mesh);
-    projectiles.push({
-      mesh,
-      pos: new THREE.Vector3(u.origin[0], u.origin[1], u.origin[2]),
-      vel: new THREE.Vector3(u.velocity[0], u.velocity[1], u.velocity[2]),
-      weapon: toolId,
-      fuse: u.fuse,
-      burstOnImpact: molotov && u.fuse <= 0,
-      energy: u.energy,
-      radius: u.radius,
-      fire: u.fire,
-      age: 0
-    });
-    action("throw_projectile", t(molotov ? "act.throw.molotov" : "act.throw.grenade", { weapon: w, fuse: num(u.fuse, 1) }), { data: { weapon: toolId, fuse: u.fuse } });
-  };
-  const detonate = (p, at, impact) => {
-    const w = toolName(p.weapon);
-    const results = world.explode(at, p.energy, p.radius, "player");
-    renderer.explode(at, p.energy, p.radius);
-    action("explode", t("act.explode", { weapon: w, energy: num(p.energy, 0), radius: num(p.radius, 1), n: results.length }), { data: { weapon: p.weapon, energyJ: p.energy, radius: p.radius, point: at } });
-    if (p.fire) {
-      fluids.splash("fuel", [at[0], Math.max(at[1], groundAt(at[0], at[2])), at[2]], 0.5);
-      fireZones.push({ point: [at[0], Math.max(0.02, groundAt(at[0], at[2])), at[2]], radius: p.fire.radius, temperature: p.fire.temperature, remaining: p.fire.seconds, acc: 0 });
-      renderer.emit("fire", at, [0, 1, 0], 24, 3);
-      action("molotov_fire", t("act.molotov_fire", { weapon: w, seconds: num(p.fire.seconds, 0), radius: num(p.fire.radius, 1) }), { data: { weapon: p.weapon, impact } });
-    }
-  };
-  const updateProjectiles = (dt) => {
-    for (let i = projectiles.length - 1; i >= 0; i--) {
-      const p = projectiles[i];
-      p.age += dt;
-      p.vel.y -= 9.81 * dt;
-      const speed = p.vel.length();
-      const step2 = speed * dt;
-      let burst = false;
-      if (step2 > 1e-6) {
-        const d = [p.vel.x / speed, p.vel.y / speed, p.vel.z / speed];
-        const r = withoutHeld(() => world.raycast(v3(p.pos), d, step2 + 0.05));
-        if (r && r.distance <= step2 + 0.04) {
-          p.pos.set(r.point[0] - d[0] * 0.03, r.point[1] - d[1] * 0.03, r.point[2] - d[2] * 0.03);
-          if (p.burstOnImpact) burst = true;
-          else {
-            const n = r.normal;
-            const vn = p.vel.x * n[0] + p.vel.y * n[1] + p.vel.z * n[2];
-            p.vel.x = (p.vel.x - 2 * vn * n[0]) * 0.35;
-            p.vel.y = (p.vel.y - 2 * vn * n[1]) * 0.35;
-            p.vel.z = (p.vel.z - 2 * vn * n[2]) * 0.35;
-          }
-        } else p.pos.addScaledVector(p.vel, dt);
-      }
-      const g = groundAt(p.pos.x, p.pos.z) + 0.045;
-      if (p.pos.y < g) {
-        p.pos.y = g;
-        if (p.burstOnImpact) burst = true;
-        else {
-          p.vel.y = Math.abs(p.vel.y) * 0.35;
-          p.vel.x *= 0.7;
-          p.vel.z *= 0.7;
-        }
-      }
-      p.mesh.position.copy(p.pos);
-      p.mesh.rotation.x += dt * 8;
-      p.fuse -= dt;
-      if (burst || !p.burstOnImpact && p.fuse <= 0 || p.age > 30) {
-        detonate(p, v3(p.pos), burst);
-        p.mesh.removeFromParent();
-        projMeshes.splice(projMeshes.indexOf(p.mesh), 1);
-        projectiles.splice(i, 1);
-      }
-    }
-  };
+  const startFire = (weapon, at, fire2, impact) => {
+    fluids.splash("fuel", [at[0], Math.max(at[1], groundAt(at[0], at[2])), at[2]], 0.5);
+    fireZones.push({ point: [at[0], Math.max(0.02, groundAt(at[0], at[2])), at[2]], radius: fire2.radius, temperature: fire2.temperature, remaining: fire2.seconds, acc: 0 });
+    renderer.emit("fire", at, [0, 1, 0], 24, 3);
+    action("molotov_fire", t("act.molotov_fire", { weapon: toolName(weapon), seconds: num(fire2.seconds, 0), radius: num(fire2.radius, 1) }), { data: { weapon, impact } });
+  };
+  function crossingBodies() {
+    const bodies = [...entries.values()].filter((e) => !e.arena).map((e) => ({ id: e.so.objectId, box: new THREE.Box3().setFromObject(e.so.root) }));
+    const { x, y, z } = camera.position;
+    const feet = groundAt(x, z);
+    bodies.push({ id: "player", box: new THREE.Box3(new THREE.Vector3(x - PLAYER_RADIUS, feet, z - PLAYER_RADIUS), new THREE.Vector3(x + PLAYER_RADIUS, y + 0.1, z + PLAYER_RADIUS)) });
+    return bodies;
+  }
+  const explosives = createExplosives({
+    THREE,
+    scene,
+    camera,
+    world,
+    renderer,
+    arsenal,
+    objects: () => [...entries.values()].filter((e) => !e.arena).map((e) => e.so.root),
+    bodies: crossingBodies,
+    toolId: () => toolId,
+    toolName,
+    withoutHeld,
+    groundAt,
+    translate: t,
+    format: num,
+    action,
+    emitHost,
+    startFire,
+    say
+  });
   const useTool = (dt, held) => {
     aim();
     const cat = tool.def.category;
     if (cat === "hand") return;
     const res = tool.trigger([aimO[0], aimO[1], aimO[2]], [aimD[0], aimD[1], aimD[2]], dt, held, "player");
+    flushEvents(toolId, tool, res.recoil);
     if (res.status === "empty") {
-      emitHost({ type: "empty", weapon: toolId });
       if (!tool.reloading && tool.reserve > 0) startReload();
       say(t(tool.reloading ? "hud.reloading" : "hud.empty"));
       return;
@@ -4164,8 +4512,13 @@ function createTestRoom(options) {
     if (res.status !== "ok") {
       if (res.status === "reloading") say(t("hud.reloading"));
       else if (res.status === "no_fuel") say(t("hud.no_fuel"));
+      else if (res.status === "fault" && res.fault) say(t("hud.fault", { fault: t(`fault.${res.fault}`) }));
+      else if (res.status === "safe") say(t("hud.safe"));
       return;
     }
+    applyUses(res, dt);
+  };
+  const applyUses = (res, dt) => {
     if (res.shots.length) fireShots(res.shots, res.recoil);
     for (const u of res.uses) {
       switch (u.kind) {
@@ -4179,7 +4532,13 @@ function createTestRoom(options) {
           heatRays(u, "heat");
           break;
         case "throw":
-          throwUse(u);
+          explosives.throwUse(u);
+          break;
+        case "place":
+          explosives.placeUse(u);
+          break;
+        case "backblast":
+          explosives.backblastUse(u);
           break;
         case "tool":
           toolWork(u, dt);
@@ -4192,6 +4551,16 @@ function createTestRoom(options) {
       }
     }
   };
+  const releaseTrigger = () => {
+    if (!tool.cooking) {
+      tool.release();
+      return;
+    }
+    aim();
+    const res = tool.release([aimO[0], aimO[1], aimO[2]], [aimD[0], aimD[1], aimD[2]]);
+    flushEvents(toolId, tool);
+    if (res) applyUses(res, 0);
+  };
   const kick = () => {
     if (!arsenal.weapons.has("kick")) return;
     aim();
@@ -4201,7 +4570,7 @@ function createTestRoom(options) {
   };
   const setTool = (id) => {
     if (!arsenal.weapons.has(id)) throw new Error(`game-test-room: unknown weapon "${id}"`);
-    tool.release();
+    releaseTrigger();
     toolId = id;
     const i = loadout.indexOf(id);
     if (i >= 0) toolIndex = i;
@@ -4209,7 +4578,8 @@ function createTestRoom(options) {
     progress = null;
     action("tool", t("act.tool", { weapon: toolName(id) }), { data: { weapon: id } });
     fire("tool", id);
-    emitHost({ type: "tool", weapon: id });
+    tool.draw();
+    flushEvents(id, tool);
   };
   const cycleTool = (dir) => {
     if (!loadout.length) return;
@@ -4442,11 +4812,16 @@ function createTestRoom(options) {
         }
         break;
       case "KeyQ": {
-        const before = tool.mode;
-        const mode = tool.cycleMode();
-        if (mode !== before) emitHost({ type: "mode", weapon: toolId, mode });
+        tool.cycleMode();
+        flushEvents(toolId, tool);
         break;
       }
+      case "KeyX":
+        clearToolFault();
+        break;
+      case "KeyB":
+        toggleSafety();
+        break;
       case "KeyZ":
         tiltKey = 1;
         break;
@@ -4463,6 +4838,9 @@ function createTestRoom(options) {
       case "KeyT":
         toggleTap();
         break;
+      case "KeyY":
+        explosives.detonateCharges();
+        break;
       case "KeyH": {
         const w = (heldEntry ?? entryOf(inspectTarget()?.object ?? ""))?.item?.weapon;
         if (w) equip(w);
@@ -4577,7 +4955,7 @@ function createTestRoom(options) {
     const reps = fastForward ? 10 : 1;
     updateAnimations(dt);
     updateItemUse(dt);
-    updateProjectiles(dt);
+    explosives.update(dt);
     syncContainers(dt);
     for (let i = 0; i < reps; i++) {
       world.update(dt);
@@ -4588,9 +4966,10 @@ function createTestRoom(options) {
     renderer.update(dt);
     updateImpacts();
     fluidView.update(dt);
-    for (const s of tools.values()) s.update(dt);
-    if (reloadingSeen && !tool.reloading) emitHost({ type: "reload", weapon: toolId, phase: "end" });
-    reloadingSeen = tool.reloading;
+    for (const [id, s] of tools) {
+      s.update(dt);
+      flushEvents(id, s);
+    }
     for (const update2 of frameListeners) update2(dt);
     for (const tr of tracers) {
       if (tr.life > 0) {
@@ -4793,12 +5172,49 @@ function createTestRoom(options) {
   };
   const hostListeners = /* @__PURE__ */ new Set();
   const frameListeners = /* @__PURE__ */ new Set();
-  let reloadingSeen = false;
   function emitHost(event) {
     for (const listener of hostListeners) listener(event);
   }
+  function flushEvents(id, state, recoil) {
+    const phase = state.phase;
+    for (const event of state.drain()) {
+      const hostEvent = toHostEvent(id, event, { ...recoil ? { recoil } : {}, phase });
+      if (hostEvent) emitHost(hostEvent);
+    }
+  }
   function startReload() {
-    if (tool.reload()) emitHost({ type: "reload", weapon: toolId, phase: "start" });
+    tool.reload();
+    flushEvents(toolId, tool);
+  }
+  function clearToolFault() {
+    if (!tool.clearFault()) return;
+    flushEvents(toolId, tool);
+    say(t("hud.clearing"));
+  }
+  function toggleSafety() {
+    tool.setSafety(!tool.safety);
+    flushEvents(toolId, tool);
+    say(t(tool.safety ? "hud.safety_on" : "hud.safety_off"));
+  }
+  function runToolCommand(request) {
+    const work = (done) => done.ok ? { ok: true, seconds: done.seconds } : { ok: false, reason: done.reason };
+    switch (request.type) {
+      case "fit":
+        return work(tool.fit(request.attachment, { install: "bench", ...request.mount ? { mount: request.mount } : {} }));
+      case "remove":
+        return work(tool.remove(request.attachment, { install: "bench" }));
+      case "toggle":
+        return tool.toggle(request.attachment) === null ? { ok: false, reason: "not_fitted" } : { ok: true };
+      case "stock":
+        return tool.setStock(request.state) ? { ok: true } : { ok: false, reason: "busy" };
+      case "underbarrel":
+        return tool.useUnderbarrel(request.on) ? { ok: true } : { ok: false, reason: "busy" };
+      case "stance":
+        tool.setStance({ ...request.aiming === void 0 ? {} : { aiming: request.aiming }, ...request.supported === void 0 ? {} : { supported: request.supported } });
+        return { ok: true };
+      default:
+        return { ok: false, reason: "unknown" };
+    }
   }
   const host = {
     THREE,
@@ -4806,7 +5222,42 @@ function createTestRoom(options) {
     camera,
     locale,
     groundAt,
-    tool: () => ({ weapon: toolId, category: tool.def.category, ammo: tool.ammo, capacity: tool.capacity, reserve: tool.reserve, reloading: tool.reloading, mode: tool.mode }),
+    tool: () => ({
+      weapon: toolId,
+      category: tool.def.category,
+      ammo: tool.ammo,
+      capacity: tool.capacity,
+      reserve: tool.reserve,
+      reloading: tool.reloading,
+      mode: tool.mode,
+      ...tool.fault ? { fault: tool.fault } : {},
+      safety: tool.safety,
+      heat: tool.heatLevel,
+      attachments: tool.attachments.map((part) => ({ id: part.id, mount: part.mount, ...part.integral ? { integral: true } : {}, ...part.on === void 0 ? {} : { on: part.on } })),
+      stock: tool.stock,
+      suppressed: tool.suppressed,
+      underbarrelActive: tool.underbarrelActive,
+      mass: tool.mass,
+      aimSeconds: tool.aimSeconds
+    }),
+    command(request) {
+      const result = runToolCommand(request);
+      flushEvents(toolId, tool);
+      return result;
+    },
+    configureTool(settings) {
+      const condition = settings[SETTING_IDS.condition];
+      const ammoQuality = settings[SETTING_IDS.ammoQuality];
+      if (condition !== void 0) toolSettings.condition = condition;
+      if (ammoQuality !== void 0) toolSettings.ammoQuality = ammoQuality;
+      const fuseMetres = settings[SETTING_IDS.fuseLength] === void 0 ? void 0 : Number(settings[SETTING_IDS.fuseLength]);
+      if (fuseMetres !== void 0 && fuseMetres > 0) fuseLength = fuseMetres;
+      for (const state of tools.values()) {
+        if (condition !== void 0) state.setCondition(condition);
+        if (ammoQuality !== void 0) state.setAmmoQuality(ammoQuality);
+        if (fuseMetres !== void 0 && fuseMetres > 0) state.setFuseLength(fuseMetres);
+      }
+    },
     on(listener) {
       hostListeners.add(listener);
       return () => hostListeners.delete(listener);
@@ -5044,7 +5495,7 @@ function createTestRoom(options) {
         stepSim(FIXED_DT);
         t0 += FIXED_DT;
       }
-      tool.release();
+      releaseTrigger();
     },
     grab,
     throwHeld,
@@ -5061,6 +5512,15 @@ function createTestRoom(options) {
       return [...entries.values()].filter((e) => !e.arena).map((e) => e.so);
     },
     update,
+    waitUntilReady(maxSeconds = 5) {
+      let waited = 0;
+      while (tool.phase && waited < maxSeconds) {
+        update(FIXED_DT);
+        waited += FIXED_DT;
+      }
+      update(FIXED_DT);
+      return waited + FIXED_DT;
+    },
     on(type, fn) {
       listeners[type].add(fn);
       return () => listeners[type].delete(fn);
@@ -5113,7 +5573,7 @@ function createTestRoom(options) {
       renderer.dispose();
       fluidView.dispose();
       for (const tr of tracers) tr.line.removeFromParent();
-      clearProjectileMeshes();
+      explosives.clear();
       if (ownRenderer) {
         gl.dispose();
         dom.remove();