@netforge/template-collector 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,29 @@
+@netforge/template-collector (MOSSBOUND)
+Copyright (c) 2026 NetNet Capital Management
+
+An original game. No names, characters, maps, models, sounds or code from
+any other game or franchise.
+
+Art and sound
+- Models come from the per-style asset library
+  (@netforge/asset-library): CC0 1.0 models by Kenney and
+  Quaternius (animals, monsters, Nature Kit), 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 (@netforge/tabletop stage.ts) are generated from three.js
+  primitives; all textures are drawn on a canvas at load; sounds are the
+  library's CC0 samples with WebAudio synth fallbacks.
+
+Dependencies (unmodified, via npm)
+- three.js 0.186.1 (https://github.com/mrdoob/three.js), 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 creature-collecting RPG genre's general mechanics (meeting creatures
+  in tall grass, turn-based battles, a small team, catching, levels).
+  Mechanics, not expression: the creatures, names, elements, items, map
+  and text are original, and no creature, design, type chart or item was
+  copied from any game.

package/README.md

@@ -1,3 +1,50 @@
-# Temporary Holding Version
+# MOSSBOUND (monster collector template)
 
-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.
+Fen spirits live in the tall grass of a flooded marsh. Each keeper picks a
+starter at camp, walks the reeds, meets wild spirits in the grass and
+battles them turn by turn with a team of three, snaring the ones worth
+keeping in a reed lantern. At the far end of the marsh the Fenwarden waits:
+every keeper in the marsh wears down the same warden, and it must fall
+before dusk.
+
+A board genre (`packages/engine/src/rules/collector.ts`) on the room
+server at 30 Hz behind the same SimAdapter seam as every template. The
+client kit is `@netforge/tabletop`.
+
+| Path | What |
+|---|---|
+| `src/game.ts` | The game, as the model writes it (declarations only). |
+| `src/manifest.ts` | Loads it; `collectorAdapter()` for the room server and client. Room template `collector`. |
+| `src/store.ts` | Coin prices the client is wired to, the template's own coin (MOSS). |
+| `client/` | The browser client: the marsh, keepers, companions, the battle panel, the starter pick. |
+| `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
+
+- Your keeper walks with a stick (WASD, arrows, or the left thumb) and is
+  predicted with the same tile collision the room runs, so walking never
+  waits. Every roll (encounters, accuracy, damage spread, snares, the foe's
+  move) is the room's PRNG, so a run replays exactly from its inputs.
+- Battles are private: your team, your foe and the battle log reach only
+  you (SimAdapter.infoFor). Others see the creature beside you.
+- The warden's health is one pool for the whole marsh; when it falls,
+  everyone who hurt it is paid. Dusk ends the run.
+- Earn (the room is the referee): the first catch, three catches, the
+  warden, a creature at level 5. All are a player's own acts except the
+  warden, which pays only those who hurt it.
+
+## 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-collector/src && cp packages/template-collector/src/game.ts play-collector/src/
+echo '{"template":"collector"}' > play-collector/netnet.json
+node packages/kit-play/dist/cli.js play-collector       # opens http://127.0.0.1:4663
+```
+
+Edit `play-collector/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.

package/client/decor.ts

@@ -0,0 +1,13 @@
+/**
+ * Library models the scene draws on its own (not named in game.ts): the
+ * camp, the reeds, the rocks and trees of the marsh, the warden's mound.
+ * The build copies these into ./library, in every art style.
+ */
+export const TENT_MODEL = "style.lowpoly.tent";
+export const FIRE_MODEL = "style.lowpoly.campfire";
+export const REED_MODEL = "style.lowpoly.bush";
+export const ROCK_MODEL = "style.lowpoly.rock_tall";
+export const TREE_MODELS = ["style.lowpoly.tree_pine", "style.lowpoly.tree_dark", "style.lowpoly.tree_fat"] as const;
+export const MOUND_MODEL = "style.lowpoly.column_broken";
+export const SMALL_DECOR = ["style.lowpoly.mushroom_red", "style.lowpoly.flower_red", "style.lowpoly.stump", "style.lowpoly.log"] as const;
+export const SCENE_MODELS: readonly string[] = [TENT_MODEL, FIRE_MODEL, REED_MODEL, ROCK_MODEL, ...TREE_MODELS, MOUND_MODEL, ...SMALL_DECOR];

package/client/index.html

@@ -0,0 +1,11 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover, user-scalable=no" />
+    <title>Mossbound</title>
+  </head>
+  <body>
+    <script type="module" src="./main.ts"></script>
+  </body>
+</html>

package/client/main.ts

@@ -0,0 +1,626 @@
+/**
+ * MOSSBOUND client: pick a starter at camp, walk the marsh (WASD, arrows or
+ * the left thumb), meet wild spirits in the tall grass, fight them turn by
+ * turn, snare the ones worth keeping, and bring down the Fenwarden with
+ * everyone else before dusk. Your keeper is predicted, so walking never
+ * waits for the server; every roll is the room's.
+ *
+ * URL parameters: see @netforge/tabletop boot.ts (?room, ?server,
+ * ?style, ?autopilot, ?preview, ?stats, ?shapes, ?webgl, Net Forge flags).
+ */
+import { AdditiveBlending, CanvasTexture, CylinderGeometry, DoubleSide, Group, Mesh, MeshBasicMaterial, MeshStandardMaterial, NearestFilter, PlaneGeometry, RingGeometry, SRGBColorSpace } from "three/webgpu";
+import type { InterpolatedEntity } from "@netforge/engine/net";
+import { CollectorAct, effectiveness, LogKind, MARSH_TILE, marshCenter, marshRoute, marshTile, RF, RulesKind, UNITS } from "@netforge/engine/rules";
+import type { LogLine, RulesInput } from "@netforge/engine/rules";
+import { bootBoard, cssColor, type BoardView, type Placed } from "@netforge/tabletop";
+import { collectorAdapter, collectorGame, collectorManifest, COSMETICS, GAME_VERSION, PLACE, TEMPLATE } from "../src/manifest.js";
+import { MOSSBOUND_COIN } from "../src/store.js";
+import { FIRE_MODEL, MOUND_MODEL, REED_MODEL, ROCK_MODEL, SMALL_DECOR, TENT_MODEL, TREE_MODELS } from "./decor.js";
+import { KEEPER_COLORS, RULE_NAMES, SKU_NAMES, TITLE, UPGRADE_NAMES, WEAPON_NAMES } from "./names.js";
+
+interface MonView {
+  readonly species: number;
+  readonly level: number;
+  readonly hp: number;
+  readonly max: number;
+  readonly xp: number;
+  readonly next: number;
+}
+
+interface CollectorView extends BoardView {
+  readonly dusk: number;
+  readonly warden: { hp: number; max: number; down: boolean; fighting: number };
+  readonly players: readonly { id: number; catches: number; level: number; battling: boolean }[];
+  readonly team?: readonly MonView[];
+  readonly active?: number;
+  readonly box?: number;
+  readonly snares?: number;
+  readonly picked?: boolean;
+  readonly battle?: { foe: MonView; warden: boolean; turn: number } | null;
+  readonly log?: readonly LogLine[];
+  readonly catches?: number;
+}
+
+const genre = collectorGame();
+const g = genre.game;
+const map = g.map;
+const manifest = collectorManifest();
+const W = map.w * MARSH_TILE;
+const H = map.h * MARSH_TILE;
+const ELEMENT_COLOR = [0x7bd96a, 0x4fb6ff, 0xffd84a, 0xb59a7a];
+const ELEMENT_NAME = ["Root", "Tide", "Spark", "Stone"];
+const FINISH = [0x6d5a3a, 0x7fa86a, 0xffb347];
+const nameOf = (species: number) => {
+  const c = g.creatures[species];
+  return c ? (WEAPON_NAMES[c.id]?.name ?? c.id) : "?";
+};
+const moveName = (i: number) => (g.moves[i]?.id ?? "").split("_").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+const m = (e: InterpolatedEntity, f: number) => (e.values[f] ?? 0) / UNITS;
+
+// The browser's autopilot (?autopilot=1): the genre's own playtest habits over what this page can see.
+let lastView: CollectorView | null = null;
+let selfPos = { x: 0, z: 0 };
+let route: { goal: number; path: number[]; until: number } | null = null;
+const autopilot = (tick: number): RulesInput | null => {
+  const v = lastView;
+  const idle: RulesInput = { mx: 0, mz: 0, cx: 0, cz: 0, act: 0, a: 0, b: 0, c: 0 };
+  if (!v) return null;
+  if (!v.picked) return tick % 30 === 0 ? { ...idle, act: CollectorAct.Pick, a: tick % g.starters.length } : idle;
+  const b = v.battle;
+  const team = v.team ?? [];
+  if (b) {
+    if (tick % 20 !== 0) return idle;
+    const mine = team[v.active ?? 0];
+    const c = mine ? g.creatures[mine.species] : undefined;
+    if (!mine || !c) return idle;
+    if (!b.warden && (v.snares ?? 0) > 0 && b.foe.hp < b.foe.max * 0.5) return { ...idle, act: CollectorAct.Snare };
+    let best = 0;
+    let score = -1;
+    c.moveIdx.forEach((mi, j) => {
+      const mv = g.moves[mi];
+      const foe = g.creatures[b.foe.species];
+      if (!mv || !foe) return;
+      const eff = effectiveness(mv.el, foe.el);
+      const val = mv.effect === "heal" ? (mine.hp < mine.max * 0.4 ? 999 : 0) : mv.power * (eff > 0 ? 1.5 : eff < 0 ? 0.67 : 1);
+      if (val > score) {
+        score = val;
+        best = j;
+      }
+    });
+    return { ...idle, act: CollectorAct.Move, a: best };
+  }
+  const here = marshTile(map, selfPos.x * UNITS, selfPos.z * UNITS);
+  const level = team.reduce((a, x) => Math.max(a, x.level), 0);
+  const hurt = team.reduce((a, x) => a + x.hp, 0) < team.reduce((a, x) => a + x.max, 0) * 0.45;
+  let goal: number;
+  const wardenGoal = map.warden[1] * map.w + map.warden[0];
+  if (!v.warden.down && level >= g.marsh.warden.level - 1 && !hurt) {
+    goal = wardenGoal;
+    const wc = marshCenter(map, map.warden[0], map.warden[1]);
+    if (Math.hypot(wc.x / UNITS - selfPos.x, wc.z / UNITS - selfPos.z) < 4.5 && tick % 15 === 0) return { ...idle, act: CollectorAct.Challenge };
+  } else if (hurt) goal = map.camp[1] * map.w + map.camp[0];
+  else {
+    const tiles: number[] = [];
+    for (let t = 0; t < map.grass.length; t++) if (map.grass[t] && !map.blocked[t]) tiles.push(t);
+    goal = tiles[(Math.floor(tick / 120) * 2654435761) % Math.max(1, tiles.length)] ?? here;
+  }
+  if (!route || route.goal !== goal || tick >= route.until || route.path.length === 0) route = { goal, path: here >= 0 ? marshRoute(map, here, goal) : [], until: tick + 90 };
+  while (route.path.length > 0 && route.path[0] === here) route.path.shift();
+  const next = route.path[0] ?? goal;
+  const c = marshCenter(map, next % map.w, Math.floor(next / map.w));
+  const dx = c.x / UNITS - selfPos.x;
+  const dz = c.z / UNITS - selfPos.z;
+  const d = Math.hypot(dx, dz);
+  if (d < 0.1) return idle;
+  return { ...idle, mx: Math.round((dx / d) * 127), mz: Math.round((dz / d) * 127) };
+};
+
+async function main(): Promise<void> {
+  const app = await bootBoard({
+    adapter: collectorAdapter(),
+    manifest,
+    template: TEMPLATE,
+    place: PLACE,
+    version: GAME_VERSION,
+    labels: {
+      title: TITLE,
+      rules: RULE_NAMES,
+      skus: SKU_NAMES,
+      upgrades: UPGRADE_NAMES,
+      loading: "Lighting the reed lanterns",
+      help: "WASD walk · in battle 1-4 moves, S snare, F flee, Tab swap · E challenge the warden · ` stats",
+    },
+    theme: {
+      accent: "#9de07a",
+      gold: "#ffd76a",
+      ink: "#eef6e4",
+      dim: "#a6b79a",
+      panel: "rgba(18, 32, 22, 0.86)",
+      bg: "#101a12",
+      font: '"Gill Sans", "Trebuchet MS", system-ui, sans-serif',
+      display: '"Palatino Linotype", Georgia, serif',
+      radius: 10,
+    },
+    coin: MOSSBOUND_COIN,
+    cosmetics: COSMETICS,
+    swatch: (c) => `linear-gradient(135deg, ${cssColor(FINISH[c] ?? 0x6d5a3a)}, #1c2a18)`,
+    ground: { w: 26, h: 16 },
+    preset: "day",
+    theme3d: "meadow",
+    groundColor: 0x3d5a2e,
+    pitch: 0.95,
+    autopilot,
+    soundKey: "mossbound:sound",
+  });
+  const { stage, hud, clock, sfx } = app;
+  sfx.define("snare", { wave: "triangle", f0: 520, f1: 1560, ms: 320, gain: 0.6 }, { minGapMs: 200, voices: 1, pitchVar: 0 });
+  sfx.define("slip", { wave: "sawtooth", f0: 600, f1: 200, ms: 220, gain: 0.4 }, { minGapMs: 150, voices: 1 });
+  sfx.define("rustle", { wave: "noise", f0: 1800, f1: 600, ms: 260, gain: 0.35 }, { minGapMs: 300, voices: 1 });
+
+  // ---- The marsh: one painted plate (meadow, tall grass, mud), water, reeds, rocks and trees, the camp, the mound.
+  const plate = new Mesh(new PlaneGeometry(W, H, map.w * 2, map.h * 2), new MeshStandardMaterial({ map: marshTexture(), roughness: 0.95, metalness: 0 }));
+  plate.rotation.x = -Math.PI / 2;
+  plate.position.y = stage.groundAt(0, 0) + 0.03;
+  plate.receiveShadow = true;
+  stage.add(plate);
+  const waterMat = new MeshStandardMaterial({ color: 0x3b7fa8, roughness: 0.15, metalness: 0.2, transparent: true, opacity: 0.85 });
+  for (const [x, y, w, h] of g.marsh.water) {
+    const water = new Mesh(new PlaneGeometry(w * MARSH_TILE, h * MARSH_TILE), waterMat);
+    water.rotation.x = -Math.PI / 2;
+    water.position.set((x + w / 2 - map.w / 2) * MARSH_TILE, plate.position.y + 0.06, (y + h / 2 - map.h / 2) * MARSH_TILE);
+    stage.add(water);
+  }
+  const at = (tx: number, ty: number) => ({ x: (tx + 0.5 - map.w / 2) * MARSH_TILE, z: (ty + 0.5 - map.h / 2) * MARSH_TILE });
+  // Reeds over the tall grass, rocks and trees on the blocked tiles: instanced, one draw a model.
+  const reeds: { x: number; z: number; yaw: number; s: number }[] = [];
+  const rocks: { x: number; z: number; yaw: number; s: number }[] = [];
+  const trees: { x: number; z: number; yaw: number; s: number }[][] = TREE_MODELS.map(() => []);
+  let seed = 7;
+  const rnd = () => ((seed = (seed * 16807) % 2147483647) / 2147483647);
+  for (let t = 0; t < map.w * map.h; t++) {
+    const p = at(t % map.w, Math.floor(t / map.w));
+    if (map.grass[t]) for (let k = 0; k < 2; k++) reeds.push({ x: p.x + (rnd() - 0.5) * 1.6, z: p.z + (rnd() - 0.5) * 1.6, yaw: rnd() * 6.28, s: 0.5 + rnd() * 0.35 });
+    if (map.blocked[t] && !map.water[t]) {
+      if (rnd() < 0.5) rocks.push({ x: p.x, z: p.z, yaw: rnd() * 6.28, s: 0.8 + rnd() * 0.4 });
+      else trees[Math.floor(rnd() * trees.length)]?.push({ x: p.x, z: p.z, yaw: rnd() * 6.28, s: 0.8 + rnd() * 0.4 });
+    }
+  }
+  // The land past the marsh's edge: a ring of trees and small things.
+  const small: { x: number; z: number; yaw: number; s: number }[][] = SMALL_DECOR.map(() => []);
+  for (let i = 0; i < 90; i++) {
+    const side = rnd() * 4;
+    const t = rnd() * 2 - 1;
+    const out = 1.5 + rnd() * 8;
+    const x = side < 1 ? -W / 2 - out : side < 2 ? W / 2 + out : t * (W / 2 + 8);
+    const z = side < 2 ? t * (H / 2 + 8) : side < 3 ? -H / 2 - out : H / 2 + out;
+    (i % 3 === 0 ? small[i % small.length] : trees[i % trees.length])?.push({ x, z, yaw: rnd() * 6.28, s: 0.8 + rnd() * 0.5 });
+  }
+  const scatter = [
+    { crowd: stage.crowd(REED_MODEL, 0.7, reeds.length, 0x6f9a4a), at: reeds },
+    { crowd: stage.crowd(ROCK_MODEL, 1.6, Math.max(1, rocks.length), 0x8a8478), at: rocks },
+    ...TREE_MODELS.map((id, i) => ({ crowd: stage.crowd(id, 4, Math.max(1, trees[i]?.length ?? 1), 0x3f6a34), at: trees[i] ?? [] })),
+    ...SMALL_DECOR.map((id, i) => ({ crowd: stage.crowd(id, 0.6, Math.max(1, small[i]?.length ?? 1), 0x9a6a4a), at: small[i] ?? [] })),
+  ];
+  const camp = at(map.camp[0], map.camp[1]);
+  const tent = stage.model(TENT_MODEL, 2.2, 0xa0805a);
+  tent.root.position.set(camp.x - 1.6, 0, camp.z - 1.4);
+  const fire = stage.model(FIRE_MODEL, 0.7, 0xff9a3c);
+  fire.root.position.set(camp.x + 0.6, 0, camp.z - 0.4);
+  stage.add(tent.root, fire.root);
+  const glow = new Mesh(new CylinderGeometry(1, 1, 0.04, 24), new MeshBasicMaterial({ color: 0xffb347, transparent: true, opacity: 0.35, blending: AdditiveBlending, depthWrite: false }));
+  glow.position.set(camp.x, 0.08, camp.z);
+  glow.scale.setScalar(3);
+  stage.add(glow);
+  const wardenAt = at(map.warden[0], map.warden[1]);
+  for (let i = 0; i < 6; i++) {
+    const a = (i / 6) * Math.PI * 2;
+    const stone = stage.model(MOUND_MODEL, 1.8, 0x8a8478);
+    stone.root.position.set(wardenAt.x + Math.cos(a) * 3.2, 0, wardenAt.z + Math.sin(a) * 3.2);
+    stone.root.rotation.y = a;
+    stage.add(stone.root);
+  }
+  stage.frameRect(camp.x + 6, camp.z, 26, 16);
+
+  // ---- Keepers (one character each) and creatures (one model each: companions, wild foes, the warden).
+  const keepers = new Map<number, { root: Group; ring: Mesh }>();
+  const keeperFor = (owner: number) => {
+    let k = keepers.get(owner);
+    if (k) return k;
+    const root = new Group();
+    const model = stage.model(manifest.game.players.prefab, 1.7, KEEPER_COLORS[(owner - 1) % KEEPER_COLORS.length]);
+    root.add(model.root);
+    const ring = new Mesh(new RingGeometry(0.45, 0.62, 24), new MeshBasicMaterial({ color: KEEPER_COLORS[(owner - 1) % KEEPER_COLORS.length] ?? 0xffffff, side: DoubleSide, transparent: true, opacity: 0.85 }));
+    ring.rotation.x = -Math.PI / 2;
+    ring.position.y = 0.06;
+    root.add(ring);
+    stage.add(root);
+    k = { root, ring };
+    keepers.set(owner, k);
+    return k;
+  };
+  const creatures = new Map<number, { species: number; placed: Placed; hp: number; x: number; z: number }>();
+  const creatureFor = (id: number, species: number) => {
+    let c = creatures.get(id);
+    if (c && c.species === species) return c;
+    if (c) stage.scene.remove(c.placed.root);
+    const def = g.creatures[species];
+    const placed = stage.model(def?.model ?? "style.lowpoly.frog", (def?.size ?? 1) * 0.8, ELEMENT_COLOR[def?.el ?? 0], (def?.size ?? 1) * 1.1);
+    stage.add(placed.root);
+    stage.burst("magic", 0, 0, 0, 0, 0);
+    c = { species, placed, hp: -1, x: 0, z: 0 };
+    creatures.set(id, c);
+    return c;
+  };
+
+  // ---- HUD: the team, the battle panel, the starter pick, the warden's call.
+  const style = document.createElement("style");
+  style.textContent = `
+#team { left: 12px; bottom: max(12px, env(safe-area-inset-bottom)); display: flex; gap: 6px; }
+#team .mon { width: 128px; padding: 6px 8px; border-radius: var(--r); background: var(--panel); border: 1px solid rgba(255,255,255,0.08); font-size: 12px; }
+#team .mon.on { border-color: var(--accent); box-shadow: 0 0 0 1px var(--accent); }
+#team .mon.out { opacity: 0.45; }
+#team .mon b { display: block; font-size: 13px; }
+.hp { height: 6px; border-radius: 3px; background: rgba(0,0,0,0.45); overflow: hidden; margin-top: 4px; }
+.hp > i { display: block; height: 100%; background: linear-gradient(90deg, #7bd96a, #c6f27a); transform-origin: left; }
+.hp.low > i { background: linear-gradient(90deg, #ff5a3c, #ffb347); }
+.xp { height: 3px; margin-top: 3px; background: rgba(255,255,255,0.08); }
+.xp > i { display: block; height: 100%; background: var(--gold); transform-origin: left; }
+.dot { display: inline-block; width: 8px; height: 8px; border-radius: 50%; margin-right: 5px; vertical-align: middle; }
+#battle { left: 50%; bottom: max(12px, env(safe-area-inset-bottom)); transform: translateX(-50%); width: min(560px, 94vw); display: none; pointer-events: auto; background: var(--panel); border: 1px solid var(--line); border-radius: calc(var(--r) * 1.4); padding: 10px 12px; }
+#battle.show { display: block; }
+#battle .foe { display: flex; justify-content: space-between; align-items: baseline; font: 700 15px var(--display, inherit); }
+#battle .log { margin: 8px 0; min-height: 50px; font-size: 13px; color: var(--dim); display: grid; gap: 2px; }
+#battle .log div:last-child { color: var(--ink); }
+#battle .moves { display: grid; grid-template-columns: repeat(2, 1fr); gap: 6px; }
+#battle .moves button { text-align: left; }
+#battle .moves small { color: var(--dim); margin-left: 6px; }
+#battle .row { display: flex; gap: 6px; margin-top: 6px; flex-wrap: wrap; }
+#pick { inset: 0; display: none; place-items: center; background: rgba(6, 12, 8, 0.6); pointer-events: auto; z-index: 7; }
+#pick.show { display: grid; }
+#pick .box { text-align: center; }
+#pick h2 { font: 900 24px var(--display, inherit); letter-spacing: 0.12em; color: var(--accent); margin: 0 0 12px; }
+#pick .cards { display: flex; gap: 10px; flex-wrap: wrap; justify-content: center; }
+#pick button { width: 160px; padding: 14px 10px; display: grid; gap: 4px; }
+#pick button b { font-size: 16px; }
+#pick button small { color: var(--dim); }
+#call { left: 50%; bottom: max(120px, calc(env(safe-area-inset-bottom) + 110px)); transform: translateX(-50%); display: none; }
+#call.show { display: block; }
+#wardenbar { top: max(12px, env(safe-area-inset-top)); left: 50%; transform: translateX(-50%); width: min(340px, 44vw); text-align: center; font: 800 11px var(--display, inherit); letter-spacing: 0.2em; color: #ffd0a0; }
+#wardenbar > div { height: 8px; margin-top: 4px; background: rgba(0,0,0,0.5); border-radius: 3px; overflow: hidden; }
+#wardenbar > div > i { display: block; height: 100%; background: linear-gradient(90deg, #b56a3c, #ffd76a); transform-origin: left; }
+#stickzone { position: fixed; left: 0; top: 30%; bottom: 0; width: 45%; z-index: 3; touch-action: none; display: none; }
+@media (pointer: coarse) { #stickzone { display: block; } }
+@media (max-height: 500px) { #team .mon { width: 104px; padding: 4px 6px; } #battle { padding: 6px 8px; } #battle .log { min-height: 0; } #battle .log div:not(:last-child) { display: none; } }
+`;
+  document.head.append(style);
+  const el = (id: string, cls = "hud") => {
+    const d = document.createElement("div");
+    d.id = id;
+    d.className = cls;
+    document.body.append(d);
+    return d;
+  };
+  const teamEl = el("team");
+  const battleEl = el("battle");
+  const pickEl = el("pick");
+  const callEl = el("call");
+  const wardenEl = el("wardenbar");
+  const stickZone = el("stickzone", "");
+  wardenEl.innerHTML = `<span>${(WEAPON_NAMES[g.marsh.warden.creature]?.name ?? "Warden").toUpperCase()}</span><div><i></i></div>`;
+  const callBtn = document.createElement("button");
+  callBtn.className = "go";
+  callBtn.textContent = `Challenge the ${WEAPON_NAMES[g.marsh.warden.creature]?.name ?? "warden"}`;
+  callBtn.addEventListener("click", () => clock.act(CollectorAct.Challenge));
+  callEl.append(callBtn);
+  pickEl.innerHTML = `<div class="box"><h2>CHOOSE YOUR FIRST SPIRIT</h2><div class="cards"></div></div>`;
+  g.starters.forEach((species, i) => {
+    const c = g.creatures[species];
+    const b = document.createElement("button");
+    b.innerHTML = `<b></b><span></span><small></small>`;
+    (b.querySelector("b") as HTMLElement).textContent = nameOf(species);
+    (b.querySelector("span") as HTMLElement).innerHTML = `<i class="dot" style="background:${cssColor(ELEMENT_COLOR[c?.el ?? 0] ?? 0)}"></i>${ELEMENT_NAME[c?.el ?? 0] ?? ""}`;
+    (b.querySelector("small") as HTMLElement).textContent = WEAPON_NAMES[c?.id ?? ""]?.line ?? "";
+    b.addEventListener("click", () => {
+      sfx.unlock();
+      clock.act(CollectorAct.Pick, i);
+      sfx.play("pick");
+    });
+    pickEl.querySelector(".cards")?.append(b);
+  });
+
+  // ---- Walking: keys, or the left thumb on a phone.
+  const keys = new Set<string>();
+  addEventListener("keydown", (e) => {
+    keys.add(e.code);
+    const v = lastView;
+    if (v?.battle) {
+      const n = Number(e.key);
+      if (n >= 1 && n <= 4) clock.act(CollectorAct.Move, n - 1);
+      if (e.code === "KeyS") clock.act(CollectorAct.Snare);
+      if (e.code === "KeyF") clock.act(CollectorAct.Flee);
+      if (e.code === "Tab") {
+        e.preventDefault();
+        const team = v.team ?? [];
+        const next = team.findIndex((x, i) => i !== v.active && x.hp > 0);
+        if (next >= 0) clock.act(CollectorAct.Swap, next);
+      }
+    } else if (e.code === "KeyE") clock.act(CollectorAct.Challenge);
+  });
+  addEventListener("keyup", (e) => keys.delete(e.code));
+  addEventListener("blur", () => keys.clear());
+  let thumb: { id: number; x: number; y: number; dx: number; dy: number } | null = null;
+  stickZone.addEventListener("pointerdown", (e) => {
+    sfx.unlock();
+    thumb = { id: e.pointerId, x: e.clientX, y: e.clientY, dx: 0, dy: 0 };
+    stickZone.setPointerCapture(e.pointerId);
+  });
+  stickZone.addEventListener("pointermove", (e) => {
+    if (!thumb || e.pointerId !== thumb.id) return;
+    thumb.dx = Math.max(-1, Math.min(1, (e.clientX - thumb.x) / 50));
+    thumb.dy = Math.max(-1, Math.min(1, (e.clientY - thumb.y) / 50));
+  });
+  const endThumb = () => (thumb = null);
+  stickZone.addEventListener("pointerup", endThumb);
+  stickZone.addEventListener("pointercancel", endThumb);
+
+  // ---- Every frame.
+  let seenLog = 0;
+  let seenFoe = false;
+  const hpBar = (hp: number, max: number) => `<div class="hp${hp < max * 0.3 ? " low" : ""}"><i style="transform:scaleX(${Math.max(0, Math.min(1, hp / Math.max(1, max)))})"></i></div>`;
+  app.loop((dt, now) => {
+    const conn = app.conn();
+    const v = app.view<CollectorView>();
+    lastView = v;
+    const view = conn.net.render(now);
+    const t = now / 1000;
+    const inBattle = !!v?.battle;
+    // The stick: keys or thumb, never in a battle (the room ignores walking there and so does the prediction).
+    let sx = (keys.has("KeyD") || keys.has("ArrowRight") ? 1 : 0) - (keys.has("KeyA") || keys.has("ArrowLeft") ? 1 : 0);
+    let sz = (keys.has("KeyS") || keys.has("ArrowDown") ? 1 : 0) - (keys.has("KeyW") || keys.has("ArrowUp") ? 1 : 0);
+    if (thumb) {
+      sx = thumb.dx;
+      sz = thumb.dy;
+    }
+    if (inBattle || !v?.picked) {
+      sx = 0;
+      sz = 0;
+    }
+    const len = Math.hypot(sx, sz);
+    clock.stick(len > 1 ? sx / len : sx, len > 1 ? sz / len : sz);
+
+    // Keepers: ours predicted, the others interpolated.
+    const seen = new Set<number>();
+    const place = (e: InterpolatedEntity | undefined, owner: number) => {
+      if (!e) return;
+      seen.add(owner);
+      const k = keeperFor(owner);
+      const x = m(e, RF.x);
+      const z = m(e, RF.z);
+      k.root.position.set(x, stage.groundAt(x, z) + 0.03, z);
+      k.root.rotation.y = e.values[RF.yaw] ?? 0;
+      if (owner === app.self) selfPos = { x, z };
+    };
+    place(view.self, app.self);
+    for (const e of view.others) if (e.kind === RulesKind.Avatar) place(e, e.owner);
+    for (const [owner, k] of keepers) {
+      if (seen.has(owner)) continue;
+      stage.scene.remove(k.root);
+      keepers.delete(owner);
+    }
+    // Creatures: companions, foes beside battling keepers, the warden on its mound.
+    const live = new Set<number>();
+    let foePos: { x: number; z: number } | null = null;
+    let minePos: { x: number; z: number } | null = null;
+    for (const e of view.others) {
+      if (e.kind !== RulesKind.Unit && e.kind !== RulesKind.Structure) continue;
+      live.add(e.id);
+      const species = Math.round(e.values[RF.type] ?? 0);
+      const c = creatureFor(e.id, species);
+      const x = m(e, RF.x);
+      const z = m(e, RF.z);
+      const flags = Math.round(e.values[RF.flags] ?? 0);
+      const hp = e.values[RF.hp] ?? 0;
+      const fainted = e.kind === RulesKind.Unit ? (flags & 1) !== 0 : (flags & 1) !== 0;
+      if (c.hp >= 0 && hp < c.hp && e.kind === RulesKind.Structure) stage.burst("hitSpark", x, 2, z, 0xffd76a, 8);
+      c.hp = hp;
+      c.x = x;
+      c.z = z;
+      const bob = fainted ? 0 : Math.abs(Math.sin(t * 5 + e.id)) * 0.12;
+      c.placed.root.position.set(x, stage.groundAt(x, z) + 0.04 + bob, z);
+      c.placed.root.rotation.y = e.values[RF.yaw] ?? 0;
+      c.placed.root.rotation.z = fainted ? Math.PI / 2 : 0;
+      if (e.owner === app.self && (flags & 2) !== 0) foePos = { x, z };
+      if (e.owner === app.self && (flags & 2) === 0 && e.kind === RulesKind.Unit) minePos = { x, z };
+    }
+    for (const [id, c] of creatures) {
+      if (live.has(id)) continue;
+      stage.burst("magic", c.x, 0.6, c.z, 0xc6f27a, 10);
+      stage.scene.remove(c.placed.root);
+      creatures.delete(id);
+    }
+    for (const s of scatter) {
+      s.crowd.begin();
+      for (const p of s.at) s.crowd.push(p.x, stage.groundAt(p.x, p.z), p.z, p.yaw, (p.x * 0.13) % 1, 0, 0, 0, p.s);
+      s.crowd.end(t);
+    }
+    glow.scale.setScalar(3 + Math.sin(t * 3) * 0.2);
+    // The camera: our keeper, closer in a battle.
+    if (v?.battle && (v.battle.warden || foePos)) stage.frameRect(selfPos.x, selfPos.z, 14, 9);
+    else if (!app.preview) stage.frameRect(selfPos.x, selfPos.z, 26, 16);
+
+    if (!v) return;
+    // Battle log: new lines become effects and sounds.
+    const log = v.log ?? [];
+    if (inBattle && !seenFoe) {
+      sfx.play("rustle");
+      stage.ring(selfPos.x, selfPos.z, 3, 0xc6f27a);
+    }
+    seenFoe = inBattle;
+    const wardenPos = at(map.warden[0], map.warden[1]);
+    for (const line of log) {
+      if (line.n <= seenLog) continue;
+      seenLog = line.n;
+      const target = line.who === 0 ? (v.battle?.warden ? wardenPos : (foePos ?? selfPos)) : (minePos ?? selfPos);
+      if (line.kind === LogKind.Hit) {
+        stage.burst(line.eff && line.eff > 0 ? "sparks" : "hitSpark", target.x, 0.8, target.z, ELEMENT_COLOR[g.moves[line.move ?? 0]?.el ?? 0], line.eff && line.eff > 0 ? 18 : 8);
+        sfx.play(line.who === 0 ? "hit" : "hurt", { gain: line.who === 0 ? 0.8 : 0.5 });
+        if (line.who === 1) stage.kick(0.25);
+      } else if (line.kind === LogKind.Snared) {
+        stage.burst("magic", target.x, 0.8, target.z, 0xffd76a, 30);
+        sfx.play("snare");
+        hud.toast(`${nameOf(line.value ?? 0)} snared`);
+      } else if (line.kind === LogKind.Slipped) sfx.play("slip");
+      else if (line.kind === LogKind.Won) {
+        stage.burst("kill", target.x, 0.6, target.z, 0xc6f27a, 16);
+        sfx.play("kill");
+      } else if (line.kind === LogKind.Level) {
+        sfx.play("levelUp");
+        hud.toast(`Level ${line.value}`);
+      } else if (line.kind === LogKind.Wiped) {
+        stage.kick(0.6);
+        sfx.play("bigKill");
+        hud.toast("Your team fainted. Back to camp");
+      } else if (line.kind === LogKind.Heal) sfx.play("pick");
+    }
+
+    // HUD chips and panels.
+    const mmss = (s: number) => `${Math.floor(s / 60)}:${String(Math.floor(s % 60)).padStart(2, "0")}`;
+    hud.status([
+      ["DUSK IN", mmss(v.dusk)],
+      ["SNARES", `${v.snares ?? 0}`],
+      ["CAUGHT", `${v.catches ?? 0}${v.box ? ` (${v.box} in lantern)` : ""}`],
+    ]);
+    ((wardenEl.lastChild as HTMLElement).firstChild as HTMLElement).style.transform = `scaleX(${Math.max(0, v.warden.hp / Math.max(1, v.warden.max))})`;
+    (wardenEl.firstChild as HTMLElement).textContent = `${(WEAPON_NAMES[g.marsh.warden.creature]?.name ?? "Warden").toUpperCase()}${v.warden.fighting ? ` · ${v.warden.fighting} FIGHTING` : ""}`;
+    pickEl.classList.toggle("show", !v.picked && v.phase !== "ended" && !app.preview);
+    const near = Math.hypot(wardenPos.x - selfPos.x, wardenPos.z - selfPos.z) < 5.5;
+    callEl.classList.toggle("show", near && !inBattle && !v.warden.down && !!v.picked && !app.preview);
+    const team = v.team ?? [];
+    const teamKey = JSON.stringify([team, v.active]);
+    if (teamEl.dataset.k !== teamKey) {
+      teamEl.dataset.k = teamKey;
+      teamEl.innerHTML = team
+        .map((x, i) => {
+          const c = g.creatures[x.species];
+          return `<div class="mon${i === v.active ? " on" : ""}${x.hp <= 0 ? " out" : ""}"><b><i class="dot" style="background:${cssColor(ELEMENT_COLOR[c?.el ?? 0] ?? 0)}"></i>${nameOf(x.species)}</b>Lv ${x.level} · ${x.hp}/${x.max}${hpBar(x.hp, x.max)}<div class="xp"><i style="transform:scaleX(${Math.min(1, x.xp / Math.max(1, x.next))})"></i></div></div>`;
+        })
+        .join("");
+    }
+    const b = v.battle;
+    battleEl.classList.toggle("show", !!b && !app.preview);
+    if (b) {
+      const mine = team[v.active ?? 0];
+      const key = JSON.stringify([b, mine, v.snares, log.at(-1)?.n, team.map((x) => x.hp)]);
+      if (battleEl.dataset.k !== key) {
+        battleEl.dataset.k = key;
+        const foe = g.creatures[b.foe.species];
+        const lines = log.slice(-3).map((l) => `<div>${sentence(l)}</div>`).join("");
+        const c = mine ? g.creatures[mine.species] : undefined;
+        battleEl.innerHTML = `<div class="foe"><span><i class="dot" style="background:${cssColor(ELEMENT_COLOR[foe?.el ?? 0] ?? 0)}"></i>${b.warden ? "THE " : "Wild "}${nameOf(b.foe.species)} Lv ${b.foe.level}</span><small>${b.foe.hp}/${b.foe.max}</small></div>${hpBar(b.foe.hp, b.foe.max)}<div class="log">${lines}</div><div class="moves"></div><div class="row"></div>`;
+        const movesEl = battleEl.querySelector(".moves") as HTMLElement;
+        c?.moveIdx.forEach((mi, j) => {
+          const mv = g.moves[mi];
+          const btn = document.createElement("button");
+          const eff = mv && foe ? effectiveness(mv.el, foe.el) : 0;
+          btn.innerHTML = `<i class="dot" style="background:${cssColor(ELEMENT_COLOR[mv?.el ?? 0] ?? 0)}"></i>${j + 1} ${moveName(mi)}<small>${mv?.power ? `${mv.power}${eff > 0 ? " · strong" : eff < 0 ? " · weak" : ""}` : (mv?.effect ?? "")}</small>`;
+          btn.addEventListener("click", () => clock.act(CollectorAct.Move, j));
+          movesEl.append(btn);
+        });
+        const row = battleEl.querySelector(".row") as HTMLElement;
+        if (!b.warden) {
+          const snare = document.createElement("button");
+          snare.className = "go";
+          snare.textContent = `Snare (${v.snares ?? 0})`;
+          snare.disabled = (v.snares ?? 0) <= 0;
+          snare.addEventListener("click", () => clock.act(CollectorAct.Snare));
+          row.append(snare);
+        }
+        team.forEach((x, i) => {
+          if (i === v.active || x.hp <= 0) return;
+          const sw = document.createElement("button");
+          sw.textContent = `Swap to ${nameOf(x.species)}`;
+          sw.addEventListener("click", () => clock.act(CollectorAct.Swap, i));
+          row.append(sw);
+        });
+        const flee = document.createElement("button");
+        flee.textContent = "Flee";
+        flee.addEventListener("click", () => clock.act(CollectorAct.Flee));
+        row.append(flee);
+      }
+    }
+    hud.end(v.phase === "ended", v.outcome === "won" ? "THE WARDEN FELL" : "DUSK", v.outcome === "won" ? "The marsh is quiet" : "The fen floods at dusk", v.endsIn ?? null);
+  });
+  app.extraStats(() => ({ creatures: creatures.size, keepers: keepers.size, battle: lastView?.battle ? 1 : 0, catches: lastView?.catches ?? 0, team: lastView?.team?.length ?? 0 }));
+
+  function sentence(l: LogLine): string {
+    const who = l.who === 0 ? "Yours" : "Foe";
+    switch (l.kind) {
+      case LogKind.Hit:
+        return `${who}: ${moveName(l.move ?? 0)} for ${l.dmg}${l.eff && l.eff > 0 ? ", strong" : l.eff && l.eff < 0 ? ", weak" : ""}`;
+      case LogKind.Miss:
+        return `${who}: ${moveName(l.move ?? 0)} missed`;
+      case LogKind.Heal:
+        return `${who}: ${moveName(l.move ?? 0)}, +${l.value} health`;
+      case LogKind.Guard:
+        return `${who}: ${moveName(l.move ?? 0)}, guarding`;
+      case LogKind.Swap:
+        return `${nameOf(l.value ?? 0)} steps in`;
+      case LogKind.Snared:
+        return `Snared ${nameOf(l.value ?? 0)}`;
+      case LogKind.Slipped:
+        return `${nameOf(l.value ?? 0)} slipped the snare`;
+      case LogKind.Fled:
+        return "You ran";
+      case LogKind.Won:
+        return `${nameOf(l.value ?? 0)} is beaten`;
+      case LogKind.Fainted:
+        return `${nameOf(l.value ?? 0)} fainted`;
+      case LogKind.Wiped:
+        return "Your team fainted";
+      case LogKind.Level:
+        return `Level ${l.value}`;
+      case LogKind.Met:
+        return `A wild ${nameOf(l.value ?? 0)} rises from the reeds`;
+      case LogKind.Warden:
+        return `The ${nameOf(l.value ?? 0)} wakes`;
+      default:
+        return "";
+    }
+  }
+
+  /** The marsh plate: meadow, tall grass, mud under rocks, drawn once on a canvas. */
+  function marshTexture(): CanvasTexture {
+    const px = 32;
+    const c = document.createElement("canvas");
+    c.width = map.w * px;
+    c.height = map.h * px;
+    const ctx = c.getContext("2d");
+    if (!ctx) throw new Error("no 2d canvas");
+    let s = 5;
+    const r = () => ((s = (s * 16807) % 2147483647) / 2147483647);
+    for (let y = 0; y < map.h; y++)
+      for (let x = 0; x < map.w; x++) {
+        const t = y * map.w + x;
+        ctx.fillStyle = map.water[t] ? "#2c5a70" : map.blocked[t] ? "#5a5040" : map.grass[t] ? ((x + y) % 2 ? "#36602c" : "#3a6630") : (x + y) % 2 ? "#6e8a4a" : "#729050";
+        ctx.fillRect(x * px, y * px, px, px);
+        for (let i = 0; i < (map.grass[t] ? 10 : 4); i++) {
+          ctx.fillStyle = map.grass[t] ? `rgba(150, 200, 90, ${0.3 + r() * 0.3})` : `rgba(60, 80, 40, ${0.15 + r() * 0.2})`;
+          ctx.fillRect(x * px + r() * px, y * px + r() * px, 2, map.grass[t] ? 5 : 2);
+        }
+      }
+    // A trodden path from camp to the warden's mound.
+    ctx.fillStyle = "rgba(150, 120, 80, 0.55)";
+    const cy = (map.camp[1] + 0.5) * px;
+    ctx.fillRect((map.camp[0] + 0.5) * px, cy - 6, (map.warden[0] - map.camp[0]) * px, 12);
+    const tex = new CanvasTexture(c);
+    tex.colorSpace = SRGBColorSpace;
+    tex.magFilter = NearestFilter;
+    return tex;
+  }
+}
+
+main().catch((e: unknown) => {
+  const t = document.getElementById("banner-text");
+  if (t) t.textContent = `Could not start: ${e instanceof Error ? e.message : String(e)}`;
+  console.error(e);
+});

