@adatechnology/game-test-room 0.16.0 → 0.17.1

package/dist/index.js

@@ -1,12 +1,12 @@
 // src/room.ts
 import { createDestruction, JOINT_DEFAULTS, resolveStrings as resolveDestructionStrings } from "@adatechnology/game-destruction";
 import { createAudioEngine, createAudioSink } from "@adatechnology/game-audio";
-import { createDestructionRenderer, createDestructionSound, specFromObject3D } from "@adatechnology/game-destruction-three";
+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";
-import { createGroundField, createVfx } from "@adatechnology/game-vfx";
-import { createGroundPatch, createVfxRenderer } from "@adatechnology/game-vfx-three";
+import { createVfx } from "@adatechnology/game-vfx";
+import { createVfxRenderer } from "@adatechnology/game-vfx-three";
 import { checkAnimation, checkBench, checkDestructible, checkSpec, createEnvironmentBus, shotExtras, useToHit } from "@adatechnology/game-contracts";
 
 // src/arena.ts
@@ -130,14 +130,6 @@ function createArena(THREE, size, scene, scenery, tapOption) {
   sc.far = 40;
   sun.shadow.bias = -6e-4;
   group.add(sun);
-  const floor = new THREE.Mesh(new THREE.PlaneGeometry(size * 2, size * 2), new THREE.MeshStandardMaterial({ color: 9342602, roughness: 0.95 }));
-  floor.rotation.x = -Math.PI / 2;
-  floor.receiveShadow = true;
-  floor.name = "floor";
-  group.add(floor);
-  const grid = new THREE.GridHelper(size * 2, size * 2, 5000274, 7829371);
-  grid.position.y = 4e-3;
-  group.add(grid);
   const sceneryObjects = resolveScenery(scenery);
   const wallObject = sceneryObjects.find((o) => o.id === WALL_ID);
   const wallZ = wallObject ? wallObject.position[2] : DEFAULT_WALL_Z;
@@ -176,16 +168,23 @@ function createArena(THREE, size, scene, scenery, tapOption) {
   const surfaces = [{ id: "floor", point: [0, 0, 0], normal: [0, 1, 0], halfSize: [size, size], porosity: 0.05 }];
   for (const o of sceneryObjects) {
     if (!o.top) continue;
-    const b = specBounds(THREE, o.spec, o.position, o.rotationY, { onlyPart: o.top.part });
-    if (!b) continue;
+    const boards = (o.top.parts ?? []).flatMap((part) => {
+      const f = specBounds(THREE, o.spec, o.position, o.rotationY, { onlyPart: part });
+      return f ? [{ part, minX: f.minX, maxX: f.maxX, minZ: f.minZ, maxZ: f.maxZ }] : [];
+    });
+    const whole = specBounds(THREE, o.spec, o.position, o.rotationY, { onlyPart: o.top.part });
+    if (!whole) continue;
+    const b = boards.length === 0 ? whole : { minX: Math.min(...boards.map((f) => f.minX)), maxX: Math.max(...boards.map((f) => f.maxX)), minZ: Math.min(...boards.map((f) => f.minZ)), maxZ: Math.max(...boards.map((f) => f.maxZ)) };
     const top = o.position[1] + o.top.y;
-    tops.push({ id: o.id, topPart: o.top.part, minX: b.minX, maxX: b.maxX, minZ: b.minZ, maxZ: b.maxZ, top });
+    tops.push({ id: o.id, topPart: o.top.part, minX: b.minX, maxX: b.maxX, minZ: b.minZ, maxZ: b.maxZ, top, ...boards.length > 0 ? { boards } : {} });
     surfaces.push({ id: o.id, point: [(b.minX + b.maxX) / 2, top, (b.minZ + b.maxZ) / 2], normal: [0, 1, 0], halfSize: [(b.maxX - b.minX) / 2, (b.maxZ - b.minZ) / 2], porosity: 0.3 });
   }
   const colliders = [];
+  const colliderIds = [];
   for (const o of sceneryObjects) {
     const b = specBounds(THREE, o.spec, o.position, o.rotationY, { minHeight: 0.1 });
     if (!b) continue;
+    colliderIds.push(o.id);
     colliders.push(o.id === WALL_ID ? [-size, b.minZ - 1, size, b.maxZ + 0.1] : [b.minX, b.minZ, b.maxX, b.maxZ]);
   }
   let tapSpout = null;
@@ -226,6 +225,7 @@ function createArena(THREE, size, scene, scenery, tapOption) {
       }
       tapSpout = [cx + 0.3, y + 0.5, cz];
       colliders.push([postX - 0.05, cz - 0.1, postX + 0.05, cz + 0.1]);
+      colliderIds.push(null);
     }
   }
   return {
@@ -233,6 +233,7 @@ function createArena(THREE, size, scene, scenery, tapOption) {
     objects: sceneryObjects,
     surfaces,
     colliders,
+    colliderIds,
     playerStart,
     wallZ,
     tops,
@@ -1881,13 +1882,19 @@ function createNarrator(c) {
 // src/player.ts
 var EYE = 1.7;
 var PLAYER_RADIUS = 0.3;
+var FOOT = 0.5;
 var WALK = 3.4;
 var CROUCH_DROP = 0.55;
 var CROUCH_WALK = 1.7;
 var CROUCH_RATE = 9;
+var BEND_RATE = 7;
+var CLEAR_SHARES = [1, 0.75, 0.5, 0.25];
+var CROUCH_TAP = 0.25;
 var RUN = 6.2;
 var JUMP = 4.6;
 var GRAVITY = 13;
+var FLOOR_CLIMB_SPEED = 3;
+var FLOOR_FALL_SPEED = 6;
 var LOOK = 22e-4;
 function createPlayer(THREE, o) {
   const cam = o.camera;
@@ -1896,6 +1903,8 @@ function createPlayer(THREE, o) {
   let y = 0;
   let eye = EYE;
   let crouch = 0;
+  let bend = 0;
+  let bendTarget = 0;
   let vy = 0;
   let walked = 0;
   let running = false;
@@ -1904,33 +1913,79 @@ function createPlayer(THREE, o) {
   const keys = /* @__PURE__ */ new Set();
   const crouchKeys = o.crouchKeys ?? ["KeyC"];
   const isCrouchHeld = () => crouchKeys.some((code) => keys.has(code));
+  let crouchLatched = false;
+  let crouchPress = null;
+  const isCrouched = () => crouchLatched || isCrouchHeld();
+  const pressCrouch = (code) => {
+    if (crouchKeys.includes(code) && !isCrouchHeld()) crouchPress = { held: 0, latched: crouchLatched };
+  };
+  const releaseCrouch = (code) => {
+    if (!crouchKeys.includes(code) || !crouchPress || isCrouchHeld()) return;
+    crouchLatched = crouchPress.held < CROUCH_TAP ? !crouchPress.latched : false;
+    crouchPress = null;
+  };
   const euler = new THREE.Euler(0, 0, 0, "YXZ");
+  const floorHere = () => o.floorAt?.(px.x, px.z) ?? 0;
+  let floorLevel = 0;
+  const followFloor = (dt) => {
+    const gap = floorHere() - floorLevel;
+    const reach = (gap > 0 ? FLOOR_CLIMB_SPEED : FLOOR_FALL_SPEED) * dt;
+    floorLevel += Math.max(-reach, Math.min(reach, gap));
+  };
   const apply = () => {
     euler.set(pitch, yaw, 0, "YXZ");
     cam.quaternion.setFromEuler(euler);
-    cam.position.set(px.x, eye + y - CROUCH_DROP * crouch, px.z);
+    cam.position.set(px.x, eye + floorLevel + y - CROUCH_DROP * crouch - bend, px.z);
     cam.updateMatrixWorld(true);
   };
   apply();
-  const blocked = (x, z) => {
-    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;
+  const outside = (x, z) => Math.abs(x) > o.limit - PLAYER_RADIUS || Math.abs(z) > o.limit - PLAYER_RADIUS;
+  const blocked = (x, z, radius = PLAYER_RADIUS) => {
+    if (outside(x, z)) 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 (o.blockers) {
-      for (const blocked2 of o.blockers) if (blocked2(x, z, PLAYER_RADIUS)) return true;
+      for (const isBlocked of o.blockers) if (isBlocked(x, z, radius)) return true;
     }
-    return false;
+    return o.footing ? o.footing(x, z, radius, y).blocked : false;
   };
+  const clearRadius = () => {
+    for (const share of CLEAR_SHARES) if (!blocked(px.x, px.z, PLAYER_RADIUS * share)) return PLAYER_RADIUS * share;
+    return null;
+  };
+  const wish = { x: 0, z: 0 };
   const move = (dx, dz) => {
-    if (!blocked(px.x + dx, px.z)) px.x += dx;
-    if (!blocked(px.x, px.z + dz)) px.z += dz;
+    wish.x += dx;
+    wish.z += dz;
+    const radius = clearRadius();
+    const free = (x, z) => radius === null ? !outside(x, z) : !blocked(x, z, radius);
+    const steps = Math.max(1, Math.ceil(Math.hypot(dx, dz) / (PLAYER_RADIUS / 3)));
+    const sx = dx / steps;
+    const sz = dz / steps;
+    for (let i = 0; i < steps; i++) {
+      if (free(px.x + sx, px.z)) px.x += sx;
+      if (free(px.x, px.z + sz)) px.z += sz;
+    }
+  };
+  const walkKeys = () => {
+    const f = (keys.has("KeyW") || keys.has("ArrowUp") ? 1 : 0) - (keys.has("KeyS") || keys.has("ArrowDown") ? 1 : 0);
+    const r = (keys.has("KeyD") || keys.has("ArrowRight") ? 1 : 0) - (keys.has("KeyA") || keys.has("ArrowLeft") ? 1 : 0);
+    if (!f && !r) return [0, 0];
+    const len = Math.hypot(f, r);
+    return [(-Math.sin(yaw) * f + Math.cos(yaw) * r) / len, (-Math.cos(yaw) * f - Math.sin(yaw) * r) / len];
   };
   let dragging = false;
   let moved = 0;
   let downAt = 0;
   let useStarted = false;
   let holdTimer = null;
+  let walkHeld = false;
+  let lookLimit = null;
   const look = (dx, dy) => {
     yaw -= dx * LOOK;
+    if (lookLimit) {
+      const off = Math.atan2(Math.sin(yaw - lookLimit.yaw), Math.cos(yaw - lookLimit.yaw));
+      yaw = lookLimit.yaw + Math.max(-lookLimit.range, Math.min(lookLimit.range, off));
+    }
     pitch = Math.max(-1.5, Math.min(1.5, pitch - dy * LOOK));
   };
   const onLockChange = () => {
@@ -2022,16 +2077,23 @@ function createPlayer(THREE, o) {
     if (isControlHeld || e.altKey && locked) {
       if (!/^F\d+$/.test(e.code)) e.preventDefault();
     }
-    if (!e.repeat) keys.add(e.code);
+    if (!e.repeat) {
+      pressCrouch(e.code);
+      keys.add(e.code);
+    }
     o.hooks.key(e.code, true, e);
   };
   const onKeyUp = (e) => {
     keys.delete(e.code);
+    releaseCrouch(e.code);
     if (typing(e)) return;
     o.hooks.key(e.code, false, e);
   };
   const onContext = (e) => e.preventDefault();
-  const onBlur = () => keys.clear();
+  const onBlur = () => {
+    keys.clear();
+    crouchPress = null;
+  };
   const onBeforeUnload = (e) => {
     if (!locked && !keys.has("ControlLeft") && !keys.has("ControlRight")) return;
     e.preventDefault();
@@ -2048,6 +2110,21 @@ function createPlayer(THREE, o) {
   window.addEventListener("blur", onBlur);
   window.addEventListener("beforeunload", onBeforeUnload);
   return {
+    get walkIntent() {
+      return walkKeys();
+    },
+    canStand(x, z) {
+      return !blocked(x, z);
+    },
+    setWalkHeld(held) {
+      walkHeld = held;
+    },
+    setBend(metres) {
+      bendTarget = metres;
+    },
+    setLookLimit(limit) {
+      lookLimit = limit;
+    },
     get yaw() {
       return yaw;
     },
@@ -2064,10 +2141,10 @@ function createPlayer(THREE, o) {
       return px.z;
     },
     get feet() {
-      return y;
+      return floorLevel + y;
     },
     get position() {
-      return [px.x, y, px.z];
+      return [px.x, floorLevel + y, px.z];
     },
     get speed() {
       return walked;
@@ -2076,49 +2153,43 @@ function createPlayer(THREE, o) {
       return running;
     },
     get crouching() {
-      return isCrouchHeld();
+      return isCrouched();
     },
     keys,
     update(dt) {
-      const crouched = isCrouchHeld();
+      if (crouchPress) crouchPress.held += dt;
+      const crouched = isCrouched();
       crouch += ((crouched ? 1 : 0) - crouch) * Math.min(1, dt * CROUCH_RATE);
       if (!crouched && crouch < 1e-3) crouch = 0;
-      const run = !crouched && (keys.has("ShiftLeft") || keys.has("ShiftRight"));
+      bend += (bendTarget - bend) * Math.min(1, dt * BEND_RATE);
+      const run = !crouched && !walkHeld && (keys.has("ShiftLeft") || keys.has("ShiftRight"));
       const fromX = px.x;
       const fromZ = px.z;
       const speed = crouched ? CROUCH_WALK : run ? RUN : WALK;
-      let f = 0;
-      let r = 0;
-      if (keys.has("KeyW") || keys.has("ArrowUp")) f += 1;
-      if (keys.has("KeyS") || keys.has("ArrowDown")) f -= 1;
-      if (keys.has("KeyD") || keys.has("ArrowRight")) r += 1;
-      if (keys.has("KeyA") || keys.has("ArrowLeft")) r -= 1;
-      if ((f || r || keys.has("Space")) && eye !== EYE) eye = EYE;
-      if (f || r) {
-        const len = Math.hypot(f, r);
-        const fx = -Math.sin(yaw);
-        const fz = -Math.cos(yaw);
-        const rx = Math.cos(yaw);
-        const rz = -Math.sin(yaw);
-        move((fx * f + rx * r) / len * speed * dt, (fz * f + rz * r) / len * speed * dt);
-      }
+      const [walkX, walkZ] = walkKeys();
+      if ((walkX || walkZ || keys.has("Space")) && eye !== EYE) eye = EYE;
+      if ((walkX || walkZ) && !walkHeld) move(walkX * speed * dt, walkZ * speed * dt);
       walked = dt > 0 ? Math.hypot(px.x - fromX, px.z - fromZ) / dt : 0;
       running = run && walked > 0;
-      if (y <= 0 && keys.has("Space")) vy = JUMP;
-      if (y > 0 || vy > 0) {
+      const floor = Math.max(floorHere(), o.footing?.(px.x, px.z, PLAYER_RADIUS * FOOT, y).floor ?? -Infinity);
+      if (y < floor && vy <= 0) y = floor;
+      if (y <= floor && keys.has("Space") && !walkHeld) vy = JUMP;
+      if (y > floor || vy > 0) {
         vy -= GRAVITY * dt;
         y += vy * dt;
-        if (y <= 0) {
-          y = 0;
+        if (y <= floor) {
+          y = floor;
           vy = 0;
         }
       }
+      followFloor(dt);
       apply();
     },
     setPose(position, yw, pt) {
       px.x = position[0];
       px.z = position[2];
-      eye = position[1];
+      floorLevel = floorHere();
+      eye = position[1] - floorLevel;
       y = 0;
       vy = 0;
       yaw = yw;
@@ -2128,7 +2199,8 @@ function createPlayer(THREE, o) {
     look(position, target) {
       px.x = position[0];
       px.z = position[2];
-      eye = position[1];
+      floorLevel = floorHere();
+      eye = position[1] - floorLevel;
       y = 0;
       vy = 0;
       const dx = target[0] - position[0];
@@ -2147,6 +2219,12 @@ function createPlayer(THREE, o) {
       move(dx, dz);
       apply();
     },
+    takeWish() {
+      const out = [wish.x, wish.z];
+      wish.x = 0;
+      wish.z = 0;
+      return out;
+    },
     walk(forward, right) {
       move(-Math.sin(yaw) * forward + Math.cos(yaw) * right, -Math.cos(yaw) * forward - Math.sin(yaw) * right);
       apply();
@@ -2168,6 +2246,204 @@ function createPlayer(THREE, o) {
   };
 }
 
+// src/furniture-push.ts
+import { createFurniturePush } from "@adatechnology/game-player";
+var PUSH_REACH = 1.1;
+var STANDOFF = 0.58;
+var LOW_TOP = 0.95;
+var LOW_STANDOFF = 0.42;
+var LOW_HAND_ON_TOP = 0.07;
+var LOW_EYE_OVER_TOP = 0.62;
+var MAX_BEND = 0.8;
+var STANDING_EYE = 1.7;
+var APPROACH_SPEED = 1.2;
+var MAX_BASE_HEIGHT = 0.12;
+var FLOOR_CLEARANCE = 0.06;
+var SWEEP_SKIN = 0.015;
+var HAND_SPREAD = 0.2;
+var HAND_TOP = 1.35;
+var HAND_UNDER_TOP = 0.05;
+var LOOK_RANGE = 0.9;
+var DRAG_GRAIN_METRES = 0.3;
+var RING_DELAY_S = 0.1;
+function contactOf(box2, player) {
+  const x = Math.max(box2.min[0] ?? 0, Math.min(box2.max[0] ?? 0, player.x));
+  const z = Math.max(box2.min[2] ?? 0, Math.min(box2.max[2] ?? 0, player.z));
+  const dx = x - player.x;
+  const dz = z - player.z;
+  const distance = Math.hypot(dx, dz);
+  if (distance < 1e-3) return { contact: [x, z], into: [-Math.sin(player.yaw), -Math.cos(player.yaw)], distance: 0 };
+  return { contact: [x, z], into: [dx / distance, dz / distance], distance };
+}
+function createRoomPush(options) {
+  const { THREE, player, world, arena, blockers } = options;
+  const control = createFurniturePush(options.rules);
+  const box3 = new THREE.Box3();
+  let leaning = null;
+  let scriptedWalk = null;
+  let dragged = 0;
+  const event = (type, lean) => options.onEvent({ type, objectId: lean.target.objectId, name: lean.target.name, massKg: lean.massKg });
+  const standsClear = (lean, dx, dz) => {
+    const minX = lean.min[0] + dx;
+    const maxX = lean.max[0] + dx;
+    const minZ = lean.min[2] + dz;
+    const maxZ = lean.max[2] + dz;
+    if (Math.max(Math.abs(minX), Math.abs(maxX)) > arena.limit || Math.max(Math.abs(minZ), Math.abs(maxZ)) > arena.limit) return false;
+    for (const c of arena.colliders) {
+      if (lean.max[0] > c[0] && lean.min[0] < c[2] && lean.max[2] > c[1] && lean.min[2] < c[3]) continue;
+      if (maxX > c[0] && minX < c[2] && maxZ > c[1] && minZ < c[3]) return false;
+    }
+    if (blockers.size === 0) return true;
+    const midX = (minX + maxX) / 2;
+    const midZ = (minZ + maxZ) / 2;
+    for (const [x, z] of [[minX, minZ], [maxX, minZ], [minX, maxZ], [maxX, maxZ], [midX, minZ], [midX, maxZ], [minX, midZ], [maxX, midZ]]) {
+      for (const isBlocked of blockers) if (isBlocked(x, z, 0)) return false;
+    }
+    return true;
+  };
+  const isFree = (lean, dx, dz) => {
+    if (!standsClear(lean, dx, dz) || !player.canStand(player.x + dx, player.z + dz)) return false;
+    const distance = Math.hypot(dx, dz);
+    const box2 = { min: [lean.min[0], lean.min[1] + FLOOR_CLEARANCE, lean.min[2]], max: [lean.max[0], lean.max[1], lean.max[2]] };
+    return world.sweepBox(box2, [dx / distance, 0, dz / distance], distance + SWEEP_SKIN, { ignore: lean.target.objectId }) === null;
+  };
+  const release = () => {
+    const lean = leaning;
+    if (!lean) return;
+    leaning = null;
+    if (lean.piece) {
+      lean.piece.held = false;
+      lean.piece.sleeping = false;
+      lean.piece.velocity = [0, 0, 0];
+    }
+    control.release();
+    player.setWalkHeld(false);
+    player.setBend(0);
+    player.setLookLimit(null);
+    options.ring(null);
+    event("release", lean);
+  };
+  const approach = (lean, dt) => {
+    const off = Math.hypot(lean.contact[0] - player.x, lean.contact[1] - player.z) - (lean.isLow ? LOW_STANDOFF : STANDOFF);
+    const move = Math.sign(off) * Math.min(Math.abs(off), APPROACH_SPEED * dt);
+    if (move !== 0) player.moveBy(lean.into[0] * move, lean.into[1] * move);
+  };
+  const moveWith = (lean, dx, dz) => {
+    lean.target.root.position.x += dx;
+    lean.target.root.position.z += dz;
+    lean.target.root.updateMatrixWorld(true);
+    player.moveBy(dx, dz);
+    lean.min[0] += dx;
+    lean.max[0] += dx;
+    lean.min[2] += dz;
+    lean.max[2] += dz;
+    lean.contact[0] += dx;
+    lean.contact[1] += dz;
+    dragged += Math.hypot(dx, dz);
+    if (dragged < DRAG_GRAIN_METRES) return;
+    dragged = 0;
+    options.dragSound(lean.target.objectId, [lean.contact[0], lean.min[1], lean.contact[1]], 0.3 + 0.5 * Math.min(1, lean.massKg / 100));
+  };
+  return {
+    get active() {
+      return leaning !== null;
+    },
+    get state() {
+      return leaning ? { objectId: leaning.target.objectId, phase: control.phase, progress: control.progress, block: control.block, massKg: leaning.massKg } : null;
+    },
+    get isBent() {
+      return leaning?.isLow ?? false;
+    },
+    get avatarState() {
+      return leaning && control.phase !== "idle" ? { phase: control.phase, progress: control.progress } : null;
+    },
+    begin() {
+      if (leaning) return true;
+      const target = options.pick();
+      if (!target || !world.has(target.objectId)) return false;
+      box3.setFromObject(target.root);
+      if (box3.min.y > player.feet + MAX_BASE_HEIGHT) return false;
+      const min = [box3.min.x, box3.min.y, box3.min.z];
+      const max = [box3.max.x, box3.max.y, box3.max.z];
+      const { contact, into, distance } = contactOf({ min, max }, player);
+      if (distance > PUSH_REACH) return false;
+      const massKg = options.massOf(target.objectId);
+      const material = options.materialOf(target.objectId);
+      const isLow = max[1] - player.feet < LOW_TOP;
+      const side = new THREE.Vector3(-into[1], 0, into[0]);
+      const way = new THREE.Vector3(into[0], 0, into[1]);
+      const up = new THREE.Vector3(0, 1, 0);
+      const basis = isLow ? new THREE.Matrix4().makeBasis(way, up, side) : new THREE.Matrix4().makeBasis(up, way.clone().negate(), side);
+      const palm = new THREE.Quaternion().setFromRotationMatrix(basis);
+      leaning = { target, massKg, piece: target.piece, min, max, contact, into, isLow, palm: [palm.x, palm.y, palm.z, palm.w] };
+      if (target.piece) target.piece.held = true;
+      control.begin(material === void 0 ? { massKg } : { massKg, material });
+      dragged = 0;
+      player.setWalkHeld(true);
+      if (isLow) player.setBend(Math.min(MAX_BEND, Math.max(0, STANDING_EYE - (max[1] - player.feet + LOW_EYE_OVER_TOP))));
+      player.setLookLimit({ yaw: Math.atan2(-into[0], -into[1]), range: LOOK_RANGE });
+      event("grip", leaning);
+      return true;
+    },
+    end() {
+      if (!leaning) return false;
+      const tap = control.isTap;
+      release();
+      return tap;
+    },
+    setWalk(walk) {
+      scriptedWalk = walk;
+    },
+    step(dt) {
+      const lean = leaning;
+      if (!lean) return;
+      if (!world.has(lean.target.objectId)) {
+        release();
+        return;
+      }
+      const gripping = control.phase === "grip";
+      if (gripping) approach(lean, dt);
+      const result = control.update(dt, { walk: scriptedWalk ?? player.walkIntent, isFree: (dx, dz) => isFree(lean, dx, dz) });
+      if (result.engaged) {
+        if (control.block !== "too_heavy") {
+          lean.piece ?? (lean.piece = options.makePiece(lean.target.objectId));
+          lean.piece.held = true;
+        }
+        event(control.block === "too_heavy" ? "too_heavy" : "engaged", lean);
+      }
+      if (result.hitObstacle) {
+        options.hitSound(lean.target.objectId, [lean.contact[0], lean.min[1] + 0.3, lean.contact[1]]);
+        event("obstacle", lean);
+      }
+      if (result.dx !== 0 || result.dz !== 0) moveWith(lean, result.dx, result.dz);
+      options.ring(control.phase === "grip" && control.heldSeconds >= RING_DELAY_S ? control.progress : null);
+    },
+    handTargets() {
+      const lean = leaning;
+      if (!lean) return null;
+      const strain = control.phase === "strain";
+      const y = lean.isLow ? lean.max[1] + 0.01 : Math.min(HAND_TOP, lean.max[1] - HAND_UNDER_TOP);
+      const shake = strain ? Math.sin(performance.now() * 0.045) * 6e-3 : 0;
+      const inset = lean.isLow ? -LOW_HAND_ON_TOP + shake : (strain ? 0.05 : 0.02) + shake;
+      const px = lean.contact[0] - lean.into[0] * inset;
+      const pz = lean.contact[1] - lean.into[1] * inset;
+      const sideX = -lean.into[1] * HAND_SPREAD;
+      const sideZ = lean.into[0] * HAND_SPREAD;
+      const grip = 0.05 + 0.2 * control.progress;
+      return {
+        R: { position: [px + sideX, y, pz + sideZ], quaternion: lean.palm },
+        L: { position: [px - sideX, y, pz - sideZ], quaternion: lean.palm },
+        grip,
+        gripL: grip
+      };
+    }
+  };
+}
+
+// src/room.ts
+import { createTerrain, createTerrainImpl, DEFAULT_PROFILE } from "@adatechnology/game-terrain";
+import { createTerrainRenderer } from "@adatechnology/game-terrain-three";
+
 // src/avatar.ts
 var DEFAULT_STRIKE_CLIPS = { hand: "punch_right", fists: "punch_right", shove: "shove_two_hands", kick: "front_kick" };
 var DEFAULT_HAND_STANCES = { fists: "fists" };
@@ -2349,6 +2625,8 @@ var en = {
     "act.strike.hand": "{weapon}: {clip} with the {hand} hand begins, impact in {seconds} s",
     "hand.left": "left",
     "hand.right": "right",
+    "act.combo.on": "{name}: on (each blow follows the sequence)",
+    "act.combo.off": "{name}: off",
     "act.flame.hit": "{weapon}: flame at {temp} \xB0C on {where}",
     "act.flame.air": "{weapon}: flame, nothing in range",
     "act.heat.hit": "{weapon}: heating {where} at {temp} \xB0C",
@@ -2372,8 +2650,10 @@ var en = {
     "act.extinguish.hit": "{weapon}: foam on {what}",
     "act.extinguish.air": "{weapon}: foam, nothing in range",
     "act.grab": "Grabbed {name} ({kg} kg)",
+    "act.bump": "Pushed {name} ({kg} kg) walking into it",
     "act.drop": "Dropped {name}",
     "act.throw": "Threw {name} at {speed} m/s",
+    "ground.name": "Ground",
     "act.landing": "{name} landed at {speed} m/s: {energy} J",
     "act.bench_failed": "{name} failed: {error}",
     "loading.working": "Working\u2026",
@@ -2407,6 +2687,14 @@ var en = {
     "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)",
+    "hud.push_on": "Pushing {name}: W pushes, S pulls, let go of E to stop",
+    "hud.push_too_heavy": "{name} does not budge ({kg} kg)",
+    "hud.push_blocked": "{name} is stuck: there is something in the way",
+    "act.push_grip": "leans on {name} ({kg} kg)",
+    "act.push_engaged": "starts pushing {name} ({kg} kg)",
+    "act.push_too_heavy": "strains against {name}: {kg} kg is too much",
+    "act.push_obstacle": "{name} hits something and locks",
+    "act.push_release": "lets go of {name}",
     "hud.empty_container": "{name} is empty",
     "hud.refused": "Wrong tool for the {kind}",
     "hud.drop": "drop",
@@ -2414,7 +2702,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 C: crouch \xB7 Space: jump \xB7 1-0 / wheel: tool \xB7 LMB: use (bare hands: punch) \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.help": "Click: look \xB7 WASD: walk \xB7 Shift: run \xB7 C: crouch (tap stays, hold while pressed) \xB7 Space: jump \xB7 1-0 / wheel: tool \xB7 LMB: use (bare hands: punch) \xB7 E: grab/drop (hold against furniture: push) \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 K: kick \xB7 N: strike combo on/off \xB7 Tab: panels \xB7 Esc: free the mouse",
     "ui.help.camera": "V: 1st/3rd person (Shift+V: kick)",
     "camera.first": "1st person",
     "camera.third": "3rd person",
@@ -2461,6 +2749,7 @@ var en = {
     "ui.slow": "Slow motion 0.25\xD7",
     "ui.fast": "Time \xD710",
     "ui.tap": "Tap",
+    "ui.kick": "Kick",
     "ui.fullscreen": "Full screen",
     "ui.fullscreen.hint": "Full screen opened from here keeps the whole keyboard in the game, Ctrl+W included (F11 does not)",
     "ui.blast.shelter": "Shelter",
@@ -2660,6 +2949,8 @@ var ptBR = {
     "act.strike.hand": "{weapon}: {clip} com a m\xE3o {hand} come\xE7a, impacto em {seconds} s",
     "hand.left": "esquerda",
     "hand.right": "direita",
+    "act.combo.on": "{name}: ligada (cada golpe segue a sequ\xEAncia)",
+    "act.combo.off": "{name}: desligada",
     "act.flame.hit": "{weapon}: chama a {temp} \xB0C em {where}",
     "act.flame.air": "{weapon}: chama, nada ao alcance",
     "act.heat.hit": "{weapon}: esquentando {where} a {temp} \xB0C",
@@ -2683,8 +2974,10 @@ var ptBR = {
     "act.extinguish.hit": "{weapon}: espuma em {what}",
     "act.extinguish.air": "{weapon}: espuma, nada ao alcance",
     "act.grab": "Pegou {name} ({kg} kg)",
+    "act.bump": "Empurrou {name} ({kg} kg) ao esbarrar",
     "act.drop": "Soltou {name}",
     "act.throw": "Arremessou {name} a {speed} m/s",
+    "ground.name": "Ch\xE3o",
     "act.landing": "{name} caiu a {speed} m/s: {energy} J",
     "act.bench_failed": "{name} falhou: {error}",
     "loading.working": "Trabalhando\u2026",
@@ -2718,6 +3011,14 @@ var ptBR = {
     "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)",
+    "hud.push_on": "Empurrando {name}: W empurra, S puxa, solte o E para parar",
+    "hud.push_too_heavy": "{name} n\xE3o se mexe ({kg} kg)",
+    "hud.push_blocked": "{name} travou: tem algo no caminho",
+    "act.push_grip": "encosta em {name} ({kg} kg)",
+    "act.push_engaged": "come\xE7a a empurrar {name} ({kg} kg)",
+    "act.push_too_heavy": "faz for\xE7a contra {name}: {kg} kg \xE9 demais",
+    "act.push_obstacle": "{name} bate em algo e trava",
+    "act.push_release": "solta {name}",
     "hud.empty_container": "{name} est\xE1 vazio",
     "hud.refused": "Ferramenta errada para {kind}",
     "hud.drop": "soltar",
@@ -2725,7 +3026,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 C: agachar \xB7 Espa\xE7o: pular \xB7 1-0 / roda: ferramenta \xB7 bot\xE3o esquerdo: usar (m\xE3o livre: soco) \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.help": "Clique: olhar \xB7 WASD: andar \xB7 Shift: correr \xB7 C: agachar (toque fixa, segurar s\xF3 enquanto aperta) \xB7 Espa\xE7o: pular \xB7 1-0 / roda: ferramenta \xB7 bot\xE3o esquerdo: usar (m\xE3o livre: soco) \xB7 E: pegar/soltar (segurar encostado no m\xF3vel: empurrar) \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 K: chute \xB7 N: liga/desliga a sequ\xEAncia de golpes \xB7 Tab: pain\xE9is \xB7 Esc: soltar o mouse",
     "ui.help.camera": "V: 1\xAA/3\xAA pessoa (Shift+V: chute)",
     "camera.first": "1\xAA pessoa",
     "camera.third": "3\xAA pessoa",
@@ -2772,6 +3073,7 @@ var ptBR = {
     "ui.slow": "C\xE2mera lenta 0,25\xD7",
     "ui.fast": "Tempo \xD710",
     "ui.tap": "Torneira",
+    "ui.kick": "Chute",
     "ui.fullscreen": "Tela cheia",
     "ui.fullscreen.hint": "A tela cheia aberta por aqui segura o teclado todo no jogo, inclusive Ctrl+W (o F11 n\xE3o)",
     "ui.blast.shelter": "Abrigo",
@@ -3238,6 +3540,8 @@ var CSS = `
 .tr-cross{position:absolute;left:50%;top:50%;width:18px;height:18px;margin:-9px 0 0 -9px}
 .tr-cross:before,.tr-cross:after{content:"";position:absolute;background:#fff;opacity:.85;box-shadow:0 0 2px #000}
 .tr-cross:before{left:8px;top:0;width:2px;height:18px}.tr-cross:after{top:8px;left:0;height:2px;width:18px}
+.tr-ring{position:absolute;left:50%;top:50%;width:64px;height:64px;margin:-32px 0 0 -32px;transform:rotate(-90deg);display:none;pointer-events:none;filter:drop-shadow(0 0 2px #000)}
+.tr-ring circle{fill:none;stroke-width:5}.tr-ring .tr-ring-bg{stroke:rgba(255,255,255,.25)}.tr-ring .tr-ring-fill{stroke:#ffd166;stroke-linecap:round}
 .tr-cross i{position:absolute;left:6px;top:6px;width:6px;height:6px;background:#0b0c0e;border-radius:50%;z-index:1}
 .tr-top{position:absolute;top:8px;left:50%;transform:translateX(-50%);text-align:center;max-width:46vw}
 .tr-tool{display:inline-block;background:rgba(10,12,16,.72);padding:4px 12px;border-radius:6px;font-size:14px;font-weight:600}
@@ -3341,6 +3645,22 @@ function createUi(o) {
   o.container.appendChild(root);
   const cross = mk3("div", "tr-cross");
   cross.appendChild(mk3("i"));
+  const ring = document.createElementNS("http://www.w3.org/2000/svg", "svg");
+  ring.setAttribute("class", "tr-ring");
+  ring.setAttribute("viewBox", "0 0 64 64");
+  const ringCircle = (className) => {
+    const circle = document.createElementNS("http://www.w3.org/2000/svg", "circle");
+    circle.setAttribute("class", className);
+    circle.setAttribute("cx", "32");
+    circle.setAttribute("cy", "32");
+    circle.setAttribute("r", "27");
+    ring.appendChild(circle);
+    return circle;
+  };
+  ringCircle("tr-ring-bg");
+  const ringFill = ringCircle("tr-ring-fill");
+  const RING_LENGTH = 2 * Math.PI * 27;
+  ringFill.style.strokeDasharray = String(RING_LENGTH);
   const top = mk3("div", "tr-top");
   const toolBox = mk3("div", "tr-tool");
   const status = mk3("div", "tr-status");
@@ -3542,6 +3862,8 @@ function createUi(o) {
     o.onFast(fast);
   });
   const tapBtn = ctl(t("ui.tap"), () => o.onTap());
+  const comboBtn = o.combo ? ctl(`${o.combo.label} (N)`, () => o.combo.onToggle()) : null;
+  if (o.kick) ctl(o.kick.label, () => o.kick.onKick());
   const fullscreenBtn = ctl(t("ui.fullscreen"), () => void toggleFullscreen());
   fullscreenBtn.title = t("ui.fullscreen.hint");
   const blastBtns = ["shelter", "fragmentHits", "confinement"].map((key) => ({ key, b: ctl(t(`ui.blast.${key}`), () => o.onBlast(key)) }));
@@ -3624,7 +3946,7 @@ function createUi(o) {
     o.onResize();
   };
   toggle.onclick = togglePanels;
-  root.append(cross, top, bottom, help, left, right, toggle);
+  root.append(cross, ring, top, bottom, help, left, right, toggle);
   const bar = (value, max, cls) => {
     const b = mk3("div", `tr-bar ${cls}`);
     const i = mk3("i");
@@ -3705,6 +4027,10 @@ function createUi(o) {
   let lastInspect = "";
   let hudPage = 0;
   const api = {
+    holdRing(value) {
+      ring.style.display = value === null ? "none" : "block";
+      if (value !== null) ringFill.style.strokeDashoffset = String(RING_LENGTH * (1 - value));
+    },
     hud(s) {
       toolBox.textContent = "";
       toolBox.append(document.createTextNode(s.toolName));
@@ -3753,6 +4079,7 @@ function createUi(o) {
       }
       slotsEl.forEach((b, i) => b.classList.toggle("on", i === s.slot));
       tapBtn.classList.toggle("on", s.tap);
+      comboBtn?.classList.toggle("on", !!s.combo);
       for (const { key: key2, b } of blastBtns) b.classList.toggle("on", s.blast[key2]);
       count.textContent = t("ui.objects", { n: s.objects });
       const ak = JSON.stringify(s.animations);
@@ -3802,6 +4129,18 @@ function createUi(o) {
 
 // src/room.ts
 var FIXED_DT = 1 / 60;
+var SOLID_SPAN = 3;
+var STEP_UP = 0.45;
+var BODY_HEIGHT = 1.75;
+var KICK_MASS = 6;
+var KICK_HEIGHT = 0.6;
+var GROUND_ID = "room_ground";
+var TERRAIN_CELL = 0.1;
+var TERRAIN_MAX_CELLS = 1e3;
+var GROUND_BURST_MAX = 28;
+var GROUND_BURST_PER_METRE = 30;
+var GROUND_DUST_RADIUS = 0.2;
+var GROUND_FIRE_EVERY = 0.3;
 var SHOVE_SPEED = 0.04;
 var METRICS_INTERVAL_S = 0.25;
 var CARRY_NEAR = 0.62;
@@ -3862,10 +4201,12 @@ function createTestRoom(options) {
   const ownWorld = !options.world;
   const world = options.world ?? createDestruction({ seed: 1, ...options.worldOptions, materials: [...options.worldOptions?.materials ?? []] });
   const pristineWorld = ownWorld ? world.serialize() : null;
-  const topOk = (t2) => {
-    const p = world.part(t2.id, t2.topPart);
-    return !!p && p.status !== "broken" && p.status !== "melted" && p.status !== "ashes";
+  const partStands = (object, part) => {
+    const p = world.part(object, part);
+    return !!p && p.status !== "broken" && p.status !== "melted" && p.status !== "ashes" && !renderer.piece(object);
   };
+  const topOk = (t2) => t2.boards ? t2.boards.some((b) => partStands(t2.id, b.part)) : partStands(t2.id, t2.topPart);
+  const topHolds = (t2, x, z) => t2.boards ? t2.boards.some((b) => x > b.minX && x < b.maxX && z > b.minZ && z < b.maxZ && partStands(t2.id, b.part)) : topOk(t2);
   const restingTops = [];
   const restingTopAt = (x, z) => {
     let top = 0;
@@ -3874,10 +4215,18 @@ function createTestRoom(options) {
   };
   const sceneryTopAt = (x, z) => {
     let top = 0;
-    for (const t2 of arena.tops) if (t2.top > top && x > t2.minX && x < t2.maxX && z > t2.minZ && z < t2.maxZ && topOk(t2)) top = t2.top;
+    for (const t2 of arena.tops) if (t2.top > top && x > t2.minX && x < t2.maxX && z > t2.minZ && z < t2.maxZ && topHolds(t2, x, z)) top = t2.top;
     return top;
   };
-  const groundAt = (x, z) => Math.max(sceneryTopAt(x, z), restingTopAt(x, z));
+  const defaultGround = options.ground ?? { surface: DEFAULT_PROFILE };
+  const terrain = createTerrain({ bounds: [-arenaSize, -arenaSize, arenaSize, arenaSize], cellSize: Math.max(TERRAIN_CELL, 2 * arenaSize / TERRAIN_MAX_CELLS), layout: defaultGround, ...options.terrainBudget ? { budget: options.terrainBudget } : {} });
+  const terrainView = createTerrainRenderer(THREE, { terrain });
+  arena.group.add(terrainView.group);
+  const groundAt = (x, z) => {
+    const top = Math.max(sceneryTopAt(x, z), restingTopAt(x, z));
+    const floor = terrain.heightAt(x, z);
+    return top > 0 ? Math.max(top, floor) : floor;
+  };
   const ownFluids = !options.fluids;
   const fluids = options.fluids ?? createFluids({ seed: 1, locale, liquids: options.liquids, groundAt });
   const pristineFluids = ownFluids ? fluids.serialize() : null;
@@ -3898,13 +4247,6 @@ function createTestRoom(options) {
     destructionSound?.onSound(key, point, volume);
     options.onSound?.(key, point, volume);
   };
-  const craterField = options.craters ? createGroundField() : void 0;
-  const craterPatch = craterField ? createGroundPatch(THREE, { field: craterField, material: new THREE.MeshStandardMaterial({ color: 9342602, roughness: 0.95 }) }) : void 0;
-  if (craterPatch) {
-    const floor = arena.group.getObjectByName("floor");
-    if (floor) floor.visible = false;
-    scene.add(craterPatch.mesh);
-  }
   const vfx = createVfxRenderer(THREE, {
     scene,
     camera,
@@ -3913,8 +4255,7 @@ function createTestRoom(options) {
     pointScale,
     vfx: createVfx({
       profile: quality,
-      groundAt: (x, z) => groundAt(x, z) + (craterField?.heightAt(x, z) ?? 0),
-      ...craterField ? { ground: craterField } : {}
+      groundAt
     })
   });
   const renderer = createDestructionRenderer(THREE, {
@@ -3935,6 +4276,7 @@ function createTestRoom(options) {
       const e = entries.get(objectId);
       if (!e) return;
       e.piece = piece;
+      leaveFootprint(objectId);
       rendererPieces.set(objectId, piece);
       action("loosened", t("act.loosened", { name: e.name }), { objectId, itemId: e.so.itemId });
     },
@@ -3959,6 +4301,31 @@ function createTestRoom(options) {
       if (best) splitOf.set(piece.objectId, best);
     }
   });
+  const showGroundBlow = (result) => {
+    const material = terrain.material(result.removed[0]?.material ?? result.exposed);
+    const def = world.materials.get(material.id);
+    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));
+  };
+  terrain.onDeform((region) => renderer.wakeRegion(region.x, region.z, region.radius));
+  const groundImpl = createTerrainImpl(terrain, { id: GROUND_ID, name: t("ground.name"), onBlow: showGroundBlow });
+  const registerGround = () => {
+    if (!world.has(GROUND_ID)) world.register(groundImpl, { id: GROUND_ID });
+  };
+  registerGround();
+  let groundFireClock = 0;
+  const showGroundFire = (dt) => {
+    groundFireClock += dt;
+    if (groundFireClock < GROUND_FIRE_EVERY) return;
+    groundFireClock = 0;
+    for (const [x, z] of terrain.burningPoints()) {
+      const y = terrain.heightAt(x, z);
+      renderer.emit("fire", [x, y + 0.05, z], [0, 1, 0], 3, 1.6);
+      if (rnd() < 0.25) renderer.emit("smoke", [x, y + 0.2, z], [0, 1, 0], 1, 1);
+    }
+  };
   const fluidView = createFluidRenderer(THREE, { scene, fluids, quality, pointScale, vfx: vfx.world });
   const filmRandom = createFilmLcg(1);
   const film = createFilmManager(THREE, {
@@ -4093,12 +4460,79 @@ function createTestRoom(options) {
   let useHeld = false;
   let useFirst = false;
   const blockers = /* @__PURE__ */ new Set();
+  const drawnScenery = (i) => {
+    const c = arena.colliders[i];
+    return arena.colliderIds[i] !== null && c[2] - c[0] <= SOLID_SPAN && c[3] - c[1] <= SOLID_SPAN;
+  };
+  const standingColliders = [];
+  const standingIds = [];
+  const footprintsWithBody = /* @__PURE__ */ new Set();
+  const standFootprints = () => {
+    standingColliders.length = 0;
+    standingIds.length = 0;
+    footprintsWithBody.clear();
+    arena.colliders.forEach((collider, i) => {
+      if (drawnScenery(i)) return;
+      standingColliders.push(collider);
+      standingIds.push(arena.colliderIds[i] ?? null);
+    });
+  };
+  standFootprints();
+  const leaveFootprint = (objectId) => {
+    const i = standingIds.indexOf(objectId);
+    if (i < 0) return;
+    standingIds.splice(i, 1);
+    standingColliders.splice(i, 1);
+    footprintsWithBody.add(objectId);
+  };
+  const footing = (x, z, radius, feet) => {
+    let floor = -Infinity;
+    let blocked = false;
+    for (const s of renderer.solidsNear(x, z, radius)) {
+      if ((s.piece?.mass ?? s.loose?.mass ?? Infinity) < KICK_MASS) continue;
+      const dx = Math.max(s.min[0] - x, 0, x - s.max[0]);
+      const dz = Math.max(s.min[2] - z, 0, z - s.max[2]);
+      if (dx * dx + dz * dz > radius * radius) continue;
+      if (s.max[1] <= feet + STEP_UP) floor = Math.max(floor, s.max[1]);
+      else if (s.min[1] < feet + BODY_HEIGHT) blocked = true;
+    }
+    return { floor, blocked };
+  };
+  const kickFrom = { x: 0, z: 0 };
+  const kickLight = (dt) => {
+    const x = player.x;
+    const z = player.z;
+    const speed = dt > 0 ? Math.hypot(x - kickFrom.x, z - kickFrom.z) / dt : 0;
+    kickFrom.x = x;
+    kickFrom.z = z;
+    if (speed < 0.2 || speed > 20) return;
+    const kicked = /* @__PURE__ */ new Set();
+    for (const s of renderer.solidsNear(x, z, PLAYER_RADIUS)) {
+      const pc = s.piece;
+      const body = pc ?? s.loose;
+      if (!body || body.mass >= KICK_MASS || kicked.has(body) || s.min[1] > player.feet + KICK_HEIGHT) continue;
+      kicked.add(body);
+      const cx = (s.min[0] + s.max[0]) / 2 - x;
+      const cz = (s.min[2] + s.max[2]) / 2 - z;
+      const d = Math.hypot(cx, cz) || 1;
+      const v = speed * 1.2;
+      if (!pc) {
+        s.loose?.push(cx / d * v, cz / d * v);
+        continue;
+      }
+      if (pc.velocity[0] * cx + pc.velocity[2] * cz >= v * d) continue;
+      pc.velocity = [cx / d * v, Math.max(pc.velocity[1], 0.6), cz / d * v];
+      pc.sleeping = false;
+    }
+  };
   const player = createPlayer(THREE, {
     camera,
     dom,
-    colliders: arena.colliders,
+    colliders: standingColliders,
+    footing: (x, z, radius, feet) => footing(x, z, radius, feet),
     blockers,
     limit: arenaSize,
+    floorAt: terrain.heightAt,
     start: arena.playerStart,
     crouchKeys: options.crouch?.keys,
     hooks: {
@@ -4122,6 +4556,68 @@ function createTestRoom(options) {
   let counter = 0;
   let slot = 0;
   const maxCarry = options.maxCarryKg ?? 60;
+  const PUSH_AHEAD = 0.6;
+  const heaviestMaterial = (id) => {
+    let best;
+    for (const p of world.state(id)?.parts ?? []) if (p.status !== "broken" && (!best || p.mass > best.mass)) best = { mass: p.mass, material: p.material };
+    return best?.material;
+  };
+  const leanedOn = () => {
+    const fx = -Math.sin(player.yaw);
+    const fz = -Math.cos(player.yaw);
+    let best = null;
+    let bestDistance = PUSH_REACH;
+    for (const e of entries.values()) {
+      if (e.arena || !e.piece && !e.free) continue;
+      const b = bodyBox(e);
+      if (!b) continue;
+      const dx = Math.max(b.minX, Math.min(b.maxX, player.x)) - player.x;
+      const dz = Math.max(b.minZ, Math.min(b.maxZ, player.z)) - player.z;
+      const distance = Math.hypot(dx, dz);
+      if (distance >= bestDistance || distance > 1e-3 && (dx * fx + dz * fz) / distance < PUSH_AHEAD) continue;
+      best = e;
+      bestDistance = distance;
+    }
+    return best ? { objectId: best.so.objectId, root: best.so.root, name: nameOf(best.so.objectId), piece: best.piece ?? null } : null;
+  };
+  const push = createRoomPush({
+    THREE,
+    player,
+    world,
+    arena: { limit: arenaSize, colliders: standingColliders },
+    blockers,
+    ...options.push ? { rules: options.push } : {},
+    pick: () => {
+      if (heldPiece || tool.def.category !== "hand" && toolId !== "fists") return null;
+      aim();
+      const r = rayWorld([aimO[0], aimO[1], aimO[2]], [aimD[0], aimD[1], aimD[2]], 3.2);
+      const aimed = r ? rendererPieces.get(r.object)?.root ?? (entries.get(r.object)?.free ? entries.get(r.object)?.so.root : void 0) : void 0;
+      if (r && aimed) return { objectId: r.object, root: aimed, name: nameOf(r.object), piece: rendererPieces.get(r.object) ?? null };
+      return leanedOn();
+    },
+    massOf: (objectId) => massOfObject(objectId),
+    materialOf: heaviestMaterial,
+    makePiece: (objectId) => {
+      const piece = renderer.makePiece(objectId, { mass: Math.max(0.2, massOfObject(objectId)) });
+      const e = entries.get(objectId);
+      if (e) e.piece = piece;
+      rendererPieces.set(objectId, piece);
+      leaveFootprint(objectId);
+      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),
+    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 } });
+      fire("push", ev);
+      if (ev.type === "engaged") say(t("hud.push_on", vars));
+      else if (ev.type === "too_heavy") say(t("hud.push_too_heavy", vars));
+      else if (ev.type === "obstacle") say(t("hud.push_blocked", vars));
+    },
+    ring: (value) => ui?.holdRing(value)
+  });
+  let pushByKey = false;
   const massOfObject = (id) => {
     const st = world.state(id);
     let m = 0;
@@ -4189,6 +4685,45 @@ function createTestRoom(options) {
     Object.defineProperty(holder, "visible", { get: () => built.visible, set: (v) => void (built.visible = v), configurable: true });
     return holder;
   };
+  const sceneryObjects = /* @__PURE__ */ new Map();
+  const placeScenery = (objectId, item, position, rotationY) => {
+    const root = buildRoot(item);
+    root.position.set(position[0], position[1], position[2]);
+    root.rotation.y = rotationY;
+    root.name = item.id;
+    scene.add(root);
+    root.updateMatrixWorld(true);
+    const own = item.impl?.(root, objectId);
+    const { spec, parts } = own ? { spec: structuredCloneSpec(own.describe()), parts: void 0 } : resolveSpec(item, root);
+    root.updateMatrixWorld(true);
+    const q = root.getWorldQuaternion(tmpQ);
+    if (own) world.register(own, { id: objectId, position, rotation: [q.x, q.y, q.z, q.w] });
+    else world.add(spec, { id: objectId, position, rotation: [q.x, q.y, q.z, q.w] });
+    const e = registerEntry(objectId, item.id, root, spec, item.name, parts, item, true, false);
+    fire("spawn", e.so);
+    return e;
+  };
+  const restoreScenery = () => {
+    for (const [objectId, o] of sceneryObjects) if (!entries.has(objectId)) placeScenery(objectId, o.item, o.position, o.rotationY);
+  };
+  const addScenery = (itemId, position, rotationY = 0) => {
+    const item = catalogMap.get(itemId);
+    if (!item) return null;
+    const objectId = `${item.id}_scenery_${sceneryObjects.size + 1}`;
+    sceneryObjects.set(objectId, { item, position: [position[0], position[1], position[2]], rotationY });
+    const e = placeScenery(objectId, item, position, rotationY);
+    action("spawn", t("act.spawn", { name: item.name, x: num(position[0], 1), z: num(position[2], 1) }), { objectId, itemId: item.id, data: { position, movable: false, scenery: true } });
+    return {
+      objectId,
+      get root() {
+        return entries.get(objectId)?.so.root ?? e.so.root;
+      },
+      remove() {
+        sceneryObjects.delete(objectId);
+        removeEntry(objectId);
+      }
+    };
+  };
   const spawn = (itemId, position, rotationY) => {
     const item = catalogMap.get(itemId);
     if (!item) throw new Error(`game-test-room: unknown item "${itemId}"`);
@@ -4240,6 +4775,77 @@ function createTestRoom(options) {
     fire("spawn", e.so);
     return e.so;
   };
+  const STEP_OVER = STEP_UP;
+  const HEADROOM = 1.9;
+  const PUSH_WALK_N = 250;
+  const PUSH_RUN_N = 450;
+  const FLOOR_FRICTION = 0.5;
+  const bodyBoxes = /* @__PURE__ */ new Map();
+  const bodyBounds = new THREE.Box3();
+  let frameStamp = 0;
+  const bodyBox = (e) => {
+    const id = e.so.objectId;
+    const known = bodyBoxes.get(id);
+    if (known && (known.stamp === frameStamp || !e.piece || e.piece.sleeping)) return known;
+    if (!e.so.root.parent || world.state(id)?.destroyed) {
+      bodyBoxes.delete(id);
+      return null;
+    }
+    bodyBounds.setFromObject(e.so.root);
+    if (bodyBounds.isEmpty()) return null;
+    const box2 = { minX: bodyBounds.min.x, maxX: bodyBounds.max.x, minZ: bodyBounds.min.z, maxZ: bodyBounds.max.z, base: bodyBounds.min.y, top: bodyBounds.max.y, stamp: frameStamp };
+    bodyBoxes.set(id, box2);
+    return box2;
+  };
+  const footPos = new THREE.Vector3();
+  const inTheWay = (e, x, z, r) => {
+    if (e.arena && !footprintsWithBody.has(e.so.objectId) || e.piece && e.piece.held) return null;
+    const ud = e.so.root.userData;
+    if ("collider" in ud && !ud.collider?.kind) return null;
+    const b = bodyBox(e);
+    if (!b || b.base > player.feet + HEADROOM) return null;
+    const c = ud.collider;
+    if (c?.kind === "cylinder" && c.radius != null) {
+      e.so.root.getWorldPosition(footPos);
+      const reach = c.radius + r;
+      return (x - footPos.x) ** 2 + (z - footPos.z) ** 2 < reach * reach ? { ...b, top: Math.min(b.top, footPos.y + (c.height ?? b.top - footPos.y)) } : null;
+    }
+    return x > b.minX - r && x < b.maxX + r && z > b.minZ - r && z < b.maxZ + r ? b : null;
+  };
+  blockers.add((x, z, r) => {
+    for (const e of entries.values()) {
+      const b = inTheWay(e, x, z, r);
+      if (b && b.top - b.base >= STEP_OVER) return true;
+    }
+    return false;
+  });
+  const pushByPlayer = (dt) => {
+    const [wx, wz] = player.takeWish();
+    const len = Math.hypot(wx, wz);
+    if (dt <= 0 || len < 1e-6) return;
+    const dx = wx / len;
+    const dz = wz / len;
+    const speed = len / dt;
+    const force = player.running ? PUSH_RUN_N : PUSH_WALK_N;
+    const ax = player.x + dx * (Math.min(len, 0.5) + 0.03);
+    const az = player.z + dz * (Math.min(len, 0.5) + 0.03);
+    for (const e of entries.values()) {
+      const piece = e.piece;
+      if (!piece) continue;
+      const b = inTheWay(e, ax, az, PLAYER_RADIUS);
+      if (!b) continue;
+      const grip = FLOOR_FRICTION * piece.mass * 9.81;
+      if (force <= grip) continue;
+      const along = piece.velocity[0] * dx + piece.velocity[2] * dz;
+      const impulse = Math.min(piece.mass * Math.max(0, speed - along), (force - grip) * dt);
+      if (impulse <= 1e-4) continue;
+      const y = (b.base + Math.max(b.base, Math.min(b.top, player.feet + 1.4))) / 2;
+      const point = [Math.max(b.minX, Math.min(b.maxX, player.x)), y, Math.max(b.minZ, Math.min(b.maxZ, player.z))];
+      piece.sleeping = false;
+      renderer.impulse(e.so.objectId, [dx * impulse, 0, dz * impulse], point);
+      log.coalesce(`bump:${e.so.objectId}`, { channel: "action", type: "bump", text: t("act.bump", { name: e.name, kg: num(piece.mass, 1) }), objectId: e.so.objectId, itemId: e.so.itemId, data: { massKg: Math.round(piece.mass * 10) / 10, pushN: force } }, 1);
+    }
+  };
   const massGuess = (spec) => {
     let m = 0;
     for (const p of spec.parts) {
@@ -4292,6 +4898,7 @@ function createTestRoom(options) {
     explosives.clear();
     fireZones.length = 0;
     burningStains.length = 0;
+    terrain.setLayout(defaultGround);
     for (const id of [...entries.keys()]) if (!entries.get(id)?.arena) removeEntry(id);
     clearLoose();
     for (const e of entries.values()) {
@@ -4329,6 +4936,8 @@ function createTestRoom(options) {
     action("reset", t("act.reset"));
   };
   const hardReset = () => {
+    pushByKey = false;
+    push.end();
     clearEverything();
     for (const id of [...entries.keys()]) removeEntry(id);
     tools.clear();
@@ -4336,6 +4945,7 @@ function createTestRoom(options) {
     if (pristineWorld) {
       for (const id of world.ids()) world.remove(id);
       world.load(pristineWorld);
+      registerGround();
     }
     if (pristineFluids) {
       fluids.load(pristineFluids);
@@ -4349,6 +4959,7 @@ function createTestRoom(options) {
     prevVy.clear();
     lastImpact.clear();
     addArena();
+    standFootprints();
     timeScale = 1;
     fastForward = false;
     walkPlan = null;
@@ -4413,10 +5024,11 @@ function createTestRoom(options) {
     }
     feetPrev = [x, z];
     avatarState.running = !player.crouching && (player.keys.has("ShiftLeft") || player.keys.has("ShiftRight"));
-    avatarState.crouch = crouchForced || player.crouching;
+    avatarState.crouch = crouchForced || player.crouching || push.isBent;
     avatarState.armed = armedForced ?? tool.def.action.kind === "firearm";
     avatarState.pitch = player.pitch;
     avatarState.holding = heldPiece !== null;
+    avatarState.push = push.avatarState;
     avatarState.itemUse = useItemPlayer ? { id: useItemName, ...useItemPlayer.pose() } : heldPiece && heldTilt > 0.01 ? { id: "tilt", position: [0.2, -0.1, -0.38], rotation: [-heldTilt, 0, 0] } : null;
     avatar.root.position.set(x, player.feet, z);
     avatar.root.rotation.set(0, player.yaw + Math.PI, 0);
@@ -4432,11 +5044,11 @@ function createTestRoom(options) {
   const stepFirstPerson = (dt) => {
     const arms = avatar?.firstPerson;
     if (!arms) return;
-    const targets = handSource?.() ?? carriedHand;
+    const targets = push.handTargets() ?? handSource?.() ?? carriedHand;
     const state = {
       camera,
       targets,
-      stance: handStances[toolId] ?? (targets ? "hold" : "relaxed"),
+      stance: push.active ? "hold" : handStances[toolId] ?? (targets ? "hold" : "relaxed"),
       speed: avatarState.speed,
       running: avatarState.running,
       crouch: avatarState.crouch,
@@ -4457,6 +5069,19 @@ function createTestRoom(options) {
       camera.updateMatrixWorld(true);
     };
   };
+  const KICK_HIP = 0.9;
+  const KICK_DROP = 0.35;
+  const legAim = () => {
+    aim();
+    const low = aimO[1] < player.feet + KICK_HIP;
+    const pitch = Math.max(-0.9, Math.min(0.1, player.pitch - (low ? 0 : KICK_DROP)));
+    aimO[0] = player.x;
+    aimO[1] = Math.min(player.feet + KICK_HIP, aimO[1]);
+    aimO[2] = player.z;
+    aimD[0] = -Math.sin(player.yaw) * Math.cos(pitch);
+    aimD[1] = Math.sin(pitch);
+    aimD[2] = -Math.cos(player.yaw) * Math.cos(pitch);
+  };
   const aim = () => {
     camera.updateMatrixWorld(true);
     camera.getWorldPosition(tmpV);
@@ -4623,17 +5248,51 @@ function createTestRoom(options) {
     if (!rendererPieces.has(objectId)) return;
     renderer.impulse(objectId, [dir[0] * momentum, dir[1] * momentum, dir[2] * momentum], point);
   };
+  const shotRay = new THREE.Raycaster();
+  const LIQUID_SLOWING = 0.25;
+  const SHOT_GRIP = 0.3;
+  const shotPush = (s, objectId, results, fallback) => {
+    const e = entries.get(objectId);
+    const speed = Math.max(80, s.speed);
+    const onIt = results.filter((r) => r.object === objectId);
+    const last = onIt[onIt.length - 1];
+    let kept = last && last.penetrated ? Math.sqrt(Math.max(0, Math.min(1, last.exitEnergy / Math.max(s.energy, 1e-6)))) : 0;
+    let point = fallback;
+    let inward = [s.direction[0], s.direction[1], s.direction[2]];
+    if (e) {
+      shotRay.set(new THREE.Vector3(...s.origin), new THREE.Vector3(...s.direction).normalize());
+      shotRay.far = 60;
+      shotRay.camera = camera;
+      const hit = shotRay.intersectObject(e.so.root, true).find((h) => h.object.isMesh && !h.object.userData.destructionDebris && h.face);
+      if (hit?.face) {
+        point = [hit.point.x, hit.point.y, hit.point.z];
+        const n = hit.face.normal.clone().transformDirection(hit.object.matrixWorld);
+        if (n.x * s.direction[0] + n.y * s.direction[1] + n.z * s.direction[2] > 0) n.negate();
+        inward = [-n.x, -n.y, -n.z];
+      }
+      const c = kept > 0 && e.containerId ? fluids.container(e.containerId) : null;
+      if (c && c.liters > 1e-4) {
+        const size = new THREE.Box3().setFromObject(e.so.root).getSize(new THREE.Vector3());
+        kept *= Math.exp(-(Math.min(size.x, size.z) * 0.9) / LIQUID_SLOWING);
+      }
+    }
+    const momentum = 2 * s.energy / speed * (1 - kept);
+    const along = s.direction[0] * inward[0] + s.direction[1] * inward[1] + s.direction[2] * inward[2];
+    const impulse = [0, 1, 2].map((k) => momentum * (along * inward[k] + SHOT_GRIP * (s.direction[k] - along * inward[k])));
+    return { impulse, point };
+  };
   const shoveFree = (pushes) => {
-    for (const [objectId, push] of pushes) {
+    for (const [objectId, push2] of pushes) {
       const e = entries.get(objectId);
       if (!e || e.piece || !e.free) continue;
       const mass = Math.max(0.2, massOfObject(objectId));
-      if (Math.hypot(...push.impulse) / mass < SHOVE_SPEED) continue;
+      if (Math.hypot(...push2.impulse) / mass < SHOVE_SPEED) continue;
       const piece = renderer.makePiece(objectId, { mass });
       e.piece = piece;
       rendererPieces.set(objectId, piece);
+      leaveFootprint(objectId);
       action("loosened", t("act.shoved", { name: e.name }), { objectId, itemId: e.so.itemId });
-      renderer.impulse(objectId, push.impulse, push.point);
+      renderer.impulse(objectId, push2.impulse, push2.point);
     }
   };
   const fireShots = (shots, recoil) => {
@@ -4656,12 +5315,11 @@ function createTestRoom(options) {
           hits++;
           end = r0.point;
           if (!first) first = { object: r0.object, part: r0.part, point: r0.point, normal: [0, 1, 0], distance: dist3(s.origin, r0.point) };
-          const speed = Math.max(80, s.speed);
-          const momentum = 2 * s.energy / speed;
-          pushPiece(r0.object, s.direction, momentum, r0.point);
-          const push = pushes.get(r0.object) ?? { impulse: [0, 0, 0], point: r0.point };
-          for (let k = 0; k < 3; k++) push.impulse[k] += s.direction[k] * momentum;
-          pushes.set(r0.object, push);
+          const blow = shotPush(s, r0.object, results, r0.point);
+          if (rendererPieces.has(r0.object)) renderer.impulse(r0.object, blow.impulse, blow.point);
+          const push2 = pushes.get(r0.object) ?? { impulse: [0, 0, 0], point: blow.point };
+          for (let k = 0; k < 3; k++) push2.impulse[k] += blow.impulse[k];
+          pushes.set(r0.object, push2);
         }
         if (shots.length <= 3 || rnd() < 0.34) tracer(m, end);
       }
@@ -4739,8 +5397,22 @@ function createTestRoom(options) {
       1
     );
   };
-  const meleeUse = (u, id = toolId) => {
+  const kickHeights = options.kickHeights ?? [0.25, 0.35, 0.45, 0.55, 0.65, 0.75, 0.85];
+  const footRay = (u) => {
+    const flat = Math.hypot(u.direction[0], u.direction[2]);
+    const direction = flat > 1e-6 ? [u.direction[0] / flat, 0, u.direction[2] / flat] : [-Math.sin(player.yaw), 0, -Math.cos(player.yaw)];
+    const feet = player.position;
+    let best = null;
+    for (const height2 of kickHeights) {
+      const origin = [feet[0], feet[1] + height2, feet[2]];
+      const hit = rayWorld(origin, direction, u.reach);
+      if (hit && (!best || hit.distance < best.distance)) best = { origin, distance: hit.distance };
+    }
+    return best ? { ...u, origin: best.origin, direction } : u;
+  };
+  const meleeUse = (use, id = toolId) => {
     const w = toolName(id);
+    const u = id === "kick" ? footRay(use) : use;
     const r = rayWorld(u.origin, u.direction, u.reach);
     if (!r) {
       action("melee", t("act.melee.miss", { weapon: w }), { data: { weapon: id } });
@@ -4761,27 +5433,49 @@ function createTestRoom(options) {
   const punchHand = options.punchHand ?? "alternate";
   const punchTools = new Set(options.punchTools ?? ["hand", "fists"]);
   let nextHand = "right";
+  const combo = options.strikeCombo;
+  let comboOn = !!combo && options.strikeComboOn === true;
+  let comboNext = 0;
+  let comboAt = -Infinity;
+  const setStrikeCombo = (on) => {
+    if (!combo || on === comboOn) return;
+    comboOn = on;
+    comboNext = 0;
+    const name = combo.name?.[locale] ?? combo.id;
+    action("combo", t(on ? "act.combo.on" : "act.combo.off", { name }), { data: { combo: combo.id, on } });
+    say(t(on ? "act.combo.on" : "act.combo.off", { name }));
+  };
   const strikeUse = (u, id = toolId) => {
-    const clip = strikeClips[id];
+    const stepIndex = comboOn && combo?.tools.includes(id) && combo.steps.length > 0 ? simTime - comboAt > combo.reset ? 0 : comboNext : null;
+    const step2 = stepIndex === null ? void 0 : combo.steps[stepIndex];
+    const clip = step2 ? step2.clip : strikeClips[id];
     const leg = id === "kick" ? kickLeg === "alternate" ? nextLeg : kickLeg : void 0;
-    const hand = punchTools.has(id) ? punchHand === "alternate" ? nextHand : punchHand : void 0;
+    const hand = step2 ? step2.hand : punchTools.has(id) ? punchHand === "alternate" ? nextHand : punchHand : void 0;
     const side = leg ? { leg } : hand ? { hand } : void 0;
     const seconds = clip === void 0 ? null : avatar?.strike?.(clip, side) ?? null;
     if (leg && seconds !== null && kickLeg === "alternate") nextLeg = leg === "right" ? "left" : "right";
-    if (hand && seconds !== null && punchHand === "alternate") nextHand = hand === "right" ? "left" : "right";
+    if (!step2 && hand && seconds !== null && punchHand === "alternate") nextHand = hand === "right" ? "left" : "right";
+    if (step2 && stepIndex !== null) {
+      comboNext = (stepIndex + 1) % combo.steps.length;
+      comboAt = simTime;
+    }
     if (clip === void 0 || seconds === null) {
-      meleeUse(u, id);
+      if (leg) {
+        legAim();
+        meleeUse({ ...u, origin: [aimO[0], aimO[1], aimO[2]], direction: [aimD[0], aimD[1], aimD[2]] }, id);
+      } else meleeUse(u, id);
       return;
     }
     const text = leg ? "act.strike.leg" : hand ? "act.strike.hand" : "act.strike";
     action("strike", t(text, { weapon: toolName(id), clip, seconds: num(seconds, 2), leg: leg ? t(`leg.${leg}`) : "", hand: hand ? t(`hand.${hand}`) : "" }), {
-      data: { weapon: id, clip, impactIn: seconds, ...leg ? { leg } : {}, ...hand ? { hand } : {} }
+      data: { weapon: id, clip, impactIn: seconds, ...leg ? { leg } : {}, ...hand ? { hand } : {}, ...step2 ? { combo: combo.id, step: stepIndex } : {} }
     });
     strikes.push({
       key: id,
       remaining: seconds,
       land: () => {
-        aim();
+        if (leg) legAim();
+        else aim();
         meleeUse({ ...u, origin: [aimO[0], aimO[1], aimO[2]], direction: [aimD[0], aimD[1], aimD[2]] }, id);
       }
     });
@@ -4967,12 +5661,14 @@ function createTestRoom(options) {
     if (res) applyUses(res, 0);
   };
   const kick = () => {
-    if (!arsenal.weapons.has("kick") || strikes.some((strike) => strike.key === "kick")) return;
+    if (!arsenal.weapons.has("kick") || strikes.some((strike) => strike.key === "kick")) return false;
     aim();
     const res = toolState("kick").trigger([aimO[0], aimO[1], aimO[2]], [aimD[0], aimD[1], aimD[2]], 0, false, "player");
-    if (res.status !== "ok") return;
+    if (res.status !== "ok") return false;
     for (const u of res.uses) if (u.kind === "melee") strikeUse(u, "kick");
+    return true;
   };
+  const kickKeys = options.kick?.keys ?? ["KeyK"];
   const setTool = (id) => {
     if (!arsenal.weapons.has(id)) throw new Error(`game-test-room: unknown weapon "${id}"`);
     releaseTrigger();
@@ -5020,6 +5716,7 @@ function createTestRoom(options) {
     else useTool(FIXED_DT, false);
   };
   const grab = () => {
+    if (push.active) return false;
     if (heldPiece) {
       const name = heldName;
       releaseHeld();
@@ -5235,7 +5932,7 @@ function createTestRoom(options) {
       const reach = Math.max(size.x, size.y, size.z) * 0.5;
       const origin = [centre.x + dir[0] * (reach + 0.02), centre.y + dir[1] * (reach + 0.02), centre.z + dir[2] * (reach + 0.02)];
       const r = withoutHeld(() => world.raycast(origin, dir, speed * FIXED_DT * 2 + 0.06));
-      if (!r || r.object === piece.objectId) return;
+      if (!r || r.object === piece.objectId || r.object === GROUND_ID) return;
       const energy = 0.5 * piece.mass * speed * speed;
       lastImpact.set(piece.objectId, simTime);
       world.hitPart(r.object, r.part, { type: "blunt", point: r.point, direction: dir, energy, radius: 0.08, source: "thrown" });
@@ -5248,12 +5945,21 @@ function createTestRoom(options) {
         data: { energyJ: Math.round(energy), speedMs: Math.round(speed * 10) / 10, target: r.object, targetPart: r.part }
       });
     };
+    const strikeGroundWith = (piece, energy) => {
+      const box2 = tmpBox.setFromObject(piece.root);
+      const centre = box2.getCenter(tmpV);
+      const size = box2.getSize(tmpV2);
+      if (sceneryTopAt(centre.x, centre.z) > 0 || restingTopAt(centre.x, centre.z) > 0) return;
+      const result = terrain.strike("blunt", { x: centre.x, z: centre.z, energy, contactRadius: Math.max(size.x, size.z) / 2 });
+      if (result.radius > 0) showGroundBlow(result);
+    };
     const land = (piece) => {
       const vy = piece.velocity[1];
       const prev = prevVy.get(piece.objectId) ?? 0;
       prevVy.set(piece.objectId, vy);
       if (piece.held || prev > -MIN_LANDING_LOG || vy < prev + 2 || !world.has(piece.objectId)) return;
       const energy = 0.5 * piece.mass * prev * prev;
+      strikeGroundWith(piece, energy);
       action("landing", t("act.landing", { name: nameOf(piece.objectId), speed: num(-prev, 1), energy: num(energy, energy < 100 ? 1 : 0) }), {
         objectId: piece.objectId,
         itemId: entryOf(piece.objectId)?.so.itemId,
@@ -5274,6 +5980,10 @@ function createTestRoom(options) {
   const onKey = (code, down, e) => {
     if (!down) {
       if (code === "KeyZ") tiltKey = 0;
+      if (code === "KeyE" && pushByKey) {
+        pushByKey = false;
+        if (push.end()) grab();
+      }
       return;
     }
     const digit = /^Digit(\d)$/.exec(code);
@@ -5284,9 +5994,15 @@ function createTestRoom(options) {
       if (idx < loadout.length) setTool(loadout[idx]);
       return;
     }
+    if (kickKeys.includes(code) && !e.ctrlKey && !e.metaKey) {
+      kick();
+      return;
+    }
     switch (code) {
       case "KeyE":
-        grab();
+        if (e.repeat) break;
+        pushByKey = !heldPiece && push.begin();
+        if (!pushByKey) grab();
         break;
       case "KeyG":
         throwHeld();
@@ -5329,6 +6045,9 @@ function createTestRoom(options) {
       case "KeyY":
         explosives.detonateCharges();
         break;
+      case "KeyN":
+        setStrikeCombo(!comboOn);
+        break;
       case "KeyH": {
         const w = (heldEntry ?? entryOf(inspectTarget()?.object ?? ""))?.item?.weapon;
         if (w) equip(w);
@@ -5457,8 +6176,9 @@ function createTestRoom(options) {
     }
     syncLiters();
     renderer.update(dt);
+    terrainView.sync(camera.position);
+    showGroundFire(dt);
     vfx.update(dt);
-    craterPatch?.sync();
     updateImpacts();
     fluidView.update(dt);
     filmBridge.update(dt);
@@ -5482,12 +6202,21 @@ function createTestRoom(options) {
   };
   const update = (dt) => {
     if (!ownsLoop) roomMetrics.frame(dt);
+    frameStamp++;
     player.update(dt);
+    if (pushByKey && !player.keys.has("KeyE")) {
+      pushByKey = false;
+      push.end();
+    }
+    push.step(paused ? 0 : dt);
+    if (!paused) kickLight(dt);
+    if (!paused) pushByPlayer(dt);
+    else player.takeWish();
     stepAvatar(paused ? 0 : dt);
     if (tiltKey || heldTilt > 0) {
       heldTilt = Math.max(0, Math.min(2.4, heldTilt + (tiltKey ? 2.2 : -3) * dt));
     }
-    if ((useHeld || useFirst) && !paused) {
+    if ((useHeld || useFirst) && !paused && !push.active) {
       if (tool.def.category === "hand") {
         if (useFirst) handUse();
       } else if (useHeld) useTool(dt, !useFirst);
@@ -5529,6 +6258,7 @@ function createTestRoom(options) {
       timeScale,
       fast: fastForward,
       tap: isTapOn(),
+      combo: combo ? comboOn : null,
       blast: { shelter: blastOn("shelter"), fragmentHits: blastOn("fragmentHits"), confinement: blastOn("confinement") },
       quality: qualityName,
       camera: avatar ? cameraMode : null,
@@ -5804,6 +6534,9 @@ function createTestRoom(options) {
     onClear(listener) {
       clearListeners.add(listener);
       return () => clearListeners.delete(listener);
+    },
+    addObject(itemId, place) {
+      return addScenery(itemId, place.position, place.rotationY);
     }
   };
   let sendingInitial = false;
@@ -5958,6 +6691,7 @@ function createTestRoom(options) {
     const n = Math.max(1, Math.round(seconds / dt));
     for (let i = 0; i < n; i++) {
       player.update(0);
+      push.step(dt);
       followHeld(dt);
       stepSim(dt);
     }
@@ -6000,6 +6734,7 @@ function createTestRoom(options) {
     } finally {
       scenarioRunning = false;
       paused = wasPaused;
+      restoreScenery();
     }
     return report;
   };
@@ -6033,6 +6768,7 @@ function createTestRoom(options) {
   const openArea = (area) => {
     clear();
     const mod = [...modules.values()].find((m) => m.id === area || m.group === area);
+    if (mod?.ground) terrain.setLayout(mod.ground);
     const label = mod?.group ?? S.groups[area] ?? area;
     ui?.showGroup(label);
     activeBench = mod && benches.has(mod.id) ? mod.id : lastBench();
@@ -6199,7 +6935,13 @@ function createTestRoom(options) {
     setFastForward(on) {
       fastForward = on;
     },
+    setStrikeCombo,
+    kick,
+    get strikeCombo() {
+      return combo ? comboOn : null;
+    },
     equip,
+    terrain,
     openArea,
     modules: () => [...modules.values()].map((m) => ({ id: m.id, name: m.name, group: m.group, hasArea: typeof m.area === "function" })),
     openAreaAsync: (area) => loading.busy(t("loading.open_area", { area: areaLabel(area) }), () => openArea(area)),
@@ -6251,6 +6993,12 @@ function createTestRoom(options) {
       debugView.updateProjectionMatrix();
       debugView.updateMatrixWorld(true);
     },
+    get playerPosition() {
+      return player.position;
+    },
+    push: { begin: () => push.begin(), end: () => push.end(), setWalk: (walk) => push.setWalk(walk), get state() {
+      return push.state;
+    } },
     setCameraMode,
     get cameraMode() {
       return cameraMode;
@@ -6272,7 +7020,6 @@ function createTestRoom(options) {
       loading.dispose();
       renderer.dispose();
       vfx.dispose();
-      craterPatch?.dispose();
       fluidView.dispose();
       filmBridge.dispose();
       film.dispose();
@@ -6350,6 +7097,8 @@ function createTestRoom(options) {
         setTool(loadout[index]);
       },
       onTap: () => toggleTap(),
+      ...combo ? { combo: { label: combo.name?.[locale] ?? combo.id, onToggle: () => setStrikeCombo(!comboOn) } } : {},
+      ...arsenal.weapons.has("kick") ? { kick: { label: `${t("ui.kick")} (${kickKeys.map((key) => key.replace(/^Key/, "")).join("/")})`, onKick: () => void kick() } } : {},
       onBlast: (key) => toggleBlast(key),
       onPlay: (objectId, clipId) => {
         playAnimation(clipId, objectId);