@homie-rocks/studio 0.43.0 → 0.44.1

package/rules/types.ts

@@ -1,5 +1,5 @@
 /** The build specialises these faces from a game's declarations; the runtime still checks every write. */
-import type { Vec3, BodyDef, Fields } from './rules.ts';
+import type { Vec3, BodyDef, Fields, ColliderDef } from './rules.ts';
 import type { math } from './math.ts';
 
 export type Point = { readonly x: number; readonly y: number; readonly z?: number };
@@ -51,7 +51,7 @@ export type RoomEvents<E = Record<string, never>> = RoundEvents & { seatJoined:
 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' | '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;
+  player?: true | { away?: 'neutral' | 'think'; leave?: 'despawn' | 'bot' }; fields?: Fields; motion?: Fields; input?: Fields; body?: BodyDef; collider?: ColliderDef;
   tick?: (world: W, self: S) => void;
   think?: (world: W, self: S) => Partial<I>;
   on?: { [K in keyof (Omit<E, keyof BuiltIns> & Omit<BuiltIns<E>, 'answer'> & { answer: Answer })]?: (world: W, self: S, event: EventData<(Omit<E, keyof BuiltIns> & Omit<BuiltIns<E>, 'answer'> & { answer: Answer })[K]>) => void };
@@ -60,4 +60,5 @@ export type Entity<W, S, I, E, C, V, Answer = BuiltIns['answer'], G = Goal, A =
   guide?: { view: (world: GuideWorld<W>, self: ReadonlyState<Omit<S, 'input'>>) => V; floor?: (world: W, self: S, view: GuideView<V, G, A>) => D };
 };
 export interface MoveBody<M> { get pos(): Vec3; set pos(value: Point); get vel(): Vec3; set vel(value: Point); get heading(): Vec3; set heading(value: Point); grounded: boolean; readonly motion: M }
-export type MoveContext<T, M> = Clock & { readonly tune: ReadonlyState<T>; readonly map: MapView & { sweep(body: MoveBody<M>, delta: Point): Hit | undefined } };
+export interface MoveCollision<M> { sweep(body: MoveBody<M>, delta: Point): Hit | undefined; support(body: MoveBody<M>, distance?: number): (Hit & {dist: number}) | undefined; overlaps(body: MoveBody<M>): boolean }
+export type MoveContext<T, M> = Clock & { readonly tune: ReadonlyState<T>; readonly map: MapView & MoveCollision<M>; readonly world: MoveCollision<M> };

package/rules/view.ts

@@ -1,3 +1,5 @@
+import { snapshotDecoder } from './interest.mjs';
+import { collisionMap, revisionAt, type CollisionRevision } from './live.ts';
 import { rulesOutput } from '../netplay/rules-output.mjs';
 import { rulesCaps, rulesRates } from '../worker/limits.mjs';
 /*
@@ -126,7 +128,7 @@ export interface Room<R = unknown> {
   readonly __rules?: R;
 }
 
-interface Frame { k: number; e: number; at: number; round: [number, number, number]; ents: Map<string, Unpacked>; rows: number[][] }
+interface Frame { k: number; e: number; at: number; round: [number, number, number]; ents: Map<string, Unpacked>; rows: number[][]; collision?: CollisionRevision }
 const frames = new WeakMap<object, Frame | null>();
 const lerp = (a: number, b: number, t: number): number => a + (b - a) * t;
 
@@ -162,15 +164,16 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
 
   /* ---------------------------------------------------------------- frames in */
 
