@volter/editor-game 0.5.67 → 0.5.68

package/src/network/network-inspector-model.ts

@@ -90,6 +90,10 @@ export interface NetworkCapabilityMap {
   ping: boolean;
   /** The room server's own view (`inspectServer`). */
   server: boolean;
+  /** Traffic per replicated entity (`getTrafficByEntity`). */
+  entityTraffic: boolean;
+  /** Tallying that can be started and stopped (`isRecording`/`setRecording`). */
+  recording: boolean;
 }
 
 export function deriveNetworkCapabilities(
@@ -115,6 +119,8 @@ export function deriveNetworkCapabilities(
     send: typeof adapter.sendMessage === 'function',
     ping: typeof adapter.ping === 'function',
     server: typeof adapter.inspectServer === 'function',
+    entityTraffic: typeof adapter.getTrafficByEntity === 'function',
+    recording: typeof adapter.isRecording === 'function' && typeof adapter.setRecording === 'function',
   };
 }
 

package/src/runtime/create-runtime.ts

@@ -598,7 +598,7 @@ async function mountOneCanvasRoot(
       id: spec.id,
       zOrder: spec.zOrder ?? 0,
       canvas,
-      hitTest: spec.hitTest,
+      hitTest: spec.hitTest ?? (mounted.hitTest ? (x, y) => mounted.hitTest!(x, y) : undefined),
     },
   };
 }

package/src/runtime/input-router.ts

@@ -76,26 +76,32 @@ function pickEventInit(original: Event): Record<string, unknown> {
     'deltaZ',
     'deltaMode',
   ];
-  const init: Record<string, unknown> = { bubbles: false, cancelable: true, composed: true };
+  const init: Record<string, unknown> = { bubbles: true, cancelable: true, composed: true };
   for (const key of keys) if (key in src) init[key] = src[key];
   return init;
 }
 
 /**
- * Forward `original` onto `canvas` as a NEW, non-bubbling event of the same
- * event-type family — so a canvas with `pointer-events:none` (never a
- * native DOM hit-test target) still receives the interaction its own event
- * pipeline (Pixi's `EventSystem`, a raycast-driven three controller, …)
- * listens for on ITS canvas. `bubbles:false` is deliberate: it stops the
- * clone from re-triggering the container's own capture listener (an
- * infinite loop) — re-dispatching the SAME event object is not an option
- * either (the DOM forbids re-dispatching an event still being dispatched).
+ * Forward `original` onto `canvas` as a NEW event of the same event-type
+ * family — so a canvas with `pointer-events:none` (never a native DOM
+ * hit-test target) still receives the interaction its own event pipeline
+ * (Pixi's `EventSystem`, a raycast-driven three controller, …) listens for.
+ * The clone BUBBLES, because Pixi hears `pointermove` on the document and
+ * `pointerup` on the window, not on its canvas; the container's capture
+ * listener sees every clone on the way down (capture runs whether or not an
+ * event bubbles), and {@link forwarded} is what lets it pass rather than be
+ * routed again. Re-dispatching the SAME event object is not an option (the
+ * DOM forbids re-dispatching an event still being dispatched).
  *
  * Best-effort: environments with no `PointerEvent`/`MouseEvent`/
  * `WheelEvent` global (Node unit tests) skip forwarding silently — those
  * tests exercise the pure claim-resolution logic above instead, which needs
  * no real `Event` objects at all.
  */
