@homie-rocks/studio 0.44.1 → 0.45.0

package/rules/core.ts

@@ -245,7 +245,6 @@ export function createCore(c: Compiled, opts: { moved?: (kind: string, tick: num
   let stateHeavy = false;
   const viewCost = new Map<KindTable, number>();
   for (const k of c.kinds) viewCost.set(k, VIEW + k.fields.length + k.motion.length);
-  const mapShapes = 4 + c.map.boxes.length + c.map.circles.length;
 
   const ticks = (seconds: unknown): number => { const s = num(seconds); const n = Math.round(s * tickHz); return s > 0 && Number.isFinite(n) ? Math.max(1, n) : 0; };
   const V = (v: unknown): Vec3 => vec3(v, dims);
@@ -611,7 +610,7 @@ export function createCore(c: Compiled, opts: { moved?: (kind: string, tick: num
     },
     ray: (from: unknown, direction: unknown, max: unknown): unknown => {
       // Charged before the cast, for every shape it may test: the map's, and every entity in the room.
-      charge(20 + 4 * (mapShapes + ents.size));
+      charge(20 + 4 * ents.size);
       const p = V(from); const d = dir(direction, dims); const far = reach(max, 'world.ray');
       if (dims === 3) {
         const delta = { x: d.x * far, y: d.y * far, z: d.z * far };
@@ -633,7 +632,7 @@ export function createCore(c: Compiled, opts: { moved?: (kind: string, tick: num
     },
     sweep: (self: unknown, delta: unknown, o?: unknown): unknown => {
       const e = mine(self, 'world.sweep');
-      charge(20 + 4 * (mapShapes + ents.size));
+      charge(20 + 4 * ents.size);
       const d = V(delta);
       const radius = e.kind.body?.radius ?? 0;
       // The ids to pass through: the first few of a list, read as plain texts. A longer list is not searched once for every entity.
@@ -1007,7 +1006,7 @@ export function createCore(c: Compiled, opts: { moved?: (kind: string, tick: num
       }
       guides?.();
       // All movers see the same world, independent of entity iteration order.
-      if (hasColliders) { left -= 64 * ents.size + 4 * mapShapes; moveGeometry = collisionMap(c.map, collisionState()[2]); }
+      if (hasColliders) { left -= 64 * ents.size; moveGeometry = collisionMap(c.map, collisionState()[2]); }
       // Phase 1: one input step and `move` for every body.
       for (const e of [...ents.values()]) {
         if (e.dead || !e.kind.body) continue;

package/rules/host.ts

@@ -100,6 +100,7 @@ export interface Host {
   readonly paused: boolean;
   readonly people: number;
   readonly viewRadiusM: number | null;
+  readonly viewSettings: Compiled['settings']['view'];
   frame(m: Record<string, unknown>): void;
   /** Start the tick loop (the first person has joined). */
   start(): void;
@@ -768,6 +769,7 @@ export function createHost(o: HostOptions): Host {
   }
 
   return {
+    get viewSettings() { return c.settings.view; },
     get viewRadiusM() { return c.settings.view?.radiusM ?? null; },
     get tick() { return core.tick; },
     get epoch() { return epoch; },

package/rules/interest.mjs

@@ -1,41 +1,77 @@
 /** Per-connection state delivery. Pure data, shared by the relay and the view.
- * Deltas name a keyframe, never an unacknowledged previous delta. Losing a delta
- * therefore loses no baseline. A new keyframe bounds recovery to one second.
+ * Deltas may name a periodic keyframe or the previous ordered frame. A missing
+ * chained predecessor is ignored until the next keyframe (at most one second).
  * No history grows with time: one keyframe per connection, no per-frame queue.
  */
+const spatial = new WeakMap(), controls = new WeakMap();
+function indexFor(snap, radius) {
+  let byRadius = spatial.get(snap.d[1]);
+  if (!byRadius) { byRadius = new Map(); spatial.set(snap.d[1], byRadius); }
+  if (byRadius.has(radius)) return byRadius.get(radius);
+  const own = new Map(), cells = new Map(), order = new Map();
+  const size = radius > 0 ? radius : 1;
+  for (const [i, e] of snap.d[1].entries()) {
+    order.set(e, i);
+    if (e[9] !== undefined && e[10] !== 1) own.set(e[9], e);
+    const p = e[3], key = `${Math.floor(p[0]/size)},${Math.floor(p[1]/size)},${Math.floor((p[2]??0)/size)}`;
+    const list = cells.get(key) ?? []; list.push(e); cells.set(key, list);
+  }
+  const index = { own, cells, size, order }; byRadius.set(radius,index); return index;
+}
 export function interestSnapshot(snap, seat, radiusM) {
   const [round, entities] = snap.d;
-  const own = seat === null ? null : entities.find(e => e[9] === seat && e[10] === 0);
-  const visible = own && radiusM !== null ? entities.filter(e => {
-    const p = e[3], q = own[3];
-    return e === own || (p[0] - q[0]) ** 2 + (p[1] - q[1]) ** 2 + ((p[2] ?? 0) - (q[2] ?? 0)) ** 2 <= radiusM ** 2;
-  }) : seat === null ? entities : own ? entities : [];
-  // Collision revisions are prediction inputs, independent of visual interest.
-  // Deliver all geometry: authored sweeps/dashes need not fit inside the view radius.
-  return { ...snap, d: [round, visible, ...snap.d.slice(2)], c: (snap.c ?? []).filter(row => row[0] === seat) };
+  let visible = entities;
+  if (seat !== null) {
+    const index = indexFor(snap, radiusM), own = index.own.get(seat);
+    visible = [];
+    if (own && radiusM === null) visible = entities;
+    else if (own) {
+      const q=own[3], x=Math.floor(q[0]/index.size), y=Math.floor(q[1]/index.size), z=Math.floor((q[2]??0)/index.size);
+      for(let dx=-1;dx<=1;dx++)for(let dy=-1;dy<=1;dy++)for(let dz=-1;dz<=1;dz++)
+        for(const e of index.cells.get(`${x+dx},${y+dy},${z+dz}`)??[]) {
+          const p=e[3];
+          if(e===own||(p[0]-q[0])**2+(p[1]-q[1])**2+((p[2]??0)-(q[2]??0))**2<=radiusM**2)visible.push(e);
+        }
+      // Snapshot order is part of the view contract, even though cells are not.
+      visible.sort((a,b)=>index.order.get(a)-index.order.get(b));
+    }
+  }
+  let control = snap.c && controls.get(snap.c);
+  if (!control) { control = new Map((snap.c ?? []).map(row => [row[0], row])); if (snap.c) controls.set(snap.c, control); }
+  return { ...snap, d: [round, visible, ...snap.d.slice(2)], c: control.has(seat) ? [control.get(seat)] : [] };
 }
+const encodedRows = new WeakMap();
+const rowText = row => {
+  let text=encodedRows.get(row);
+  if(!text){text=row.map(v=>JSON.stringify(v));encodedRows.set(row,text);}
+  return text;
+};
 
-export function snapshotEncoder(keyframeTicks) {
+export function snapshotEncoder(keyframeTicks, chained = false) {
   let base = null;
-  let rows = new Map();
+  let rows = new Map(), keyTick = -Infinity;
   return {
-    reset() { base = null; rows.clear(); },
-    encode(snap) {
-      if (!base || snap.e !== base.e || snap.k <= base.k || snap.k - base.k >= keyframeTicks) {
-        base = snap;
-        rows = new Map(snap.d[1].map(e => [e[0], e.map(v => JSON.stringify(v))]));
+    reset() { base = null; rows.clear(); keyTick = -Infinity; },
+    encode(snap, seat = null) {
+      if (!base || snap.e !== base.e || snap.k <= base.k || snap.k - keyTick >= keyframeTicks) {
+        base = snap; keyTick = snap.k;
+        rows = new Map(snap.d[1].map(e => [e[0], rowText(e)]));
         return snap;
       }
       const present = new Set(), changed = [];
+      const own = chained && seat !== null ? snap.d[1].filter(e => e[9] === seat && e[10] !== 1) : null;
       for (const entity of snap.d[1]) {
         const id = entity[0]; present.add(id);
+        if (own?.includes(entity)) continue;
         const before = rows.get(id);
         if (!before) { changed.push(entity); continue; }
         let mask = 0; const values = [];
-        for (let i = 1; i < entity.length; i++) if (JSON.stringify(entity[i]) !== before[i]) { mask |= 1 << i; values.push(entity[i]); }
+        for (let i = 1; i < entity.length; i++) if (rowText(entity)[i] !== before[i]) { mask |= 1 << i; values.push(entity[i]); }
         if (mask) changed.push([id, mask, values]);
       }
-      return { ...snap, d: { base: base.k, round: snap.d[0], ...(snap.d.length > 2 ? { collision: snap.d[2] } : {}), changed, removed: [...rows.keys()].filter(id => !present.has(id)) } };
+      const out = { ...snap, d: { base: base.k, round: snap.d[0], ...(snap.d.length > 2 ? { collision: snap.d[2] } : {}), changed, removed: [...rows.keys()].filter(id => !present.has(id)), ...(chained ? { chain: true } : {}), ...(own ? { own } : {}) } };
+      if (chained) { base = snap; rows = new Map(snap.d[1].map(e => [e[0], rowText(e)])); }
+      return out;
     },
   };
 }
@@ -57,8 +93,18 @@ export function snapshotDecoder() {
         return snap;
       }
       const d = snap.d;
-      if (!base || !d || d.base !== base.k || snap.e !== base.e || snap.k <= base.k) return null;
+      if (!base || !d || snap.e !== base.e || snap.k <= base.k) return null;
+      if (d.own !== undefined && (!Array.isArray(d.own) || !d.own.every(e => Array.isArray(e) && e.length >= 9 && typeof e[0] === 'string'))) return null;
       if (!Array.isArray(d.round) || !Array.isArray(d.removed) || !Array.isArray(d.changed)) return null;
+      if (d.base !== base.k) {
+        // A skipped remote delta must not stall local prediction or collider edits.
+        // Keep the remote baseline unchanged until a keyframe repairs the chain.
+        if (!d.chain || !d.own?.length || !Array.isArray(d.round)) return null;
+        const visible = new Map(rows);
+        for (const id of d.removed) visible.delete(id);
+        for (const e of d.own) visible.set(e[0], e);
+        return { ...snap, d: [d.round, [...visible.values()], ...(d.collision === undefined ? [] : [d.collision])] };
+      }
       const next = new Map(rows);
       for (const id of d.removed) next.delete(id);
       for (const change of d.changed) {
@@ -75,7 +121,46 @@ export function snapshotDecoder() {
         if (j !== change[2].length) return null;
         next.set(entity[0], entity);
       }
-      return { ...snap, d: [d.round, [...next.values()], ...(d.collision === undefined ? [] : [d.collision])] };
+      for (const e of d.own ?? []) next.set(e[0], e);
+      const decoded = { ...snap, d: [d.round, [...next.values()], ...(d.collision === undefined ? [] : [d.collision])] };
+      if (d.chain) { base = decoded; rows = next; }
+      return decoded;
     },
   };
 }
+
+/** Studio-chosen visual precision and rates. The controlled body stays exact.
+ * Exits are immediate even between far updates; new arrivals never wait.
+ */
+const quantizedRows = new WeakMap();
+export function scheduledView({ radiusM = null, precisionM = 0, nearM = null, farHz = null } = {}, tickHz = 20) {
+  let previous = new Map(), epoch = null;
+  return (snap, seat) => {
+    if (snap.e !== epoch) { previous.clear(); epoch = snap.e; }
+    const selected = interestSnapshot(snap, seat, radiusM);
+    const own = selected.d[1].find(e => e[9] === seat && e[10] !== 1);
+    const next = new Map();
+    const entities = selected.d[1].map(entity => {
+      let row = entity;
+      if (entity !== own) {
+        const distance = own ? Math.hypot(...entity[3].map((n, i) => n - (own[3][i] ?? 0))) : 0;
+        const old = previous.get(entity[0]);
+        const interval = farHz && nearM !== null && distance > nearM ? Math.max(1, Math.round(tickHz / farHz)) : 1;
+        if (old && snap.k % interval !== 0) row = old;
+        else if (precisionM > 0) {
+          let versions = quantizedRows.get(entity);
+          if (!versions) { versions = new Map(); quantizedRows.set(entity, versions); }
+          row = versions.get(precisionM);
+          if (!row) {
+            row = entity.slice();
+            for (const i of [3, 4]) row[i] = entity[i].map(n => Number((Math.round(n / precisionM) * precisionM).toPrecision(12)));
+            versions.set(precisionM, row);
+          }
+        }
+      }
+      next.set(entity[0], row); return row;
+    });
+    previous = next;
+    return { ...selected, d: [selected.d[0], entities, ...selected.d.slice(2)] };
+  };
+}

package/rules/live.ts

@@ -1,3 +1,5 @@
+import { overlapsTerrain } from './terrain.ts';
+import { nearbyMap } from './map-index.ts';
 /** Declared collision geometry, shared by authority and prediction. Entity fields
  * own its lifetime and dimensions; this projection contains no gameplay state. */
 import type { Vec3, ColliderDef } from './rules.ts';
@@ -27,7 +29,7 @@ export function castCollider2(row: ColliderRow, p: Vec3, d: Vec3, radius: number
 }
 export function collisionMap(map: MapShapes, rows: readonly ColliderRow[]): MapShapes {
   if (!rows.length) return map;
-  const boxes = [...map.boxes], circles = [...map.circles], spheres = [...(map.spheres ?? [])], capsules = [...(map.capsules ?? [])];
+  const boxes: any[] = [], circles: any[] = [], spheres: any[] = [], capsules: any[] = [];
   for (const [id, shape, x, y, z, w, d, h] of rows) {
     const at = { x, y, z };
     if (shape === 'box') boxes.push({ min: { x: x - w / 2, y: y - d / 2, z }, max: { x: x + w / 2, y: y + d / 2, z: z + h }, id } as any);
@@ -35,7 +37,7 @@ export function collisionMap(map: MapShapes, rows: readonly ColliderRow[]): MapS
     else if (shape === 'sphere') spheres.push({ at: { x, y, z: z + w / 2 }, r: w / 2, id } as any);
     else capsules.push({ at, r: w / 2, height: h, id } as any);
   }
-  return { ...map, boxes, circles, spheres, capsules };
+  return { bounds: map.bounds, staticMap: map, boxes, circles, spheres, capsules };
 }
 /** Latest known revision at the requested tick. Unknown future edits are never
  * guessed: a later snapshot rebases the body and replays its pending inputs. */
@@ -60,14 +62,14 @@ export function collisionQueries(map: () => MapShapes, shape: () => BodyShape, d
       return h && h.nz > 0.5 ? Object.freeze({ at: Object.freeze({ ...p, z: p.z - d * h.t }), normal: Object.freeze({ x: h.nx, y: h.ny, z: h.nz }), dist: d * h.t, ...(h.id ? { entity: h.id } : {}) }) : undefined;
     },
     overlaps: (body: unknown) => {
-      const m = map(), p = position(body), s = shape(), a = solidAt(p, s);
+      const p = position(body), s = shape(), a = solidAt(p, s), m = nearbyMap(map(), p, {x:0,y:0,z:0}, s.radius, s.height || 2*s.radius, dims);
       charge(20 + 8 * (m.boxes.length + m.circles.length + (m.spheres?.length ?? 0) + (m.capsules?.length ?? 0)));
       const overlap = (b: ReturnType<typeof solidAt>): boolean => {
         let sq = 0;
         for (const k of dims === 2 ? ['x', 'y'] as const : ['x', 'y', 'z'] as const) { const gap = Math.max(0, a.min[k] - b.max[k], b.min[k] - a.max[k]); sq += gap * gap; }
         return sq < (a.r + b.r) ** 2 || a.r + b.r === 0 && a.min.x < b.max.x && a.max.x > b.min.x && a.min.y < b.max.y && a.max.y > b.min.y && (dims === 2 || a.min.z < b.max.z && a.max.z > b.min.z);
       };
-      return m.boxes.some(b => overlap({ ...b, r: 0 })) || m.circles.some(b => overlap({ min: {...b.at,z:m.bounds.min.z}, max: {...b.at,z:m.bounds.max.z}, r: b.r })) || (m.spheres ?? []).some(b => overlap({ min: b.at, max: b.at, r: b.r })) || (m.capsules ?? []).some(b => overlap(solidAt(b.at, { shape: 'capsule', radius: b.r, height: b.height })));
+      return (m.heightTiles ?? []).some(t => t.base !== undefined && overlapsTerrain(t, a)) || m.boxes.some(b => overlap({ ...b, r: 0 })) || m.circles.some(b => overlap({ min: {...b.at,z:m.bounds.min.z}, max: {...b.at,z:m.bounds.max.z}, r: b.r })) || (m.spheres ?? []).some(b => overlap({ min: b.at, max: b.at, r: b.r })) || (m.capsules ?? []).some(b => overlap(solidAt(b.at, { shape: 'capsule', radius: b.r, height: b.height })));
     },
   };
 }

package/rules/map-index.ts

@@ -0,0 +1,51 @@
+/** Immutable build-time BVH. Queries charge nodes visited and narrow-phase work,
+ * never the number of shapes in the level. Live geometry is a separate overlay. */
+import { charge } from './guard.ts';
+import type { MapShapes } from './math.ts';
+import type { Vec3 } from './rules.ts';
+type Key = 'boxes' | 'circles' | 'spheres' | 'capsules' | 'heightTiles';
+type Entry = { key: Key; value: any; min: Vec3; max: Vec3; order: number };
+type Node = { min: Vec3; max: Vec3; left?: Node; right?: Node; entries?: Entry[] };
+const indexes = new WeakMap<object, Node>();
+const axes = ['x','y','z'] as const;
+export function indexMap(map: MapShapes): void {
+  const entries: Entry[] = [];
+  for (const key of ['boxes','circles','spheres','capsules','heightTiles'] as const) for (const value of map[key] ?? []) {
+    const v:any=value; let min:Vec3,max:Vec3;
+    if(key==='boxes') { min=v.min;max=v.max; }
+    else if(key==='heightTiles') { min={...v.at,z:v.at.z+Math.min(v.base??Infinity,...v.heights)};max={x:v.at.x+v.size.x,y:v.at.y+v.size.y,z:v.at.z+Math.max(...v.heights)}; }
+    else { min={x:v.at.x-v.r,y:v.at.y-v.r,z:key==='circles'?-Infinity:key==='capsules'?v.at.z:v.at.z-v.r};max={x:v.at.x+v.r,y:v.at.y+v.r,z:key==='circles'?Infinity:key==='capsules'?v.at.z+v.height:v.at.z+v.r}; }
+    entries.push({key,value,min,max,order:entries.length});
+  }
+  function build(es:Entry[]):Node {
+    const min={x:Infinity,y:Infinity,z:Infinity},max={x:-Infinity,y:-Infinity,z:-Infinity};
+    for(const e of es)for(const k of axes){min[k]=Math.min(min[k],e.min[k]);max[k]=Math.max(max[k],e.max[k]);}
+    if(es.length<=8)return {min,max,entries:es};
+    // Choose the widest finite axis; unbounded columns still split horizontally.
+    let k: 'x' | 'y' | 'z' = max.x-min.x>=max.y-min.y?'x':'y';
+    if(Number.isFinite(max.z-min.z) && max.z-min.z>max[k]-min[k])k='z';
+    es.sort((a,b)=>(a.min[k]+a.max[k])-(b.min[k]+b.max[k])||a.order-b.order);
+    const mid=es.length>>1;return {min,max,left:build(es.slice(0,mid)),right:build(es.slice(mid))};
+  }
+  indexes.set(map,build(entries));
+}
+/** The segment of a body's reference point against bounds expanded by its extents. */
+export function nearbyMap(map: MapShapes, p:Vec3, d:Vec3, radius:number, height:number, dims=3):MapShapes {
+  const parent=map.staticMap;
+  const root=indexes.get(parent??map);
+  if(!root)return map;
+  const out:any={bounds:map.bounds,boxes:[],circles:[],spheres:[],capsules:[],heightTiles:[]};
+  function touches(n:{min:Vec3;max:Vec3}):boolean {
+    charge(12);let near=0,far=1;
+    for(const k of dims===2?['x','y'] as const:axes){const lo=n.min[k]-(k==='z'?height:radius),hi=n.max[k]+(k==='z'?0:radius);
+      if(d[k]===0){if(p[k]<lo-1e-7||p[k]>hi+1e-7)return false;}
+      else {let a=(lo-p[k])/d[k],b=(hi-p[k])/d[k];if(a>b)[a,b]=[b,a];near=Math.max(near,a);far=Math.min(far,b);if(near>far+1e-7)return false;}
+    }return true;
+  }
+  const found:Entry[]=[];
+  function visit(n:Node){if(!touches(n))return;if(n.entries){for(const e of n.entries)if(touches(e))found.push(e);}else{visit(n.left!);visit(n.right!);}}
+  visit(root);charge(found.length*Math.ceil(Math.log2(found.length+1)));
+  found.sort((a,b)=>a.order-b.order);for(const e of found)out[e.key].push(e.value);
+  if(parent)for(const key of ['boxes','circles','spheres','capsules','heightTiles'] as const)for(const v of map[key]??[]){charge(12);out[key].push(v);}
+  return out;
+}

package/rules/math.ts

@@ -1,3 +1,4 @@
+import { nearbyMap } from './map-index.ts';
 import { collisionQueries } from './live.ts';
 /*
  * math.ts — `world.math` and `ctx.math`: the maths rules may not take from `Math`, in plain arithmetic.
@@ -183,7 +184,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 }[]; spheres?: readonly { at: Vec3; r: number }[]; capsules?: readonly { at: Vec3; r: number; height: number }[]; heightTiles?: readonly import('./rules.ts').MapHeightTile[] }
+export interface MapShapes { staticMap?: 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;
 
@@ -237,6 +238,8 @@ function rayBounds(px: number, py: number, dx: number, dy: number, b: { min: Vec
 }
 /** A circle (or a point, r 0) moved along d against the static map: the first thing in the way, and how many shapes were tested. */
 export function castMap(map: MapShapes, px: number, py: number, dx: number, dy: number, r: number): { hit: Hit | null; tested: number } {
+  map = nearbyMap(map, {x:px,y:py,z:0}, {x:dx,y:dy,z:0}, r, 0, 2);
+  charge(16 + 4 * (map.boxes.length + map.circles.length));
   let best: Hit | null = rayBounds(Math.max(map.bounds.min.x + r, Math.min(map.bounds.max.x - r, px)), Math.max(map.bounds.min.y + r, Math.min(map.bounds.max.y - r, py)), dx, dy, map.bounds, r);
   for (const b of map.boxes) { const h = rayBox(px, py, dx, dy, b.min, b.max, r); if (h && (!best || h.t < best.t)) best = { ...h, id: (b as any).id }; }
   for (const c of map.circles) { const h = rayCircle(px, py, dx, dy, c.at.x, c.at.y, c.r + r); if (h && (!best || h.t < best.t)) best = { ...h, id: (c as any).id }; }
@@ -250,7 +253,7 @@ export function castMap(map: MapShapes, px: number, py: number, dx: number, dy:
  */
 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));
+  charge(20);
   const fr = Math.fround;
   // Both are whatever `move` handed over: each is read as a plain number or as nothing, and nothing is called to convert it.
   const num = (a: unknown): number => { const x = typeof a === 'number' ? fr(a) : 0; return Number.isFinite(x) ? x : 0; };

package/rules/rules.ts

@@ -1,3 +1,5 @@
+import { prepareTile } from './terrain.ts';
+import { indexMap } from './map-index.ts';
 /*
  * rules.ts — the rules contract, version 2: what a rules module declares, and how the runtime reads it.
  * =============================================================================
@@ -179,7 +181,7 @@ export interface RoomSettings {
   tickHz: number;
   inputHz: number;
   /** Omit the radius to send the whole room. No implicit visibility or bandwidth cap. */
-  view: { radiusM: number | null };
+  view: { radiusM: number | null; precisionM?: number; nearM?: number | null; farHz?: number | null };
   durability: { movementSeconds: number };
   budget: { tick: number };
   predict: { catchM: number | null; catchUp: number; snapM: number | null; blendMs: number; interpMs: number | null };
@@ -227,13 +229,13 @@ export function roomSettings(raw: unknown): { settings: RoomSettings; problems:
   if (host === 'browser' && r.view?.radiusM != null) problems.push('"room.view.radiusM" needs room.host "server"; browser hosting sends the whole room');
   if (r.view !== undefined) {
     if (!r.view || typeof r.view !== 'object' || Array.isArray(r.view)) problems.push('"room.view" is an object with an optional radiusM');
-    else for (const key of Object.keys(r.view)) if (key !== 'radiusM') problems.push(`"room.view.${key}" is not a setting; use radiusM`);
+    else for (const key of Object.keys(r.view)) if (!['radiusM', 'precisionM', 'nearM', 'farHz'].includes(key)) problems.push(`"room.view.${key}" is not a setting; use radiusM, precisionM, nearM or farHz`);
   }
   const p = r.predict && typeof r.predict === 'object' ? r.predict : {};
   return {
     settings: {
       host, offline, tickHz, inputHz,
-      view: { radiusM: r.view?.radiusM === null ? null : num('view.radiusM', r.view?.radiusM, null) },
+      view: { radiusM: r.view?.radiusM === null ? null : num('view.radiusM', r.view?.radiusM, null), ...(r.view?.precisionM !== undefined ? { precisionM: num('view.precisionM', r.view.precisionM, 0) as number } : {}), ...(r.view?.nearM !== undefined ? { nearM: num('view.nearM', r.view.nearM, null) } : {}), ...(r.view?.farHz !== undefined ? { farHz: whole('view.farHz', r.view.farHz, 1, tickHz, tickHz) } : {}) },
       durability: { movementSeconds: whole('durability.movementSeconds', r.durability?.movementSeconds, 1, 60, 1) },
       budget: { tick: Math.max(1, Math.floor(num('budget.tick', r.budget?.tick, budgetFor(tickHz)) as number)) },
       predict: { catchM: num('predict.catchM', p.catchM, null), catchUp: num('predict.catchUp', p.catchUp, 1.25) as number, snapM: num('predict.snapM', p.snapM, null), blendMs: num('predict.blendMs', p.blendMs, 100) as number, interpMs: num('predict.interpMs', p.interpMs, null) },
@@ -246,7 +248,7 @@ 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 MapHeightTile { readonly at: Vec3; readonly size: Readonly<{ x: number; y: number }>; readonly heights: readonly [number, number, number, number] }
+export interface MapHeightTile { readonly base?: number; readonly diagonal?: '00-11' | '10-01'; 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 => {
@@ -280,15 +282,19 @@ export function compileMap(raw: unknown, name = 'main'): GameMap {
     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({
+  if ([m.boxes, m.circles, m.spheres, m.capsules, m.heightTiles].reduce((n, list) => n + (list?.length ?? 0), 0) > 100000) throw new Error(`${where}: at most 100000 static shapes`);
+  const result = 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'] });
+      if (t.base !== undefined && (typeof t.base !== 'number' || !Number.isFinite(t.base) || t.heights.some((h:number) => h < t.base))) throw new Error(`${what}: base must be finite and at or below every top sample`);
+      if (t.diagonal !== undefined && !['00-11','10-01'].includes(t.diagonal)) throw new Error(`${what}: diagonal is 00-11 or 10-01`);
+      const tile = Object.freeze({ ...(t.base !== undefined ? {base:t.base} : {}), ...(t.diagonal ? {diagonal:t.diagonal} : {}), at, size: Object.freeze({ x: t.size[0], y: t.size[1] }), heights: Object.freeze([...t.heights]) as unknown as MapHeightTile['heights'] });
+      prepareTile(tile);
+      return tile;
     })),
     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) => {
@@ -305,6 +311,8 @@ export function compileMap(raw: unknown, name = 'main'): GameMap {
     })),
     spots: Object.freeze(spots),
   });
+  indexMap(result);
+  return result;
 }
 
 /* ------------------------------------------------------------------ compiled tables */

package/rules/terrain.ts

@@ -0,0 +1,93 @@
+/** Solid triangulated height tiles. Each source triangle is a closed vertical
+ * prism; their union preserves noncoplanar samples without a convex-hull fill. */
+import { charge } from './guard.ts';
+import type { Vec3, MapHeightTile } from './rules.ts';
+import type { Solid, Hit3 } from './collision.ts';
+type Plane = { n: Vec3; c: number };
+type Prism = { vertices: Vec3[]; faces: Vec3[][]; planes: Plane[]; edges: Vec3[] };
+const cache = new WeakMap<MapHeightTile, Prism[]>();
+const sub=(a:Vec3,b:Vec3):Vec3=>({x:a.x-b.x,y:a.y-b.y,z:a.z-b.z});
+const add=(a:Vec3,b:Vec3,t=1):Vec3=>({x:a.x+b.x*t,y:a.y+b.y*t,z:a.z+b.z*t});
+const dot=(a:Vec3,b:Vec3)=>a.x*b.x+a.y*b.y+a.z*b.z;
+const cross=(a:Vec3,b:Vec3):Vec3=>({x:a.y*b.z-a.z*b.y,y:a.z*b.x-a.x*b.z,z:a.x*b.y-a.y*b.x});
+const clamp=(x:number)=>Math.max(0,Math.min(1,x));
+export function prepareTile(t:MapHeightTile):void {
+  if(t.base===undefined)return;
+  const top=t.heights.map((h,i)=>({x:t.at.x+(i%2)*t.size.x,y:t.at.y+(i>>1)*t.size.y,z:t.at.z+h}));
+  const tris=t.diagonal==='10-01'?[[0,1,2],[1,3,2]]:[[0,1,3],[0,3,2]];
+  const prisms:Prism[]=[];
+  for(const tri of tris){
+    const upper=tri.map(i=>top[i]),lower=upper.map(v=>({...v,z:t.at.z+t.base!}));
+    if(upper.every(v=>v.z===lower[0].z))continue;
+    const vertices=[...upper,...lower],faces=[upper,[...lower].reverse()];
+    for(let i=0;i<3;i++){const j=(i+1)%3;faces.push([upper[i],lower[i],lower[j]],[upper[i],lower[j],upper[j]]);}
+    const center=vertices.reduce((s,v)=>add(s,v,1/6),{x:0,y:0,z:0}),planes:Plane[]=[],valid:Vec3[][]=[],edges:Vec3[]=[];
+    for(const face of faces){let n=cross(sub(face[1],face[0]),sub(face[2],face[0]));const len=Math.sqrt(dot(n,n));if(len<1e-12)continue;n={x:n.x/len,y:n.y/len,z:n.z/len};let c=dot(n,face[0]);if(dot(n,center)>c){n={x:-n.x,y:-n.y,z:-n.z};c=-c;}planes.push({n,c});valid.push(face);for(let i=0;i<3;i++)edges.push(sub(face[(i+1)%3],face[i]));}
+    prisms.push({vertices,faces:valid,planes,edges});
+  }
+  cache.set(t,prisms);
+}
+// Closest point on a triangle, including vertex and edge Voronoi regions.
+function triangle(p:Vec3,a:Vec3,b:Vec3,c:Vec3):Vec3 {
+  const ab=sub(b,a),ac=sub(c,a),ap=sub(p,a),d1=dot(ab,ap),d2=dot(ac,ap);
+  if(d1<=0&&d2<=0)return a;
+  const bp=sub(p,b),d3=dot(ab,bp),d4=dot(ac,bp);if(d3>=0&&d4<=d3)return b;
+  const vc=d1*d4-d3*d2;if(vc<=0&&d1>=0&&d3<=0)return add(a,ab,d1/(d1-d3));
+  const cp=sub(p,c),d5=dot(ab,cp),d6=dot(ac,cp);if(d6>=0&&d5<=d6)return c;
+  const vb=d5*d2-d1*d6;if(vb<=0&&d2>=0&&d6<=0)return add(a,ac,d2/(d2-d6));
+  const va=d3*d6-d5*d4;if(va<=0&&d4-d3>=0&&d5-d6>=0)return add(b,sub(c,b),(d4-d3)/(d4-d3+d5-d6));
+  const den=1/(va+vb+vc);return add(add(a,ab,vb*den),ac,vc*den);
+}
+function segmentPair(a:Vec3,b:Vec3,c:Vec3,d:Vec3):Vec3 {
+  const u=sub(b,a),v=sub(d,c),w=sub(a,c),aa=dot(u,u),bb=dot(u,v),cc=dot(v,v),dd=dot(u,w),ee=dot(v,w);
+  let s=aa?clamp((bb*ee-cc*dd)/(aa*cc-bb*bb)||0):0;
+  let t=cc?clamp((bb*s+ee)/cc):0;
+  s=aa?clamp((bb*t-dd)/aa):0;t=cc?clamp((bb*s+ee)/cc):0;
+  return sub(add(a,u,s),add(c,v,t));
+}
+function clip(prism:Prism,p:Vec3,d:Vec3):Hit3|null {
+  let near=0,far=1,n={x:0,y:0,z:0};
+  for(const plane of prism.planes){charge(8);const gap=plane.c-dot(plane.n,p),speed=dot(plane.n,d);if(Math.abs(speed)<1e-12){if(gap< -1e-9)return null;continue;}const t=gap/speed;if(speed<0){if(t>=near){near=t;n=plane.n;}}else far=Math.min(far,t);if(near>far+1e-9)return null;}
+  return near>=0&&near<=1&&far>=0?{t:near,nx:n.x,ny:n.y,nz:n.z}:null;
+}
+function distance(prism:Prism,a:Vec3,b:Vec3):Vec3 {
+  if(clip(prism,a,sub(b,a)))return {x:0,y:0,z:0};
+  let best={x:Infinity,y:Infinity,z:Infinity},sq=Infinity;
+  const take=(v:Vec3)=>{const n=dot(v,v);if(n<sq){sq=n;best=v;}};
+  for(const [x,y,z] of prism.faces){charge(36);take(sub(a,triangle(a,x,y,z)));take(sub(b,triangle(b,x,y,z)));take(segmentPair(a,b,x,y));take(segmentPair(a,b,y,z));take(segmentPair(a,b,z,x));}
+  return best;
+}
+function boxCast(prism:Prism,a:Solid,d:Vec3):Hit3|null {
+  const axes:Vec3[]=[{x:1,y:0,z:0},{x:0,y:1,z:0},{x:0,y:0,z:1},...prism.planes.map(p=>p.n)];
+  for(const e of prism.edges)for(const k of axes.slice(0,3))axes.push(cross(e,k));
+  let near=0,far=1,normal={x:0,y:0,z:0};
+  for(const axis of axes){charge(16);const len=Math.sqrt(dot(axis,axis));if(len<1e-10)continue;const n={x:axis.x/len,y:axis.y/len,z:axis.z/len};let lo=Infinity,hi=-Infinity;
+    for(const v of prism.vertices){const p=dot(n,v);lo=Math.min(lo,p);hi=Math.max(hi,p);}
+    let amin=0,amax=0;for(const k of ['x','y','z'] as const){amin+=n[k]*(n[k]>=0?a.min[k]:a.max[k]);amax+=n[k]*(n[k]>=0?a.max[k]:a.min[k]);}
+    const speed=dot(n,d);if(Math.abs(speed)<1e-12){if(amax<=lo+1e-9||amin>=hi-1e-9)return null;continue;}
+    let enter=(lo-amax)/speed,exit=(hi-amin)/speed;if(enter>exit)[enter,exit]=[exit,enter];
+    if(enter>=near){near=enter;normal={x:n.x*(speed>0?-1:1),y:n.y*(speed>0?-1:1),z:n.z*(speed>0?-1:1)};}far=Math.min(far,exit);if(near>far)return null;
+  }
+  return near<=1&&dot(normal,d)<0?{t:near,nx:normal.x,ny:normal.y,nz:normal.z}:null;
+}
+export function castTerrain(tile:MapHeightTile,a:Solid,d:Vec3):Hit3|null {
+  charge(12);
+  let best:Hit3|null=null;
+  for(const prism of cache.get(tile)??[]){
+    let hit:Hit3|null=null;
+    if(a.r===0)hit=a.min.x===a.max.x&&a.min.y===a.max.y&&a.min.z===a.max.z?clip(prism,a.min,d):boxCast(prism,a,d);
+    else {let t=0;for(let i=0;i<32;i++){charge(24);const v=distance(prism,add(a.min,d,t),add(a.max,d,t)),len=Math.sqrt(dot(v,v)),gap=len-a.r;if(i===0&&gap< -1e-7)break;if(len===0)break;const n={x:v.x/len,y:v.y/len,z:v.z/len},closing=-dot(n,d);if(closing<=1e-9)break;if(gap<=1e-7){hit={t,nx:n.x,ny:n.y,nz:n.z};break;}t+=gap/closing;if(t>1)break;if(i===31)hit={t,nx:n.x,ny:n.y,nz:n.z};}}
+    if(hit&&(!best||hit.t<best.t))best=hit;
+  }return best;
+}
+export function overlapsTerrain(tile:MapHeightTile,a:Solid):boolean {
+  for(const prism of cache.get(tile)??[]){
+    if(a.r>0){const v=distance(prism,a.min,a.max);if(dot(v,v)<a.r*a.r-1e-9)return true;}
+    else {
+      // SAT overlap uses the same face, edge and box axes as continuous casts.
+      const axes=[{x:1,y:0,z:0},{x:0,y:1,z:0},{x:0,y:0,z:1},...prism.planes.map(p=>p.n)];
+      for(const e of prism.edges)for(const k of axes.slice(0,3))axes.push(cross(e,k));
+      let separated=false;for(const n of axes){charge(16);if(dot(n,n)<1e-18)continue;const ps=prism.vertices.map(v=>dot(n,v));let lo=0,hi=0;for(const k of ['x','y','z'] as const){lo+=n[k]*(n[k]>=0?a.min[k]:a.max[k]);hi+=n[k]*(n[k]>=0?a.max[k]:a.min[k]);}if(hi<=Math.min(...ps)+1e-9||lo>=Math.max(...ps)-1e-9){separated=true;break;}}if(!separated)return true;
+    }
+  }return false;
+}

package/starters/coin-dash/game.json

@@ -2,10 +2,20 @@
   "id": "coin-dash",
   "name": "Coin Dash",
   "blurb": "Run for the coins before the others do. Sixty-second rounds, and the score is kept on the server, where nobody can change it.",
-  "players": { "min": 1, "max": 8 },
+  "players": {
+    "min": 1,
+    "max": 8
+  },
   "entry": "src/view.ts",
   "example": true,
-  "netplay": { "v": 1, "public": true },
-  "room": { "host": "server" },
-  "landing": { "pitch": "Run for the coins. First one there takes it.", "controls": { "phone": "Drag to run.", "computer": "WASD or arrows to run." } }
+  "room": {
+    "host": "server"
+  },
+  "landing": {
+    "pitch": "Run for the coins. First one there takes it.",
+    "controls": {
+      "phone": "Drag to run.",
+      "computer": "WASD or arrows to run."
+    }
+  }
 }

package/starters/ember-vale/game.json

@@ -8,10 +8,6 @@
   },
   "roundSeconds": 90,
   "entry": "src/view.ts",
-  "netplay": {
-    "v": 1,
-    "public": true
-  },
   "saves": true,
   "decide": false,
   "landing": {

package/starters/ember-vale/src/view.ts

@@ -1,7 +1,7 @@
 // Presentation only: openRoom gives predicted own movement and interpolated other bodies.
 // Send intent; rules decide outcomes. Keep rendered obstacles aligned with room.map.
 /** Ember Vale: server-run hunts, with the hero save and memorials owned by its player. */
-import { AI_MARK, BUBBLE_FONT, createBubbles, createControls, createLabels, paintBubbles, type BubbleIn, type BubbleOut, createSaves, easeView, exposePort, fitView, stripAi, type BodyBase, type Fit, type LabelIn, type LabelOut, type NetEvent } from '@homie-rocks/studio/port';
+import { AI_MARK, BUBBLE_FONT, createBubbles, createControls, createLabels, paintBubbles, type BubbleIn, type BubbleOut, createSaves, easeView, exposePort, fitView, stripAi, type Slot, type Fit, type LabelIn, type LabelOut, type NetEvent } from '@homie-rocks/studio/port';
 // The Game Lab: tunables, phases, tracks and overlays (no-ops outside the lab).
 import { lab } from '@homie-rocks/studio/lab';
 import { openRoom, type Entity } from '@homie-rocks/studio/rules/view';
@@ -28,7 +28,7 @@ const clamp = (v: number, a: number, b: number): number => Math.max(a, Math.min(
 
 /** The hero: the one thing that lasts. Kept in the save key 'hero'. */
 interface Hero { v: 1; name: string; level: number; xp: number; gold: number; hardcore: boolean; kills: number; deaths: number; born: number }
-interface Body extends BodyBase { x: number; y: number; hp: number; maxHp: number; level: number; face: number; flags: number; downUntil: number; atkAt: number; strikeAt: number; tx: number; ty: number; seenAt?: number; ax?: number; ay?: number }
+interface Body { slot: number; seat: number | null; name: string; bot: boolean; score: number; agent?: Slot['agent']; x: number; y: number; hp: number; maxHp: number; level: number; face: number; flags: number; downUntil: number; atkAt: number; strikeAt: number; tx: number; ty: number; seenAt?: number; ax?: number; ay?: number }
 /** A slime; while it is struck: where its push starts (kx, ky), along (kdx, kdy), from when (kat, after the hit-stop). */
 interface Slime { id: number; x: number; y: number; hp: number; maxHp: number; size: number; hitAt: number; lastHit: number; kx?: number; ky?: number; kdx?: number; kdy?: number; kat?: number }
 type SlimeRow = [id: number, x: number, y: number, hp: number, size: number];

package/starters/gem-rush/game.json

@@ -8,10 +8,6 @@
   },
   "roundSeconds": 60,
   "entry": "src/view.ts",
-  "netplay": {
-    "v": 1,
-    "public": true
-  },
   "landing": {
     "pitch": "Grab the gems. Bump your rivals away.",
     "controls": {

package/starters/gem-rush-3d/game.json

@@ -8,10 +8,6 @@
   },
   "roundSeconds": 60,
   "entry": "src/view.ts",
-  "netplay": {
-    "v": 1,
-    "public": true
-  },
   "needs": {
     "three": "0.185.1",
     "@types/three": "0.185.1"

package/starters/hero-rush-3d/game.json

@@ -8,10 +8,6 @@
   },
   "roundSeconds": 60,
   "entry": "src/view.ts",
-  "netplay": {
-    "v": 1,
-    "public": true
-  },
   "needs": {
     "three": "0.185.1",
     "@types/three": "0.185.1"

package/starters/hero-rush-3d/src/move.ts

@@ -4,6 +4,8 @@ import { defineMove, type Vec3 } from '@homie-rocks/studio/rules';
 
 import type { MoveBody, MoveContext } from '@homie-rocks/studio/rules/types';
 
+// Solid slopes use the same contact tangent as walls; the capsule keeps its full
+// clearance. Never replace this sweep with an unchecked height assignment.
 function slide<M>(body: MoveBody<M>, delta: Vec3, ctx: MoveContext<unknown, M>) {
   const before = body.pos, hit = ctx.world.sweep(body, delta);
   if (!hit) return;