@babylonjs-toolkit/next 9.30.0 → 9.34.0

package/lib/loopbackhub.js

@@ -0,0 +1,986 @@
+import { NetworkRoute, NetworkConditionsSimulator, RpcChannel, NetworkProtocol, NetDisconnectReason, NetworkError, FUSION_CONTROL_WELCOME, ShutdownReason, GameMode, NETWORK_DEFAULT_TICK_RATE, NETWORK_START_SCENE_LOAD_ID, NetworkFrameKind, NetworkDespawnReason, NetworkObjectBlockFlags, NetworkIdUtility, NetworkObjectOptions, FUSION_CONTROL_SHUTDOWN, FUSION_CONTROL_CONNECT_RESULT, FUSION_CONTROL_SESSION, FUSION_CONTROL_AREA, FUSION_CONTROL_PLAYER_LEFT, FUSION_CONTROL_HOST_MIGRATION, FUSION_CONTROL_CONNECT_REQUEST, FUSION_CONTROL_PLAYER_JOINED, NETWORK_SHARED_ID_PLAYER_STRIDE, FUSION_CONTROL_MASTER_CLIENT } from './scenemanager';
+import { NETWORK_RECONNECT_GRACE_SECONDS } from './network_reconnect_grace_seconds';
+export class LoopbackHub {
+    constructor(options = {}) {
+        this.transports = new Map();
+        this.pendingDeliveries = [];
+        this.linkDeliveryTimes = new Map();
+        this.clockMs = 0;
+        this.deliverySequence = 0;
+        this.transportCount = 0;
+        this.sessionUpdateTimer = null;
+        this.publishedSession = null;
+        this.sessionLocked = false;
+        this.conditions = new NetworkConditionsSimulator(options.seed != null ? options.seed : 1);
+        this.conditions.latencyMs = options.latencyMs || 0;
+        this.conditions.jitterMs = options.jitterMs || 0;
+        this.conditions.lossPercent = options.lossPercent || 0;
+        this.realTime = options.realTime === true;
+        this.realTimeOriginMs = performance.now();
+        this.sessionLogic = new FusionSessionLogic(this);
+        if (this.realTime)
+            this.sessionUpdateTimer = setInterval(() => this.sessionLogic.update(this.nowMilliseconds()), LoopbackHub.SESSION_UPDATE_INTERVAL_MS);
+    }
+    get logic() {
+        return this.sessionLogic;
+    }
+    get sessionMetadata() {
+        return this.publishedSession;
+    }
+    get isLocked() {
+        return this.sessionLocked;
+    }
+    createTransport() {
+        this.transportCount += 1;
+        const clientKey = LoopbackHub.CLIENT_KEY_PREFIX + this.transportCount;
+        const transport = new LoopbackTransport(this, clientKey);
+        this.transports.set(clientKey, transport);
+        return transport;
+    }
+    advance(milliseconds) {
+        const targetMs = this.clockMs + milliseconds;
+        this.deliverDue(targetMs);
+        this.clockMs = targetMs;
+        this.sessionLogic.update(this.clockMs);
+    }
+    dispose() {
+        if (this.sessionUpdateTimer != null)
+            clearInterval(this.sessionUpdateTimer);
+        this.sessionUpdateTimer = null;
+    }
+    nowMilliseconds() {
+        return this.realTime ? performance.now() - this.realTimeOriginMs : this.clockMs;
+    }
+    sendFrame(clientKey, sourcePlayerId, frame) {
+        const copy = frame.slice();
+        this.enqueue(LoopbackHub.linkFromRoom(clientKey), () => {
+            const transport = this.transports.get(clientKey);
+            if (transport != null)
+                transport.deliverFrame(sourcePlayerId, copy);
+        });
+    }
+    sendControl(clientKey, name, payload) {
+        const copy = JSON.parse(JSON.stringify(payload));
+        this.enqueue(LoopbackHub.linkFromRoom(clientKey), () => {
+            const transport = this.transports.get(clientKey);
+            if (transport != null)
+                transport.deliverControl(name, copy);
+        });
+    }
+    setSessionMetadata(session) {
+        this.publishedSession = session;
+    }
+    lockSession(locked) {
+        this.sessionLocked = locked;
+    }
+    joinClient(clientKey, request) {
+        return this.sessionLogic.join(clientKey, request);
+    }
+    sendFromClient(clientKey, route, targetPlayerId, frame, channel) {
+        if (this.conditions.shouldDrop(channel))
+            return;
+        const envelope = NetworkProtocol.encodeEnvelope(route, targetPlayerId, frame);
+        this.enqueue(LoopbackHub.linkToRoom(clientKey), () => this.sessionLogic.receiveFrame(clientKey, envelope, channel));
+    }
+    sendControlFromClient(clientKey, name, payload) {
+        const copy = JSON.parse(JSON.stringify(payload));
+        this.enqueue(LoopbackHub.linkToRoom(clientKey), () => this.sessionLogic.receiveControl(clientKey, name, copy));
+    }
+    leaveClient(clientKey) {
+        this.enqueue(LoopbackHub.linkToRoom(clientKey), () => {
+            this.sessionLogic.leave(clientKey);
+            this.transports.delete(clientKey);
+        });
+    }
+    dropClient(clientKey) {
+        this.transports.delete(clientKey);
+        this.sessionLogic.drop(clientKey);
+    }
+    static linkToRoom(clientKey) {
+        return clientKey + LoopbackHub.LINK_SEPARATOR + LoopbackHub.ROOM_LINK_NAME;
+    }
+    static linkFromRoom(clientKey) {
+        return LoopbackHub.ROOM_LINK_NAME + LoopbackHub.LINK_SEPARATOR + clientKey;
+    }
+    enqueue(link, deliver) {
+        const previousTimeMs = this.linkDeliveryTimes.get(link) || 0;
+        const timeMs = Math.max(this.nowMilliseconds() + this.conditions.sampleDelayMs(), previousTimeMs);
+        this.linkDeliveryTimes.set(link, timeMs);
+        if (this.realTime) {
+            setTimeout(deliver, timeMs - this.nowMilliseconds());
+            return;
+        }
+        this.deliverySequence += 1;
+        const delivery = { timeMs: timeMs, sequence: this.deliverySequence, deliver: deliver };
+        let insertAt = this.pendingDeliveries.length;
+        while (insertAt > 0 && this.pendingDeliveries[insertAt - 1].timeMs > timeMs)
+            insertAt--;
+        this.pendingDeliveries.splice(insertAt, 0, delivery);
+    }
+    deliverDue(targetMs) {
+        while (this.pendingDeliveries.length > 0 && this.pendingDeliveries[0].timeMs <= targetMs) {
+            const delivery = this.pendingDeliveries.shift();
+            this.clockMs = Math.max(this.clockMs, delivery.timeMs);
+            delivery.deliver();
+        }
+    }
+}
+LoopbackHub.SESSION_UPDATE_INTERVAL_MS = 250;
+LoopbackHub.CLIENT_KEY_PREFIX = "loopback-";
+LoopbackHub.ROOM_LINK_NAME = "room";
+LoopbackHub.LINK_SEPARATOR = ">";
+export class LoopbackTransport {
+    constructor(hub, clientKey) {
+        this.handlers = null;
+        this.connected = false;
+        this.transportName = "Loopback";
+        this.hub = hub;
+        this.clientKey = clientKey;
+    }
+    get isConnected() {
+        return this.connected;
+    }
+    get conditions() {
+        return this.hub.conditions;
+    }
+    connect(request) {
+        try {
+            const welcome = this.hub.joinClient(this.clientKey, request);
+            this.connected = true;
+            return Promise.resolve(welcome);
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }
+    sendFrame(route, targetPlayerId, frame, channel) {
+        if (!this.connected)
+            return;
+        this.hub.sendFromClient(this.clientKey, route, targetPlayerId, frame, channel);
+    }
+    sendControl(name, payload) {
+        if (!this.connected)
+            return;
+        this.hub.sendControlFromClient(this.clientKey, name, payload);
+    }
+    setHandlers(handlers) {
+        this.handlers = handlers;
+    }
+    disconnect() {
+        if (this.connected)
+            this.hub.leaveClient(this.clientKey);
+        this.connected = false;
+        return Promise.resolve();
+    }
+    simulateDrop() {
+        if (!this.connected)
+            return;
+        this.connected = false;
+        this.hub.dropClient(this.clientKey);
+        if (this.handlers != null)
+            this.handlers.onDisconnected(NetDisconnectReason.Timeout);
+    }
+    deliverFrame(sourcePlayerId, frame) {
+        if (this.connected && this.handlers != null)
+            this.handlers.onFrame(sourcePlayerId, frame);
+    }
+    deliverControl(name, payload) {
+        if (name === FUSION_CONTROL_WELCOME)
+            return;
+        if (this.connected && this.handlers != null)
+            this.handlers.onControl(name, payload);
+    }
+}
+export class FusionSessionLogic {
+    constructor(outputs) {
+        this.clients = new Map();
+        this.sharedObjects = new Map();
+        this.sessionMode = null;
+        this.session = null;
+        this.sessionTickRate = NETWORK_DEFAULT_TICK_RATE;
+        this.sessionPrefabTableHash = 0;
+        this.lastPlayerId = 0;
+        this.currentHostPlayerId = 0;
+        this.currentMasterClientPlayerId = 0;
+        this.dedicatedEndpoint = null;
+        this.latestHostSnapshot = null;
+        this.latestSceneInfoFrame = null;
+        this.latestSceneInfo = null;
+        this.migration = null;
+        this.migrationHeldFrames = [];
+        this.outputs = outputs;
+    }
+    get gameMode() {
+        return this.sessionMode;
+    }
+    get players() {
+        const players = [];
+        this.clients.forEach((record) => {
+            players.push({ clientKey: record.clientKey, playerId: record.playerId, connected: record.connected, isHost: record.isHost });
+        });
+        return players;
+    }
+    get hostPlayerId() {
+        return this.currentHostPlayerId;
+    }
+    get masterClientPlayerId() {
+        return this.currentMasterClientPlayerId;
+    }
+    get hostSnapshot() {
+        return this.latestHostSnapshot;
+    }
+    get isMigratingHost() {
+        return this.migration != null;
+    }
+    join(clientKey, request) {
+        if (this.sessionMode == null)
+            this.createSession(request);
+        else
+            this.checkCompatible(request);
+        const migrationRecord = (request.hostMigration === true) ? this.findMigrationRejoin(request.reconnectPlayerId) : null;
+        const resumesMigration = migrationRecord != null;
+        const heldRecord = resumesMigration ? migrationRecord : this.findHeldPlayer(request.reconnectPlayerId);
+        if (heldRecord == null)
+            this.checkCapacity();
+        const record = (heldRecord != null) ? this.resumeClient(heldRecord, clientKey) : this.addClient(clientKey);
+        record.authIdentity = request.authIdentity ?? null;
+        const needsApproval = heldRecord == null && this.needsApproval(record);
+        record.admitted = !needsApproval;
+        const previousMasterClient = this.currentMasterClientPlayerId;
+        this.currentMasterClientPlayerId = this.computeMasterClient();
+        const welcome = this.buildWelcome(record);
+        welcome.isPendingApproval = needsApproval;
+        this.outputs.sendControl(clientKey, FUSION_CONTROL_WELCOME, welcome);
+        if (needsApproval)
+            this.requestApproval(record, request.connectionTokenBase64);
+        else if (heldRecord == null || resumesMigration)
+            this.announceJoin(record);
+        if (resumesMigration)
+            record.awaitingMigrationRejoin = false;
+        if (resumesMigration && record.isHost && this.migration != null)
+            this.completeHostMigration(record);
+        if (this.currentMasterClientPlayerId !== previousMasterClient)
+            this.broadcastMasterClient(clientKey);
+        if (record.admitted)
+            this.replaySharedState(record);
+        this.publishSession();
+        return welcome;
+    }
+    receiveFrame(clientKey, payload, channel = RpcChannel.Reliable) {
+        const record = this.clients.get(clientKey);
+        if (record == null || !record.connected)
+            return;
+        if (!record.admitted) {
+            record.heldPayloads.push({ payload: payload.slice(), channel: channel });
+            return;
+        }
+        const envelope = NetworkProtocol.decodeEnvelope(payload);
+        this.routeFrame(record, envelope, channel);
+    }
+    receiveControl(clientKey, name, payload) {
+        const record = this.clients.get(clientKey);
+        if (record == null || !record.connected)
+            return;
+        if (name === FUSION_CONTROL_CONNECT_RESULT && record.isHost) {
+            this.resolveConnectRequest(payload);
+            return;
+        }
+        if (name === FUSION_CONTROL_SESSION && this.maySetSession(record))
+            this.updateSession(payload);
+        if (name === FUSION_CONTROL_AREA && this.sessionMode === GameMode.Shared)
+            this.updatePlayerArea(record, payload);
+    }
+    update(nowMilliseconds) {
+        const expiredKeys = [];
+        this.clients.forEach((record) => {
+            if (!record.connected && record.dropDeadlineMs <= nowMilliseconds)
+                expiredKeys.push(record.clientKey);
+        });
+        for (const clientKey of expiredKeys)
+            this.leave(clientKey);
+    }
+    sendFromServer(route, targetPlayerId, frame, channel = RpcChannel.Reliable) {
+        if (route === NetworkRoute.ToPlayer) {
+            const target = this.findAdmittedPlayer(targetPlayerId);
+            if (target != null)
+                this.outputs.sendFrame(target.clientKey, FusionSessionLogic.SESSION_PLAYER_ID, frame, channel);
+            return;
+        }
+        this.forEachAdmitted(null, (record) => this.outputs.sendFrame(record.clientKey, FusionSessionLogic.SESSION_PLAYER_ID, frame, channel));
+    }
+    sendControlFromServer(name, payload, targetPlayerId) {
+        if (name === FUSION_CONTROL_CONNECT_RESULT) {
+            this.resolveConnectRequest(payload);
+            return;
+        }
+        if (targetPlayerId !== FusionSessionLogic.SESSION_PLAYER_ID) {
+            const target = this.findAdmittedPlayer(targetPlayerId);
+            if (target != null)
+                this.outputs.sendControl(target.clientKey, name, payload);
+            return;
+        }
+        this.forEachAdmitted(null, (record) => this.outputs.sendControl(record.clientKey, name, payload));
+    }
+    drop(clientKey) {
+        const record = this.clients.get(clientKey);
+        if (record == null || !record.connected)
+            return;
+        this.holdForReconnect(record);
+        if (record.isHost && this.migration == null && this.hasOtherConnectedPlayer(record)) {
+            this.startHostMigration(record);
+            return;
+        }
+        this.refreshMasterClient();
+        this.publishSession();
+    }
+    leave(clientKey) {
+        const record = this.clients.get(clientKey);
+        if (record == null)
+            return;
+        if (this.migration != null && record.connected && record.admitted) {
+            this.holdForReconnect(record);
+            this.publishSession();
+            return;
+        }
+        this.clients.delete(clientKey);
+        if (record.isHost) {
+            if (this.hasOtherConnectedPlayer(record))
+                this.startHostMigration(record);
+            else
+                this.endSession(ShutdownReason.DisconnectedByPluginLogic);
+            return;
+        }
+        if (record.admitted) {
+            this.broadcastControl(FUSION_CONTROL_PLAYER_LEFT, { playerId: record.playerId }, null);
+            this.refreshMasterClient();
+            this.applySharedLeaveRules(record.playerId);
+            this.sharedObjects.forEach((object) => object.receivers.delete(record.playerId));
+        }
+        if (this.clients.size === 0 && this.dedicatedEndpoint == null) {
+            this.resetSession();
+            return;
+        }
+        this.publishSession();
+    }
+    holdForReconnect(record) {
+        record.connected = false;
+        record.dropDeadlineMs = this.outputs.nowMilliseconds() + NETWORK_RECONNECT_GRACE_SECONDS * FusionSessionLogic.MILLISECONDS_PER_SECOND;
+    }
+    startHostMigration(oldHost) {
+        this.clients.delete(oldHost.clientKey);
+        const elected = this.findLowestConnectedPlayer();
+        if (elected == null) {
+            this.endSession(ShutdownReason.DisconnectedByPluginLogic);
+            return;
+        }
+        elected.isHost = true;
+        this.currentHostPlayerId = elected.playerId;
+        this.migration = { newHostPlayerId: elected.playerId, previousHostPlayerId: oldHost.playerId };
+        this.migrationHeldFrames.length = 0;
+        this.forEachAdmitted(null, (record) => {
+            record.awaitingMigrationRejoin = true;
+        });
+        const snapshot = (this.latestHostSnapshot != null) ? this.latestHostSnapshot : new Uint8Array(0);
+        const payload = { newHostPlayerId: elected.playerId, snapshotBase64: NetworkProtocol.bytesToBase64(snapshot), previousHostPlayerId: oldHost.playerId };
+        this.forEachAdmitted(null, (record) => this.outputs.sendControl(record.clientKey, FUSION_CONTROL_HOST_MIGRATION, payload));
+        this.publishSession();
+    }
+    completeHostMigration(host) {
+        this.migration = null;
+        const heldFrames = this.migrationHeldFrames.splice(0, this.migrationHeldFrames.length);
+        for (const held of heldFrames)
+            this.outputs.sendFrame(host.clientKey, held.sourcePlayerId, held.frame);
+    }
+    findMigrationRejoin(playerId) {
+        const record = this.findPlayer(playerId);
+        return (record != null && record.awaitingMigrationRejoin) ? record : null;
+    }
+    findLowestConnectedPlayer() {
+        let lowest = null;
+        this.forEachAdmitted(null, (record) => {
+            if (lowest == null || record.playerId < lowest.playerId)
+                lowest = record;
+        });
+        return lowest;
+    }
+    attachDedicatedServer(serverEndpoint, request = null) {
+        this.dedicatedEndpoint = serverEndpoint;
+        this.sessionMode = GameMode.Server;
+        this.currentHostPlayerId = FusionSessionLogic.SESSION_PLAYER_ID;
+        if (request != null) {
+            const playerCount = (request.playerCount > 0) ? request.playerCount : FusionSessionLogic.DEFAULT_PLAYER_COUNT;
+            this.session = this.createSessionInfo(request.sessionName, playerCount, request.isOpen !== false, request.isVisible !== false, request.sessionProperties || {});
+            this.sessionTickRate = (request.tickRate > 0) ? request.tickRate : NETWORK_DEFAULT_TICK_RATE;
+            this.sessionPrefabTableHash = request.prefabTableHash;
+        }
+        else if (this.session == null) {
+            this.session = this.createSessionInfo("", FusionSessionLogic.DEFAULT_PLAYER_COUNT, true, true, {});
+        }
+        this.publishSession();
+        return {
+            playerId: FusionSessionLogic.SESSION_PLAYER_ID,
+            gameMode: GameMode.Server,
+            hostPlayerId: FusionSessionLogic.SESSION_PLAYER_ID,
+            masterClientPlayerId: 0,
+            serverTimeMs: this.outputs.nowMilliseconds(),
+            session: this.sessionSnapshot(),
+            tickRate: this.sessionTickRate,
+            prefabTableHash: this.sessionPrefabTableHash,
+            isDedicated: true,
+            playerIds: []
+        };
+    }
+    createSession(request) {
+        const requestedMode = request.gameMode;
+        if (requestedMode === GameMode.Client)
+            throw FusionSessionLogic.error(ShutdownReason.GameNotFound);
+        const isHostSession = requestedMode === GameMode.Host || requestedMode === GameMode.AutoHostOrClient;
+        if (!isHostSession && requestedMode !== GameMode.Shared)
+            throw FusionSessionLogic.error(ShutdownReason.InvalidArguments);
+        this.sessionMode = isHostSession ? GameMode.Host : GameMode.Shared;
+        const playerCount = (request.playerCount > 0) ? request.playerCount : FusionSessionLogic.DEFAULT_PLAYER_COUNT;
+        this.session = this.createSessionInfo(request.sessionName, playerCount, request.isOpen !== false, request.isVisible !== false, request.sessionProperties || {});
+        this.sessionTickRate = (request.tickRate > 0) ? request.tickRate : NETWORK_DEFAULT_TICK_RATE;
+        this.sessionPrefabTableHash = request.prefabTableHash;
+    }
+    createSessionInfo(name, maxPlayers, isOpen, isVisible, properties) {
+        return { name: name, isValid: true, isOpen: isOpen, isVisible: isVisible, playerCount: 0, maxPlayers: maxPlayers, properties: Object.assign({}, properties), region: FusionSessionLogic.REGION };
+    }
+    checkCompatible(request) {
+        const requestedMode = request.gameMode;
+        const isHostedSession = this.sessionMode === GameMode.Host || this.sessionMode === GameMode.Server;
+        const joinsAsClient = requestedMode === GameMode.Client || requestedMode === GameMode.AutoHostOrClient;
+        const resumesAsHost = this.migration != null && request.hostMigration === true && requestedMode === GameMode.Host && request.reconnectPlayerId === this.migration.newHostPlayerId;
+        const modeFits = isHostedSession ? (joinsAsClient || resumesAsHost) : requestedMode === GameMode.Shared;
+        if (!modeFits)
+            throw FusionSessionLogic.error(ShutdownReason.IncompatibleConfiguration);
+        if (request.prefabTableHash !== this.sessionPrefabTableHash)
+            throw FusionSessionLogic.error(ShutdownReason.IncompatibleConfiguration);
+    }
+    checkCapacity() {
+        if (!this.session.isOpen)
+            throw FusionSessionLogic.error(ShutdownReason.GameClosed);
+        if (this.clients.size >= this.session.maxPlayers)
+            throw FusionSessionLogic.error(ShutdownReason.GameIsFull);
+    }
+    addClient(clientKey) {
+        this.lastPlayerId += 1;
+        const isHost = this.sessionMode === GameMode.Host && this.currentHostPlayerId === 0;
+        if (isHost)
+            this.currentHostPlayerId = this.lastPlayerId;
+        const record = { clientKey: clientKey, playerId: this.lastPlayerId, connected: true, isHost: isHost, admitted: false, heldPayloads: [], dropDeadlineMs: 0, area: null, awaitingMigrationRejoin: false, authIdentity: null };
+        this.clients.set(clientKey, record);
+        return record;
+    }
+    findHeldPlayer(playerId) {
+        if (playerId == null || playerId <= 0)
+            return null;
+        for (const record of this.clients.values()) {
+            if (record.playerId === playerId && !record.connected)
+                return record;
+        }
+        return null;
+    }
+    resumeClient(record, clientKey) {
+        this.clients.delete(record.clientKey);
+        record.clientKey = clientKey;
+        record.connected = true;
+        record.dropDeadlineMs = 0;
+        this.clients.set(clientKey, record);
+        return record;
+    }
+    needsApproval(record) {
+        const isHostedSession = this.sessionMode === GameMode.Host || this.sessionMode === GameMode.Server;
+        return isHostedSession && !record.isHost;
+    }
+    buildWelcome(record) {
+        const playerIds = [];
+        this.clients.forEach((client) => {
+            if (client.connected && (client.admitted || client === record))
+                playerIds.push(client.playerId);
+        });
+        playerIds.sort((left, right) => left - right);
+        return {
+            playerId: record.playerId,
+            gameMode: this.welcomeGameMode(record),
+            hostPlayerId: this.currentHostPlayerId,
+            masterClientPlayerId: this.currentMasterClientPlayerId,
+            serverTimeMs: this.outputs.nowMilliseconds(),
+            session: this.sessionSnapshot(),
+            tickRate: this.sessionTickRate,
+            prefabTableHash: this.sessionPrefabTableHash,
+            isDedicated: this.dedicatedEndpoint != null,
+            playerIds: playerIds
+        };
+    }
+    welcomeGameMode(record) {
+        if (record.isHost)
+            return GameMode.Host;
+        return (this.sessionMode === GameMode.Shared) ? GameMode.Shared : GameMode.Client;
+    }
+    requestApproval(record, tokenBase64) {
+        const payload = { playerId: record.playerId, tokenBase64: tokenBase64 || "", authIdentity: record.authIdentity };
+        if (this.dedicatedEndpoint != null) {
+            this.dedicatedEndpoint.receiveControl(FUSION_CONTROL_CONNECT_REQUEST, payload);
+            return;
+        }
+        const host = this.findPlayer(this.currentHostPlayerId);
+        if (host != null && host.connected)
+            this.outputs.sendControl(host.clientKey, FUSION_CONTROL_CONNECT_REQUEST, payload);
+    }
+    resolveConnectRequest(result) {
+        const record = this.findPlayer(result.playerId);
+        if (record == null || record.admitted)
+            return;
+        if (!result.accepted) {
+            this.outputs.sendControl(record.clientKey, FUSION_CONTROL_SHUTDOWN, { reason: ShutdownReason.ConnectionRefused });
+            this.leave(record.clientKey);
+            return;
+        }
+        record.admitted = true;
+        this.outputs.sendControl(record.clientKey, FUSION_CONTROL_CONNECT_RESULT, { playerId: record.playerId, accepted: true });
+        this.announceJoin(record);
+        const heldPayloads = record.heldPayloads.splice(0, record.heldPayloads.length);
+        for (const held of heldPayloads)
+            this.receiveFrame(record.clientKey, held.payload, held.channel);
+        this.publishSession();
+    }
+    announceJoin(record) {
+        this.broadcastControl(FUSION_CONTROL_PLAYER_JOINED, { playerId: record.playerId }, record.clientKey);
+    }
+    routeFrame(sender, envelope, channel = RpcChannel.Reliable) {
+        switch (envelope.route) {
+            case NetworkRoute.ToHost:
+                this.sendToHost(sender, envelope.frame, channel);
+                return;
+            case NetworkRoute.ToPlayer:
+                this.sendToPlayer(sender, envelope.targetPlayerId, envelope.frame, channel);
+                return;
+            case NetworkRoute.ToAllClients:
+                this.forEachAdmitted(null, (record) => {
+                    if (!record.isHost)
+                        this.outputs.sendFrame(record.clientKey, sender.playerId, envelope.frame, channel);
+                });
+                return;
+            case NetworkRoute.ToAllOthers:
+                this.sendToAllOthers(sender.playerId, sender.clientKey, envelope.frame, channel);
+                return;
+            case NetworkRoute.ToRoomAuthority:
+                this.handleRoomFrame(sender, envelope.frame);
+                return;
+            default:
+                return;
+        }
+    }
+    sendToHost(sender, frame, channel = RpcChannel.Reliable) {
+        if (this.dedicatedEndpoint != null) {
+            this.dedicatedEndpoint.receiveFrame(sender.playerId, frame);
+            return;
+        }
+        const host = this.findAdmittedPlayer(this.currentHostPlayerId);
+        if (host != null) {
+            this.outputs.sendFrame(host.clientKey, sender.playerId, frame, channel);
+            return;
+        }
+        if (this.migration != null)
+            this.holdForNewHost(sender.playerId, frame);
+    }
+    holdForNewHost(sourcePlayerId, frame) {
+        if (NetworkProtocol.frameKind(frame) === NetworkFrameKind.Ping)
+            return;
+        this.migrationHeldFrames.push({ sourcePlayerId: sourcePlayerId, frame: frame.slice() });
+        if (this.migrationHeldFrames.length > FusionSessionLogic.MAX_MIGRATION_HELD_FRAMES)
+            this.migrationHeldFrames.shift();
+    }
+    sendToPlayer(sender, targetPlayerId, frame, channel = RpcChannel.Reliable) {
+        if (targetPlayerId === FusionSessionLogic.SESSION_PLAYER_ID && this.dedicatedEndpoint != null) {
+            this.dedicatedEndpoint.receiveFrame(sender.playerId, frame);
+            return;
+        }
+        const target = this.findAdmittedPlayer(targetPlayerId);
+        if (target != null)
+            this.outputs.sendFrame(target.clientKey, sender.playerId, frame, channel);
+    }
+    sendToAllOthers(sourcePlayerId, exceptKey, frame, channel = RpcChannel.Reliable) {
+        this.forEachAdmitted(exceptKey, (record) => this.outputs.sendFrame(record.clientKey, sourcePlayerId, frame, channel));
+        if (this.dedicatedEndpoint != null)
+            this.dedicatedEndpoint.receiveFrame(sourcePlayerId, frame);
+    }
+    handleRoomFrame(sender, frame) {
+        switch (NetworkProtocol.frameKind(frame)) {
+            case NetworkFrameKind.Ping:
+                this.answerPing(sender, frame);
+                return;
+            case NetworkFrameKind.SharedState:
+                if (this.sessionMode === GameMode.Shared)
+                    this.acceptSharedState(sender, frame);
+                return;
+            case NetworkFrameKind.AuthorityRequest:
+                if (this.sessionMode === GameMode.Shared)
+                    this.handleAuthorityRequest(sender, frame);
+                return;
+            case NetworkFrameKind.Despawn:
+                if (this.sessionMode === GameMode.Shared)
+                    this.handleSharedDespawn(sender, frame);
+                return;
+            case NetworkFrameKind.HostSnapshot:
+                if (sender.isHost)
+                    this.latestHostSnapshot = frame.slice();
+                return;
+            case NetworkFrameKind.SceneInfo:
+                if (this.sessionMode === GameMode.Shared && sender.playerId === this.currentMasterClientPlayerId)
+                    this.acceptSceneInfo(sender, frame);
+                return;
+            default:
+                return;
+        }
+    }
+    answerPing(sender, frame) {
+        const clientTimeMs = NetworkProtocol.decodePing(frame);
+        const pong = NetworkProtocol.encodePong({ clientTimeMs: clientTimeMs, serverTimeMs: this.outputs.nowMilliseconds(), serverTick: 0 });
+        this.outputs.sendFrame(sender.clientKey, FusionSessionLogic.SESSION_PLAYER_ID, pong);
+    }
+    acceptSharedState(sender, frame) {
+        const decoded = NetworkProtocol.decodeSharedState(frame);
+        const acceptedBlocks = decoded.blocks.filter((block) => this.storeSharedBlock(sender.playerId, block, decoded));
+        if (acceptedBlocks.length === 0)
+            return;
+        const hasInterestBlocks = acceptedBlocks.some((block) => this.sharedObjects.get(block.header.networkId).position != null);
+        if (hasInterestBlocks) {
+            this.forEachAdmitted(sender.clientKey, (receiver) => this.forwardSharedBlocks(sender, receiver, acceptedBlocks, decoded));
+            return;
+        }
+        const forwarded = (acceptedBlocks.length === decoded.blocks.length) ? frame : NetworkProtocol.encodeSharedState({ senderTick: decoded.senderTick, senderServerTimeMs: decoded.senderServerTimeMs, sceneLoadId: decoded.sceneLoadId, blocks: acceptedBlocks });
+        this.sendToAllOthers(sender.playerId, sender.clientKey, forwarded);
+    }
+    forwardSharedBlocks(sender, receiver, blocks, decoded) {
+        const receiverBlocks = [];
+        for (const block of blocks) {
+            const object = this.sharedObjects.get(block.header.networkId);
+            if (object.position == null) {
+                receiverBlocks.push(block);
+                continue;
+            }
+            const forwardedBlock = this.filterInterestBlock(receiver, block.header.networkId, object, block);
+            if (forwardedBlock != null)
+                receiverBlocks.push(forwardedBlock);
+        }
+        if (receiverBlocks.length === 0)
+            return;
+        const frame = NetworkProtocol.encodeSharedState({ senderTick: decoded.senderTick, senderServerTimeMs: decoded.senderServerTimeMs, sceneLoadId: decoded.sceneLoadId, blocks: receiverBlocks });
+        this.outputs.sendFrame(receiver.clientKey, sender.playerId, frame);
+    }
+    filterInterestBlock(receiver, objectId, object, block) {
+        const relevant = FusionSessionLogic.areaHolds(receiver.area, object.position);
+        const hasObject = object.receivers.has(receiver.playerId);
+        if (relevant && hasObject)
+            return block;
+        if (relevant) {
+            object.receivers.add(receiver.playerId);
+            return FusionSessionLogic.storedSpawnBlock(object);
+        }
+        if (hasObject)
+            this.sendOutOfInterest(receiver, objectId, object);
+        return null;
+    }
+    updatePlayerArea(record, area) {
+        record.area = area;
+        const enteringBlocks = [];
+        let latestTick = 0;
+        let latestTimeMs = 0;
+        this.sharedObjects.forEach((object, objectId) => {
+            if (object.position == null || object.authorityPlayerId === record.playerId)
+                return;
+            const relevant = FusionSessionLogic.areaHolds(area, object.position);
+            const hasObject = object.receivers.has(record.playerId);
+            if (relevant && !hasObject) {
+                object.receivers.add(record.playerId);
+                enteringBlocks.push(FusionSessionLogic.storedSpawnBlock(object));
+                latestTick = Math.max(latestTick, object.senderTick);
+                latestTimeMs = Math.max(latestTimeMs, object.senderServerTimeMs);
+            }
+            else if (!relevant && hasObject) {
+                this.sendOutOfInterest(record, objectId, object);
+            }
+        });
+        if (enteringBlocks.length === 0)
+            return;
+        const frame = NetworkProtocol.encodeSharedState({ senderTick: latestTick, senderServerTimeMs: latestTimeMs, sceneLoadId: this.currentSceneLoadId(), blocks: enteringBlocks });
+        this.outputs.sendFrame(record.clientKey, FusionSessionLogic.SESSION_PLAYER_ID, frame);
+    }
+    sendOutOfInterest(receiver, objectId, object) {
+        object.receivers.delete(receiver.playerId);
+        const despawn = NetworkProtocol.encodeDespawn({ objectId: objectId, reason: NetworkDespawnReason.OutOfInterest });
+        this.outputs.sendFrame(receiver.clientKey, FusionSessionLogic.SESSION_PLAYER_ID, despawn);
+    }
+    currentSceneLoadId() {
+        return (this.latestSceneInfo != null) ? this.latestSceneInfo.loadId : NETWORK_START_SCENE_LOAD_ID;
+    }
+    storeSharedBlock(senderPlayerId, block, frame) {
+        const header = block.header;
+        const existing = this.sharedObjects.get(header.networkId);
+        if (existing == null)
+            return this.storeSharedSpawn(senderPlayerId, block, frame);
+        if (existing.authorityPlayerId !== senderPlayerId)
+            return false;
+        existing.deltaBytes = block.deltaBytes;
+        existing.senderTick = frame.senderTick;
+        existing.senderServerTimeMs = frame.senderServerTimeMs;
+        if (header.position != null)
+            existing.position = header.position.slice();
+        const changesInputAuthority = (header.flags & (NetworkObjectBlockFlags.Spawn | NetworkObjectBlockFlags.InputAuthorityChanged)) !== 0;
+        if (changesInputAuthority)
+            existing.spawnHeader.inputAuthority = header.inputAuthority;
+        return true;
+    }
+    storeSharedSpawn(senderPlayerId, block, frame) {
+        const header = block.header;
+        if ((header.flags & NetworkObjectBlockFlags.Spawn) === 0)
+            return false;
+        if (!this.mayCreateObject(senderPlayerId, header.networkId))
+            return false;
+        const spawnHeader = Object.assign({}, header, { flags: NetworkObjectBlockFlags.Spawn | NetworkObjectBlockFlags.Full, position: undefined });
+        const authorityPlayerId = (header.stateAuthority > 0) ? header.stateAuthority : senderPlayerId;
+        const position = (header.position != null) ? header.position.slice() : null;
+        this.sharedObjects.set(header.networkId, { spawnHeader: spawnHeader, deltaBytes: block.deltaBytes, authorityPlayerId: authorityPlayerId, senderTick: frame.senderTick, senderServerTimeMs: frame.senderServerTimeMs, position: position, receivers: new Set() });
+        return true;
+    }
+    mayCreateObject(playerId, networkId) {
+        if (NetworkIdUtility.isSceneObject(networkId))
+            return playerId === this.currentMasterClientPlayerId;
+        const rangeStart = NetworkIdUtility.forSharedSpawn(playerId, 0);
+        return networkId >= rangeStart && networkId < rangeStart + NETWORK_SHARED_ID_PLAYER_STRIDE;
+    }
+    handleAuthorityRequest(sender, frame) {
+        const request = NetworkProtocol.decodeAuthorityRequest(frame);
+        const object = this.sharedObjects.get(request.objectId);
+        if (object == null)
+            return;
+        if (request.release) {
+            if (object.authorityPlayerId === sender.playerId)
+                this.setSharedAuthority(request.objectId, object, 0);
+            return;
+        }
+        if (this.mayTakeAuthority(object, sender.playerId))
+            this.setSharedAuthority(request.objectId, object, sender.playerId);
+    }
+    mayTakeAuthority(object, playerId) {
+        if (object.authorityPlayerId === 0 || object.authorityPlayerId === playerId)
+            return true;
+        if (this.findPlayer(object.authorityPlayerId) == null)
+            return true;
+        return (object.spawnHeader.options & NetworkObjectOptions.AllowStateAuthorityOverride) !== 0;
+    }
+    setSharedAuthority(objectId, object, playerId) {
+        object.authorityPlayerId = playerId;
+        const result = NetworkProtocol.encodeAuthorityResult({ objectId: objectId, playerId: playerId });
+        this.sendToAllOthers(FusionSessionLogic.SESSION_PLAYER_ID, null, result);
+    }
+    handleSharedDespawn(sender, frame) {
+        const despawn = NetworkProtocol.decodeDespawn(frame);
+        const object = this.sharedObjects.get(despawn.objectId);
+        if (object == null || object.authorityPlayerId !== sender.playerId)
+            return;
+        this.sharedObjects.delete(despawn.objectId);
+        this.sendToAllOthers(sender.playerId, sender.clientKey, frame);
+    }
+    applySharedLeaveRules(playerId) {
+        const heldIds = [];
+        this.sharedObjects.forEach((object, objectId) => {
+            if (object.authorityPlayerId === playerId)
+                heldIds.push(objectId);
+        });
+        for (const objectId of heldIds) {
+            const object = this.sharedObjects.get(objectId);
+            const options = object.spawnHeader.options;
+            if ((options & NetworkObjectOptions.DestroyWhenStateAuthorityLeaves) !== 0) {
+                this.sharedObjects.delete(objectId);
+                const despawn = NetworkProtocol.encodeDespawn({ objectId: objectId, reason: NetworkDespawnReason.AuthorityLeft });
+                this.sendToAllOthers(FusionSessionLogic.SESSION_PLAYER_ID, null, despawn);
+            }
+            else if ((options & NetworkObjectOptions.MasterClientObject) !== 0) {
+                this.setSharedAuthority(objectId, object, this.currentMasterClientPlayerId);
+            }
+            else {
+                this.setSharedAuthority(objectId, object, 0);
+            }
+        }
+    }
+    acceptSceneInfo(sender, frame) {
+        const sceneInfo = NetworkProtocol.decodeSceneInfo(frame);
+        if (this.latestSceneInfo != null && sceneInfo.loadId <= this.latestSceneInfo.loadId)
+            return;
+        this.dropReplacedSceneObjects(this.latestSceneInfo, sceneInfo);
+        this.latestSceneInfo = sceneInfo;
+        this.latestSceneInfoFrame = frame.slice();
+        this.sendToAllOthers(sender.playerId, sender.clientKey, frame);
+    }
+    dropReplacedSceneObjects(previous, next) {
+        const nextBySlot = new Map();
+        for (const scene of next.scenes)
+            nextBySlot.set(scene.slot, FusionSessionLogic.sceneKey(scene));
+        const previousScenes = (previous != null) ? previous.scenes : next.scenes.filter((scene) => scene.loadId === NETWORK_START_SCENE_LOAD_ID);
+        const previousBySlot = new Map();
+        for (const scene of previousScenes)
+            previousBySlot.set(scene.slot, FusionSessionLogic.sceneKey(scene));
+        const keepsUnnamedStartScene = previous == null && !nextBySlot.has(0);
+        for (const objectId of Array.from(this.sharedObjects.keys())) {
+            if (!NetworkIdUtility.isSceneObject(objectId))
+                continue;
+            const slot = NetworkIdUtility.getSceneSlot(objectId);
+            if (slot === 0 && keepsUnnamedStartScene)
+                continue;
+            if (!previousBySlot.has(slot) || previousBySlot.get(slot) !== nextBySlot.get(slot))
+                this.sharedObjects.delete(objectId);
+        }
+    }
+    replaySharedState(record) {
+        if (this.sessionMode !== GameMode.Shared)
+            return;
+        if (this.latestSceneInfoFrame != null)
+            this.outputs.sendFrame(record.clientKey, this.currentMasterClientPlayerId, this.latestSceneInfoFrame);
+        if (this.sharedObjects.size === 0)
+            return;
+        const blocks = [];
+        let latestTick = 0;
+        let latestTimeMs = 0;
+        this.sharedObjects.forEach((object) => {
+            if (object.position != null && object.authorityPlayerId !== record.playerId) {
+                if (!FusionSessionLogic.areaHolds(record.area, object.position))
+                    return;
+                object.receivers.add(record.playerId);
+            }
+            blocks.push(FusionSessionLogic.storedSpawnBlock(object));
+            latestTick = Math.max(latestTick, object.senderTick);
+            latestTimeMs = Math.max(latestTimeMs, object.senderServerTimeMs);
+        });
+        if (blocks.length === 0)
+            return;
+        const sceneLoadId = this.currentSceneLoadId();
+        const frame = NetworkProtocol.encodeSharedState({ senderTick: latestTick, senderServerTimeMs: latestTimeMs, sceneLoadId: sceneLoadId, blocks: blocks });
+        this.outputs.sendFrame(record.clientKey, FusionSessionLogic.SESSION_PLAYER_ID, frame);
+    }
+    computeMasterClient() {
+        if (this.sessionMode !== GameMode.Shared)
+            return 0;
+        let masterClient = 0;
+        this.forEachAdmitted(null, (record) => {
+            if (masterClient === 0 || record.playerId < masterClient)
+                masterClient = record.playerId;
+        });
+        return masterClient;
+    }
+    refreshMasterClient() {
+        const masterClient = this.computeMasterClient();
+        if (masterClient === this.currentMasterClientPlayerId)
+            return;
+        this.currentMasterClientPlayerId = masterClient;
+        this.broadcastMasterClient(null);
+    }
+    broadcastMasterClient(exceptKey) {
+        this.broadcastControl(FUSION_CONTROL_MASTER_CLIENT, { playerId: this.currentMasterClientPlayerId }, exceptKey);
+    }
+    maySetSession(record) {
+        return record.isHost || (this.sessionMode === GameMode.Shared && record.playerId === this.currentMasterClientPlayerId);
+    }
+    updateSession(update) {
+        if (this.session == null)
+            return;
+        if (update.isOpen != null)
+            this.session.isOpen = update.isOpen;
+        if (update.isVisible != null)
+            this.session.isVisible = update.isVisible;
+        if (update.properties != null)
+            this.session.properties = Object.assign({}, update.properties);
+        this.broadcastControl(FUSION_CONTROL_SESSION, this.sessionSnapshot(), null);
+        this.publishSession();
+    }
+    endSession(reason) {
+        this.clients.forEach((record) => {
+            if (record.connected)
+                this.outputs.sendControl(record.clientKey, FUSION_CONTROL_SHUTDOWN, { reason: reason });
+        });
+        this.clients.clear();
+        this.resetSession();
+    }
+    resetSession() {
+        this.sharedObjects.clear();
+        this.sessionMode = null;
+        this.session = null;
+        this.currentHostPlayerId = 0;
+        this.currentMasterClientPlayerId = 0;
+        this.latestHostSnapshot = null;
+        this.latestSceneInfoFrame = null;
+        this.latestSceneInfo = null;
+        this.migration = null;
+        this.migrationHeldFrames.length = 0;
+        this.outputs.lockSession(true);
+    }
+    publishSession() {
+        if (this.session == null)
+            return;
+        const snapshot = this.sessionSnapshot();
+        this.outputs.setSessionMetadata(snapshot);
+        this.outputs.lockSession(!snapshot.isOpen || this.clients.size >= snapshot.maxPlayers);
+    }
+    sessionSnapshot() {
+        let connectedCount = 0;
+        this.clients.forEach((record) => {
+            if (record.connected)
+                connectedCount += 1;
+        });
+        return Object.assign({}, this.session, { playerCount: connectedCount, properties: Object.assign({}, this.session.properties) });
+    }
+    broadcastControl(name, payload, exceptKey) {
+        this.forEachAdmitted(exceptKey, (record) => this.outputs.sendControl(record.clientKey, name, payload));
+        if (this.dedicatedEndpoint != null)
+            this.dedicatedEndpoint.receiveControl(name, payload);
+    }
+    forEachAdmitted(exceptKey, action) {
+        for (const record of Array.from(this.clients.values())) {
+            if (record.connected && record.admitted && record.clientKey !== exceptKey)
+                action(record);
+        }
+    }
+    hasOtherConnectedPlayer(record) {
+        for (const other of this.clients.values()) {
+            if (other !== record && other.connected)
+                return true;
+        }
+        return false;
+    }
+    findPlayer(playerId) {
+        for (const record of this.clients.values()) {
+            if (record.playerId === playerId)
+                return record;
+        }
+        return null;
+    }
+    findAdmittedPlayer(playerId) {
+        const record = this.findPlayer(playerId);
+        return (record != null && record.connected && record.admitted) ? record : null;
+    }
+    static storedSpawnBlock(object) {
+        const header = Object.assign({}, object.spawnHeader, { stateAuthority: object.authorityPlayerId });
+        return { header: header, deltaBytes: object.deltaBytes };
+    }
+    static areaHolds(area, position) {
+        if (area == null || area.position == null)
+            return false;
+        const offsetX = position[0] - area.position[0];
+        const offsetY = position[1] - area.position[1];
+        const offsetZ = position[2] - area.position[2];
+        return Math.sqrt(offsetX * offsetX + offsetY * offsetY + offsetZ * offsetZ) <= area.radius;
+    }
+    static sceneKey(scene) {
+        return scene.index + "|" + scene.path + "|" + scene.loadId;
+    }
+    static error(reason) {
+        return new NetworkError(ShutdownReason[reason]);
+    }
+}
+FusionSessionLogic.MILLISECONDS_PER_SECOND = 1000;
+FusionSessionLogic.DEFAULT_PLAYER_COUNT = 8;
+FusionSessionLogic.SESSION_PLAYER_ID = 0;
+FusionSessionLogic.MAX_MIGRATION_HELD_FRAMES = 1024;
+FusionSessionLogic.REGION = "local";