+/** The clones this router dispatched: they bubble through the container's capture listener, which
+ *  lets them pass instead of routing them again. */
+const forwarded = new WeakSet<Event>();
+
 function forwardEvent(canvas: HTMLCanvasElement, original: Event): void {
   const g = globalThis as unknown as {
     PointerEvent?: new (type: string, init?: unknown) => Event;
@@ -110,7 +116,9 @@ function forwardEvent(canvas: HTMLCanvasElement, original: Event): void {
         : (g.MouseEvent ?? g.PointerEvent);
   if (!Ctor || typeof canvas.dispatchEvent !== 'function') return;
   try {
-    canvas.dispatchEvent(new Ctor(original.type, pickEventInit(original)));
+    const clone = new Ctor(original.type, pickEventInit(original));
+    forwarded.add(clone);
+    canvas.dispatchEvent(clone);
   } catch {
     // Best-effort forwarding — a construction failure here must never break
     // the (already-delivered) original event's own handling.
@@ -142,6 +150,7 @@ export function createInputRouter(
   const bottomId = stackOrder(entries)[0]?.id;
 
   const handler = (evt: Event) => {
+    if (forwarded.has(evt)) return;
     const rect = container.getBoundingClientRect?.() ?? { left: 0, top: 0 };
     const clientX = (evt as unknown as { clientX?: number }).clientX ?? 0;
     const clientY = (evt as unknown as { clientY?: number }).clientY ?? 0;
@@ -150,7 +159,11 @@ export function createInputRouter(
     const claimant = resolveClaimingRoot(entries, x, y);
     if (claimant && claimant !== bottomId) {
       const entry = byId.get(claimant);
-      if (entry) forwardEvent(entry.canvas, evt);
+      if (entry) {
+        // The claim is exclusive: the world beneath never hears a press its HUD took.
+        evt.stopPropagation();
+        forwardEvent(entry.canvas, evt);
+      }
     }
   };
 

package/src/services/game-network.ts

@@ -18,8 +18,10 @@
  */
 
 import { pack, unpack } from '@colyseus/msgpackr';
-import { decode, encode, type Iterator } from '@colyseus/schema';
+import { type DataChange, decode, encode, type Iterator } from '@colyseus/schema';
 import { SchemaSerializer } from '@colyseus/sdk';
+import { editorHost } from '@volter/editor-sdk/host';
+import { getPlayStartedAt, isPlayModeActive } from '../play/play-mode';
 import type {
   ConnectionState,
   NetConditioning,
@@ -99,14 +101,18 @@ interface Mirror {
   patches: number;
   patchBytes: number;
   types: Map<string, MutableType>;
+  entities: Map<string, MutableEntity>;
   socket: WebSocket;
   /** When the last delayed frame is due, per direction: a later frame never overtakes it. */
   dueIn: number;
+  /** The game's own `onmessage`, handed each frame when the conditioned delay lets it through. */
+  receive: ((event: MessageEvent) => unknown) | null;
   dueOut: number;
 }
 
 const mirrors: Mirror[] = [];
 const mirrorOf = new WeakMap<WebSocket, Mirror>();
+const gameHandlers = new WeakMap<WebSocket, ((this: WebSocket, event: MessageEvent) => unknown) | null>();
 const pingWaiters = new WeakMap<Mirror, (rttMs: number) => void>();
 /** The link conditioner (Unity's network simulator): latency and jitter on every observed room
  *  socket, both directions, in order. A WebSocket is reliable and ordered, so loss is not one of
@@ -147,7 +153,73 @@ function roll(now: number): void {
   window0 = { start: now, msgsIn: 0, msgsOut: 0, bytesIn: 0, bytesOut: 0 };
 }
 
+interface MutableEntity {
+  path: string;
+  syncs: number;
+  changes: number;
+  patchBytesMin: number;
+  patchBytesMax: number;
+}
+
+/** Whether traffic and the log are tallied (Godot's profiler Start/Stop). */
+let recording = false;
+
+/** The project-local choice Godot calls Autostart: a run starts recording at its first room
+ *  socket. Off unless chosen, as Godot's is. */
+export const NETWORK_AUTOSTART_SECTION = 'networkProfilerAutostart';
+/** The run (its Play start) Autostart last applied to. */
+let autostartedRun: number | null | undefined;
+
+/** Each object of a decoded state by its path from the root: schema fields and collection entries. */
+function statePaths(state: unknown): Map<object, readonly string[]> {
+  const paths = new Map<object, readonly string[]>();
+  const visit = (value: unknown, path: readonly string[]): void => {
+    if (!value || typeof value !== 'object' || paths.has(value)) return;
+    paths.set(value, path);
+    const metadata = (value as { constructor?: Record<symbol, unknown> }).constructor?.[Symbol.metadata] as
+      | Record<string, unknown>
+      | undefined;
+    if (metadata) {
+      for (const key of Object.keys(metadata)) {
+        const name = /^\d+$/.test(key) ? (metadata[key] as { name?: string } | undefined)?.name : undefined;
+        if (name) visit((value as Record<string, unknown>)[name], [...path, name]);
+      }
+      return;
+    }
+    (value as { forEach?: (each: (child: unknown, key: unknown) => void) => void }).forEach?.((child, key) =>
+      visit(child, [...path, String(key)]),
+    );
+  };
+  visit(state, []);
+  return paths;
+}
+
+/** Tally one patch against the entities its changes touched: an entity is a root field, or an
+ *  entry of a root collection (`players.abc`). */
+function recordEntities(mirror: Mirror, changes: readonly DataChange[], size: number): void {
+  if (!recording || changes.length === 0) return;
+  const paths = statePaths(mirror.serializer?.getState());
+  const touched = new Map<string, number>();
+  for (const change of changes) {
+    const full = [...(paths.get(change.ref as object) ?? []), String(change.dynamicIndex ?? change.field)];
+    const entity = full.slice(0, full.length > 1 ? 2 : 1).join('.');
+    touched.set(entity, (touched.get(entity) ?? 0) + 1);
+  }
+  for (const [path, count] of touched) {
+    let entry = mirror.entities.get(path);
+    if (!entry) {
+      entry = { path, syncs: 0, changes: 0, patchBytesMin: size, patchBytesMax: size };
+      mirror.entities.set(path, entry);
+    }
+    entry.syncs += 1;
+    entry.changes += count;
+    entry.patchBytesMin = Math.min(entry.patchBytesMin, size);
+    entry.patchBytesMax = Math.max(entry.patchBytesMax, size);
+  }
+}
+
 function record(mirror: Mirror, direction: 'in' | 'out', type: string, size: number, payload?: unknown): void {
+  if (!recording) return;
   const now = Date.now();
   roll(now);
   if (direction === 'in') {
@@ -210,9 +282,15 @@ function observeIncoming(mirror: Mirror, bytes: Uint8Array): void {
       mirror.stateBytes = bytes.byteLength;
       record(mirror, 'in', 'state', bytes.byteLength);
     } else if (code === ROOM_STATE_PATCH) {
+      const decoder = mirror.serializer?.decoder;
+      let changes: readonly DataChange[] = [];
+      if (decoder) decoder.triggerChanges = (all) => (changes = all);
       mirror.serializer?.patch(bytes, it);
-      mirror.patches += 1;
-      mirror.patchBytes += bytes.byteLength;
+      recordEntities(mirror, changes, bytes.byteLength);
+      if (recording) {
+        mirror.patches += 1;
+        mirror.patchBytes += bytes.byteLength;
+      }
       record(mirror, 'in', 'patch', bytes.byteLength);
     } else if (code === ROOM_DATA) {
       const type = messageType(bytes, it);
@@ -300,16 +378,32 @@ function attach(socket: WebSocket, url: string): void {
     rttMs: null,
     stateBytes: 0,
     patches: 0,
+    entities: new Map(),
     patchBytes: 0,
     types: new Map(),
     socket,
     dueIn: 0,
     dueOut: 0,
+    receive: null,
   };
+  // Autostart decides a RUN's recording once, at its first room socket; a reconnect inside the
+  // same run keeps whatever Start or Stop the person chose.
+  // Outside Play there is no run to key on: a socket opening with none live starts one.
+  const run = isPlayModeActive() ? getPlayStartedAt() : null;
+  const idle = !mirrors.some((other) => other.state === 'connected' || other.state === 'connecting');
+  if (run !== autostartedRun || (run === null && idle)) {
+    autostartedRun = run;
+    recording = editorHost().projectLocalState.read<boolean>(NETWORK_AUTOSTART_SECTION) ?? false;
+  }
   mirrors.push(mirror);
   mirrorOf.set(socket, mirror);
+  // ONE conditioned delivery per frame: the mirror reads it and the game receives it at the same
+  // moment, so the tables and Ping see the link the game sees (both directions of the delay).
   socket.addEventListener('message', (event: MessageEvent) => {
-    if (event.data instanceof ArrayBuffer) observeIncoming(mirror, new Uint8Array(event.data));
+    conditioned(mirror, 'in', () => {
+      if (event.data instanceof ArrayBuffer) observeIncoming(mirror, new Uint8Array(event.data));
+      mirror.receive?.(event);
+    });
   });
   socket.addEventListener('close', (event: CloseEvent) => {
     mirror.state = 'disconnected';
@@ -362,18 +456,20 @@ export function installGameNetwork(): void {
         attach(this, String(url));
       }
 
-      // The SDK receives through `onmessage`; a room socket's handler is handed each frame
-      // after the conditioner's delay. The mirror's own listener reads it on arrival.
+      // The SDK receives through `onmessage`; a room socket's handler is handed each frame by the
+      // mirror's conditioned delivery (`attach`), in the same turn the mirror reads it.
       override set onmessage(handler: ((this: WebSocket, event: MessageEvent) => unknown) | null) {
         const mirror = mirrorOf.get(this);
-        super.onmessage =
-          handler && mirror
-            ? (event: MessageEvent) => conditioned(mirror, 'in', () => handler.call(this, event))
-            : handler;
+        if (!mirror) {
+          super.onmessage = handler;
+          return;
+        }
+        gameHandlers.set(this, handler);
+        mirror.receive = handler ? (event) => handler.call(this, event) : null;
       }
 
       override get onmessage(): ((this: WebSocket, event: MessageEvent) => unknown) | null {
-        return super.onmessage;
+        return mirrorOf.has(this) ? (gameHandlers.get(this) ?? null) : super.onmessage;
       }
     };
     window.WebSocket = Observed as typeof WebSocket;
@@ -636,6 +732,7 @@ export const observedGameNetwork: NetworkingAdapter = {
   clearTraffic(): void {
     for (const mirror of mirrors) {
       mirror.types.clear();
+      mirror.entities.clear();
       mirror.patches = 0;
       mirror.patchBytes = 0;
     }
@@ -648,6 +745,19 @@ export const observedGameNetwork: NetworkingAdapter = {
     const mirror = current();
     return mirror ? [...mirror.types.values()].map(({ type, countIn, countOut, bytesIn, bytesOut }) => ({ type, countIn, countOut, bytesIn, bytesOut })) : [];
   },
+  getTrafficByEntity() {
+    const mirror = current();
+    return mirror
+      ? [...mirror.entities.values()]
+          .map(({ path, syncs, changes, patchBytesMin, patchBytesMax }) => ({ path, syncs, changes, patchBytesMin, patchBytesMax }))
+          .sort((a, b) => b.syncs - a.syncs)
+      : [];
+  },
+  isRecording: () => recording,
+  setRecording(on: boolean): void {
+    recording = on;
+    notify();
+  },
   getServerConfig() {
     const mirror = current();
     if (!mirror) return null;