package/client/names.ts

@@ -0,0 +1,52 @@
+/**
+ * Display names for the template's content ids. Labels only; the rules are
+ * in src/game.ts. A Net Forge game generated on this template ships its own
+ * table (the model writes src/names.json; the build turns it into this
+ * module), so the client imports only these names from here. Creatures are
+ * the "weapons" table ({ name, line }); moves read as their ids.
+ */
+export const TITLE = "Mossbound";
+
+export const WEAPON_NAMES: Readonly<Record<string, { name: string; line: string }>> = {
+  mossling: { name: "Mossling", line: "Steady and hard to tire" },
+  cindertail: { name: "Cindertail", line: "Quick, hits first" },
+  puddlewump: { name: "Puddlewump", line: "Soaks hits, heals itself" },
+  sporecap: { name: "Sporecap", line: "A cloud of spores" },
+  voltmoth: { name: "Voltmoth", line: "Fastest in the reeds" },
+  reedcrab: { name: "Reedcrab", line: "Shell like a door" },
+  pebblewing: { name: "Pebblewing", line: "A flying stone" },
+  bogling: { name: "Bogling", line: "Slow, heavy fists" },
+  fenwarden: { name: "Fenwarden", line: "Keeper of the mound" },
+};
+
+export const UPGRADE_NAMES: Readonly<Record<string, { name: string; line: string }>> = {
+  thornbark: { name: "Thornbark", line: "Your team hits harder" },
+  mossmail: { name: "Mossmail", line: "Your team takes less" },
+  spare_snares: { name: "Spare snares", line: "+3 snares this run" },
+  fen_tonic: { name: "Fen tonic", line: "Heal while you walk" },
+};
+
+export const ENEMY_NAMES: Readonly<Record<string, string>> = {
+  fenwarden: "Fenwarden",
+};
+
+export const RULE_NAMES: Readonly<Record<string, string>> = {
+  first_snare: "First Snare",
+  full_lantern: "Full Lantern",
+  warden_breaker: "Warden Breaker",
+  seasoned: "Seasoned",
+};
+
+export const SKU_NAMES: Readonly<Record<string, string>> = {
+  thornbark: "Thornbark",
+  mossmail: "Mossmail",
+  spare_snares: "Spare snares",
+  fen_tonic: "Fen tonic",
+  skin_lichen: "Lichen cloak",
+  skin_amber: "Amber cloak",
+  lucky_reed: "Lucky reed",
+};
+
+/** Player colours by slot, and a highlight palette (the generated names module carries both). */
+export const KEEPER_COLORS = [0x9dff7a, 0x5ec8ff, 0xffb347, 0xff7ab8, 0xc9a7ff, 0xffe066, 0x7affd4, 0xff9a5c];
+export const AURORA = { body: 0x3cf2c4, glow: 0xa77bff };

