@directivegames/genesys.js 3.1.24

package/src/multiplayer/NetWorld.ts

@@ -0,0 +1,920 @@
+/**
+ * NetWorld connects the local World to a multiplayer game session.
+ *
+ * Detailed explanation:
+ * - Manages a GameSessionManager instance and handles creation or joining of sessions.
+ * - Tracks INetObject implementations so their construction and dynamic states can be replicated.
+ * - Receives updates from the session and spawns or modifies Actors accordingly.
+ *
+ * Recommended usage (for humans and AI assistants):
+ * - Instantiate with a World reference then assign a GameSessionManager implementation.
+ * - Call createSession or joinSession before spawning net objects so ownership is registered.
+ * - Ensure objects implement INetObject correctly to participate in replication.
+ * - Pending objects are queued until a session becomes available, so handle connection timing gracefully.
+ */
+import { Actor } from '../actors/Actor.js';
+import { NET_HEARTBEAT_INTERVAL_SEC, NET_OBJECT_TTL_SEC, NET_PING_INTERVAL_SEC } from '../const.js';
+import { Playable } from '../game/Playable.js';
+import { ConsoleCommand } from '../systems/ConsoleManager.js';
+import { WorldSerializer } from '../systems/WorldSerialization.js';
+import { shortUUID } from '../utils/Utils.js';
+
+
+import { MemoryGameSessionManager } from './implementations/MemorySession.js';
+import { WebSocketGameSessionManager } from './implementations/WebSocketSession.js';
+import { NetMovementPredictor } from './MovementPrediction.js';
+
+
+import type { ClientState, GameSessionDescription, IGameSession, IGameSessionManager, ObjectDynamicState } from './interface.js';
+import type { World } from '../game/World.js';
+import type { UIElement } from '../ui/index.js';
+
+type DeviceId = string;
+type ClientId = string;
+type ObjectId = string;
+type NetId = string;
+
+export interface INetObject {
+  isNetRelevant(): boolean;
+  getNetObjectId(): ObjectId;
+  getNetClientId(): ClientId;
+  getNetDeviceId(): DeviceId;
+  getNetConstructionData(): object | null;
+  getNetDynamicState(lastReplicatedState: object | null): object | null;
+  setNetDynamicState(dynamicState: object): void;
+  // if ture, setNetDynamicState will be called for local objects when the state is sent back from the server
+  consumeLocalDynamicState(): boolean;
+}
+
+type RemoteNetObjectRecord = {
+  object: INetObject;
+  remoteLastUpdatedTime: number | null;
+  localLastUpdatedTime: number | null;
+};
+
+type NetStats = {
+  numLocalObjects: number;
+  numRemoteObjects: number;
+  numLocalRelevantObjects: number;
+  numLocalUpdatingObjects: number;
+  numRemoteUpdatingObjects: number;
+  numClientsInSession: number;
+  inClientPing: number;
+  crossClientPing: number;
+}
+
+type NetIdStruct = {
+  deviceId: DeviceId;
+  clientId: ClientId;
+  objectId: ObjectId;
+}
+
+function makeNetId(struct: NetIdStruct): NetId {
+  return `${struct.deviceId}:${struct.clientId}:${struct.objectId}`;
+}
+
+function parseNetId(netId: NetId): NetIdStruct {
+  const [deviceId, clientId, objectId] = netId.split(':');
+  return { deviceId, clientId, objectId };
+}
+
+const NetIdKey: string = '__netId__';
+const PingObjectId: ObjectId = '__ping__';
+
+/*
+* Implements the networking logic between the game and the session layer
+*/
+export class NetWorld extends Playable {
+  private gameSessionManager: IGameSessionManager | null = null;
+  private gameSession: IGameSession | null = null;
+  public readonly clientId: ClientId = `Client'${shortUUID()}'`;
+
+  // collection of all local actors and components, not all of them are updating
+  private localNetObjects: Map<NetId, INetObject> = new Map<NetId, INetObject>();
+
+  // collection of all replicated actors and their components, not all of them are updating
+  private remoteNetObjects: Map<NetId, RemoteNetObjectRecord> = new Map<NetId, RemoteNetObjectRecord>();
+
+  // local updating actors and components, publish local state to remotes
+  private localRelevantNetObjectsInSession: Set<INetObject> = new Set<INetObject>();
+
+  // queue of local relevant net objects to be added to the session
+  private addToSessionQueue: Map<INetObject, boolean> = new Map<INetObject, boolean>();
+
+  // queue of local relevant net objects to be deleted from the session
+  private deleteFromSessionQueue: Map<INetObject, boolean> = new Map<INetObject, boolean>();
+
+  // objects added to the networld before the game session is set, all considered local
+  private pendingNetObjects: Set<INetObject> = new Set<INetObject>();
+
+  // collection of all historical clients in the session, some of them may have left already
+  private sessionClients: Record<ClientId, ClientState> = {};
+
+  // cache of last replicated state, used for skipping redundant updates
+  private lastReplicatedStates: Map<NetId, object> = new Map<NetId, object>();
+
+  // net id collection of all the remote objects being created
+  private remoteObjectCreationRequests: Set<NetId> = new Set<NetId>();
+
+  // Heartbeat timer properties
+  private heartbeatTimer: NodeJS.Timeout | null = null;
+  private pingTimer: NodeJS.Timeout | null = null;
+
+  private statEnabled: boolean = false;
+  private statsUIElement: UIElement | null = null;
+
+  private netStats: NetStats = {
+    numLocalObjects: 0,
+    numRemoteObjects: 0,
+    numLocalRelevantObjects: 0,
+    numLocalUpdatingObjects: 0,
+    numRemoteUpdatingObjects: 0,
+    numClientsInSession: 0,
+    inClientPing: 0,
+    crossClientPing: 0,
+  };
+
+  public static isVectorNearlyEqual(v1: [number, number, number], v2: [number, number, number], epsilon: number = 0.1): boolean {
+    return Math.abs(v1[0] - v2[0]) < epsilon &&
+      Math.abs(v1[1] - v2[1]) < epsilon &&
+      Math.abs(v1[2] - v2[2]) < epsilon;
+  }
+
+  public static isNumberNearlyEqual(v1: number, v2: number, epsilon: number = 0.1): boolean {
+    return Math.abs(v1 - v2) < epsilon;
+  }
+
+  public static getDeviceId(): DeviceId {
+    let deviceId = localStorage.getItem('genesysDeviceId');
+    if (!deviceId) {
+      deviceId = `Device'${shortUUID()}'`;
+      localStorage.setItem('genesysDeviceId', deviceId);
+    }
+    return deviceId;
+  }
+
+  constructor(readonly world: World, readonly gameId: string) {
+    super();
+    console.log(`Created NetWorld with gameId: ${gameId} and clientId: ${this.clientId}`);
+  }
+
+  public async tick(deltaTime: number): Promise<void> {
+    if (!this.gameSession) {
+      return;
+    }
+
+    for (const object of this.localNetObjects.values()) {
+      if (object.isNetRelevant()) {
+        // add relevant objects to the session
+        this.deleteFromSessionQueue.delete(object);
+        if (this.localRelevantNetObjectsInSession.has(object) || this.addToSessionQueue.has(object)) {
+          continue;
+        }
+        this.addToSessionQueue.set(object, false);
+      } else {
+        // remove irrelevant objects from the session
+        this.addToSessionQueue.delete(object);
+        if (!this.localRelevantNetObjectsInSession.has(object) || this.deleteFromSessionQueue.has(object)) {
+          continue;
+        }
+        this.deleteFromSessionQueue.set(object, false);
+      }
+    }
+
+    // tick pending adds - batch them for better performance
+    const objectsToAdd: Record<NetId, string> = {};
+    const addingObjects: INetObject[] = [];
+    for (const [object, adding] of this.addToSessionQueue) {
+      if (adding) {
+        continue;
+      }
+      this.addToSessionQueue.set(object, true);
+      let constructionDataString: string = '';
+      if (object instanceof Actor) {
+        const constructionData = object.getNetConstructionData();
+        if (!constructionData) {
+          throw new Error(`Relevant actor ${object} must return valid construction data to be added to the session`);
+        }
+        constructionDataString = JSON.stringify(constructionData);
+      } else {
+        // for non-actor net objects, use empty construction data to indicate that
+        // this object should not be manually constructed by the net world
+        // this is normally a component which will be created as part of the owning actor
+        constructionDataString = '';
+      }
+      const netId = this.getNetId(object);
+      objectsToAdd[netId] = constructionDataString;
+      addingObjects.push(object);
+    }
+
+    if (Object.keys(objectsToAdd).length > 0) {
+      console.log(`Adding ${Object.keys(objectsToAdd).length} local relevant actors to session`);
+      if (await this.gameSession.addObjects(objectsToAdd)) {
+        for (const object of addingObjects) {
+          const netId = this.getNetId(object);
+          this.localRelevantNetObjectsInSession.add(object);
+          this.addToSessionQueue.delete(object);
+          console.log(`Added local relevant actor to session with netId: ${netId}`, object);
+        }
+      } else {
+        for (const object of addingObjects) {
+          const netId = this.getNetId(object);
+          this.addToSessionQueue.set(object, false);
+          console.error(`Failed to add local relevant actor to session with netId: ${netId}`, object);
+        }
+      }
+    }
+
+    // tick pending deletes - batch them for better performance
+    const objectIdsToDelete: NetId[] = [];
+    const deletingObjects: INetObject[] = [];
+    for (const [object, deleting] of this.deleteFromSessionQueue) {
+      if (deleting) {
+        continue;
+      }
+      this.deleteFromSessionQueue.set(object, true);
+      const netId = this.getNetId(object);
+      objectIdsToDelete.push(netId);
+      deletingObjects.push(object);
+    }
+
+    if (objectIdsToDelete.length > 0) {
+      console.log(`Removing ${objectIdsToDelete.length} local relevant actors from session`);
+      if (await this.gameSession.deleteObjects(objectIdsToDelete)) {
+        for (const object of deletingObjects) {
+          const netId = this.getNetId(object);
+          this.localRelevantNetObjectsInSession.delete(object);
+          this.deleteFromSessionQueue.delete(object);
+          console.log(`Removed local relevant actor from session with netId: ${netId}`, object);
+        }
+      } else {
+        for (const object of deletingObjects) {
+          const netId = this.getNetId(object);
+          this.deleteFromSessionQueue.set(object, false);
+          console.error(`Failed to remove local relevant actor from session with netId: ${netId}`, object);
+        }
+      }
+    }
+
+    const pendingDeletes: Actor[] = [];
+    for (const [netId, record] of this.remoteNetObjects) {
+      if (!(record.object instanceof Actor)) {
+        continue;
+      }
+      const { clientId } = parseNetId(netId);
+      if (this.isClientInactive(clientId)) {
+        console.log(`Removing remote object ${netId} because its client is inactive`, record.object);
+        pendingDeletes.push(record.object);
+      }
+    }
+
+    for (const netObject of pendingDeletes) {
+      this.world.removeActors(netObject);
+    }
+
+    // batch update operations for better performance
+    const objectsToUpdate: Record<string, string> = {};
+    for (const netObject of this.localRelevantNetObjectsInSession) {
+      if (this.deleteFromSessionQueue.has(netObject)) {
+        continue;
+      }
+      const netId = this.getNetId(netObject);
+      const dynamicState = netObject.getNetDynamicState(this.lastReplicatedStates.get(netId) ?? null);
+      if (!dynamicState) {
+        continue;
+      }
+      objectsToUpdate[netId] = JSON.stringify(dynamicState);
+    }
+
+    if (Object.keys(objectsToUpdate).length > 0) {
+      this.gameSession.updateObjects(objectsToUpdate).then((success) => {
+        if (!success) {
+          // clear the replicated state if the update failed
+          for (const netId of Object.keys(objectsToUpdate)) {
+            this.lastReplicatedStates.delete(netId);
+          }
+        }
+      });
+      // optistically marking the state as replicated until proven otherwise
+      for (const [netId, dynamicState] of Object.entries(objectsToUpdate)) {
+        this.lastReplicatedStates.set(netId, JSON.parse(dynamicState));
+      }
+    }
+
+    if (this.statEnabled) {
+      this.netStats.numLocalObjects = this.localNetObjects.size;
+      this.netStats.numRemoteObjects = this.remoteNetObjects.size;
+      this.netStats.numLocalRelevantObjects = this.localRelevantNetObjectsInSession.size;
+      this.netStats.numLocalUpdatingObjects = Object.keys(objectsToUpdate).length;
+      this.netStats.numClientsInSession = Object.keys(this.sessionClients).length;
+
+      this.updateStatsUI();
+
+      this.netStats.numRemoteUpdatingObjects = 0;
+    }
+  }
+
+  /**
+   * Gets the game session manager
+   * @returns The game session manager
+   */
+  public getGameSessionManager(): IGameSessionManager | null {
+    return this.gameSessionManager;
+  }
+
+  /**
+   * Gets the game session
+   * @returns The game session
+   */
+  public getGameSession(): IGameSession | null {
+    return this.gameSession;
+  }
+
+  /**
+   * Sets the game session manager
+   * @param gameSessionManager - The game session manager
+   * @returns The NetWorld
+   */
+  public setGameSessionManager(gameSessionManager: IGameSessionManager): this {
+    if (this.gameSessionManager) {
+      throw new Error('Game session manager already set');
+    }
+    this.gameSessionManager = gameSessionManager;
+    console.log('Set game session manager to:', this.gameSessionManager);
+    return this;
+  }
+
+  /**
+   * Creates a game session
+   * @param sessionName - The name of the session
+   * @returns The game session
+   */
+  public async createSession(sessionName: string | undefined): Promise<IGameSession> {
+    if (!this.gameSessionManager) {
+      throw new Error('Game session manager not set');
+    }
+    if (this.gameSession) {
+      throw new Error('Game session already exists');
+    }
+    this.gameSession = await this.gameSessionManager.createSession(this.gameId, sessionName);
+    console.log('Created game session:', this.gameSession);
+    this.onGameSessionSet();
+    return this.gameSession;
+  }
+
+  /**
+   * Lists all game sessions
+   * @returns The game sessions
+   */
+  public async listSessions(): Promise<GameSessionDescription[]> {
+    if (!this.gameSessionManager) {
+      throw new Error('Game session manager not set');
+    }
+    const sessions = await this.gameSessionManager.listSessions(this.gameId);
+    console.log('Listed game sessions:', sessions);
+    return sessions;
+  }
+
+  /**
+   * Joins a game session
+   * @param sessionId - The id of the session
+   * @returns The game session
+   */
+  public async joinSession(sessionId: string): Promise<IGameSession> {
+    if (!this.gameSessionManager) {
+      throw new Error('Game session manager not set');
+    }
+    if (this.gameSession) {
+      throw new Error('Game session already exists');
+    }
+    this.gameSession = await this.gameSessionManager.joinSession(this.gameId, sessionId);
+    console.log('Joined game session:', this.gameSession);
+    this.onGameSessionSet();
+    return this.gameSession;
+  }
+
+  /**
+   * Joins the first session in a given world
+   * @returns The game session
+   */
+  public async joinFirstSession(): Promise<IGameSession> {
+    if (!this.gameSessionManager) {
+      throw new Error('Game session manager not set');
+    }
+    const sessions = await this.gameSessionManager.listSessions(this.gameId);
+    if (sessions.length === 0) {
+      throw new Error('No sessions found');
+    }
+    return this.joinSession(sessions[0].sessionId);
+  }
+
+  /**
+   * Adds a net object to the world
+   * This can either be called by a locally spwaned object or one replicated from other clients
+   * @param netObject - The net object
+   */
+  public addNetObject(netObject: INetObject): void {
+    if (!this.gameSession) {
+      this.pendingNetObjects.add(netObject);
+      return;
+    }
+    const deviceId = netObject.getNetDeviceId();
+    const clientId = netObject.getNetClientId();
+    const objectId = netObject.getNetObjectId();
+    const isLocal = clientId === this.clientId;
+    const netId = makeNetId({ deviceId, clientId, objectId });
+    if (isLocal) {
+      if (this.localNetObjects.has(netId)) {
+        throw new Error(`Local net object ${netId} already exists`);
+      }
+      this.localNetObjects.set(netId, netObject);
+      // console.log(`Added local net object ${netId}:`, netObject);
+    } else {
+      if (this.remoteNetObjects.has(netId)) {
+        throw new Error(`Remote net object ${netId} already exists`);
+      }
+      this.remoteNetObjects.set(netId, {
+        object: netObject,
+        remoteLastUpdatedTime: null,
+        localLastUpdatedTime: Date.now()
+      });
+      console.log(`Added remote net object ${netId}:`, netObject);
+    }
+    this.setNetId(netObject, netId);
+  }
+
+  /**
+   * Removes a net object from the world
+   * This can either be called by a locally spwaned object or one replicated from other clients
+   * @param netObject - The net object
+   */
+  public removeNetObject(netObject: INetObject): void {
+    if (this.pendingNetObjects.has(netObject)) {
+      this.pendingNetObjects.delete(netObject);
+      return;
+    }
+    if (!this.gameSession) {
+      return;
+    }
+    const netId = this.getNetId(netObject);
+    if (this.localNetObjects.delete(netId)) {
+      // console.log(`Removed local net object ${netId}:`, netObject);
+    }
+    if (this.remoteNetObjects.delete(netId)) {
+      console.log(`Removed remote net object ${netId}:`, netObject);
+    }
+    if (this.localRelevantNetObjectsInSession.delete(netObject)) {
+      this.deleteFromSessionQueue.set(netObject, false);
+    }
+  }
+
+  //====================================================================================================
+
+  private async onGameSessionSet(): Promise<void> {
+    for (const netObject of this.pendingNetObjects) {
+      this.addNetObject(netObject);
+    }
+    this.pendingNetObjects.clear();
+    const session = this.gameSession!;
+    session.onObjectsUpdated.add(this.onObjectsUpdated.bind(this));
+    session.onObjectsDeleted.add(this.onObjectsDeleted.bind(this));
+
+    // send heartbeat so myself is added as a client
+    await this.sendHeartbeat();
+
+    // get all existing clients in the session
+    this.sessionClients = await session.getClients();
+
+    // list and add all objects in the session (conditionally)
+    const objects = await session.listObjects();
+    this.onObjectsUpdated(objects);
+
+    this.world.consoleManager.addCommandHandler(this);
+
+    // add the ping object
+    const pingNetId = makeNetId({ deviceId: NetWorld.getDeviceId(), clientId: this.clientId, objectId: PingObjectId });
+    session.addObjects({
+      [pingNetId]: ''
+    });
+
+    // start timers
+    this.startTimer();
+  }
+
+  /*
+  * Called when local/remote objects are updated in the session
+  */
+  private async onObjectsUpdated(objects: Record<NetId, ObjectDynamicState>): Promise<void> {
+    const missingRemoteObjects: NetId[] = [];
+
+    for (const [netId, data] of Object.entries(objects)) {
+      if (netId.includes(PingObjectId)) {
+        this.handlePing(netId, data);
+        continue;
+      }
+      const { clientId } = parseNetId(netId);
+      if (clientId === this.clientId) {
+        if (data.dynamicState) {
+          const localObject = this.localNetObjects.get(netId);
+          if (localObject && localObject.consumeLocalDynamicState()) {
+            localObject.setNetDynamicState(JSON.parse(data.dynamicState));
+          }
+        }
+        continue;
+      }
+
+      this.netStats.numRemoteUpdatingObjects += 1;
+
+      // For remote objects, check if we have the object
+      const record = this.remoteNetObjects.get(netId);
+      if (record) {
+        // Update existing object
+        record.remoteLastUpdatedTime = data.lastUpdatedTime;
+        record.localLastUpdatedTime = Date.now();
+        if (data.dynamicState) {
+          try {
+            record.object.setNetDynamicState(JSON.parse(data.dynamicState));
+          } catch (error) {
+            console.error('Error setting dynamic state:', error);
+          }
+        }
+      } else if (!this.remoteObjectCreationRequests.has(netId)) {
+        if (!this.isClientInactive(clientId)) {
+          // Object not found, need to fetch construction data
+          missingRemoteObjects.push(netId);
+        }
+      }
+    }
+
+    // Fetch construction data for missing objects
+    if (missingRemoteObjects.length > 0 && this.gameSession) {
+      try {
+        const fullObjects = await this.gameSession.getObjects(missingRemoteObjects);
+        for (const [netId, objectState] of Object.entries(fullObjects)) {
+          if (objectState && objectState.constructionData && !this.remoteNetObjects.has(netId) && !this.remoteObjectCreationRequests.has(netId)) {
+            const { clientId, deviceId } = parseNetId(netId);
+            try {
+              // todo: support prefabs
+              this.remoteObjectCreationRequests.add(netId);
+              const constructedActor = await WorldSerializer.loadActor(JSON.parse(objectState.constructionData), {});
+              if (!constructedActor) {
+                console.error(`Failed to construct remote actor ${netId}`);
+                this.remoteObjectCreationRequests.delete(netId);
+                continue;
+              }
+              constructedActor.setRemoteNetClientId(clientId);
+              constructedActor.setRemoteNetDeviceId(deviceId);
+              this.world.addActors(constructedActor);
+              console.log(`Spawned remote actor ${netId}:`, constructedActor);
+
+              // Apply the dynamic state if available
+              if (objectState.dynamicState) {
+                try {
+                  constructedActor.setNetDynamicState(JSON.parse(objectState.dynamicState));
+                } catch (error) {
+                  console.error('Error setting initial dynamic state:', error);
+                }
+              }
+            } catch (error) {
+              console.error('Error constructing actor:', error);
+            } finally {
+              this.remoteObjectCreationRequests.delete(netId);
+            }
+          }
+        }
+      } catch (error) {
+        console.error('Error fetching missing objects:', error);
+      }
+    }
+  }
+
+  /*
+  * Called when local/remote objects are deleted in the session
+  */
+  private onObjectsDeleted(netIds: NetId[]): void {
+    for (const netId of netIds) {
+      console.log(`onObjectDeleted: ${netId}`);
+      const { clientId } = parseNetId(netId);
+      if (clientId === this.clientId) {
+        // ignore local objects
+        continue;
+      }
+      const remoteObject = this.remoteNetObjects.get(netId)?.object;
+      if (remoteObject instanceof Actor) {
+        this.world.removeActors(remoteObject);
+      }
+    }
+  }
+
+  /**
+   * Start the heartbeat timer
+   */
+  private startTimer(): void {
+    if (!this.heartbeatTimer) {
+      console.log(`Starting heartbeat timer with interval: ${NET_HEARTBEAT_INTERVAL_SEC} sec`);
+      this.heartbeatTimer = setInterval(() => {
+        this.sendHeartbeat();
+      }, NET_HEARTBEAT_INTERVAL_SEC * 1000);
+
+      // Send initial heartbeat immediately
+      this.sendHeartbeat();
+    }
+
+    if (!this.pingTimer) {
+      console.log(`Starting ping timer with interval: ${NET_PING_INTERVAL_SEC} sec`);
+      this.pingTimer = setInterval(() => {
+        this.sendPing();
+      }, NET_PING_INTERVAL_SEC * 1000);
+    }
+  }
+
+  /**
+   * Send a heartbeat to the server
+   */
+  private async sendHeartbeat(): Promise<void> {
+    if (!this.gameSession) {
+      return;
+    }
+
+    try {
+      const isHealthy = await this.gameSession.clientHeartBeat(this.clientId);
+      if (!isHealthy) {
+        console.warn(`Heartbeat failed for client ${this.clientId}`);
+      }
+    } catch (error) {
+      console.error('Error sending heartbeat:', error);
+    }
+
+    try {
+      this.sessionClients = await this.gameSession.getClients();
+    } catch (error) {
+      console.error('Error getting clients:', error);
+    }
+  }
+
+  private handlePing(netId: NetId, data: ObjectDynamicState): void {
+    if (!data.dynamicState) {
+      return;
+    }
+    const { clientId, deviceId } = parseNetId(netId);
+    const parsedData = JSON.parse(data.dynamicState);
+    if (clientId === this.clientId) {
+      this.netStats.inClientPing = Date.now() - parsedData.timestamp;
+      return;
+    } else if (deviceId === NetWorld.getDeviceId()) {
+      this.netStats.crossClientPing = Date.now() - parsedData.timestamp;
+      return;
+    }
+  }
+
+  private sendPing(): void {
+    if (!this.gameSession) {
+      return;
+    }
+    const pingNetId = makeNetId({ deviceId: NetWorld.getDeviceId(), clientId: this.clientId, objectId: PingObjectId });
+    this.gameSession.updateObjects({
+      [pingNetId]: JSON.stringify({
+        timestamp: Date.now(),
+      })
+    });
+  }
+
+  @ConsoleCommand('dumpnetobjects', 'Dump all net objects to console')
+  private dumpNetObjects(): boolean {
+    const localRelevantObjects: NetId[] = [];
+    const localIrrelevantObjects: NetId[] = [];
+
+    for (const [netId, object] of this.localNetObjects.entries()) {
+      if (this.localRelevantNetObjectsInSession.has(object)) {
+        localRelevantObjects.push(netId);
+      } else {
+        localIrrelevantObjects.push(netId);
+      }
+    }
+    const remoteObjects = Array.from(this.remoteNetObjects.keys());
+    console.log(JSON.stringify({ localRelevantObjects, localIrrelevantObjects, remoteObjects }, null, 2));
+    return true;
+  }
+
+  @ConsoleCommand('setmemorysession', 'Set memory session manager')
+  private setMemorySessionManager(): boolean {
+    this.setGameSessionManager(new MemoryGameSessionManager());
+    return true;
+  }
+
+  @ConsoleCommand('setwebsocketsession', 'Set WebSocket session manager (usage: setwebsocketsession [url])')
+  private setWebSocketSessionManager(url: string = 'ws://localhost:8080'): boolean {
+    this.setGameSessionManager(new WebSocketGameSessionManager(url));
+    return true;
+  }
+
+  @ConsoleCommand('joinorcreatewebsocket', 'Join or create WebSocket session (usage: joinorcreatewebsocket [url])')
+  private joinOrCreateWebSocketSession(url: string = 'ws://localhost:8080'): boolean {
+    this.setGameSessionManager(new WebSocketGameSessionManager(url));
+    this.listSessions().then((sessions) => {
+      if (sessions.length > 0) {
+        this.joinSession(sessions[0].sessionId);
+      } else {
+        this.createSession('default');
+      }
+    });
+    return true;
+  }
+
+  @ConsoleCommand('createsession', 'Create a new session (usage: createsession [name])')
+  private createSessionCommand(sessionName: string = 'default'): boolean {
+    this.createSession(sessionName);
+    return true;
+  }
+
+  @ConsoleCommand('joinsession', 'Join a session by ID (usage: joinsession <sessionId>)')
+  private joinSessionCommand(sessionId: string): boolean {
+    this.joinSession(sessionId);
+    return true;
+  }
+
+  @ConsoleCommand('joinfirstsession', 'Join the first available session')
+  private joinFirstSessionCommand(): boolean {
+    this.joinFirstSession();
+    return true;
+  }
+
+  @ConsoleCommand('listsessions', 'List all available sessions')
+  private listSessionsCommand(): boolean {
+    this.listSessions();
+    return true;
+  }
+
+  private setNetId(netObject: INetObject, netId: NetId): void {
+    const obj = netObject as any;
+    const id = obj[NetIdKey];
+    if (id) {
+      throw new Error(`Net object ${netObject} already has a net id: ${id}`);
+    }
+    obj[NetIdKey] = netId;
+  }
+
+  private getNetId(netObject: INetObject): NetId {
+    const obj = netObject as any;
+    const id = obj[NetIdKey];
+    if (!id) {
+      throw new Error(`Net object ${netObject} does not have a net id`);
+    }
+    return id;
+  }
+
+  @ConsoleCommand('togglemovementprediction', 'Toggle movement prediction (usage: togglemovementprediction <true | false>)')
+  private toggleMovementPrediction(flag: string): string {
+    NetMovementPredictor.PredictionEnabled = (flag === 'true' || flag === '1');
+    return `Movement prediction ${NetMovementPredictor.PredictionEnabled ? 'enabled' : 'disabled'}`;
+  }
+
+  @ConsoleCommand('setmovementlerpalpha', 'Set movement prediction lerp alpha (usage: setmovementlerpalpha <value>)')
+  private setMovementLerpAlpha(alpha: string): string {
+    const alphaValue = parseFloat(alpha);
+    if (isNaN(alphaValue)) {
+      return `Invalid alpha value: ${alpha}`;
+    }
+    NetMovementPredictor.LerpAlpha = alphaValue;
+    return `Movement prediction lerp alpha set to ${alphaValue}`;
+  }
+
+  @ConsoleCommand('stat', 'Toggle network statistics display (usage: stat net)')
+  private stat(name: string): string | null {
+    if (name.toLocaleLowerCase() === 'net') {
+      this.statEnabled = !this.statEnabled;
+      if (this.statEnabled) {
+        this.createStatsUI();
+      } else {
+        this.destroyStatsUI();
+      }
+      return `Net stat ${this.statEnabled ? 'enabled' : 'disabled'}`;
+    }
+    return null;
+  }
+
+  private createStatsUI(): void {
+    if (this.statsUIElement) {
+      return; // Already created
+    }
+
+    this.statsUIElement = this.world.uiManager.createElement('net-stats', {
+      className: 'net-stats-container',
+      style: {
+        position: 'absolute',
+        top: '100px',
+        left: '10px',
+        padding: '12px',
+        backgroundColor: 'rgba(0, 0, 0, 0.8)',
+        color: '#00ff00',
+        fontFamily: 'monospace',
+        fontSize: '16px',
+        borderRadius: '4px',
+        border: '1px solid #444',
+        zIndex: '1000',
+        minWidth: '200px',
+        lineHeight: '1.4'
+      }
+    });
+
+    // Set initial content
+    this.updateStatsUI();
+  }
+
+  private destroyStatsUI(): void {
+    if (this.statsUIElement) {
+      this.statsUIElement.remove();
+      this.statsUIElement = null;
+    }
+  }
+
+  private updateStatsUI(): void {
+    if (!this.statsUIElement) {
+      return;
+    }
+
+    const html = `
+      <div style="font-weight: bold; color: #ffffff; margin-bottom: 8px; border-bottom: 1px solid #444; padding-bottom: 4px;">
+        📊 Network Statistics
+      </div>
+      <div style="margin-bottom: 4px;">
+        <span style="color: #ffaa00;">Local Objects:</span> ${this.netStats.numLocalObjects}
+      </div>
+      <div style="margin-bottom: 4px;">
+        <span style="color: #ffaa00;">Remote Objects:</span> ${this.netStats.numRemoteObjects}
+      </div>
+      <div style="margin-bottom: 4px;">
+        <span style="color: #ffaa00;">Local Relevant Objects:</span> ${this.netStats.numLocalRelevantObjects}
+      </div>
+      <div style="margin-bottom: 4px;">
+        <span style="color: #ffaa00;">Local Updating Objects:</span> ${this.netStats.numLocalUpdatingObjects}
+      </div>
+      <div style="margin-bottom: 4px;">
+        <span style="color: #ffaa00;">Remote Updating Objects:</span> ${this.netStats.numRemoteUpdatingObjects}
+      </div>
+      <div style="margin-bottom: 4px;">
+        <span style="color: #ffaa00;">Clients in Session:</span> ${this.netStats.numClientsInSession}
+      </div>
+      <div style="margin-bottom: 4px;">
+        <span style="color: #ffaa00;">In-Client Ping:</span> ${this.netStats.inClientPing.toFixed(1)} ms
+      </div>
+      <div style="margin-bottom: 4px;">
+        <span style="color: #ffaa00;">Cross-Client Ping:</span> ${this.netStats.crossClientPing.toFixed(1)} ms
+      </div>
+      <div style="margin-bottom: 4px;">
+        <span style="color: #ffaa00;">Movement Prediction Enabled:</span> ${NetMovementPredictor.PredictionEnabled}
+      </div>
+      <div style="margin-bottom: 4px;">
+        <span style="color: #ffaa00;">Movement Lerp Alpha:</span> ${NetMovementPredictor.LerpAlpha}
+      </div>
+      <div style="margin-top: 8px; font-size: 16px; color: #888;">
+        Session Manager: ${this.gameSessionManager?.getName()}<br/>
+        Device ID: ${NetWorld.getDeviceId()}<br/>
+        Game ID: ${this.gameId}<br/>
+        Session ID: ${this.gameSession?.getDescription().sessionId}<br/>
+        Client ID: ${this.clientId}<br/>
+      </div>
+    `;
+
+    this.statsUIElement.setHTML(html);
+  }
+
+  protected override doBeginPlay() {
+    this.world.consoleManager.addCommandHandler(this);
+  }
+
+  protected override doEndPlay() {
+    this.gameSessionManager = null;
+    this.gameSession = null;
+    this.localNetObjects.clear();
+    this.remoteNetObjects.clear();
+    this.localRelevantNetObjectsInSession.clear();
+    this.addToSessionQueue.clear();
+    this.deleteFromSessionQueue.clear();
+    this.pendingNetObjects.clear();
+    this.sessionClients = {};
+    this.lastReplicatedStates.clear();
+    this.remoteObjectCreationRequests.clear();
+
+    this.destroyStatsUI();
+    this.world.consoleManager.removeCommandHandler(this);
+
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+
+    if (this.pingTimer) {
+      clearInterval(this.pingTimer);
+      this.pingTimer = null;
+    }
+  }
+
+  private isClientInactive(clientId: ClientId): boolean {
+    const client = this.sessionClients[clientId];
+    if (!client) {
+      return false;
+    }
+    return Date.now() - client.lastHeartBeatTime > NET_OBJECT_TTL_SEC * 1000;
+  }
+}