@netforge/template-dungeon 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 NetNet Capital Management
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/NOTICE

@@ -0,0 +1,35 @@
+@netforge/template-dungeon (CRYPTWICK)
+Copyright (c) 2026 NetNet Capital Management
+
+An original game. No names, characters, sprites, models, sounds or code
+from any other game or franchise. Nothing from PokéSurvivor (its code and
+sprites are non-commercial) or SpriteCollab was used or consulted for code.
+
+Art and sound
+- Models come from the per-style asset library
+  (@netforge/asset-library): CC0 1.0 models by Quaternius (wickbearers,
+  the dead) and Kenney (columns, crates and rocks), each pack listed
+  with its source URL and licence verification in that package's NOTICE and
+  manifest/packs.json. The files are fetched and built, never committed
+  here; the build copies only the models this game uses.
+- Fallback shapes (client/library.ts) are generated from three.js
+  primitives; textures are drawn on a canvas at load.
+
+Dependencies (unmodified, via npm)
+- three.js 0.186.1 (https://github.com/mrdoob/three.js), MIT.
+- nipplejs 1.0.4 (https://github.com/yoannmoinet/nipplejs), MIT.
+- @netforge/engine and @netforge/engine-sim (this repository);
+  see their NOTICE files (bitECS MPL-2.0, Rapier Apache-2.0, Colyseus MIT,
+  zod MIT).
+
+Patterns (ideas only)
+- The dungeon-crawl and survivor-like genres' general mechanics (rooms
+  joined by corridors, rooms that wake as you near them, loot in cleared
+  rooms, permadeath runs, auto-firing weapons, pick-one-of-three
+  level-ups, a boss in the deepest room). Mechanics, not expression; no
+  level, item, enemy or text was copied from any game. The floor plan is
+  generated by our own code (engine dungeon.ts) from a seed.
+- Flow-field pathing (a breadth-first distance field steered down its
+  gradient), a textbook technique, implemented in engine-sim walls.ts.
+- Hit-stop, screen shake and damage numbers as described in common
+  game-feel talks and articles (e.g. "Juice it or lose it", GDC 2012).

package/README.md

@@ -1,3 +1,55 @@
-# Temporary Holding Version
+# CRYPTWICK (Template 3: co-op dungeon crawl)
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Four wickbearers go down into a candle-lit crypt, room by room. The crypt
+is grown from a seed (`dungeon(...)`): ten rooms joined by corridors, the
+start room at the top and the Wax Abbot in the deepest one. Rooms wake as
+the party nears them and their dead come through the doors; a cleared room
+leaves a reliquary (pick an upgrade) and brings back anyone who fell. Runs
+are permadeath: if the whole party is down at once, the descent is over.
+
+| Path | What |
+|---|---|
+| `src/game.ts` | The game, as the model writes it (declarations only): the crypt's spec, the dead, weapons, the crawl system, earn, store. |
+| `src/manifest.ts` | Loads and compiles it; `dungeonAdapter()` for the room server and client. Room template `dungeon`. |
+| `src/store.ts` | Store hooks on the Kit's API names (`kit.coins.*`, `kit.store.*`): a revive (50 coins), a cosmetic (300 coins) and the wick charm (losable gear, 150 coins), shown under the token's own symbol and logo; mock until the token is live. |
+| `client/` | The browser client: three.js scene, the crypt's floors and walls (`client/crypt.ts`, with an x-ray cut so a wall never hides your wickbearer and a fog of war over rooms nobody has entered), HUD, input (keys, gamepad, touch), game feel. |
+| `test/` | Playtest bots through `engine.test.run`, and the store. |
+| `llms.txt` | How to change the game (for agents). |
+
+## How it plays on the server
+
+- Server-authoritative at 30 Hz on the survivor machinery (auto-firing
+  weapons, shards and level-up cards, co-op downs and revives, keepers,
+  bosses with telegraphed attacks). Your own wickbearer is predicted.
+- The crypt's walls are boxes in the sim (`field.walls`): players meet them
+  in Rapier, and enemies, bolts and spawns are resolved against them by hand
+  like pillars. Floors (`field.floors`) are the only ground: spawns land on
+  them, and enemies behind a wall walk round through the doors on a flow
+  field (engine-sim `walls.ts`), with a wider grid for big bodies.
+- The crawl is a system in game.ts (the model can read and change it): room
+  wakes, encounters by depth, off-screen spawns inside the woken room, the
+  quiet timer that wakes the nearest room when the party waits, reliquaries
+  and the respawn on clear.
+- Earn: room.cleared (2 and 7 rooms), the Abbot, and 60 kills by one wickbearer, once per
+  run each, on the same pay structure as EMBERWATCH. The room server is the
+  referee; before graduation earn is credited as points, after it the
+  game's own coins under its own name.
+
+## Run it
+
+This template runs on your own computer with play money through
+`kit play` (`@netforge/kit-play`). From the repository root:
+
+```sh
+pnpm install --frozen-lockfile && pnpm build
+mkdir -p play-dungeon/src && cp packages/template-dungeon/src/game.ts play-dungeon/src/
+echo '{"template":"dungeon"}' > play-dungeon/netnet.json
+node packages/kit-play/dist/cli.js play-dungeon       # opens http://127.0.0.1:4663
+```
+
+Edit `play-dungeon/src/game.ts` and run it again to try a change. Real-token
+earning, stakes and claims run only on the hosted Net Forge server.
+
+Open the Invite link in another tab or on a phone on the same network to
+play together (`?room=<id>`). Keys: WASD or arrows, Space dash, 1 2 3 pick.
+Touch: drag on the left half, DASH button, tap a card. ` shows stats.

package/client/crypt.ts

@@ -0,0 +1,274 @@
+/**
+ * The crypt as drawn: dark rock under everything, a flagstone floor on
+ * every room and corridor (game.ts field.floors), stone walls on every
+ * wall box (field.walls), and candles in sconces at the room corners. One merged mesh for all the walls and one for all
+ * the floors, so the whole level is a handful of draws.
+ *
+ * Rooms nobody has walked into yet stay dim (a soft fog of war that lifts
+ * as a wickbearer enters); the walls stay readable so the plan is always
+ * there to see.
+ *
+ * An art style that paints surfaces (ps1's textures) paints these too
+ * (surface roles "floor", "wall", "stone"); the toon, pixel, voxel and
+ * hand-drawn styles reshade them in post like everything else.
+ */
+import { BufferAttribute, BufferGeometry, CanvasTexture, Color, CylinderGeometry, Group, Mesh, MeshBasicMaterial, MeshStandardMaterial, MeshStandardNodeMaterial, PlaneGeometry, RepeatWrapping, SphereGeometry, SRGBColorSpace, Vector3 } from "three/webgpu";
+import { clamp, dot, float, length, positionWorld, select, uniform } from "three/tsl";
+import type { Texture } from "three/webgpu";
+import type { WallBox } from "@netforge/engine-sim";
+
+/** Walls are drawn this tall (the sim's are 3 m): low enough that a wall south of you hides less of the room. */
+export const WALL_DRAW_HEIGHT = 2.2;
+/** Candles burn in sconces this high in the room corners, under the wall tops. */
+const SCONCE_HEIGHT = 1.75;
+/** Brightness of a floor nobody has walked into yet, and of one a wickbearer has. */
+const UNSEEN = 0.2;
+const LIT = 0.8;
+
+function hash01(n: number): number {
+  let t = (n + 0x6d2b79f5) >>> 0;
+  t = Math.imul(t ^ (t >>> 15), t | 1);
+  t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+  return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+}
+
+/** Worn flagstones, drawn on a canvas (one repeat covers 4 m). */
+function flagstones(): CanvasTexture {
+  const c = document.createElement("canvas");
+  c.width = c.height = 256;
+  const g = c.getContext("2d");
+  if (g) {
+    g.fillStyle = "#3b342d";
+    g.fillRect(0, 0, 256, 256);
+    for (let j = 0; j < 4; j++) {
+      for (let i = 0; i < 4; i++) {
+        const k = j * 4 + i;
+        const off = j % 2 === 0 ? 0 : 32;
+        const v = 70 + Math.floor(hash01(k) * 26);
+        g.fillStyle = `rgb(${v + 8}, ${v}, ${v - 10})`;
+        g.fillRect(((i * 64 + off) % 256) + 2, j * 64 + 2, 60, 60);
+        // Cracks and wear.
+        g.strokeStyle = "rgba(20, 16, 12, 0.35)";
+        g.beginPath();
+        g.moveTo(((i * 64 + off) % 256) + 8 + hash01(k + 50) * 40, j * 64 + 6);
+        g.lineTo(((i * 64 + off) % 256) + 10 + hash01(k + 90) * 44, j * 64 + 58);
+        g.stroke();
+      }
+    }
+    g.fillStyle = "rgba(255, 220, 160, 0.04)";
+    for (let n = 0; n < 300; n++) g.fillRect(hash01(n * 3) * 256, hash01(n * 3 + 1) * 256, 2, 2);
+  }
+  const t = new CanvasTexture(c);
+  t.wrapS = t.wrapT = RepeatWrapping;
+  t.colorSpace = SRGBColorSpace;
+  t.userData = { tile: 4 };
+  return t;
+}
+
+/** Coursed stone blocks for the walls (one repeat covers 2 m). */
+function masonry(): CanvasTexture {
+  const c = document.createElement("canvas");
+  c.width = c.height = 128;
+  const g = c.getContext("2d");
+  if (g) {
+    g.fillStyle = "#1d1a18";
+    g.fillRect(0, 0, 128, 128);
+    for (let j = 0; j < 4; j++) {
+      for (let i = -1; i < 3; i++) {
+        const v = 52 + Math.floor(hash01(j * 7 + i + 20) * 22);
+        g.fillStyle = `rgb(${v}, ${v - 4}, ${v - 9})`;
+        g.fillRect(i * 64 + (j % 2) * 32 + 2, j * 32 + 2, 60, 28);
+      }
+    }
+  }
+  const t = new CanvasTexture(c);
+  t.wrapS = t.wrapT = RepeatWrapping;
+  t.colorSpace = SRGBColorSpace;
+  t.userData = { tile: 2 };
+  return t;
+}
+
+/**
+ * Boxes as one geometry with world-space UVs (so a texture tiles at the
+ * same scale on a 1 m stub and a 40 m run). `h` is the height; the floor
+ * is y = 0.
+ */
+function boxesGeometry(boxes: readonly WallBox[], h: number, tile: number): BufferGeometry {
+  const pos: number[] = [];
+  const nor: number[] = [];
+  const uv: number[] = [];
+  const idx: number[] = [];
+  const quad = (a: number[], b: number[], c: number[], d: number[], n: number[], uvOf: (p: number[]) => [number, number]) => {
+    const base = pos.length / 3;
+    for (const p of [a, b, c, d]) {
+      pos.push(p[0] ?? 0, p[1] ?? 0, p[2] ?? 0);
+      nor.push(n[0] ?? 0, n[1] ?? 0, n[2] ?? 0);
+      const [u, v] = uvOf(p);
+      uv.push(u / tile, v / tile);
+    }
+    idx.push(base, base + 1, base + 2, base, base + 2, base + 3);
+  };
+  for (const b of boxes) {
+    const x0 = b.x - b.hx;
+    const x1 = b.x + b.hx;
+    const z0 = b.z - b.hz;
+    const z1 = b.z + b.hz;
+    const xz = (p: number[]): [number, number] => [p[0] ?? 0, p[2] ?? 0];
+    const xy = (p: number[]): [number, number] => [p[0] ?? 0, p[1] ?? 0];
+    const zy = (p: number[]): [number, number] => [p[2] ?? 0, p[1] ?? 0];
+    quad([x0, h, z1], [x1, h, z1], [x1, h, z0], [x0, h, z0], [0, 1, 0], xz);
+    quad([x0, 0, z1], [x1, 0, z1], [x1, h, z1], [x0, h, z1], [0, 0, 1], xy);
+    quad([x1, 0, z0], [x0, 0, z0], [x0, h, z0], [x1, h, z0], [0, 0, -1], xy);
+    quad([x1, 0, z1], [x1, 0, z0], [x1, h, z0], [x1, h, z1], [1, 0, 0], zy);
+    quad([x0, 0, z0], [x0, 0, z1], [x0, h, z1], [x0, h, z0], [-1, 0, 0], zy);
+  }
+  const g = new BufferGeometry();
+  g.setAttribute("position", new BufferAttribute(new Float32Array(pos), 3));
+  g.setAttribute("normal", new BufferAttribute(new Float32Array(nor), 3));
+  g.setAttribute("uv", new BufferAttribute(new Float32Array(uv), 2));
+  g.setIndex(idx);
+  g.computeBoundingSphere();
+  return g;
+}
+
+/**
+ * The x-ray cut: wall fragments near the line from the camera to your
+ * wickbearer (and in front of them) are not drawn, so a wall south of you
+ * never hides you. Works on the node material every backend draws, and the
+ * art styles carry it over (they copy opacity nodes and the alpha test).
+ */
+export class WallCut {
+  readonly camera = uniform(new Vector3(0, 20, 20));
+  readonly hero = uniform(new Vector3(0, 1, 0));
+  /** Radius of the cut, m. */
+  readonly radius = uniform(1.6);
+
+  /** A wall material with the cut in it. */
+  material(color: number, map: Texture | null, roughness: number): MeshStandardNodeMaterial {
+    const m = new MeshStandardNodeMaterial({ color, roughness, flatShading: true });
+    if (map) m.map = map;
+    const c = this.camera;
+    const seg = this.hero.sub(c);
+    const p = positionWorld;
+    const t = clamp(dot(p.sub(c), seg).div(dot(seg, seg)), 0, 1);
+    const d = length(p.sub(c.add(seg.mul(t))));
+    // Cut: close to the sight line, before the hero, and above the wall's foot (the base still outlines the room).
+    const cut = d.lessThan(this.radius).and(t.lessThan(0.97)).and(p.y.greaterThan(0.12));
+    m.opacityNode = select(cut, float(0), float(1));
+    m.alphaTest = 0.5;
+    return m;
+  }
+
+  update(camera: Vector3, hero: Vector3): void {
+    this.camera.value.copy(camera);
+    this.hero.value.set(hero.x, hero.y + 0.9, hero.z);
+  }
+}
+
+interface FloorPiece {
+  readonly box: WallBox;
+  readonly material: MeshStandardMaterial;
+  lit: number;
+  seen: boolean;
+}
+
+export class CryptLevel {
+  readonly group = new Group();
+  /** Where candles burn ([x, y, z]): the scene drifts embers off the near ones. */
+  readonly flames: [number, number, number][] = [];
+  private readonly floors: FloorPiece[] = [];
+  readonly cut = new WallCut();
+
+  constructor(
+    walls: readonly WallBox[],
+    floors: readonly WallBox[],
+    half: number,
+    surface: ((kind: "floor" | "wall" | "stone" | "ground") => Texture | null) | null,
+  ) {
+    // Rock under everything: what the camera sees past the walls.
+    const rock = new Mesh(new PlaneGeometry(half * 2 + 60, half * 2 + 60), new MeshStandardMaterial({ color: 0x0b0a0c, roughness: 1 }));
+    rock.rotation.x = -Math.PI / 2;
+    rock.position.y = -0.02;
+    rock.userData.surface = "rock";
+    this.group.add(rock);
+
+    // Floors: one mesh per room or corridor, so each can lift out of the dark on its own.
+    const floorMap = surface?.("floor") ?? flagstones();
+    const ftile = (floorMap.userData as { tile?: number }).tile ?? 4;
+    for (const f of floors) {
+      const map = floorMap.clone();
+      map.needsUpdate = true;
+      map.repeat.set((f.hx * 2) / ftile, (f.hz * 2) / ftile);
+      map.offset.set(((f.x - f.hx) / ftile) % 1, ((f.z - f.hz) / ftile) % 1);
+      const material = new MeshStandardMaterial({ map, roughness: 0.95, color: new Color(UNSEEN, UNSEEN, UNSEEN) });
+      const m = new Mesh(new PlaneGeometry(f.hx * 2, f.hz * 2), material);
+      m.rotation.x = -Math.PI / 2;
+      m.position.set(f.x, 0.005, f.z);
+      m.receiveShadow = true;
+      m.userData.surface = "floor";
+      this.group.add(m);
+      this.floors.push({ box: f, material, lit: UNSEEN, seen: false });
+    }
+
+    // Walls: one merged mesh with a darker cap, so the plan reads from above.
+    const wallMap = surface?.("wall") ?? masonry();
+    wallMap.wrapS = wallMap.wrapT = RepeatWrapping;
+    const wtile = (wallMap.userData as { tile?: number }).tile ?? 2;
+    const wall = new Mesh(boxesGeometry(walls, WALL_DRAW_HEIGHT, wtile), this.cut.material(0x9a8f84, wallMap, 0.92));
+    wall.castShadow = true;
+    wall.receiveShadow = true;
+    wall.userData.surface = "wall";
+    this.group.add(wall);
+    const capMat = this.cut.material(0x2b2420, null, 1);
+    const cap = new Mesh(boxesGeometry(walls.map((b) => ({ x: b.x, z: b.z, hx: b.hx + 0.04, hz: b.hz + 0.04 })), 0.08, 1), capMat);
+    cap.position.y = WALL_DRAW_HEIGHT;
+    this.group.add(cap);
+
+    // Candles: a sconce flame at each room's inner corners (rooms are the floors big enough to be rooms).
+    const flameMat = new MeshBasicMaterial({ color: new Color(0xffb04a).multiplyScalar(5) });
+    const flameGeo = new SphereGeometry(0.16, 8, 6);
+    const sconceGeo = new CylinderGeometry(0.22, 0.12, 0.24, 6);
+    const sconceMat = new MeshStandardMaterial({ color: 0x2a2420, roughness: 0.6, metalness: 0.4 });
+    for (const f of floors) {
+      if (f.hx < 4 || f.hz < 4) continue;
+      for (const [sx, sz] of [
+        [-1, -1],
+        [1, -1],
+        [-1, 1],
+        [1, 1],
+      ] as const) {
+        // A candle in an iron sconce, set into the corner.
+        const x = f.x + sx * (f.hx - 0.3);
+        const z = f.z + sz * (f.hz - 0.3);
+        const sconce = new Mesh(sconceGeo, sconceMat);
+        sconce.position.set(x, SCONCE_HEIGHT - 0.12, z);
+        this.group.add(sconce);
+        const flame = new Mesh(flameGeo, flameMat);
+        flame.position.set(x, SCONCE_HEIGHT + 0.1, z);
+        this.group.add(flame);
+        this.flames.push([x, SCONCE_HEIGHT + 0.15, z]);
+      }
+    }
+  }
+
+  /** Lift the dark off every floor a wickbearer stands on (or within 2 m of). */
+  update(dt: number, players: readonly (readonly [number, number])[]): void {
+    for (const f of this.floors) {
+      if (!f.seen) {
+        for (const [x, z] of players) {
+          if (Math.abs(x - f.box.x) <= f.box.hx + 2 && Math.abs(z - f.box.z) <= f.box.hz + 2) f.seen = true;
+        }
+      }
+      const goal = f.seen ? LIT : UNSEEN;
+      if (Math.abs(goal - f.lit) < 0.002) continue;
+      f.lit += (goal - f.lit) * Math.min(1, dt * 2.5);
+      // Candle-warm: a touch less blue than red.
+      f.material.color.setRGB(f.lit, f.lit * 0.93, f.lit * 0.84);
+    }
+  }
+
+  /** A fresh descent: every room goes back into the dark. */
+  reset(): void {
+    for (const f of this.floors) f.seen = false;
+  }
+}

package/client/debris.ts

@@ -0,0 +1,267 @@
+/**
+ * Client-side physics dressing on engine-sim's PhysicsWorld (Rapier, the
+ * same build the server runs): chunks that fly off killed enemies and
+ * bounce off the floor, walls and pillars, and a scatter of rocks and stumps
+ * the keepers shove around and novas blast away.
+ *
+ * Presentation only. None of it feeds back into the authoritative sim, so
+ * it never needs to match the server or other players exactly; every
+ * client drives the props from the same interpolated keeper positions, so
+ * what they see agrees closely anyway.
+ */
+import { Color, InstancedMesh, Matrix4, MeshStandardMaterial, Quaternion, Vector3 } from "three/webgpu";
+import type { BufferGeometry, Material, Scene } from "three/webgpu";
+import { CylinderGeometry, DodecahedronGeometry } from "three/webgpu";
+import { Layer, createPhysics } from "@netforge/engine-sim";
+import type { BodyId, PhysicsWorld, ResolvedSimConfig } from "@netforge/engine-sim";
+
+const HZ = 60;
+const MAX_CHUNKS = 220;
+const MAX_STEPS = 4;
+const CHUNK_LIFE = 2.2;
+
+interface Chunk {
+  id: BodyId;
+  life: number;
+  max: number;
+  size: number;
+  color: Color;
+}
+
+interface Prop {
+  id: BodyId;
+  barrel: boolean;
+  /** Last speed, for impact thuds. */
+  speed: number;
+}
+
+/** Seeded PRNG so every client scatters the props in the same places. */
+function rng(seed: number): () => number {
+  let s = seed >>> 0;
+  return () => {
+    s = (s + 0x6d2b79f5) >>> 0;
+    let t = s;
+    t = Math.imul(t ^ (t >>> 15), t | 1);
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+/** An art style's own drawing of a debris shape (the voxel style's cube chunks, rocks and stumps); null keeps the primitive. */
+export type DebrisShape = (name: "chunk" | "rock" | "stump") => { readonly geometry: BufferGeometry; readonly material: Material } | null;
+
+function instanced(geometry: BufferGeometry, color: number, capacity: number, emissive = 0x000000, styled?: ReturnType<DebrisShape>): InstancedMesh {
+  const material = styled?.material ?? new MeshStandardMaterial({ color, roughness: 0.75, flatShading: true, emissive, emissiveIntensity: 0.6 });
+  const mesh = new InstancedMesh(styled?.geometry ?? geometry, material, capacity);
+  mesh.count = 0;
+  mesh.frustumCulled = false;
+  mesh.castShadow = true;
+  mesh.receiveShadow = true;
+  const white = new Color(1, 1, 1);
+  for (let i = 0; i < capacity; i++) mesh.setColorAt(i, white);
+  return mesh;
+}
+
+export class PhysicsDressing {
+  readonly physics: PhysicsWorld;
+  private readonly chunks: Chunk[] = [];
+  private readonly props: Prop[] = [];
+  private readonly keepers = new Map<number, BodyId>();
+  private readonly chunkMesh: InstancedMesh;
+  private readonly crateMesh: InstancedMesh;
+  private readonly barrelMesh: InstancedMesh;
+  private acc = 0;
+  private readonly m = new Matrix4();
+  private readonly q = new Quaternion();
+  private readonly p = new Vector3();
+  private readonly s = new Vector3();
+  private readonly random = rng(0xe3b1);
+  /** Impacts this frame (world position and speed), for thud sounds. */
+  readonly impacts: { x: number; y: number; z: number; speed: number }[] = [];
+  /** Effects fired so far (playtest checks). */
+  readonly counts = { chunks: 0, blasts: 0 };
+
+  constructor(scene: Scene, config: ResolvedSimConfig, opts: { props?: boolean; shape?: DebrisShape } = {}) {
+    this.physics = createPhysics({ gravity: [0, -24, 0], tickRate: HZ });
+    const P = this.physics;
+    const h = config.arena.halfExtent;
+    const wall = config.arena.wallHeight;
+    P.addStaticBox([h + 1, 0.5, h + 1], [0, -0.5, 0], { friction: 0.8, layer: Layer.Level });
+    P.addStaticBox([h + 1, wall, 0.5], [0, wall, h + 0.5], { layer: Layer.Level });
+    P.addStaticBox([h + 1, wall, 0.5], [0, wall, -h - 0.5], { layer: Layer.Level });
+    P.addStaticBox([0.5, wall, h + 1], [h + 0.5, wall, 0], { layer: Layer.Level });
+    P.addStaticBox([0.5, wall, h + 1], [-h - 0.5, wall, 0], { layer: Layer.Level });
+    for (const pl of config.arena.pillars) {
+      P.addBody({ type: "static", shape: { cylinder: [pl.height / 2, pl.radius] }, position: [pl.x, pl.height / 2, pl.z], layer: Layer.Level, friction: 0.6 });
+    }
+    // The crypt's walls stop rubble and chunks too.
+    for (const w of config.arena.walls ?? []) {
+      P.addStaticBox([w.hx, wall / 2, w.hz], [w.x, wall / 2, w.z], { layer: Layer.Level, friction: 0.6 });
+    }
+
+    // Props: crates and barrels around the pillars and in the open, the same scatter on every client.
+    const props = rng(0x51f7);
+    const spots: [number, number][] = [];
+    for (const pl of config.arena.pillars) {
+      for (let k = 0; k < 3; k++) {
+        const a = props() * Math.PI * 2;
+        const d = pl.radius + 1.2 + props() * 1.5;
+        spots.push([pl.x + Math.cos(a) * d, pl.z + Math.sin(a) * d]);
+      }
+    }
+    // Loose rubble in the rooms (never in the rock between them): two or three per room, off its middle.
+    for (const f of config.arena.floors ?? []) {
+      if (f.hx < 4 || f.hz < 4) continue;
+      const n = 2 + Math.floor(props() * 2);
+      for (let k = 0; k < n; k++) {
+        const x = f.x + (props() * 2 - 1) * (f.hx - 1.2);
+        const z = f.z + (props() * 2 - 1) * (f.hz - 1.2);
+        if (Math.abs(x - f.x) < 2.5 && Math.abs(z - f.z) < 2.5) continue;
+        spots.push([x, z]);
+      }
+    }
+    if (opts.props === false) spots.length = 0;
+    for (const [x, z] of spots) {
+      const barrel = props() < 0.4;
+      const yaw = props() * Math.PI;
+      const id = P.addBody({
+        type: "dynamic",
+        shape: barrel ? { cylinder: [0.45, 0.35] } : { box: [0.4, 0.4, 0.4] },
+        position: [x, barrel ? 0.45 : 0.4, z],
+        rotation: [0, Math.sin(yaw / 2), 0, Math.cos(yaw / 2)],
+        density: 40,
+        friction: 0.7,
+        restitution: 0.15,
+        linearDamping: 0.4,
+        angularDamping: 0.6,
+        layer: Layer.Prop,
+        mask: Layer.Level | Layer.Prop | Layer.Player | Layer.Debris,
+      });
+      this.props.push({ id, barrel, speed: 0 });
+    }
+
+    this.chunkMesh = instanced(new DodecahedronGeometry(1, 0), 0xffffff, MAX_CHUNKS, 0, opts.shape?.("chunk"));
+    // One family with the field's stone and the Nature Kit stumps: loose rocks and cut stumps, not crates and barrels.
+    this.crateMesh = instanced(new DodecahedronGeometry(0.5), 0x5e5246, Math.max(1, this.props.length), 0, opts.shape?.("rock"));
+    this.barrelMesh = instanced(new CylinderGeometry(0.33, 0.38, 0.9, 7), 0x4e3a28, Math.max(1, this.props.length), 0, opts.shape?.("stump"));
+    scene.add(this.chunkMesh, this.crateMesh, this.barrelMesh);
+  }
+
+  /** Keepers push props: one kinematic capsule per player, moved to where it is drawn. */
+  keeper(owner: number, x: number, y: number, z: number, up: boolean): void {
+    let id = this.keepers.get(owner);
+    if (id === undefined) {
+      id = this.physics.addBody({ type: "kinematic", shape: { capsule: [0.5, 0.4] }, position: [x, y, z], layer: Layer.Player, mask: Layer.Prop | Layer.Debris });
+      this.keepers.set(owner, id);
+    }
+    this.physics.setKinematicTarget(id, [x, up ? y : -5, z]);
+  }
+
+  /** Forget keepers not seen this frame. */
+  keepOnly(owners: ReadonlySet<number>): void {
+    for (const [owner, id] of this.keepers) {
+      if (owners.has(owner)) continue;
+      this.physics.removeBody(id);
+      this.keepers.delete(owner);
+    }
+  }
+
+  /** Chunks off a killed enemy, thrown along the push direction. */
+  shatter(x: number, z: number, radius: number, color: Color, count: number, dirX = 0, dirZ = 0): void {
+    const P = this.physics;
+    this.counts.chunks += count;
+    for (let i = 0; i < count; i++) {
+      if (this.chunks.length >= MAX_CHUNKS) this.retire(0);
+      const size = radius * (0.22 + this.random() * 0.25);
+      const a = this.random() * Math.PI * 2;
+      const sp = 2 + this.random() * 3.5;
+      const id = P.addBody({
+        type: "dynamic",
+        shape: { box: [size, size, size] },
+        position: [x + Math.cos(a) * radius * 0.5, radius + 0.2 + this.random() * radius, z + Math.sin(a) * radius * 0.5],
+        density: 8,
+        friction: 0.6,
+        restitution: 0.35,
+        angularDamping: 0.3,
+        linearVelocity: [Math.cos(a) * sp + dirX * 5, 3.5 + this.random() * 4, Math.sin(a) * sp + dirZ * 5],
+        angularVelocity: [(this.random() - 0.5) * 18, (this.random() - 0.5) * 18, (this.random() - 0.5) * 18],
+        layer: Layer.Debris,
+        mask: Layer.Level | Layer.Prop,
+      });
+      const life = CHUNK_LIFE * (0.7 + this.random() * 0.6);
+      this.chunks.push({ id, life, max: life, size, color });
+    }
+  }
+
+  /** A blast (nova) shoves props and chunks out of `radius`. */
+  blast(x: number, z: number, radius: number, strength: number): void {
+    const P = this.physics;
+    this.counts.blasts++;
+    const hits = P.overlap({ cylinder: [1.5, radius] }, [x, 1.5, z], { mask: Layer.Prop | Layer.Debris });
+    for (const id of hits) P.applyKnockback(id, [x, 0, z], strength, { lift: strength * 0.35 });
+  }
+
+  private retire(i: number): void {
+    const c = this.chunks[i];
+    if (!c) return;
+    this.physics.removeBody(c.id);
+    this.chunks[i] = this.chunks[this.chunks.length - 1] as Chunk;
+    this.chunks.pop();
+  }
+
+  update(dt: number): void {
+    this.impacts.length = 0;
+    this.acc = Math.min(this.acc + dt, MAX_STEPS / HZ);
+    while (this.acc >= 1 / HZ) {
+      this.acc -= 1 / HZ;
+      this.physics.step();
+    }
+    for (let i = this.chunks.length - 1; i >= 0; i--) {
+      const c = this.chunks[i] as Chunk;
+      c.life -= dt;
+      if (c.life <= 0) this.retire(i);
+    }
+    // Draw.
+    const P = this.physics;
+    let n = 0;
+    for (const c of this.chunks) {
+      const [x, y, z] = P.position(c.id);
+      const [qx, qy, qz, qw] = P.rotation(c.id);
+      const k = Math.min(1, c.life / (c.max * 0.35));
+      this.p.set(x, y, z);
+      this.q.set(qx, qy, qz, qw);
+      this.s.setScalar(c.size * 1.25 * k);
+      this.m.compose(this.p, this.q, this.s);
+      this.chunkMesh.setMatrixAt(n, this.m);
+      this.chunkMesh.setColorAt(n, c.color);
+      n++;
+    }
+    this.chunkMesh.count = n;
+    this.chunkMesh.instanceMatrix.needsUpdate = true;
+    if (this.chunkMesh.instanceColor) this.chunkMesh.instanceColor.needsUpdate = true;
+    let crates = 0;
+    let barrels = 0;
+    this.s.setScalar(1);
+    for (const prop of this.props) {
+      const [x, y, z] = P.position(prop.id);
+      const [vx, vy, vz] = P.velocity(prop.id);
+      const speed = Math.hypot(vx, vy, vz);
+      if (prop.speed - speed > 3) this.impacts.push({ x, y, z, speed: prop.speed - speed });
+      prop.speed = speed;
+      const [qx, qy, qz, qw] = P.rotation(prop.id);
+      this.p.set(x, y, z);
+      this.q.set(qx, qy, qz, qw);
+      this.m.compose(this.p, this.q, this.s);
+      if (prop.barrel) this.barrelMesh.setMatrixAt(barrels++, this.m);
+      else this.crateMesh.setMatrixAt(crates++, this.m);
+    }
+    this.crateMesh.count = crates;
+    this.barrelMesh.count = barrels;
+    this.crateMesh.instanceMatrix.needsUpdate = true;
+    this.barrelMesh.instanceMatrix.needsUpdate = true;
+  }
+
+  get liveChunks(): number {
+    return this.chunks.length;
+  }
+}

package/client/decor.ts

@@ -0,0 +1,13 @@
+/**
+ * Library models the CRYPTWICK scene draws on its own (template machinery,
+ * not game content). The crypt draws its walls, floors and candles itself.
+ * The build copies these with the models game.ts uses.
+ */
+
+/** Enemy models are drawn about this many hit radii tall. */
+export const ENEMY_HEIGHT_PER_RADIUS = 3.2;
+/** Keepers are drawn this tall, m. */
+export const KEEPER_HEIGHT = 1.8;
+
+/** The crypt draws its own walls, floors and candles: no library dressing of its own. */
+export const SCENE_MODELS: readonly string[] = [];