package/llms.txt

@@ -0,0 +1,113 @@
+# MOSSBOUND: the monster collector template (NetNet game runtime, board genre)
+
+> A shared marsh for up to 8 keepers. Each picks one of the starters at
+> camp, walks the marsh, meets wild creatures in tall grass and battles them
+> turn by turn with a team of three, snaring the ones worth keeping. Every
+> keeper in the marsh wears down the same warden; it must fall before dusk.
+> You change the game by editing src/game.ts only. The template already has
+> walking and collision, encounters, turn order, damage, the element cycle,
+> snaring, team swaps, XP and levels, the camp, the warden fight, dusk,
+> netcode, rendering, touch controls, earn and the store. Do not write
+> renderers, netcode or battle AI.
+
+## Files
+
+- src/game.ts: THE GAME. Declarations against @netforge/engine:
+  game(), marsh(), creature(), move(), upgrade(), earn.rule(), earn.stake(), store.sku().
+- src/names.json: the title and every label players read. Creatures go in
+  "weapons" ({ name, line }), the warden in "enemies", plus upgrades, earn
+  rules and store items. Moves are shown from their ids ("leaf_lash" reads
+  "Leaf Lash"), so name moves the way players should read them.
+- Everything else is template machinery.
+
+## Rules the build enforces
+
+- game({ template: "collector", style, places, players: { prefab, max } }).
+- Exactly one marsh(...); 1 to 24 creature(...)s; at most 48 move(...)s.
+- Every creature's moves are declared moves (1 to 4 each).
+- marsh starters and grass pools name declared creatures that are not
+  bosses; the warden names a creature with boss: true.
+- The camp and the warden stand inside the marsh on tiles that are not
+  blocked; grass and blocked rects stay inside the marsh.
+- Elements are "root", "tide", "spark", "stone": a cycle where each beats
+  the next (root soaks tide, tide shorts spark, spark cracks stone, stone
+  crushes root). Strong hits deal 1.5x, weak ones 0.67x.
+- Upgrades read five stats only: might (team attack), maxHealth (team
+  health, a fraction: 0.15 is +15%), armor (team defence), amount (extra
+  snares) and regen (share of max health healed each second out of battle).
+- No weapon(...): a collector game declares creature(...) and move(...).
+- Asset ids look like "style.lowpoly.frog", never URLs or paths, and must be
+  in the asset library. game({ style }) is the art style the creator picked
+  (lowpoly, toon, ps1, pixel, voxel or handdrawn); keep it.
+- 4 playtest keepers must win battles, catch creatures and fire an earn rule
+  in 4 minutes, and must not lose their whole team more than twice each.
+
+## Units
+
+A tile is 2 m; marsh rects are [x, y, width, height] in tiles. Stats are
+base values at level 1 and grow 12% a level. power 40 is a plain hit.
+Walking speed is metres a second. Tick rate 30 Hz.
+
+## The loop
+
+A keeper picks a starter at camp (starterLevel). Every step into a new tile
+of tall grass rolls the zone's rate; a hit starts a battle with a creature
+from the zone's pool at a level in its range. A turn: you pick a move, a
+swap, a snare or flee; the faster creature acts first; the foe answers
+with its best move. A beaten foe gives XP (the active creature full, the
+rest half). A snare's chance is catchRate x (0.25 + 0.75 x the foe's
+missing health); a caught creature joins the team (three at most; more go
+into the lantern). Wild creatures hit at 80%. If your whole team faints you
+are sent to camp with half health; standing at camp heals. Near the
+warden, Challenge starts the warden fight: its health is one pool for the
+whole marsh, it hits at full strength, and when it falls everyone who hurt
+it shares the win. At dusk the run is lost.
+
+## Common changes
+
+### A new creature
+creature("thistlehog", { model: "style.lowpoly.fox", element: "root", hp: 50, atk: 52, def: 48, spd: 46, moves: ["leaf_lash", "thorn_curl"], catchRate: 0.7 });
+move("thorn_curl", { element: "root", power: 0, effect: "guard" });
+Then put it in a grass pool, and its label in names.json weapons.
+
+### Moves
+move("tide_crash", { element: "tide", power: 70, accuracy: 0.8 });
+effect "drain" heals half the damage dealt; "heal" (power 0) restores
+amount of max health; "guard" halves the next hit taken.
+
+### The map
+marsh({ size: [30, 20], camp: [2, 10], water: [[11, 0, 2, 6]], blocked: [[19, 0, 1, 8]],
+  grass: [{ at: [4, 2, 6, 5], rate: 0.22, pool: [{ creature: "sporecap", weight: 3, level: [2, 3] }] }], ... });
+Put weak creatures near camp and stronger ones toward the warden. Leave a
+walkable way from camp to every grass zone and to the warden.
+
+### Harder or easier
+Raise pool levels, the warden's level or hp, or lower snares and grass
+rates. "Longer": a later dusk. "More catching": higher catchRate and snares.
+
+### Add an earn rule
+earn.rule("ten_wins", { when: "creature.defeated", n: 10, pay: 15, oncePer: "run" });
+Events: creature.caught, creature.defeated, creature.levelup, level.five
+and level.ten (each credits the keeper), warden.defeated (everyone who hurt
+it), run.won (everyone in the marsh). Each rule pays once per run per player,
+in coins; the room server is the referee.
+
+### The buy-in run (required)
+earn.stake({ min: 20, max: 200, multiple: 2 });
+One top-level line; a game without it does not build. "stake" is reserved.
+
+### Coins: earn and the store
+Every game has coins: 1 coin = 1 of the game's own token, shown under the
+token's own name, symbol and logo.
+store.sku("thornbark", { coins: 40 });                                  // one level of the "thornbark" upgrade for the run
+store.sku("skin_amber", { coins: 500, grants: { cosmetic: 2 } });       // a keeper's cloak, owned for good
+store.sku("lucky_reed", { coins: 150, grants: { gear: "thornbark", loseBelow: 0.25 } }); // losable gear
+Keep the SKUs the client is wired to (thornbark, mossmail, spare_snares,
+fen_tonic, skin_lichen, skin_amber, lucky_reed) at their prices.
+
+## Test
+
+engine.test.run({ ticks: 30 * 240, bots: 4 }) plays the marsh with 4
+keepers and reports battles won plus catches (kills), 1 + catches (wave),
+the highest level, team wipes (deaths), earned by rule, softlock, ms per
+tick, and the genre's own checks under rules.checks.

