@homie-rocks/studio 0.38.0 → 0.40.0

package/rules/host.ts

@@ -290,6 +290,10 @@ export function createHost(o: HostOptions): Host {
     agents.on('ask', (d) => o.send({ t: 'ev', k: 'agent:ask', d }));
   }
   function guideBeat(): void {
+    // Roles come from admitted peers and reserved server seats, never player input.
+    const guideSeats = agentSlots().filter(slot => slot.agent?.role === 'guide').map(slot => slot.slot).sort((a, b) => a - b);
+    const previous = (core.world as { guideSeats: readonly number[] }).guideSeats;
+    if (guideSeats.length !== previous.length || guideSeats.some((seat, i) => seat !== previous[i])) core.setPolicy({ guideSeats });
     if (!agents) return;
     const bodies = core.bodies();
     for (const b of bodies) {
@@ -498,7 +502,7 @@ export function createHost(o: HostOptions): Host {
             speech: raw.speech === 'off' || raw.speech === 'lines' ? raw.speech : 'game' };
           if (previous.kind !== policy.kind || previous.aiSeats !== policy.aiSeats || previous.guides !== policy.guides) rosterText = '';
         }
-        if (p) core.setPolicy({ bots: p.bots === 'off' ? 'off' : 'fill', level: num(own(own(p, 'skill'), 'level') ?? own(p, 'level')), levelMax: num(own(p, 'levelMax')), reserved: policy.kind === 'hybrid' || policy.kind === 'beginner' ? policy.aiSeats + policy.guides : 0 });
+        if (p) core.setPolicy({ kids: own(p, 'kids') === true, ...(own(p, 'level') !== undefined ? { guideLevel: num(own(p, 'level')) } : {}), levelSet: Boolean(own(p, 'by')), bots: p.bots === 'off' ? 'off' : 'fill', level: num(own(own(p, 'skill'), 'level') ?? own(p, 'level')), levelMax: num(own(p, 'levelMax')), reserved: policy.kind === 'hybrid' || policy.kind === 'beginner' ? policy.aiSeats + policy.guides : 0 });
         return;
       }
       default: return;

package/rules/math.ts

@@ -12,6 +12,7 @@
  * Every call is charged 4 units to the running handler's budget (guard.ts), beside what any guarded call costs.
  * =============================================================================
  */
+import { castMap3, restsOnMap, type BodyShape } from './collision.ts';
 import { brand, charge, own, put } from './guard.ts';
 import { num } from './pack.ts';
 
@@ -181,7 +182,7 @@ export const exact = Object.freeze({ sin, cos, atan, atan2, exp, log, pow });
 /* ------------------------------------------------------------------ the ground plane: a point or a circle against the map */
 
 /** The shapes of a map the sweep reads (rules.ts `GameMap` has them). */
-export interface MapShapes { bounds: { min: Vec3; max: Vec3 }; boxes: readonly { min: Vec3; max: Vec3 }[]; circles: readonly { at: Vec3; r: number }[] }
+export interface MapShapes { bounds: { min: Vec3; max: Vec3 }; boxes: readonly { min: Vec3; max: Vec3 }[]; circles: readonly { at: Vec3; r: number }[]; spheres?: readonly { at: Vec3; r: number }[]; capsules?: readonly { at: Vec3; r: number; height: number }[]; heightTiles?: readonly import('./rules.ts').MapHeightTile[] }
 /** How close a swept body stops to what it hit, in metres. */
 export const SKIN = 0.001;
 
