@oyna360/lobby-sdk 0.1.0

package/dist/platform-lobby.js

@@ -0,0 +1,679 @@
+import { MeshBuilder, SceneLoader, Vector3 as BVector3 } from '@babylonjs/core';
+import '@babylonjs/loaders/glTF';
+import { sanitizeLobbyChat, sanitizeLobbyDataChannel, sanitizeLobbyDataPayload, } from './protocol';
+import { AvatarFactory } from './avatar-factory';
+import { AvatarAssetManager } from './avatar-asset-manager';
+import { ensureDracoDecoder } from './draco';
+import { LocalPlayerController } from './local-player-controller';
+import { NetworkClient } from './network-client';
+import { PlatformBridge } from './platform-bridge';
+import { RemotePlayerManager } from './remote-player-manager';
+import { SceneManager } from './scene-manager';
+import { PortalManager, ZoneManager } from './zones';
+import { applyStarterLayout as applyStarterLayoutFn } from './starter-layout';
+import { applyPlazaLayout as applyPlazaLayoutFn } from './plaza-layout';
+import { applyLobbyCollisions } from './lobby-colliders';
+import { attachLobbyDebug, buildLobbyDebugReport } from './lobby-debug';
+import { attachLobbyPerfDiag, lobbyPerfNoteLocalUpdate, isLobbyPerfDiagEnabled } from './lobby-perf-diag';
+import { attachRealDeviceAvatarDiag } from './lobby-real-device-diag';
+import { attachPlazaDiag } from './lobby-plaza-diag';
+import { attachPlayground } from './playground/playground-system';
+import { LobbyMusic } from './lobby-music';
+import { attachLobbyChatUi } from './lobby-chat-ui';
+import { attachLobbyPresenceUi } from './lobby-presence-ui';
+import { attachLobbyVoiceUi } from './lobby-voice-ui';
+import { attachLobbyConnectionUi } from './lobby-connection-ui';
+import { attachLobbyOrientationUi } from './lobby-orientation-ui';
+import { ensureLobbyPersianFont } from './lobby-font';
+import { provisionalSpawnSlot, resolveSpawnPose } from './spawn-utils';
+import { LobbyVoiceChat } from './voice-chat';
+const DEFAULT_LOBBY_FEATURES = {
+    chatEnabled: true,
+    voiceEnabled: true,
+    chatAllowed: true,
+    voiceAllowed: true,
+};
+export class PlatformLobby {
+    canvas;
+    strictRoom;
+    init;
+    config;
+    roomId;
+    wsUrl;
+    sceneManager;
+    localAvatar;
+    localController;
+    remotePlayers;
+    network = null;
+    zoneManager = new ZoneManager();
+    portalManager = new PortalManager();
+    plugins = [];
+    overlayHandlers = new Map();
+    listeners = new Map();
+    lastNetworkSend = 0;
+    destroyed = false;
+    ready = false;
+    playground = null;
+    music = new LobbyMusic();
+    chatDispose = null;
+    presenceDispose = null;
+    voiceDispose = null;
+    connectionDispose = null;
+    orientationDispose = null;
+    voiceChat = null;
+    lobbyFeatures = { ...DEFAULT_LOBBY_FEATURES };
+    resizeHandler = () => this.sceneManager?.resize();
+    constructor(init, canvas, roomId, wsUrl, config = {}, strictRoom = false) {
+        this.canvas = canvas;
+        this.strictRoom = strictRoom;
+        this.init = init;
+        this.roomId = roomId;
+        this.wsUrl = wsUrl;
+        this.config = {
+            enableMultiplayer: true,
+            ...config,
+        };
+    }
+    static async create(options) {
+        const init = PlatformBridge.fromInit(options.platformInit);
+        const roomId = options.roomId ?? init.lobby?.roomId ?? `game:${init.game.slug}`;
+        const wsUrl = options.wsUrl ?? init.lobby?.wsUrl ?? 'http://localhost:3001/lobby';
+        const strictRoom = options.strictRoom ?? init.lobby?.strictRoom ?? false;
+        const lobby = new PlatformLobby(init, options.canvas, roomId, wsUrl, options.config ?? {}, strictRoom);
+        await lobby.bootstrap();
+        return lobby;
+    }
+    static async createFromPlatform(canvas, config) {
+        const init = await PlatformBridge.waitForInit();
+        return PlatformLobby.create({
+            canvas,
+            roomId: init.lobby?.roomId ?? `game:${init.game.slug}`,
+            strictRoom: init.lobby?.strictRoom,
+            platformInit: init,
+            config,
+            wsUrl: init.lobby?.wsUrl,
+        });
+    }
+    static async createDev(options) {
+        const init = PlatformBridge.createDevInit({
+            mockUser: options.mockUser,
+            mockAvatar: options.mockAvatar,
+            gameSlug: options.roomId?.replace(/^game:/, '') ?? 'dev-game',
+        });
+        return PlatformLobby.create({
+            canvas: options.canvas,
+            roomId: options.roomId ?? init.lobby.roomId,
+            platformInit: init,
+            config: { enableMultiplayer: false, ...options.config },
+            wsUrl: options.wsUrl ?? init.lobby?.wsUrl,
+        });
+    }
+    async bootstrap() {
+        // Font CDN must never block first paint (can hang >60s on filtered networks).
+        void ensureLobbyPersianFont();
+        // Warm Draco WASM in parallel with scene setup (HTTP-cached on repeat visits).
+        void ensureDracoDecoder();
+        this.sceneManager = new SceneManager(this.canvas, this.config);
+        const layout = this.config;
+        const provisionalSlot = provisionalSpawnSlot(this.init.user.id, layout.spawnSlotCount ?? layout.spawnPoints?.length ?? 16);
+        const spawnPose = resolveSpawnPose(layout, provisionalSlot);
+        this.remotePlayers = new RemotePlayerManager(this.sceneManager.scene, this.init.user.id);
+        window.addEventListener('resize', this.resizeHandler);
+        // Register + fire-and-forget preload so first paint / render loop stay unblocked.
+        this.applyConfiguredAvatarBases();
+        // Show sky/ground immediately — do not freeze the canvas while the local GLB parses.
+        let lastTime = performance.now();
+        this.sceneManager.startRenderLoop(() => {
+            if (this.destroyed)
+                return;
+            const now = performance.now();
+            const dt = Math.min(0.05, (now - lastTime) / 1000);
+            lastTime = now;
+            if (!this.localController)
+                return;
+            const tLocal = isLobbyPerfDiagEnabled() ? performance.now() : 0;
+            const state = this.localController.update(dt);
+            if (isLobbyPerfDiagEnabled()) {
+                lobbyPerfNoteLocalUpdate(performance.now() - tLocal);
+            }
+            this.playground?.update(dt, this.localController, state.position);
+            this.sceneManager.followPlayer(this.localAvatar.position, dt, this.localController.getIgnoreMeshes());
+            this.zoneManager.updatePlayer(this.init.user.id, state.position);
+            const portalHits = this.portalManager.updatePlayer(this.init.user.id, state.position);
+            for (const hit of portalHits) {
+                hit.onTrigger?.();
+                this.emit('portalTrigger', {
+                    portalId: hit.portalId,
+                    toGameSlug: hit.toGameSlug,
+                    toScene: hit.toScene,
+                });
+            }
+            if (this.network?.isConnected() && now - this.lastNetworkSend > 50) {
+                this.lastNetworkSend = now;
+                this.network.sendMove({
+                    position: state.position,
+                    rotationY: state.rotationY,
+                    animation: state.animation,
+                });
+                this.voiceChat?.refreshMesh();
+            }
+            this.remotePlayers.update(dt);
+        });
+        this.localAvatar = await AvatarFactory.createAsync(this.sceneManager.scene, this.init.avatar, 'local-player', this.init.user.displayName, this.init.user.username, { collider: true });
+        if (this.destroyed)
+            return;
+        this.localController = new LocalPlayerController(this.localAvatar, spawnPose.position, this.sceneManager.scene, () => this.sceneManager.camera, this.config);
+        this.localController.teleportTo(spawnPose.position, spawnPose.rotationY);
+        this.localController.setSounds(this.music);
+        this.canvas.addEventListener('pointerdown', () => {
+            void this.music.unlock(true);
+        });
+        if (this.config.enableMultiplayer !== false && this.init.session.token !== 'dev-token') {
+            this.connectNetwork();
+        }
+        this.emit('ready', undefined);
+        this.ready = true;
+        const uiMessages = this.config.uiMessages;
+        if (this.config.enableMultiplayer !== false && this.config.enablePresenceUi !== false) {
+            this.presenceDispose = attachLobbyPresenceUi(this, uiMessages);
+        }
+        if (this.config.enableChat !== false)
+            this.attachChat();
+        if (this.config.enableVoice !== false && this.config.enableMultiplayer !== false) {
+            this.attachVoice();
+        }
+        if (this.config.enableMultiplayer !== false && this.config.enableConnectionUi !== false) {
+            this.connectionDispose = attachLobbyConnectionUi(this, uiMessages);
+        }
+        if (this.config.enableOrientationUi !== false) {
+            this.orientationDispose = attachLobbyOrientationUi({
+                locale: this.config.locale,
+                messages: uiMessages,
+            });
+        }
+        for (const plugin of this.plugins) {
+            void plugin.setup(this);
+        }
+        if (typeof window !== 'undefined') {
+            this.attachDebug(window);
+            const perf = attachLobbyPerfDiag(() => this.sceneManager.scene, () => this.sceneManager.engine, window);
+            attachRealDeviceAvatarDiag({
+                upsertRemote: (player) => this.diagUpsertRemote(player),
+                removeRemote: (userId) => this.diagRemoveRemote(userId),
+                waitRemote: (userId, timeoutMs) => this.diagWaitRemote(userId, timeoutMs),
+                waitRemoteReady: (userId, timeoutMs) => this.diagWaitRemoteReady(userId, timeoutMs),
+                applyRemoteMove: (payload) => this.diagApplyRemoteMove(payload),
+                isAvatarBaseCached: (id) => this.isAvatarBaseCached(id),
+                preloadAvatarBases: (ids) => this.preloadAvatarBases(ids),
+                registerAvatarBases: (defs) => this.registerAvatarBases(defs),
+                getScene: () => this.sceneManager.scene,
+                getEngine: () => this.sceneManager.engine,
+            }, perf, window);
+            attachPlazaDiag(() => this.sceneManager.scene, () => this.sceneManager.engine, perf, window);
+            window.__OYNA360_SDK_BUILD__ = 'avatar-join-v13';
+            console.info('[lobby-sdk] build avatar-join-v13');
+        }
+    }
+    /**
+     * DIAG ONLY: upsert a synthetic remote player for performance measurement.
+     * Does not change multiplayer protocol behavior.
+     */
+    diagUpsertRemote(player) {
+        this.remotePlayers.upsert(player);
+    }
+    /** DIAG ONLY: remove a synthetic/remote player used for measurement. */
+    diagRemoveRemote(userId) {
+        this.remotePlayers.remove(userId);
+    }
+    /** DIAG ONLY: wait until a remote userId appears in the remote list (or timeout). */
+    async diagWaitRemote(userId, timeoutMs = 60_000) {
+        const start = performance.now();
+        while (performance.now() - start < timeoutMs) {
+            if (this.remotePlayers.list().some((p) => p.userId === userId))
+                return true;
+            await new Promise((r) => setTimeout(r, 50));
+        }
+        return false;
+    }
+    /** DIAG ONLY: wait until remote GLB/placeholder swap finished. */
+    async diagWaitRemoteReady(userId, timeoutMs = 60_000) {
+        const start = performance.now();
+        while (performance.now() - start < timeoutMs) {
+            if (this.remotePlayers.isRemoteReady(userId))
+                return true;
+            await new Promise((r) => setTimeout(r, 50));
+        }
+        return false;
+    }
+    /** Register shared base avatar GLBs (catalog). Does not load until preload/spawn. */
+    registerAvatarBases(defs) {
+        AvatarAssetManager.registerAvatarBases(defs);
+    }
+    registerAvatarBase(def) {
+        AvatarAssetManager.registerAvatarBase(def);
+    }
+    listAvatarBases() {
+        return AvatarAssetManager.listAvatarBases();
+    }
+    isAvatarBaseCached(id) {
+        if (!this.sceneManager?.scene)
+            return false;
+        return AvatarAssetManager.isAvatarBaseCached(this.sceneManager.scene, id);
+    }
+    /**
+     * Warm container cache for one base. Non-throwing; returns null on failure.
+     * Safe to call after bootstrap — does not block the render loop by itself.
+     */
+    preloadAvatarBase(id) {
+        return AvatarAssetManager.preloadAvatarBase(this.sceneManager.scene, id);
+    }
+    /**
+     * Warm container cache for bases (all registered if ids omitted).
+     * Failures are per-id; lobby continues on the normal async spawn path.
+     */
+    preloadAvatarBases(ids) {
+        return AvatarAssetManager.preloadAvatarBases(this.sceneManager.scene, ids);
+    }
+    /** Apply config.avatarBases + init.avatarBases + optional fire-and-forget preload (non-blocking). */
+    applyConfiguredAvatarBases() {
+        const fromConfig = this.config.avatarBases ?? [];
+        const fromInit = this.init.avatarBases ?? [];
+        const bases = [...fromConfig, ...fromInit];
+        if (bases.length) {
+            AvatarAssetManager.registerAvatarBases(bases);
+        }
+        const flag = this.config.preloadAvatarBases;
+        if (flag === false)
+            return;
+        // Always warm registered bases (config and/or launch catalog) unless explicitly disabled.
+        if (!bases.length && flag !== true && !Array.isArray(flag))
+            return;
+        const ids = Array.isArray(flag) ? flag : undefined;
+        void AvatarAssetManager.preloadAvatarBases(this.sceneManager.scene, ids).then((results) => {
+            const failed = results.filter((r) => !r.ok);
+            if (failed.length) {
+                console.warn('[lobby-sdk] avatar base preload incomplete', failed.map((f) => f.id));
+            }
+        });
+    }
+    /** DIAG ONLY: update synthetic remote move/animation targets (no network). */
+    diagApplyRemoteMove(payload) {
+        this.remotePlayers.applyMove(payload);
+    }
+    connectNetwork() {
+        this.voiceChat = new LobbyVoiceChat({
+            sendJoin: (mode) => this.network?.sendVoiceJoin(mode),
+            sendLeave: () => this.network?.sendVoiceLeave(),
+            sendMute: (muted) => this.network?.sendVoiceMute(muted),
+            sendOffer: (toUserId, sdp) => this.network?.sendVoiceOffer(toUserId, sdp),
+            sendAnswer: (toUserId, sdp) => this.network?.sendVoiceAnswer(toUserId, sdp),
+            sendIce: (toUserId, candidate) => this.network?.sendVoiceIce(toUserId, candidate),
+        });
+        this.voiceChat.setContext(this.init.user.id, []);
+        this.voiceChat.setPositionProvider((userId) => {
+            if (userId === this.init.user.id) {
+                return this.localController.getState().position;
+            }
+            return this.remotePlayers.getPosition(userId);
+        });
+        this.network = new NetworkClient(this.wsUrl, this.roomId, this.init.session.token, {
+            onWelcome: (self, players, meta) => {
+                this.localController.teleportTo(self.position, self.rotationY);
+                if (meta?.lobbyFeatures)
+                    this.lobbyFeatures = meta.lobbyFeatures;
+                this.voiceChat?.setContext(this.init.user.id, meta?.friendUserIds ?? []);
+                if (meta?.voicePeers) {
+                    this.voiceChat?.handleVoiceState(meta.voicePeers, meta?.friendUserIds ?? []);
+                }
+                for (const p of players)
+                    this.remotePlayers.upsert(p);
+                this.emit('connected', undefined);
+            },
+            onPlayerJoined: (player) => {
+                this.remotePlayers.upsert(player);
+                this.emit('playerJoined', {
+                    userId: player.userId,
+                    displayName: player.displayName,
+                    username: player.username,
+                });
+            },
+            onPlayerLeft: (payload) => {
+                const info = this.remotePlayers.getIdentity(payload.userId);
+                this.remotePlayers.remove(payload.userId);
+                this.emit('playerLeft', {
+                    userId: payload.userId,
+                    displayName: payload.displayName ?? info?.displayName,
+                    username: payload.username ?? info?.username,
+                });
+            },
+            onPlayerMoved: (payload) => {
+                this.remotePlayers.applyMove(payload);
+            },
+            onPlayersMoved: (moves) => {
+                for (const payload of moves) {
+                    if (payload.userId === this.init.user.id)
+                        continue;
+                    this.remotePlayers.applyMove(payload);
+                }
+            },
+            onPlayerEmote: (userId, emote) => {
+                this.remotePlayers.applyEmote(userId, emote);
+            },
+            onChat: (payload) => {
+                if (payload.userId === this.init.user.id)
+                    return;
+                this.emit('chat', payload);
+            },
+            onData: (payload) => {
+                if (payload.userId === this.init.user.id)
+                    return;
+                this.emit('data', payload);
+            },
+            onVoiceState: (peers, friendUserIds) => {
+                this.voiceChat?.handleVoiceState(peers, friendUserIds);
+            },
+            onVoiceJoined: (peer) => {
+                this.voiceChat?.handleVoiceJoined(peer);
+            },
+            onVoiceLeft: (userId) => {
+                this.voiceChat?.handleVoiceLeft(userId);
+            },
+            onVoiceMute: (userId, muted) => {
+                this.voiceChat?.handleVoiceMute(userId, muted);
+            },
+            onVoiceOffer: (fromUserId, sdp) => {
+                void this.voiceChat?.handleOffer(fromUserId, sdp);
+            },
+            onVoiceAnswer: (fromUserId, sdp) => {
+                void this.voiceChat?.handleAnswer(fromUserId, sdp);
+            },
+            onVoiceIce: (fromUserId, candidate) => {
+                void this.voiceChat?.handleIce(fromUserId, candidate);
+            },
+            onError: (code, message) => {
+                this.emit('error', { code, message });
+            },
+            onDisconnected: () => {
+                this.emit('disconnected', undefined);
+            },
+            onReconnecting: (attempt) => {
+                this.emit('reconnecting', { attempt });
+            },
+            onReconnectFailed: () => {
+                this.emit('reconnectFailed', undefined);
+            },
+        }, { strictRoom: this.strictRoom });
+        this.network.connect();
+    }
+    on(event, handler) {
+        if (!this.listeners.has(event))
+            this.listeners.set(event, new Set());
+        this.listeners.get(event).add(handler);
+        if (event === 'ready' && this.ready) {
+            handler(undefined);
+        }
+        return () => this.off(event, handler);
+    }
+    off(event, handler) {
+        this.listeners.get(event)?.delete(handler);
+    }
+    emit(event, payload) {
+        for (const handler of this.listeners.get(event) ?? []) {
+            handler(payload);
+        }
+    }
+    use(plugin) {
+        this.plugins.push(plugin);
+        if (this.ready)
+            void plugin.setup(this);
+        return this;
+    }
+    /** Optional starter-plaza template. Appearance and start routing stay in the game. */
+    applyPlazaLayout(config) {
+        applyPlazaLayoutFn(this, config);
+        applyLobbyCollisions(this.sceneManager.scene);
+        if (!this.playground)
+            this.playground = attachPlayground(this);
+        return this;
+    }
+    applyStarterLayout(config) {
+        applyStarterLayoutFn(this, config);
+        applyLobbyCollisions(this.sceneManager.scene);
+        return this;
+    }
+    attachDebug(win) {
+        return attachLobbyDebug(this, win ?? window);
+    }
+    getDebugReport() {
+        return buildLobbyDebugReport(this);
+    }
+    addZone(options) {
+        this.zoneManager.addZone({
+            id: options.id,
+            bounds: options.bounds,
+            onEnter: (playerId) => {
+                options.onEnter?.(playerId);
+                this.emit('zoneEnter', { zoneId: options.id, playerId });
+            },
+            onExit: (playerId) => {
+                options.onExit?.(playerId);
+                this.emit('zoneExit', { zoneId: options.id, playerId });
+            },
+        });
+    }
+    /**
+     * Game-owned portal. The SDK only detects the player and fires `onTrigger` / `portalTrigger`.
+     * It never navigates the browser — the game starts its own gameplay.
+     */
+    addPortal(options) {
+        this.portalManager.addPortal(options);
+    }
+    /** Platform identity: user, avatar, session, room. */
+    getSession() {
+        return this.init.session;
+    }
+    getUser() {
+        return this.init.user;
+    }
+    getAvatar() {
+        return this.init.avatar;
+    }
+    /** Other players currently synced in this lobby room. */
+    getPlayers() {
+        return this.remotePlayers.list();
+    }
+    async loadGLB(url, name) {
+        const result = await SceneLoader.ImportMeshAsync('', url, undefined, this.sceneManager.scene);
+        const root = result.meshes[0];
+        if (name)
+            root.name = name;
+        return root;
+    }
+    onOverlay(id, handler) {
+        this.overlayHandlers.set(id, handler);
+    }
+    emitOverlay(id, payload) {
+        this.overlayHandlers.get(id)?.(payload);
+    }
+    playEmote(emote) {
+        this.network?.sendEmote(emote);
+    }
+    /** Live lobby chat. Not saved. Always echoes locally so the sender sees the line. */
+    sendChat(text) {
+        if (!this.canUseChat())
+            return false;
+        const clean = sanitizeLobbyChat(text);
+        if (!clean)
+            return false;
+        this.emit('chat', {
+            userId: this.init.user.id,
+            username: this.init.user.username,
+            displayName: this.init.user.displayName,
+            text: clean,
+            at: Date.now(),
+        });
+        this.network?.sendChat(clean);
+        return true;
+    }
+    /**
+     * Ephemeral game data for this lobby room (matchmaking, pad sync, …).
+     * Independent of chat — works when chat is disabled/banned.
+     * Local-echoes so the sender sees the same `data` event as peers.
+     * Prefer namespaced channels: `{gameSlug}.{feature}` (e.g. `fc.pad-room`).
+     */
+    sendData(channel, payload) {
+        if (!this.canUseData())
+            return false;
+        const ch = sanitizeLobbyDataChannel(channel);
+        const body = sanitizeLobbyDataPayload(payload);
+        if (!ch || !body)
+            return false;
+        if (!this.network?.isConnected())
+            return false;
+        this.emit('data', {
+            userId: this.init.user.id,
+            username: this.init.user.username,
+            displayName: this.init.user.displayName,
+            channel: ch,
+            payload: body,
+            at: Date.now(),
+        });
+        this.network.sendData(ch, body);
+        return true;
+    }
+    attachChat() {
+        if (this.chatDispose)
+            return this;
+        this.chatDispose = attachLobbyChatUi(this, this.canvas);
+        return this;
+    }
+    attachVoice() {
+        if (this.voiceDispose || !this.voiceChat)
+            return this;
+        this.voiceDispose = attachLobbyVoiceUi(this);
+        return this;
+    }
+    getVoiceChat() {
+        return this.voiceChat;
+    }
+    getLobbyFeatures() {
+        return this.lobbyFeatures;
+    }
+    canUseChat() {
+        return this.lobbyFeatures.chatEnabled && this.lobbyFeatures.chatAllowed;
+    }
+    /** Game data channel — defaults on when flags are omitted. */
+    canUseData() {
+        return this.lobbyFeatures.dataEnabled !== false && this.lobbyFeatures.dataAllowed !== false;
+    }
+    canUseVoice() {
+        return this.lobbyFeatures.voiceEnabled && this.lobbyFeatures.voiceAllowed;
+    }
+    /** Virtual joystick / on-screen pad. x = strafe, z = forward (-1..1). */
+    setMoveStick(x, z) {
+        this.localController.setStick(x, z);
+    }
+    setLookStick(x, y) {
+        this.sceneManager.thirdPerson.setLookStick(x, y);
+    }
+    addLookDelta(dx, dy) {
+        this.sceneManager.thirdPerson.addLookDelta(dx, dy);
+    }
+    /** Game-side camera distance (third-person orbit radius). */
+    setCameraOrbit(radius, limits) {
+        const tp = this.sceneManager.thirdPerson;
+        const cam = tp.camera;
+        if (typeof limits?.lower === 'number')
+            cam.lowerRadiusLimit = limits.lower;
+        if (typeof limits?.upper === 'number')
+            cam.upperRadiusLimit = limits.upper;
+        const clamped = Math.min(cam.upperRadiusLimit ?? 16, Math.max(cam.lowerRadiusLimit ?? 2.2, radius));
+        tp.wantedRadius = clamped;
+        cam.radius = clamped;
+    }
+    tryPlaygroundInteract() {
+        return this.playground?.trySlide() ?? false;
+    }
+    getLocalController() {
+        return this.localController;
+    }
+    noteMusicToggle() {
+        this.music.noteUserToggled();
+    }
+    toggleMusic() {
+        return this.music.toggleMuted();
+    }
+    setMusicMuted(muted) {
+        this.music.setMuted(muted);
+    }
+    isMusicMuted() {
+        return this.music.isMuted();
+    }
+    jump() {
+        this.localController.jump();
+    }
+    setJumpHeld(on) {
+        this.localController.setJumpHeld(on);
+    }
+    setSprint(on) {
+        this.localController.setSprint(on);
+    }
+    /** Ask the hub to close this lobby iframe and return home. Never navigates itself. */
+    requestExit() {
+        if (typeof window === 'undefined' || window.parent === window)
+            return;
+        const token = this.init.session?.token;
+        if (token) {
+            window.parent.postMessage({ type: 'platform:session:end', sessionToken: token }, '*');
+        }
+        window.parent.postMessage({ type: 'platform:lobby:exit' }, '*');
+    }
+    getInitPayload() {
+        return this.init;
+    }
+    getLocalPose() {
+        return this.localController.getState();
+    }
+    getScene() {
+        return this.sceneManager.scene;
+    }
+    getUiLocale() {
+        return this.config.locale === 'en' ? 'en' : 'fa';
+    }
+    getEngine() {
+        return this.sceneManager.engine;
+    }
+    addMeshAt(position, size = 1) {
+        const box = MeshBuilder.CreateBox('custom-mesh', { size }, this.sceneManager.scene);
+        box.position = new BVector3(position.x, position.y + size / 2, position.z);
+        return box;
+    }
+    destroy() {
+        if (this.destroyed)
+            return;
+        this.destroyed = true;
+        window.removeEventListener('resize', this.resizeHandler);
+        this.chatDispose?.();
+        this.chatDispose = null;
+        this.presenceDispose?.();
+        this.presenceDispose = null;
+        this.voiceDispose?.();
+        this.voiceDispose = null;
+        this.connectionDispose?.();
+        this.connectionDispose = null;
+        this.orientationDispose?.();
+        this.orientationDispose = null;
+        this.voiceChat?.dispose();
+        this.voiceChat = null;
+        this.network?.disconnect();
+        this.localController.dispose();
+        this.music.dispose();
+        this.playground?.dispose();
+        this.remotePlayers.dispose();
+        this.sceneManager.dispose();
+        this.zoneManager.clear();
+        this.portalManager.clear();
+        this.emit('destroyed', undefined);
+    }
+}
+//# sourceMappingURL=platform-lobby.js.map