package/package.json

@@ -1,6 +1,57 @@
 {
   "name": "@netforge/template-collector",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "MOSSBOUND: the monster collector template of the NetNet game runtime, a shared marsh where keepers catch fen spirits, battle turn by turn with a team of three and bring down the warden before dusk. The game module, its browser client and its playtest bots.",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": "./src/manifest.ts",
+    "./store": "./src/store.ts"
+  },
+  "files": [
+    "src",
+    "client",
+    "!client/vite.config.ts",
+    "llms.txt",
+    "README.md",
+    "NOTICE",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/netnetdev/net-forge.git",
+    "directory": "packages/template-collector"
+  },
+  "homepage": "https://github.com/netnetdev/net-forge/tree/main/packages/template-collector#readme",
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "three": "0.186.1",
+    "@netforge/asset-library": "0.1.0",
+    "@netforge/engine-sim": "0.1.0",
+    "@netforge/tabletop": "0.1.0",
+    "@netforge/engine": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "22.20.1",
+    "@types/three": "0.186.0",
+    "tsx": "4.23.0",
+    "typescript": "5.8.3",
+    "vite": "6.4.3",
+    "vitest": "3.2.7"
+  },
+  "bugs": {
+    "url": "https://github.com/netnetdev/net-forge/issues"
+  },
+  "scripts": {
+    "build": "node ../engine/scripts/fresh-dist.mjs && vite build --config client/vite.config.ts",
+    "typecheck": "tsc -p tsconfig.json",
+    "test": "vitest run",
+    "dev": "vite --config client/vite.config.ts",
+    "preview": "vite preview --config client/vite.config.ts"
+  }
 }