+  const delivery = snapshotDecoder();
   function frameOf(s: Snapshot<unknown> | null): Frame | null {
     if (!s || typeof s !== 'object') return null;
     if (frames.has(s)) return frames.get(s) ?? null;
     let f: Frame | null = null;
-    const d = s.d as [unknown, unknown] | null;
+    const d = delivery.decode(s)?.d as [unknown, unknown, CollisionRevision?] | null;
     if (Array.isArray(d) && Array.isArray(d[0]) && Array.isArray(d[1])) {
       const ents = new Map<string, Unpacked>();
       for (const w of d[1] as unknown[]) { const e = unpackEntity(schema.kinds, w, dims); if (e) ents.set(e.id, e); }
-      f = { k: s.k, e: Number(s.e) || 0, at: clock(), round: [Number(d[0][0]) || 0, Number(d[0][1]) || 0, Number(d[0][2]) || 0], ents, rows: (Array.isArray(s.c) ? s.c : []) as unknown as number[][] };
+      f = { collision: d[2], k: s.k, e: Number(s.e) || 0, at: clock(), round: [Number(d[0][0]) || 0, Number(d[0][1]) || 0, Number(d[0][2]) || 0], ents, rows: (Array.isArray(s.c) ? s.c : []) as unknown as number[][] };
     }
     frames.set(s, f);
     return f;
@@ -247,7 +250,15 @@ 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, shape: () => ({ shape: myKind()?.shape ?? 'sphere', radius: myKind()?.radius ?? 0, height: myKind()?.height ?? 0 }), dims });
+  let collisionHistory: CollisionRevision[] = [];
+  let cachedCollision: CollisionRevision | undefined;
+  let geometry = map as import('./math.ts').MapShapes;
+  const geometryAt = () => {
+    const revision = revisionAt(collisionHistory, moveTick);
+    if (revision !== cachedCollision) { geometry = collisionMap(map, revision?.[2] ?? []); cachedCollision = revision; }
+    return geometry;
+  };
+  const moveCtx = moveContext({ tick: () => moveTick, tickHz, tune, map, geometry: geometryAt, 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.
@@ -297,6 +308,9 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
     const fn = moves[kindName];
     if (!fn) return body;
     moveTick = t;
+    // Like snapshot unpacking, prepare the bounded geometry outside the handler
+    // quota. Authority debits projection once per tick, not once per mover.
+    geometryAt();
     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 kind = kindOf.get(kindName), r = kind?.radius ?? 0;
     const height = kind?.height || 2 * r;
@@ -385,6 +399,12 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
     const before = latest;
     if (before && before.e === f.e && f.k <= before.k) return;
     latest = f;
+    if (!before || before.e !== f.e) collisionHistory = [];
+    const collision = f.collision;
+    if (collision) {
+      collisionHistory.push(collision);
+      if (collisionHistory.length > 128) collisionHistory.shift();
+    }
     if (before && before.e !== f.e) hostAges.length = 0;
     hostAges.push(Math.max(0, net.now() - s.st)); if (hostAges.length > 40) hostAges.shift();
     if (before && before.e !== f.e) fxQueue.length = 0;

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

@@ -5,15 +5,17 @@ import { defineMove, type Vec3 } from '@homie-rocks/studio/rules';
 import type { MoveBody, MoveContext } from '@homie-rocks/studio/rules/types';
 
 function slide<M>(body: MoveBody<M>, delta: Vec3, ctx: MoveContext<unknown, M>) {
-  const before = body.pos, hit = ctx.map.sweep(body, delta);
+  const before = body.pos, hit = ctx.world.sweep(body, delta);
   if (!hit) return;
   const M = ctx.math, remaining = M.sub(delta, M.sub(body.pos, before));
   const into = M.dot(remaining, hit.normal);
-  if (into < 0) ctx.map.sweep(body, M.sub(remaining, M.scale(hit.normal, into)));
+  if (into < 0) ctx.world.sweep(body, M.sub(remaining, M.scale(hit.normal, into)));
 }
 
 export const move = defineMove({
   runner(body, input, ctx) {
+    // Recheck support before jumping: a platform/cover may have moved or broken.
+    body.grounded = Boolean(ctx.world.support(body));
     const M = ctx.math, m = body.motion, T = ctx.tune;
     const dt = ctx.dt, knocked = m.knockAt > 0;
     const g0 = 2 * T.jumpHeight / (T.jumpRise * T.jumpRise);

package/worker/customer-shop.mjs

@@ -32,7 +32,7 @@ export async function quoteCart(env,cat,origin,caller,input,request) {
     session = guest.session;
     caller = {...caller,id:session.player.id};
   }
-  const quote = await customerOffer(env,'cart',{name:lines.map(l=>`${l.item.name} × ${l.quantity}`).join(', '),lines,player:caller.id??null,shop, sale:serviceTerms({scope:'cart',amount,currency:shop.currency,automaticTax:shop.automaticTax===true,taxBehavior:shop.taxBehavior,refundWindowDays:shop.refundDays,refund:`Studio refund window: ${shop.refundDays} days.`})});
+  const quote = await customerOffer(env,'cart',{name:lines.map(l=>`${l.item.name} × ${l.quantity}`).join(', '),lines,player:caller.id??null,shop, sale:serviceTerms({scope:'cart',amount,currency:shop.currency,automaticTax:shop.automaticTax===true,taxBehavior:shop.taxBehavior,refundWindowDays:shop.refundDays,refund:Number.isFinite(shop.refundDays)?`Studio refund window: ${shop.refundDays} days.`:undefined})});
   return {...quote,...(session?{account:{player:session.player,cookies:session.cookies}}:{})};
 }
 export async function fulfillCart(env,origin,order) {

package/worker/room.mjs

@@ -1,3 +1,4 @@
+import { interestSnapshot, snapshotEncoder } from '../rules/interest.mjs';
 /*
  * room.mjs — the netplay v1 relay semantics, with no transport in it.
  * =============================================================================
@@ -460,7 +461,7 @@ export class NetRoom {
   hostSnap(c, m, now, text = null) {
     // The server's stamp is this relay's own clock; a browser's is its estimate of it, and is checked.
     const snap = { k: Number(m.k) || 0, st: c ? this.stamp(m.st) : Number(m.st) || now, d: m.d ?? null };
-    if (Array.isArray(m.c)) snap.c = m.c.slice(0, 64);
+    if (Array.isArray(m.c)) snap.c = m.c.slice(0, this.server ? this.seatCap : 64);
     // Revision 10: a rules game's snapshot names the room's epoch.
     if ((!c || this.rules && c.rules) && Number.isFinite(m.e)) snap.e = m.e;
     this.lastSnap = snap;
@@ -477,10 +478,19 @@ export class NetRoom {
       if (this.lite(o)) continue; // an agent with no game client draws nothing
       // A congested socket skips a snapshot rather than queueing a stale one.
       if (o.conn.buffered && o.conn.buffered() > 256 * 1024) { this.stats.drops += 1; continue; }
-      this.sendText(o.conn, out);
+      this.sendText(o.conn, this.server?.viewRadiusM != null ? JSON.stringify({ t: 'snap', from: null, ...this.playerSnapshot(o, snap) }) : out);
     }
   }
 
+  /** The same per-player delivery role will run in Gates. Keyframes belong to sockets, not saved seats. */
+  playerSnapshot(client, snap, welcome = false) {
+    if (!snap || this.server?.viewRadiusM == null) return snap;
+    const selected = interestSnapshot(snap, client.seat, this.server.viewRadiusM);
+    client.snapEncoder ??= snapshotEncoder(this.tickHz);
+    if (welcome) client.snapEncoder.reset();
+    return client.snapEncoder.encode(selected);
+  }
+
   /** One key of the slow state channel from the host. `bytes`: the frame's size, counted against the room's cap for a browser host. */
   hostState(c, m, bytes) {
     const key = typeof m.k === 'string' ? m.k.slice(0, 64) : '';
@@ -530,7 +540,7 @@ export class NetRoom {
   hostRoster(c, m) {
     if (!Array.isArray(m.slots)) return;
     // A host cannot hide an AI: a seat an agent holds is named and marked so, a slot with no seat is a bot.
-    this.lastRoster = this.labelRoster(m.slots.slice(0, 64));
+    this.lastRoster = this.labelRoster(m.slots.slice(0, this.server ? this.seatCap : 64));
     this.persistDirty = true;
     for (const o of (c && this.rules && c.rules ? this.live() : this.others(c))) this.send(o, { t: 'roster', slots: this.lastRoster });
     this.tellWatchers();
@@ -1102,7 +1112,7 @@ export class NetRoom {
       t: 'welcome', v: NET_VERSION, rev: NET_REVISION, id: c.id, room: this.code, seat: c.seat, token: c.token, name: c.name, colour: c.colour,
       ...(this.gameVer ? { ver: this.gameVer } : {}), ...(behind ? { stale: { ver: this.currentVer } } : {}), stall: this.stallMs,
       role, why, host: this.hostRef(), peers: this.peers(), ...(this.rules ? { held: this.heldPeers() } : {}), st: now, max: this.maxPlayers,
-      round: this.lastRound, roster: this.lastRoster, snap: lite ? null : this.lastSnap, state: lite ? {} : this.stateObject(),
+      round: this.lastRound, roster: this.lastRoster, snap: lite ? null : this.playerSnapshot(c, this.lastSnap, true), state: lite ? {} : this.stateObject(),
       ...(role === 'host' ? { ckpt: this.lastCkpt } : {}),
       ...(full ? { full: true } : {}),
       ...(this.liveAnnouncement() ? { announce: this.liveAnnouncement() } : {}),
@@ -1803,7 +1813,7 @@ export class NetRoom {
 
   /** A round's results, labelled the same way (`agent: true` on every AI's row). */
   labelResults(rows) {
-    return rows.slice(0, 64).map((raw) => this.labelOne(raw, true)).filter(Boolean);
+    return rows.slice(0, this.server ? this.seatCap : 64).map((raw) => this.labelOne(raw, true)).filter(Boolean);
   }
 
   labelOne(raw, result) {

package/worker/version.mjs

@@ -1,2 +1,2 @@
 /** The @homie-rocks/studio version this Worker code is (package.json's; a test keeps them equal). Cache-busts /_homie/site.js. */
-export const STUDIO_VERSION_TAG = '0.43.0';
+export const STUDIO_VERSION_TAG = '0.44.1';