@@ -244,9 +245,9 @@ export function castMap(map: MapShapes, px: number, py: number, dx: number, dy:
 /**
  * `ctx.map.sweep(body, delta)`: move `body.pos` along `delta` and stop at the first static shape in the way. The server
  * and a browser both move a body with this, so they agree to the last bit. Returns nothing, or `{ at, normal }`.
- * Charged 20 units and 4 for each shape of the map. With `dims` 2 a body always rests on the ground.
+ * The 2D path charges 20 units and 4 per shape; 3D also charges each convex cast and terrain tile. With `dims` 2 a body always rests on the ground.
  */
-export function sweepMap(map: MapShapes, body: unknown, delta: unknown, radius: number, _dims: number): unknown {
+export function sweepMap(map: MapShapes, body: unknown, delta: unknown, radius: number, dims: number, shape: BodyShape = { shape: 'sphere', radius, height: 2 * radius }): unknown {
   // Charged before the cast, for every shape of the map it may test.
   charge(20 + 4 * (4 + map.boxes.length + map.circles.length));
   const fr = Math.fround;
@@ -256,6 +257,15 @@ export function sweepMap(map: MapShapes, body: unknown, delta: unknown, radius:
   const pos = own(body, 'pos');
   const dx = num(own(delta, 'x')); const dy = num(own(delta, 'y'));
   const px = num(own(pos, 'x')); const py = num(own(pos, 'y'));
+  if (dims === 3) {
+    const p = v(px, py, num(own(pos, 'z'))), d = v(dx, dy, num(own(delta, 'z')));
+    const h = castMap3(map, p, d, shape);
+    const length = Math.sqrt(dx * dx + dy * dy + d.z * d.z);
+    const t = h ? Math.max(0, h.t - (length > 0 ? SKIN / length : 0)) : 1;
+    const at = v(fr(px + dx * t), fr(py + dy * t), fr(p.z + d.z * t));
+    put(body, 'pos', at); put(body, 'grounded', restsOnMap(map, at, shape));
+    return h ? Object.freeze({ at, normal: v(h.nx, h.ny, h.nz) }) : undefined;
+  }
   const { hit: h } = castMap(map, px, py, dx, dy, radius);
   put(body, 'grounded', true);
   if (!h) { put(body, 'pos', v(fr(px + dx), fr(py + dy), 0)); return undefined; }
@@ -271,12 +281,12 @@ export function sweepMap(map: MapShapes, body: unknown, delta: unknown, radius:
  * map. One function, so that the browser (view.ts) and the person the build check plays hold the same one. The
  * server's own (core.ts `moveCtx`) is made beside the rest of its world, and charges as that does.
  */
-export function moveContext(o: { tick: () => number; tickHz: number; tune: unknown; map: MapShapes; name: string; spots: Readonly<Record<string, readonly unknown[]>>; radius: () => number; dims: number }): unknown {
+export function moveContext(o: { tick: () => number; tickHz: number; tune: unknown; map: MapShapes; name: string; spots: Readonly<Record<string, readonly unknown[]>>; radius: () => number; shape?: () => BodyShape; dims: number }): unknown {
   const none = Object.freeze([]);
   return brand(Object.freeze({
     get tick() { return o.tick(); }, dt: 1 / o.tickHz, tune: o.tune, math,
     // As the server's `ctx.ticks` reads it: a plain number, or nothing.
     ticks: (seconds: unknown): number => { const s = num(seconds); const n = Math.round(s * o.tickHz); return s > 0 && Number.isFinite(n) ? Math.max(1, n) : 0; },
-    map: brand(Object.freeze({ name: o.name, spot: (name: string) => (own(o.spots, name) as readonly unknown[] | undefined)?.[0], spots: (name: string) => own(o.spots, name) ?? none, sweep: (body: unknown, delta: unknown) => sweepMap(o.map, body, delta, o.radius(), o.dims) })),
+    map: brand(Object.freeze({ name: o.name, spot: (name: string) => (own(o.spots, name) as readonly unknown[] | undefined)?.[0], spots: (name: string) => own(o.spots, name) ?? none, sweep: (body: unknown, delta: unknown) => sweepMap(o.map, body, delta, o.radius(), o.dims, o.shape?.()) })),
   }));
 }

package/rules/rules.ts

@@ -71,7 +71,7 @@ const plain = (t: FieldKind) => (o?: FieldOptions): Field => made(t, o);
 /**
  * The types of declared state. Whole numbers (`u8` to `u32`, `i8` to `i32`) are held to their range; `bit` is true or
  * false; `fix` is a fixed-point number in steps of 1/4096; `vec3` is a position or a velocity in metres; `dir` is a
- * unit vector on the ground plane; `tick` is a moment and `ticks` a length on the room's clock; `ref` is the id of an
+ * unit vector in the declared dimensions; `tick` is a moment and `ticks` a length on the room's clock; `ref` is the id of an
  * entity or a player; `text`, `list` and `map` name their largest size. `press` (in `input` only) is a button that
  * fires once.
  */
@@ -236,7 +236,8 @@ export function roomSettings(raw: unknown): { settings: RoomSettings; problems:
 
 export interface MapBox { readonly min: Vec3; readonly max: Vec3 }
 export interface MapCircle { readonly at: Vec3; readonly r: number }
-export interface GameMap { readonly name: string; readonly bounds: MapBox; readonly boxes: readonly MapBox[]; readonly circles: readonly MapCircle[]; readonly spots: Readonly<Record<string, readonly Vec3[]>> }
+export interface MapHeightTile { readonly at: Vec3; readonly size: Readonly<{ x: number; y: number }>; readonly heights: readonly [number, number, number, number] }
+export interface GameMap { readonly name: string; readonly heightTiles: readonly MapHeightTile[]; readonly bounds: MapBox; readonly boxes: readonly MapBox[]; readonly circles: readonly MapCircle[]; readonly spheres: readonly MapCircle[]; readonly capsules: readonly (MapCircle & { height: number })[]; readonly spots: Readonly<Record<string, readonly Vec3[]>> }
 
 const vecOf = (a: unknown, what: string): Vec3 => {
   const p = Array.isArray(a) ? { x: a[0], y: a[1], z: a[2] ?? 0 } : a as { x?: unknown; y?: unknown; z?: unknown } | null;
@@ -247,8 +248,7 @@ const vecOf = (a: unknown, what: string): Vec3 => {
 
 /**
  * One map file (`games/<id>/map/<name>.json`), checked: `bounds` (the world's edges), `boxes` and `circles` (solid
- * shapes on the ground plane) and named `spots`. Positions are metres, `z` up. Height tiles, spheres and capsules
- * arrive with 3D bodies.
+ * shapes on the ground plane), spheres, upright capsules, height tiles and named `spots`. Positions are metres, `z` up.
  */
 export function compileMap(raw: unknown, name = 'main'): GameMap {
   const m = raw && typeof raw === 'object' ? raw as Record<string, any> : {};
@@ -256,7 +256,7 @@ export function compileMap(raw: unknown, name = 'main'): GameMap {
   if (!m.bounds) throw new Error(`${where} needs "bounds": { "min": [x, y], "max": [x, y] }, the edges of the world in metres`);
   const box = (b: any, what: string): MapBox => {
     const min = vecOf(b?.min, `${what}.min`); const max = vecOf(b?.max, `${what}.max`);
-    if (!(max.x > min.x) || !(max.y > min.y)) throw new Error(`${what}: "max" is above and to the right of "min"`);
+    if (!(max.x > min.x) || !(max.y > min.y) || max.z < min.z) throw new Error(`${what}: "max" is above and to the right of "min"`);
     return Object.freeze({ min, max });
   };
   const spots: Record<string, readonly Vec3[]> = {};
@@ -264,13 +264,33 @@ export function compileMap(raw: unknown, name = 'main'): GameMap {
     if (!/^[a-z][A-Za-z0-9_-]{0,31}$/.test(key) || !Array.isArray(list)) throw new Error(`${where} spots.${key}: a spot name is a short word and holds a list of points`);
     spots[key] = Object.freeze(list.map((p, i) => vecOf(p, `${where} spots.${key}[${i}]`)));
   }
+  const roundShape = (c: any, what: string): MapCircle => {
+    const r = Number(c?.r);
+    if (!Number.isFinite(r) || !(r > 0)) throw new Error(`${what} needs a finite positive radius`);
+    return Object.freeze({ at: vecOf(c?.at, `${what}.at`), r });
+  };
+  if ([m.boxes, m.circles, m.spheres, m.capsules, m.heightTiles].some(list => list !== undefined && !Array.isArray(list))) throw new Error(`${where}: shapes are lists`);
+  if ([m.boxes, m.circles, m.spheres, m.capsules, m.heightTiles].reduce((n, list) => n + (list?.length ?? 0), 0) > 4096) throw new Error(`${where}: at most 4096 static shapes`);
   return Object.freeze({
     name,
+    heightTiles: Object.freeze((m.heightTiles ?? []).map((t: any, i: number) => {
+      const what = `${where} heightTiles[${i}]`;
+      const at = vecOf(t?.at, `${what}.at`);
+      if (!Array.isArray(t.size) || t.size.length !== 2 || t.size.some((v: unknown) => typeof v !== 'number' || !Number.isFinite(v) || v <= 0)) throw new Error(`${what}: size is two positive finite lengths`);
+      if (!Array.isArray(t.heights) || t.heights.length !== 4 || t.heights.some((v: unknown) => typeof v !== 'number' || !Number.isFinite(v))) throw new Error(`${what}: heights are four finite offsets, in row order`);
+      return Object.freeze({ at, size: Object.freeze({ x: t.size[0], y: t.size[1] }), heights: Object.freeze([...t.heights]) as unknown as MapHeightTile['heights'] });
+    })),
+    spheres: Object.freeze((m.spheres ?? []).map((c: any, i: number) => roundShape(c, `${where} spheres[${i}]`))),
+    capsules: Object.freeze((m.capsules ?? []).map((c: any, i: number) => {
+      const shape = roundShape(c, `${where} capsules[${i}]`);
+      if (!Number.isFinite(c.height) || c.height < 2 * shape.r) throw new Error(`${where} capsules[${i}]: height is at least twice the radius`);
+      return Object.freeze({ ...shape, height: c.height });
+    })),
     bounds: box(m.bounds, `${where} bounds`),
     boxes: Object.freeze((Array.isArray(m.boxes) ? m.boxes : []).map((b: unknown, i: number) => box(b, `${where} boxes[${i}]`))),
     circles: Object.freeze((Array.isArray(m.circles) ? m.circles : []).map((c: any, i: number) => {
       const r = Number(c?.r);
-      if (!(r > 0)) throw new Error(`${where} circles[${i}] needs "r", its radius in metres`);
+      if (!Number.isFinite(r) || !(r > 0)) throw new Error(`${where} circles[${i}] needs "r", its radius in metres`);
       return Object.freeze({ at: vecOf(c?.at, `${where} circles[${i}].at`), r });
     })),
     spots: Object.freeze(spots),
@@ -430,6 +450,8 @@ export function compileRules(def: RulesDef, env: CompileEnv = {}): Compiled {
   if (dims !== 2 && dims !== 3) throw new Error('rules name their space: space: { dims: 2 } or { dims: 3 }');
   const settings = env.settings ?? ROOM_DEFAULTS;
   const map = env.map ?? compileMap({ bounds: { min: [-32, -32], max: [32, 32] } });
+  if (dims === 2 && (map.spheres.length || map.capsules.length || map.heightTiles.length)) throw new Error('spheres, capsules and height tiles need space.dims: 3');
+  if (dims === 3 && map.bounds.max.z <= map.bounds.min.z) throw new Error('a 3D map needs bounds with positive height');
   const { tune, publicTune } = tunablesOf(env.tune);
 
   const events: Record<string, FieldList> = {};
@@ -475,9 +497,10 @@ export function compileRules(def: RulesDef, env: CompileEnv = {}): Compiled {
       const b = e.body;
       const shapes = dims === 2 ? ['circle'] : ['sphere', 'capsule', 'box'];
       if (!b || !shapes.includes(b.shape)) throw new Error(`${at}.body.shape is ${shapes.map((s) => `'${s}'`).join(' or ')} when space.dims is ${dims}`);
-      if (typeof b.radius !== 'number' || typeof b.maxSpeed !== 'number' || !(b.radius > 0) || !(b.maxSpeed >= 0)) throw new Error(`${at}.body needs radius (metres) and maxSpeed (metres a second)`);
+      if (typeof b.radius !== 'number' || typeof b.maxSpeed !== 'number' || !Number.isFinite(b.radius) || !Number.isFinite(b.maxSpeed) || !(b.radius > 0) || !(b.maxSpeed >= 0)) throw new Error(`${at}.body needs radius (metres) and maxSpeed (metres a second)`);
       if (b.move !== undefined && b.move !== 'owner') throw new Error(`${at}.body.move is 'owner', or left out`);
-      body = { shape: b.shape, radius: b.radius, height: typeof b.height === 'number' && b.height > 0 ? b.height : 0, maxSpeed: b.maxSpeed, sweep: b.sweep === true, owner: b.move === 'owner' };
+      if (dims === 3 && b.height !== undefined && (!Number.isFinite(b.height) || b.height <= 0 || b.shape === 'capsule' && b.height < b.radius * 2)) throw new Error(`${at}.body.height must be finite, positive and at least twice the radius for a capsule`);
+      body = { shape: b.shape, radius: b.radius, height: dims === 3 && b.shape === 'sphere' ? 2 * b.radius : typeof b.height === 'number' && b.height > 0 ? b.height : 0, maxSpeed: b.maxSpeed, sweep: b.sweep === true, owner: b.move === 'owner' };
     }
     if (player && !body) throw new Error(`${at}: a player's kind needs a body`);
     const moveFn = move && typeof move[name] === 'function' ? move[name] as MoveFn : null;
@@ -535,7 +558,7 @@ export interface Schema {
   contract: 2;
   dims: 2 | 3;
   seats: number;
-  kinds: { name: string; player: boolean; owner: boolean; radius: number; maxSpeed: number; score: string | null; fields: FieldList; motion: FieldList; input: FieldList }[];
+  kinds: { name: string; player: boolean; owner: boolean; radius: number; shape?: string; height?: number; maxSpeed: number; score: string | null; fields: FieldList; motion: FieldList; input: FieldList }[];
   effects: Record<string, FieldList>;
   effectNames: string[];
   commands: Record<string, FieldList>;
@@ -546,7 +569,7 @@ export interface Schema {
 export function schemaOf(c: Compiled): Schema {
   return {
     contract: RULES_CONTRACT, dims: c.dims, seats: c.seats,
-    kinds: c.kinds.map((k) => ({ name: k.name, player: Boolean(k.player), owner: Boolean(k.body?.owner), radius: k.body?.radius ?? 0, maxSpeed: k.body?.maxSpeed ?? 0, score: k.score, fields: k.fields, motion: k.motion, input: k.input })),
+    kinds: c.kinds.map((k) => ({ name: k.name, player: Boolean(k.player), owner: Boolean(k.body?.owner), radius: k.body?.radius ?? 0, ...(c.dims === 3 && k.body ? { shape: k.body.shape, height: k.body.height || 2 * k.body.radius } : {}), maxSpeed: k.body?.maxSpeed ?? 0, score: k.score, fields: k.fields, motion: k.motion, input: k.input })),
     effects: c.effects, effectNames: c.effectNames, commands: c.commands, shared: c.shared, rounds: c.rounds, settings: c.settings,
   };
 }

package/rules/types.ts

@@ -22,7 +22,7 @@ export interface MapView { readonly name: string; spot(name: string): Vec3 | und
 export interface Clock { readonly tick: number; readonly dt: number; ticks(seconds: number): number; readonly math: typeof math }
 export interface Round { readonly n: number; readonly phase: 'live' | 'over'; readonly endsAt: number }
 export type World<E, F, S, V, C, A, T, Room extends boolean = false> = Clock & {
-  readonly tune: ReadonlyState<T>; readonly map: MapView; readonly stage: string; readonly level: number; readonly levelMax: number;
+  readonly tune: ReadonlyState<T>; readonly map: MapView; readonly stage: string; readonly level: number; readonly levelMax: number; readonly guideLevel: number; readonly guideSeats: readonly number[]; readonly kids: boolean; readonly levelSet: boolean;
   readonly shared: Room extends true ? S : ReadonlyState<S>;
   readonly round: Round & (Room extends true ? { end(): void } : {});
   random(): number;
@@ -49,7 +49,7 @@ export type Undeliverable<E> = { [K in keyof E]: { to: string; event: K; data: E
 export type BuiltIns<E = Record<string, never>> = { arrive: { why: 'join' | 'spawn' }; leave: {}; takeover: {}; undeliverable: Undeliverable<E>; answer: { ask: string; by: string; picks: Readonly<Record<string, unknown>>; why?: string } };
 export type RoomEvents<E = Record<string, never>> = RoundEvents & { seatJoined: { seat: number; id: string; driver: 'person' | 'bot' | 'ai'; owner: string; took: boolean }; seatAway: { seat: number; id: string; away: boolean }; seatLeft: { seat: number; id: string }; answer: BuiltIns['answer']; undeliverable: BuiltIns<E>['undeliverable'] };
 export type RoundEvents = { roundStart: { n: number }; roundOver: { n: number; results: readonly { seat: number; id: string; driver: 'person' | 'bot' | 'ai'; score: number; place: number }[] } };
-type GuideWorld<W> = Pick<W, Extract<keyof W, 'tick' | 'dt' | 'ticks' | 'math' | 'map' | 'tune' | 'stage' | 'level' | 'levelMax' | 'round' | 'shared' | 'near' | 'inBox' | 'ray'>>;
+type GuideWorld<W> = Pick<W, Extract<keyof W, 'tick' | 'dt' | 'ticks' | 'math' | 'map' | 'tune' | 'stage' | 'level' | 'levelMax' | 'guideLevel' | 'guideSeats' | 'kids' | 'levelSet' | 'round' | 'shared' | 'near' | 'inBox' | 'ray'>>;
 export type Entity<W, S, I, E, C, V, Answer = BuiltIns['answer'], G = Goal, A = GuideRequest, D = GuideDecision> = {
   player?: true | { away?: 'neutral' | 'think'; leave?: 'despawn' | 'bot' }; fields?: Fields; motion?: Fields; input?: Fields; body?: BodyDef;
   tick?: (world: W, self: S) => void;

package/rules/view.ts

@@ -46,10 +46,28 @@ import { BudgetError } from './guard.ts';
 import { moveContext } from './math.ts';
 import { coerce, dir, stepMove, thawFields, unpackEntity, unpackFields, unpackVec, vec3 } from './pack.ts';
 import type { Unpacked } from './pack.ts';
+import { compileMap } from './rules.ts';
 import type { FieldList, MoveFn, Schema, Vec3 } from './rules.ts';
 
+/** Unit headings take the shortest arc, including an exact half turn. Linear
+ * interpolation passes through zero at a half turn and visibly flips a character. */
+export function blendHeading(a: Vec3, b: Vec3, t: number, dims: 2 | 3): Vec3 {
+  if (t <= 0) return a;
+  if (t >= 1) return b;
+  const dot = Math.max(-1, Math.min(1, a.x * b.x + a.y * b.y + a.z * b.z));
+  if (dot > 0.9995) return dir({ x: lerp(a.x, b.x, t), y: lerp(a.y, b.y, t), z: lerp(a.z, b.z, t) }, dims);
+  if (dot < -0.9995) {
+    const side = Math.abs(a.z) < 0.9 ? dir({ x: -a.y, y: a.x, z: 0 }, 3) : dir({ x: a.z, y: 0, z: -a.x }, 3);
+    const c = Math.cos(Math.PI * t), s = Math.sin(Math.PI * t);
+    return dir({ x: a.x * c + side.x * s, y: a.y * c + side.y * s, z: a.z * c + side.z * s }, dims);
+  }
+  const angle = Math.acos(dot), scale = Math.sin(angle);
+  const from = Math.sin((1 - t) * angle) / scale, to = Math.sin(t * angle) / scale;
+  return dir({ x: a.x * from + b.x * to, y: a.y * from + b.y * to, z: a.z * from + b.z * to }, dims);
+}
+
 /** What the build hands the view library for one game: its declarations, its public tunables and its map. No code. */
-export interface GameData { vocab?: Vocabulary; id: string; schema: Schema; tune: Record<string, unknown>; map: { name?: string; bounds: { min: unknown; max: unknown }; boxes?: unknown[]; circles?: unknown[]; spots?: Record<string, unknown[]> } }
+export interface GameData { vocab?: Vocabulary; id: string; schema: Schema; tune: Record<string, unknown>; map: { name?: string; bounds: { min: unknown; max: unknown }; boxes?: unknown[]; circles?: unknown[]; spheres?: unknown[]; capsules?: unknown[]; heightTiles?: unknown[]; spots?: Record<string, unknown[]> } }
 let current: { game: GameData; move: Record<string, MoveFn>; load?: () => Promise<RulesHostFactory> } | null = null;
 /** Called by the build's own two lines at the top of a view's bundle, before the view's code runs. */
 export function setGame(game: GameData, move: Record<string, MoveFn> = {}, load?: () => Promise<RulesHostFactory>): void { current = { game, move, load }; }
@@ -67,6 +85,8 @@ export type RoomStatus = 'connecting' | 'playing' | 'offline' | 'closed';
 export interface RoomRound { n: number; phase: 'live' | 'over'; endsAt: number; secondsLeft: number; results?: RoundInfo['results'] }
 export interface RosterRow { seat: number; name: string; driver: 'person' | 'bot' | 'ai'; score: number; me: boolean }
 export interface OpenRoomOptions {
+  /** Play a private rules round while an online room has no body for this player. */
+  fallback?: 'solo';
   game?: GameData;
   move?: Record<string, MoveFn>;
   net?: NetplayOptions;
@@ -97,7 +117,7 @@ export interface Room<R = unknown> {
   askButtons(id: string, offer?: Record<string, unknown>): AskButton[];
   readonly tune: Readonly<Record<string, unknown>>;
   /** The game's static map: its edges, its solid shapes and its named spots, in metres. */
-  readonly map: { readonly bounds: { min: Vec3; max: Vec3 }; readonly boxes: readonly { min: Vec3; max: Vec3 }[]; readonly circles: readonly { at: Vec3; r: number }[]; readonly spots: Readonly<Record<string, readonly Vec3[]>> };
+  readonly map: { readonly bounds: { min: Vec3; max: Vec3 }; readonly boxes: readonly { min: Vec3; max: Vec3 }[]; readonly circles: readonly { at: Vec3; r: number }[]; readonly heightTiles: readonly import('./rules.ts').MapHeightTile[]; readonly spheres: readonly { at: Vec3; r: number }[]; readonly capsules: readonly { at: Vec3; r: number; height: number }[]; readonly spots: Readonly<Record<string, readonly Vec3[]>> };
   readonly net: Netplay;
   /** Run the room's clock up to now (called by itself on a timer and whenever the view reads the room). */
   pump(): void;
@@ -124,11 +144,11 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
   const agents = game.vocab && agentFactory ? agentFactory(net, game.vocab, { roles: ['guide', 'party'], view: () => ({}), manual: true, viewOnly: true }) : null;
   const kindOf = new Map(schema.kinds.map((k) => [k.name, k]));
   const listeners = new Map<string, Set<(e: any) => void>>();
-  const emit = (name: string, e: unknown): void => { for (const fn of listeners.get(name) ?? []) { try { fn(e); } catch (err) { console.warn(`[room] on('${name}')`, err); } } };
-  const vecOf = (a: unknown): Vec3 => { const p = Array.isArray(a) ? { x: a[0], y: a[1], z: a[2] ?? 0 } : a; return vec3(p, dims); };
-  const map = { bounds: { min: vecOf(game.map.bounds.min), max: vecOf(game.map.bounds.max) }, boxes: (game.map.boxes ?? []).map((b: any) => ({ min: vecOf(b.min), max: vecOf(b.max) })), circles: (game.map.circles ?? []).map((c: any) => ({ at: vecOf(c.at), r: Number(c.r) })) };
-  const spots: Record<string, readonly Vec3[]> = {};
-  for (const [key, list] of Object.entries(game.map.spots ?? {})) spots[key] = Object.freeze(list.map(vecOf));
+  let solo: Room<R> | null = null, noBodyMs = 0, checkedAt = clock();
+  const soloListeners = new Map<string, () => void>();
+  const emit = (name: string, e: unknown, local = false): void => { if (Boolean(solo) !== local) return; for (const fn of listeners.get(name) ?? []) { try { fn(e); } catch (err) { console.warn(`[room] on('${name}')`, err); } } };
+  const map = compileMap(game.map, game.map.name ?? 'main');
+  const spots = map.spots;
   const tune = Object.freeze({ ...(lab.rulesTune({ public: game.tune }).public as Record<string, unknown>) });
 
   let status: RoomStatus = 'connecting';
@@ -183,6 +203,7 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
   let observedLeadAt = 0;
   let catchTick: number | null = null;
   let catchAt = 0;
+  let headingBlend: { from: Vec3; at: number } | null = null;
   let offsets: { delta: Vec3; at: number; path: Vec3; fade: number; last: number }[] = [];
   const predict = schema.settings.predict;
   const quantile = (list: number[], q: number): number => [...list].sort((a, b) => a - b)[Math.floor((list.length - 1) * q)] ?? 0;
@@ -199,6 +220,8 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
       if (path) {
         // Loss can make even a small correction longer than the distance travelled in
         // 100 ms. Bound its fade by actual progress, or it pulls steady movement backwards.
+        // A forced knock can travel much faster than running. It must not also
+        // erase a large offset at that speed and almost double the drawn impulse.
         // Only one queued fade advances at a time. A stopped body finishes its correction.
         if (waiting) o.at = now;
         else {
@@ -224,7 +247,7 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
   const tickAt = (now: number): number => (base ? base.tick + (now - base.at) / period * speed : 0);
   /** The tick `move` is being run for: the step just taken, or the one after it while the own body is drawn between ticks. */
   let moveTick = 0;
-  const moveCtx = moveContext({ tick: () => moveTick, tickHz, tune, map, name: game.map.name ?? 'main', spots, radius: () => myKind()?.radius ?? 0, dims });
+  const moveCtx = moveContext({ tick: () => moveTick, tickHz, tune, map, name: game.map.name ?? 'main', spots, radius: () => myKind()?.radius ?? 0, shape: () => ({ shape: myKind()?.shape ?? 'sphere', radius: myKind()?.radius ?? 0, height: myKind()?.height ?? 0 }), dims });
   function authorityRtt(): number {
     // The helper's ping ends at the relay. A browser host adds another network leg in both directions.
     // Snapshot stamps use the relay clock, so their observed age measures the complete downstream path.
@@ -257,7 +280,7 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
     base = { tick: k + Math.ceil(rtt / period + target) + sendEvery - 1, at: clock() };
     stepped = Math.floor(base.tick) - 1;
     entries = []; pending = []; history.clear(); replayHeld = {}; held = {}; lastSent = ''; leads.length = 0; pressed = new Set();
-    speed = 1; phases.length = 0; phases.push({ ...base, rate: 1 }); catchTick = null; offsets = []; correction.rebases += 1;
+    speed = 1; phases.length = 0; phases.push({ ...base, rate: 1 }); catchTick = null; offsets = []; headingBlend = null; correction.rebases += 1;
     const u = mine && latest?.ents.get(mine.id); if (u) adopt(u);
     if (mine) {
       history.set(stepped, copyMine(mine));
@@ -275,8 +298,9 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
     if (!fn) return body;
     moveTick = t;
     const out = stepMove(fn, body, input, moveCtx, Math.max(1, Math.floor(schema.settings.budget.tick / 4)), kindOf.get(kindName)?.motion ?? [], dims, (err) => { if (!(err instanceof BudgetError)) console.warn('[room] move', err); });
-    const r = kindOf.get(kindName)?.radius ?? 0;
-    out.pos = vec3({ x: Math.max(map.bounds.min.x + r, Math.min(map.bounds.max.x - r, out.pos.x)), y: Math.max(map.bounds.min.y + r, Math.min(map.bounds.max.y - r, out.pos.y)), z: out.pos.z }, dims);
+    const kind = kindOf.get(kindName), r = kind?.radius ?? 0;
+    const height = kind?.height || 2 * r;
+    out.pos = vec3({ x: Math.max(map.bounds.min.x + r, Math.min(map.bounds.max.x - r, out.pos.x)), y: Math.max(map.bounds.min.y + r, Math.min(map.bounds.max.y - r, out.pos.y)), z: dims === 3 ? Math.max(map.bounds.min.z, Math.min(map.bounds.max.z - height, out.pos.z)) : 0 }, dims);
     return out;
   }
   /** The input values the last step held (a press is never held). */
@@ -329,6 +353,7 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
     if (closed) return;
     if (net.offline && !net.rulesHosting) setStatus(net.closedWhy ? 'closed' : 'offline');
     const now = clock();
+    checkSolo(now);
     const hidden = typeof document !== 'undefined' && document.hidden === true;
     // Effects play for everyone who draws the room: a watcher has no body and still sees them.
     fire();
@@ -378,7 +403,9 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
         mine!.motion = motionOf(me.kind, me.motion);
       } else {
         const previous = mine!.pos;
-        const shown = meNow()?.pos ?? previous;
+        const shownBody = meNow();
+        const shown = shownBody?.pos ?? previous;
+        const oldHeading = mine!.heading;
         const oldOffset = visualOffset(clock()), oldOffsets = offsets;
         adopt(me);
         history.set(f.k, copyMine(mine!));
@@ -402,6 +429,7 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
           history.set(t, copyMine(mine!));
         }
         pending = pending.filter(e => e.t > f.k || e.t > ack && f.k + 1 - e.t <= Math.ceil(tickHz / 4));
+        if (shownBody && distance(oldHeading, mine!.heading) > 0.0001) headingBlend = { from: shownBody.heading, at: clock() };
         const error = distance(previous, mine!.pos);
         correction.last = error;
         if (error > 0.00001) { correction.count++; correction.max = Math.max(correction.max, error); }
@@ -466,6 +494,7 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
     setStatus(seat === null || me ? 'playing' : status);
   }
   function roundNow(): RoomRound | null {
+    if (solo) return solo.round;
     if (!round || !latest) return null;
     // The room's clock now, from the newest snapshot: a view never turns a tick into time itself.
     const serverTick = latest.k + ((net.connected || net.rulesHosting) ? (clock() - latest.at) / period : 0);
@@ -527,21 +556,26 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
    * drawn frame, not on the next tick.
    */
   function meNow(): Entity | null {
+    if (solo) return solo.me;
     if (!mine || !latest) return null;
     const server = latest.ents.get(mine.id);
     if (!server) return null;
     const kind = kindOf.get(mine.kind);
     let pos = mine.pos;
     let heading = mine.heading;
+    let velocity = mine.vel, grounded = mine.grounded, motion = mine.motion;
     let settled = true;
-    let preview: { pos: Vec3; heading: Vec3 } | null = null;
+    let preview: ReturnType<typeof runMove> | null = null;
     if (kind && base) {
       const a = Math.max(0, Math.min(1, tickAt(clock()) - stepped));
       const now: Record<string, unknown> = {};
       for (const [name, fd] of kind.input) now[name] = fd.t === 'press' ? pressed.has(name) : coerce(fd, sample[name] ?? fd.init, dims);
       const next = runMove(kind.name, { pos: mine.pos, vel: mine.vel, heading: mine.heading, grounded: mine.grounded, motion: motionOf(mine.kind, mine.motion) }, Object.freeze(now), stepped + 1);
       pos = vec3({ x: lerp(mine.pos.x, next.pos.x, a), y: lerp(mine.pos.y, next.pos.y, a), z: lerp(mine.pos.z, next.pos.z, a) }, dims);
-      heading = next.heading;
+      heading = blendHeading(mine.heading, next.heading, a, dims);
+      velocity = vec3({ x: lerp(mine.vel.x, next.vel.x, a), y: lerp(mine.vel.y, next.vel.y, a), z: lerp(mine.vel.z, next.vel.z, a) }, dims);
+      // A takeoff is airborne as soon as it rises; a landing waits for its contact.
+      grounded = mine.grounded && (a === 0 || next.grounded);
       preview = next;
       settled = distance(next.pos, mine.pos) < 0.00001;
     }
@@ -551,17 +585,25 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
       if (catchTick >= tickAt(now)) catchTick = null;
       else {
         // Catch-up can reach the fractional current tick before its next whole step exists.
-        // Use the same preview as normal drawing, rather than hold and jump when that step arrives.
+        // Use the normal drawing preview, including its 3D pose, instead of holding then jumping.
         const t = Math.floor(catchTick), a = history.get(t), b = history.get(t + 1) ?? (t === stepped ? preview : null);
-        if (a && b) { const f = catchTick - t; pos = { x: lerp(a.pos.x, b.pos.x, f), y: lerp(a.pos.y, b.pos.y, f), z: lerp(a.pos.z, b.pos.z, f) }; heading = b.heading; }
-        else if (a) pos = a.pos;
+        if (a && b) { const f = catchTick - t; pos = { x: lerp(a.pos.x, b.pos.x, f), y: lerp(a.pos.y, b.pos.y, f), z: lerp(a.pos.z, b.pos.z, f) }; heading = blendHeading(a.heading, b.heading, f, dims);
+          velocity = vec3({ x: lerp(a.vel.x, b.vel.x, f), y: lerp(a.vel.y, b.vel.y, f), z: lerp(a.vel.z, b.vel.z, f) }, dims);
+          grounded = a.grounded && (f === 0 || b.grounded); motion = a.motion;
+        } else if (a) { pos = a.pos; heading = a.heading; velocity = a.vel; grounded = a.grounded; motion = a.motion; }
       }
     }
     const offset = visualOffset(clock(), pos, settled);
     pos = { x: pos.x + offset.x, y: pos.y + offset.y, z: pos.z + offset.z };
-    return entityOf({ ...server, pos, vel: mine.vel, heading, grounded: mine.grounded, motion: mine.motion }, true);
+    if (headingBlend) {
+      const t = predict.blendMs > 0 ? Math.min(1, (clock() - headingBlend.at) / predict.blendMs) : 1;
+      heading = blendHeading(headingBlend.from, heading, t, dims);
+      if (t >= 1) headingBlend = null;
+    }
+    return entityOf({ ...server, pos, vel: velocity, heading, grounded, motion }, true);
   }
   function drawn(id: string): Entity | null {
+    if (solo) return solo.get(id);
     if (mine && id === mine.id) return meNow();
     const s = net.sample();
     const a = s ? frameOf(s.a) : latest;
@@ -571,12 +613,13 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
     // A placed body jumps: nobody's view glides across a placement.
     if (ea.r !== eb.r || a?.e !== b?.e || !s) return entityOf(eb);
     const t = s.alpha;
-    const h = dir({ x: lerp(ea.heading.x, eb.heading.x, t), y: lerp(ea.heading.y, eb.heading.y, t), z: lerp(ea.heading.z, eb.heading.z, t) }, dims);
-    return entityOf({ ...eb, pos: vec3({ x: lerp(ea.pos.x, eb.pos.x, t), y: lerp(ea.pos.y, eb.pos.y, t), z: lerp(ea.pos.z, eb.pos.z, t) }, dims), vel: eb.vel, heading: h });
+    const h = blendHeading(ea.heading, eb.heading, t, dims);
+    return entityOf({ ...(t < 1 ? ea : eb), grounded: t >= 1 ? eb.grounded : ea.grounded && (t === 0 || eb.grounded), pos: vec3({ x: lerp(ea.pos.x, eb.pos.x, t), y: lerp(ea.pos.y, eb.pos.y, t), z: lerp(ea.pos.z, eb.pos.z, t) }, dims), vel: vec3({ x: lerp(ea.vel.x, eb.vel.x, t), y: lerp(ea.vel.y, eb.vel.y, t), z: lerp(ea.vel.z, eb.vel.z, t) }, dims), heading: h });
   }
   function get(id: string): Entity | null { return drawn(id); }
   function each(kind: string, fn: (e: Entity) => void): void {
     pump();
+    if (solo) { solo.each(kind, fn); return; }
     const s = net.sample();
     const a = s ? frameOf(s.a) : latest;
     const b = s ? frameOf(s.b) : latest;
@@ -587,20 +630,51 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
     for (const id of ids) { const e = drawn(id); if (e) fn(e); }
   }
   function roster(): RosterRow[] {
+    if (solo) return solo.roster;
     const scores = new Map<number, number>();
     if (latest) for (const u of latest.ents.values()) { const k = kindOf.get(u.kind); if (u.seat !== undefined && k?.score) scores.set(u.seat, Number(u.fields[k.score]) || 0); }
     return (net.slots ?? []).map((sl) => ({ seat: sl.slot, name: sl.name, driver: sl.agent ? 'ai' as const : sl.bot ? 'bot' as const : 'person' as const, score: scores.get(sl.slot) ?? 0, me: sl.seat !== null && sl.seat === net.seat }));
   }
+  function forwardSolo(name: string): void {
+    if (solo && !soloListeners.has(name)) soloListeners.set(name, solo.on(name, e => emit(name, e, true)));
+  }
+  function stopSolo(): void {
+    for (const off of soloListeners.values()) off(); soloListeners.clear();
+    const old = solo; solo = null; old?.close();
+  }
+  function checkSolo(now: number): void {
+    if (opts.fallback !== 'solo') return;
+    const elapsed = Math.min(300, Math.max(0, now - checkedAt)); checkedAt = now;
+    if (net.offline || net.watching) { noBodyMs = 0; stopSolo(); return; }
+    if (net.link !== 'online') { noBodyMs = 0; return; }
+    if (mine && net.seat !== null && latest?.ents.has(mine.id)) {
+      noBodyMs = 0;
+      if (solo) { stopSolo(); net.line(null); emit('status', status); emit('placed', { id: mine.id }); }
+      return;
+    }
+    if (solo || net.seat === null && !net.full) return;
+    noBodyMs += elapsed;
+    if (noBodyMs < 4000 || !(schema.settings.offline || schema.settings.host === 'browser')) return;
+    // Keep the online socket and its seat queue. The separate offline room emits no wire
+    // traffic, writes no room save to the server, and closes as soon as a body arrives.
+    const g = globalThis as unknown as Record<string, unknown>;
+    const probes = [g.__homieNet, g.__homiePort];
+    solo = openRoom<R>({ game, move: moves, now: opts.now, timers: opts.timers, net: { config: null, post: null, linkOverlay: false } });
+    [g.__homieNet, g.__homiePort] = probes;
+    for (const name of listeners.keys()) forwardSolo(name);
+    net.line(net.full ? 'This room is full · playing on your own until a seat is free' : 'Playing on your own until the next round');
+    emit('status', 'offline', true);
+  }
   let extra: Record<string, () => unknown> = {};
-  const myScore = (): number | null => { const k = myKind(); const u = mine && latest ? latest.ents.get(mine.id) : null; return k?.score && u ? Number(u.fields[k.score]) || 0 : null; };
-  const busy = (): boolean => status !== 'playing' || !mine || latest?.ents.get(mine.id)?.away === true;
+  const myScore = (): number | null => { if (solo) { const k = schema.kinds.find(k => k.player); return k?.score && solo.me ? Number(solo.me[k.score]) || 0 : null; } const k = myKind(); const u = mine && latest ? latest.ents.get(mine.id) : null; return k?.score && u ? Number(u.fields[k.score]) || 0 : null; };
+  const busy = (): boolean => solo ? !solo.me : status !== 'playing' || !mine || latest?.ents.get(mine.id)?.away === true;
   // The probes the testing tools read (`check`, `shoot`, `perf`, the playtest judge): the same two objects a game written the old way publishes.
   net.expose({
     self: () => { const m = meNow(); return m ? { x: m.pos.x, y: m.pos.y, z: m.pos.z } : null; },
     peer: (seat: number) => { if (!latest) return null; for (const u of latest.ents.values()) if (u.seat === seat) return { x: u.pos.x, y: u.pos.y, z: u.pos.z }; return null; },
     prediction: () => ({ ...correction, observedLeadAt, lastSendAt, now: clock(), serverTick: latest?.k, tick: stepped, catchTick, lead: targetLead(), medianLead: medianLead(), rate: speed, rtt: authorityRtt(), hostAge: quantile(hostAges, 0.5), pending: pending.length }),
     scores: () => roster().map((r) => ({ seat: r.seat, score: r.score })),
-    score: myScore, tick: () => latest?.k ?? 0, epoch: () => epoch, hosted: () => net.rulesHosting ? 'browser' : schema.settings.host, status: () => status,
+    score: myScore, tick: () => latest?.k ?? 0, epoch: () => epoch, hosted: () => net.rulesHosting ? 'browser' : schema.settings.host, status: () => solo ? 'offline' : status,
   });
   if (typeof window !== 'undefined') {
     exposePort(net as Netplay<unknown, unknown, unknown>, {
@@ -616,27 +690,47 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
   if (typeof document !== 'undefined') document.addEventListener('visibilitychange', onShow);
 
   return {
-    get status() { return status; },
-    get seat() { return net.seat; },
+    get status() { return solo ? 'offline' : status; },
+    get seat() { return solo ? solo.seat : net.seat; },
     get me() { pump(); return meNow(); },
     each, get,
-    on(name, fn) { let set = listeners.get(name); if (!set) { set = new Set(); listeners.set(name, set); } set.add(fn); return () => { set?.delete(fn); }; },
-    get shared() { return Object.freeze(unpackFields(schema.shared, net.stateOf('shared'), dims)); },
+    on(name, fn) { let set = listeners.get(name); if (!set) { set = new Set(); listeners.set(name, set); } set.add(fn); forwardSolo(name); return () => { set?.delete(fn); }; },
+    get shared() { if (solo) return solo.shared; return Object.freeze(unpackFields(schema.shared, net.stateOf('shared'), dims)); },
     input(s) {
+      if (solo) { solo.input(s); return; }
       const kind = myKind() ?? schema.kinds.find((k) => k.player) ?? null;
       const next: Record<string, unknown> = {};
-      for (const [name, fd] of kind?.input ?? []) { if (fd.t === 'press') { if (s[name] === true || s[name] === 1) pressed.add(name); } else if (s[name] !== undefined) next[name] = s[name]; }
+      let changed = false;
+      for (const [name, fd] of kind?.input ?? []) {
+        if (fd.t === 'press') { if ((s[name] === true || s[name] === 1) && !pressed.has(name)) changed = true; }
+        else { if (s[name] !== undefined) next[name] = s[name]; if ((next[name] ?? fd.init) !== (sample[name] ?? fd.init)) changed = true; }
+      }
+      // A fresh control can replace a preview partway through a tick (especially
+      // a jump). Keep the pose at the instant of the press; only subsequent time
+      // may advance the new path, rather than drawing elapsed time with new input.
+      if (changed) pump();
+      const shown = changed ? meNow()?.pos : null;
+      for (const [name, fd] of kind?.input ?? []) if (fd.t === 'press' && (s[name] === true || s[name] === 1)) pressed.add(name);
       sample = next;
+      if (shown) {
+        const now = clock(), nextShown = meNow()?.pos;
+        if (nextShown && distance(shown, nextShown) > 0.00001) {
+          const carried = visualOffset(now);
+          // Coalesce the carried blend: analogue controls may change every frame.
+          offsets = [{ delta: { x: carried.x + shown.x - nextShown.x, y: carried.y + shown.y - nextShown.y, z: carried.z + shown.z - nextShown.z },
+            at: now, last: now, fade: 1, path: { x: nextShown.x - carried.x, y: nextShown.y - carried.y, z: nextShown.z - carried.z } }];
+        }
+      }
     },
-    command(name, data = {}) { if (schema.commands[name]) net.send('cmd', [name, data]); else console.warn(`[room] no command "${name}" is declared in shapes.commands`); },
+    command(name, data = {}) { if (solo) { solo.command(name, data); return; } if (schema.commands[name]) net.send('cmd', [name, data]); else console.warn(`[room] no command "${name}" is declared in shapes.commands`); },
     get round() { return roundNow(); },
     get roster() { return roster(); },
     follow(id) { const e = id ? latest?.ents.get(id) : null; net.follow(e && e.seat !== undefined ? e.seat : null); },
     probe(x) { extra = { ...extra, ...x }; },
-    ask(id, askId, args = {}) { const e = latest?.ents.get(id); if (e && e.seat !== undefined) agents?.ask(e.seat, askId, args); },
-    askButtons(id, offer = {}) { const e = latest?.ents.get(id); return e && e.seat !== undefined ? agents?.askButtons(e.seat, offer) ?? [] : []; },
+    ask(id, askId, args = {}) { if (solo) return; const e = latest?.ents.get(id); if (e && e.seat !== undefined) agents?.ask(e.seat, askId, args); },
+    askButtons(id, offer = {}) { if (solo) return []; const e = latest?.ents.get(id); return e && e.seat !== undefined ? agents?.askButtons(e.seat, offer) ?? [] : []; },
     tune, map: Object.freeze({ ...map, spots: Object.freeze(spots) }), net: net as Netplay,
     pump,
-    close() { closed = true; if (timer) clearInterval(timer); if (typeof document !== 'undefined') document.removeEventListener('visibilitychange', onShow); agents?.stop(); net.close(); setStatus('closed'); },
+    close() { stopSolo(); closed = true; if (timer) clearInterval(timer); if (typeof document !== 'undefined') document.removeEventListener('visibilitychange', onShow); agents?.stop(); net.close(); setStatus('closed'); },
   };
 }

package/starters/ember-vale/game.json

@@ -2,10 +2,16 @@
   "id": "ember-vale",
   "name": "Ember Vale",
   "blurb": "A hero who lasts for days. Hunt slimes with whoever is here tonight; your level, gold and name follow you to every device. Go hardcore and a death is forever.",
-  "players": { "min": 1, "max": 8 },
+  "players": {
+    "min": 1,
+    "max": 8
+  },
   "roundSeconds": 90,
-  "entry": "src/main.ts",
-  "netplay": { "v": 1, "public": true, "movement": "owner" },
+  "entry": "src/view.ts",
+  "netplay": {
+    "v": 1,
+    "public": true
+  },
   "saves": true,
   "decide": false,
   "landing": {
@@ -16,6 +22,12 @@
       "Every night ends with a ranking; your hero keeps what it earned.",
       "Hardcore: one life. Fall and you join the Hall of the Fallen."
     ],
-    "controls": { "phone": "Drag on the left to move, STRIKE on the right.", "computer": "WASD or arrows to move, Space to strike." }
+    "controls": {
+      "phone": "Drag on the left to move, STRIKE on the right.",
+      "computer": "WASD or arrows to move, Space to strike."
+    }
+  },
+  "room": {
+    "host": "server"
   }
 }