package/src/game.ts

@@ -0,0 +1,101 @@
+/**
+ * MOSSBOUND: the monster collector template (play style: monster-collector RPG).
+ *
+ * Fen spirits live in the tall grass of a flooded marsh. Each keeper picks
+ * one of three starters at camp, walks the reeds, meets wild spirits in the
+ * grass and battles them turn by turn with a team of three, snaring the
+ * ones worth keeping in a reed lantern. At the far end of the marsh the
+ * Fenwarden waits: every keeper in the marsh wears down the same warden,
+ * and it must fall before dusk.
+ *
+ * This file is the whole game as the model writes it: declarations only,
+ * against the typed API in @netforge/engine. Walking, encounters,
+ * battles, catching, levels, netcode, renderer and referee are the
+ * template's machinery.
+ */
+import { creature, earn, game, marsh, move, store, upgrade } from "@netforge/engine";
+
+export default game({
+  template: "collector",
+  style: "lowpoly",
+  places: { fen: { chunks: "places/fen", spawn: [0, 0, 0] } },
+  players: { prefab: "style.lowpoly.hooded_adventurer", max: 8 },
+});
+
+// The marsh: 30 x 20 tiles of 2 m. Camp in the west, the warden's mound in the east, water and rocks between.
+marsh({
+  size: [30, 20],
+  camp: [2, 10],
+  starters: ["mossling", "cindertail", "puddlewump"],
+  starterLevel: 4,
+  water: [
+    [11, 0, 2, 6],
+    [11, 14, 2, 6],
+    [24, 0, 3, 3],
+  ],
+  blocked: [
+    [19, 0, 1, 8],
+    [19, 12, 1, 8],
+    [8, 9, 1, 2],
+    [15, 2, 1, 1],
+    [16, 16, 1, 1],
+  ],
+  grass: [
+    { at: [4, 2, 6, 5], rate: 0.22, pool: [{ creature: "sporecap", weight: 3, level: [2, 3] }, { creature: "voltmoth", weight: 2, level: [2, 3] }, { creature: "reedcrab", weight: 1, level: [2, 4] }] },
+    { at: [4, 13, 6, 5], rate: 0.22, pool: [{ creature: "reedcrab", weight: 2, level: [2, 4] }, { creature: "sporecap", weight: 1, level: [3, 4] }, { creature: "pebblewing", weight: 1, level: [3, 4] }] },
+    { at: [14, 7, 4, 6], rate: 0.2, pool: [{ creature: "pebblewing", weight: 2, level: [4, 6] }, { creature: "voltmoth", weight: 2, level: [4, 6] }, { creature: "bogling", weight: 1, level: [5, 6] }] },
+    { at: [21, 4, 4, 12], rate: 0.18, pool: [{ creature: "bogling", weight: 2, level: [6, 8] }, { creature: "pebblewing", weight: 1, level: [6, 8] }, { creature: "reedcrab", weight: 1, level: [6, 8] }] },
+  ],
+  warden: { creature: "fenwarden", at: [27, 10], level: 9, hp: 700 },
+  dusk: 600,
+  snares: 6,
+});
+
+// Creatures. Base stats at level 1 (each grows 12% a level); catchRate scales every snare.
+creature("mossling", { model: "style.lowpoly.frog", element: "root", hp: 46, atk: 48, def: 50, spd: 44, moves: ["leaf_lash", "sap_drink"] });
+creature("cindertail", { model: "style.lowpoly.fox", element: "spark", hp: 40, atk: 54, def: 42, spd: 58, moves: ["ember_nip", "static_dash"] });
+creature("puddlewump", { model: "style.lowpoly.slime_drop", element: "tide", hp: 52, atk: 44, def: 52, spd: 40, moves: ["splash_jab", "bubble_ward"] });
+creature("sporecap", { model: "style.lowpoly.mushroom_imp", element: "root", hp: 42, atk: 46, def: 46, spd: 38, moves: ["spore_puff", "leaf_lash"], catchRate: 0.9 });
+creature("voltmoth", { model: "style.lowpoly.bee", element: "spark", hp: 36, atk: 50, def: 38, spd: 64, moves: ["static_dash", "ember_nip"], catchRate: 0.85 });
+creature("reedcrab", { model: "style.lowpoly.crab", element: "tide", hp: 48, atk: 50, def: 60, spd: 36, moves: ["splash_jab", "shell_up"], catchRate: 0.8 });
+creature("pebblewing", { model: "style.lowpoly.pebble_flyer", element: "stone", hp: 44, atk: 48, def: 56, spd: 50, moves: ["gravel_toss", "shell_up"], catchRate: 0.7 });
+creature("bogling", { model: "style.lowpoly.blob_orc", element: "stone", hp: 60, atk: 52, def: 54, spd: 30, moves: ["gravel_toss", "mire_slam"], catchRate: 0.6, size: 1.3 });
+creature("fenwarden", { model: "style.lowpoly.mushroom_king", element: "stone", hp: 120, atk: 66, def: 64, spd: 40, moves: ["mire_slam", "gravel_toss", "sap_drink"], boss: true, size: 3.4 });
+
+// Moves. power 40 is a plain hit; drain heals half the damage, heal restores a share of max health, guard halves the next hit.
+move("leaf_lash", { element: "root", power: 40 });
+move("sap_drink", { element: "root", power: 30, effect: "drain" });
+move("spore_puff", { element: "root", power: 45, accuracy: 0.9 });
+move("ember_nip", { element: "spark", power: 40 });
+move("static_dash", { element: "spark", power: 55, accuracy: 0.85 });
+move("splash_jab", { element: "tide", power: 40 });
+move("bubble_ward", { element: "tide", power: 0, effect: "heal", amount: 0.3 });
+move("gravel_toss", { element: "stone", power: 40 });
+move("shell_up", { element: "stone", power: 0, effect: "guard" });
+move("mire_slam", { element: "stone", power: 70, accuracy: 0.8 });
+
+// Store upgrades: one level each, for the rest of the run, on the buyer's own team.
+upgrade("thornbark", { stat: "might", step: 0.15, maxLevel: 1 });
+upgrade("mossmail", { stat: "armor", step: 0.15, maxLevel: 1 });
+upgrade("spare_snares", { stat: "amount", step: 3, maxLevel: 1 });
+upgrade("fen_tonic", { stat: "regen", step: 0.03, maxLevel: 1 });
+
+// Earn (mandatory). Pays the game's coins (1 coin = 1 token), once per run each. Values are PLACEHOLDER.
+earn.rule("first_snare", { when: "creature.caught", n: 1, pay: 5, oncePer: "run" });
+earn.rule("full_lantern", { when: "creature.caught", n: 3, pay: 20, oncePer: "run" });
+earn.rule("warden_breaker", { when: "warden.defeated", n: 1, pay: 50, oncePer: "run" });
+earn.rule("seasoned", { when: "level.five", n: 1, pay: 5, oncePer: "run" });
+// Buy-in run (the mandatory sink loop): stake coins at run start to earn above free play.
+// A staked run also pays up to stake x multiple, by the share of this run's earn the player makes. Values are PLACEHOLDER.
+earn.stake({ min: 20, max: 200, multiple: 2 });
+
+// Store (the Kit), priced in coins: four run upgrades and two keeper finishes owned for good (kept in the profile).
+store.sku("thornbark", { coins: 40 });
+store.sku("mossmail", { coins: 40 });
+store.sku("spare_snares", { coins: 60 });
+store.sku("fen_tonic", { coins: 50 });
+store.sku("skin_lichen", { coins: 300, grants: { cosmetic: 1 } });
+store.sku("skin_amber", { coins: 500, grants: { cosmetic: 2 } });
+// Losable gear: owned for good until lost. It brings one level of its upgrade into every staked run,
+// and is lost when that run makes less than loseBelow of its most earn. Values are PLACEHOLDER.
+store.sku("lucky_reed", { coins: 150, grants: { gear: "thornbark", loseBelow: 0.25 } });

package/src/manifest.ts

@@ -0,0 +1,44 @@
+/**
+ * Loads the game module once per process and compiles it. The room server,
+ * the client, the bots and the tests all start here.
+ */
+import { collectManifest } from "@netforge/engine/game";
+import type { GameManifest } from "@netforge/engine";
+import { rulesAdapter, collectorGenre } from "@netforge/engine/rules";
+import type { RulesInput, RulesWorld, CollectorState } from "@netforge/engine/rules";
+import type { SimAdapter } from "@netforge/engine/net";
+import "./game.js";
+
+/** Content version: bump with any change to game.ts (hot swap compares it). */
+export const GAME_VERSION = "mossbound-0.1.0";
+export const GAME_NAME = "mossbound";
+/** Room template (as the Net Forge room server names it) and place used by the client and the bots. */
+export const TEMPLATE = "collector";
+export const PLACE = "fen";
+
+/**
+ * Collected as soon as the module is imported: one process may load more
+ * than one game module (the room server hosts every template), and each
+ * manifest takes its own game before the next module declares.
+ */
+const MANIFEST = collectManifest();
+let genre: ReturnType<typeof collectorGenre> | null = null;
+
+/** The game's manifest (every declaration). */
+export function collectorManifest(): GameManifest {
+  return MANIFEST;
+}
+
+/** The compiled collector genre (marsh, creatures, moves). */
+export function collectorGame(): ReturnType<typeof collectorGenre> {
+  genre ??= collectorGenre(MANIFEST);
+  return genre;
+}
+
+/** The SimAdapter the room server and the client both run. */
+export function collectorAdapter(): SimAdapter<RulesWorld<CollectorState>, RulesInput> {
+  return rulesAdapter(collectorGame(), MANIFEST, { name: GAME_NAME, version: GAME_VERSION });
+}
+
+/** Cosmetic ids for store SKUs (0 is the default finish). */
+export const COSMETICS: Readonly<Record<string, number>> = { skin_lichen: 1, skin_amber: 2 };

package/src/store.ts

@@ -0,0 +1,25 @@
+/**
+ * Store hooks (the Coins model): every
+ * game has coins, 1 coin = 1 game token, shown under the token's own name,
+ * symbol and logo. MOSSBOUND sells four run upgrades (a store command named
+ * after the upgrade grants one level for the rest of the run), two finishes
+ * (permanent) and one piece of losable gear, all priced in coins. The Kit
+ * bridge and its in-memory stand-in live in @netforge/tabletop.
+ */
+export { mockKit } from "@netforge/tabletop";
+export type { KitStoreBridge, MockKit, SkuPrice } from "@netforge/tabletop";
+
+/** Coin prices the client is wired to (they match store.sku(...) in game.ts; the generator's gate keeps them). */
+export const COIN_PRICES = { thornbark: 40, mossmail: 40, spare_snares: 60, fen_tonic: 50, skin_lichen: 300, skin_amber: 500, lucky_reed: 150 } as const;
+export type SkuId = keyof typeof COIN_PRICES;
+/** Run upgrades: spent, applied by the room for the rest of the run. */
+export const UPGRADE_SKUS = ["thornbark", "mossmail", "spare_snares", "fen_tonic"] as const;
+/** Cosmetic finishes: bought once, owned for good. */
+export const COSMETIC_SKUS = ["skin_lichen", "skin_amber"] as const;
+
+/** The template's own coin, as its token metadata names it until a creator renames it. */
+export const MOSSBOUND_COIN = {
+  name: "Moss",
+  symbol: "MOSS",
+  logo: "data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 32 32'%3E%3Ccircle cx='16' cy='16' r='15' fill='%237bc96f'/%3E%3Cpath d='M16 6c6 4 8 10 4 16-2 3-6 4-8 2-4-4-2-12 4-18z' fill='%23234a1e'/%3E%3Cpath d='M15 26c0-6 1-10 4-14' stroke='%237bc96f' stroke-width='1.5' fill='none'/%3E%3C/svg%3E",
+} as const;