- {isHost && lobbyStatus === 'hosting' && (
+ {!isGuestMode && (
<>
diff --git a/src/components/game/hooks/useWorkerBridge.ts b/src/components/game/hooks/useWorkerBridge.ts
index eb063869..345761e5 100644
--- a/src/components/game/hooks/useWorkerBridge.ts
+++ b/src/components/game/hooks/useWorkerBridge.ts
@@ -29,7 +29,7 @@ import {
} from '@/store/gameSetupStore';
import { useUIStore } from '@/store/uiStore';
import { useGameStore } from '@/store/gameStore';
-import { isMultiplayerMode } from '@/store/multiplayerStore';
+import { isMultiplayerMode, useMultiplayerStore } from '@/store/multiplayerStore';
import { MapData } from '@/data/maps';
import { debugInitialization, debugNetworking } from '@/utils/debugLogger';
import { syncWorkerPlayerResources } from './syncWorkerPlayerResources';
@@ -62,6 +62,23 @@ export interface UseWorkerBridgeReturn {
getGameTime: () => number;
}
+type VoidstrikeMultiplayerDebug = {
+ requestChecksum: () => Promise<{ tick: number; checksum: string }>;
+ getStatus: () => {
+ connectionStatus: ReturnType
['connectionStatus'];
+ desyncState: ReturnType['desyncState'];
+ desyncTick: ReturnType['desyncTick'];
+ localPlayerId: string | null;
+ fogOfWar: boolean;
+ renderTick: number;
+ renderGameTime: number;
+ };
+};
+
+type VoidstrikeGlobal = typeof globalThis & {
+ __voidstrikeMultiplayerDebug__?: VoidstrikeMultiplayerDebug;
+};
+
export function useWorkerBridge({ map, onGameOver }: UseWorkerBridgeProps): UseWorkerBridgeReturn {
// Refs
const workerBridgeRef = useRef(null);
@@ -82,6 +99,45 @@ export function useWorkerBridge({ map, onGameOver }: UseWorkerBridgeProps): UseW
const mapRef = useRef(map);
mapRef.current = map;
+ const installMultiplayerDebugApi = useCallback((bridge: WorkerBridge) => {
+ const debugTarget = globalThis as VoidstrikeGlobal;
+ debugTarget.__voidstrikeMultiplayerDebug__ = {
+ requestChecksum: () =>
+ new Promise((resolve, reject) => {
+ const timeout = window.setTimeout(() => {
+ unsubscribe();
+ reject(new Error('Checksum request timed out'));
+ }, 5000);
+
+ const unsubscribe = bridge.eventBus.on<{ tick: number; checksum: string }>(
+ 'checksum',
+ ({ tick, checksum }) => {
+ window.clearTimeout(timeout);
+ unsubscribe();
+ resolve({ tick, checksum });
+ }
+ );
+
+ bridge.requestChecksum();
+ }),
+ getStatus: () => {
+ const multiplayerState = useMultiplayerStore.getState();
+ const gameSetupState = useGameSetupStore.getState();
+ const adapter = RenderStateWorldAdapter.getInstance();
+
+ return {
+ connectionStatus: multiplayerState.connectionStatus,
+ desyncState: multiplayerState.desyncState,
+ desyncTick: multiplayerState.desyncTick,
+ localPlayerId: gameSetupState.localPlayerId,
+ fogOfWar: gameSetupState.fogOfWar,
+ renderTick: adapter.getTick(),
+ renderGameTime: adapter.getGameTime(),
+ };
+ },
+ };
+ }, []);
+
// Handle render state updates from worker
const handleRenderState = useCallback((state: RenderState) => {
if (
@@ -166,6 +222,7 @@ export function useWorkerBridge({ map, onGameOver }: UseWorkerBridgeProps): UseW
mapHeight,
tickRate: 20,
isMultiplayer,
+ multiplayerMessageHandling: isMultiplayer ? 'worker' : 'main-thread',
playerId: localPlayerId ?? 'spectator',
aiEnabled: !isMultiplayer,
aiDifficulty: 'medium',
@@ -195,6 +252,7 @@ export function useWorkerBridge({ map, onGameOver }: UseWorkerBridgeProps): UseW
eventUnsubscribersRef.current.push(unsubscribeLocalPlayer);
await bridge.initialize();
+ installMultiplayerDebugApi(bridge);
bridge.setDebugSettings(useUIStore.getState().debugSettings);
bridge.setTerrainGrid(currentMap.terrain);
@@ -213,6 +271,7 @@ export function useWorkerBridge({ map, onGameOver }: UseWorkerBridgeProps): UseW
mapHeight,
tickRate: 20,
isMultiplayer,
+ multiplayerMessageHandling: 'worker',
playerId: localPlayerId ?? 'spectator',
aiEnabled: false,
});
@@ -251,7 +310,13 @@ export function useWorkerBridge({ map, onGameOver }: UseWorkerBridgeProps): UseW
initializePromiseRef.current = initPromise;
return initPromise;
- }, [handleRenderState, handleGameEvent, handleGameOver, handleWorkerError]);
+ }, [
+ handleRenderState,
+ handleGameEvent,
+ handleGameOver,
+ handleWorkerError,
+ installMultiplayerDebugApi,
+ ]);
// Spawn initial entities
const spawnEntities = useCallback(async () => {
@@ -294,6 +359,7 @@ export function useWorkerBridge({ map, onGameOver }: UseWorkerBridgeProps): UseW
WorkerBridge.resetInstance();
workerBridgeRef.current = null;
}
+ delete (globalThis as VoidstrikeGlobal).__voidstrikeMultiplayerDebug__;
RenderStateWorldAdapter.resetInstance();
worldProviderRef.current = null;
eventBusRef.current = null;
diff --git a/src/engine/core/Game.ts b/src/engine/core/Game.ts
index f531c17e..a021e511 100644
--- a/src/engine/core/Game.ts
+++ b/src/engine/core/Game.ts
@@ -52,6 +52,7 @@ import { commandIdGenerator } from '../network/types';
import type { GameStatePort } from './GameStatePort';
import { ZustandStateAdapter } from '@/adapters/ZustandStateAdapter';
import { getCommandSigningManager, resetCommandSigningManager } from '../network/CommandSigning';
+import { shouldHandleMultiplayerMessagesOnMainThread } from './multiplayerMessageHandling';
// Re-export types for backwards compatibility
export type { GameState, TerrainCell, GameConfig } from './GameCore';
@@ -132,7 +133,7 @@ export class Game extends GameCore {
this.audioSystem = new AudioSystem(this as IGameInstance);
// Initialize desync detection for multiplayer
- if (this.config.isMultiplayer) {
+ if (shouldHandleMultiplayerMessagesOnMainThread(this.config)) {
this.desyncDetection = new DesyncDetectionManager(this as IGameInstance, {
enabled: true,
pauseOnDesync: false,
diff --git a/src/engine/core/GameCore.ts b/src/engine/core/GameCore.ts
index 176f028e..1010bed8 100644
--- a/src/engine/core/GameCore.ts
+++ b/src/engine/core/GameCore.ts
@@ -56,6 +56,12 @@ export interface GameConfig {
mapHeight: number;
tickRate: number;
isMultiplayer: boolean;
+ /**
+ * Selects which runtime owns inbound multiplayer command handling.
+ * - `main-thread`: direct Game instance handles lockstep networking
+ * - `worker`: WorkerBridge/GameWorker handle multiplayer, main thread stays UI-only
+ */
+ multiplayerMessageHandling: 'main-thread' | 'worker';
playerId: string;
aiEnabled: boolean;
aiDifficulty: 'easy' | 'medium' | 'hard' | 'insane';
@@ -67,6 +73,7 @@ export const DEFAULT_CONFIG: GameConfig = {
mapHeight: 128,
tickRate: 20,
isMultiplayer: false,
+ multiplayerMessageHandling: 'main-thread',
playerId: 'player1',
aiEnabled: true,
aiDifficulty: 'medium',
diff --git a/src/engine/core/multiplayerMessageHandling.ts b/src/engine/core/multiplayerMessageHandling.ts
new file mode 100644
index 00000000..8b84c330
--- /dev/null
+++ b/src/engine/core/multiplayerMessageHandling.ts
@@ -0,0 +1,12 @@
+import type { GameConfig } from './GameCore';
+
+/**
+ * In worker mode, WorkerBridge forwards inbound peer commands to GameWorker and the
+ * main-thread Game instance must stay out of lockstep validation to avoid duplicate
+ * processing against a non-advancing local tick.
+ */
+export function shouldHandleMultiplayerMessagesOnMainThread(
+ config: Pick
+): boolean {
+ return config.isMultiplayer && config.multiplayerMessageHandling !== 'worker';
+}
diff --git a/src/hooks/useLobbySync.ts b/src/hooks/useLobbySync.ts
index 90d6593e..df0a69a0 100644
--- a/src/hooks/useLobbySync.ts
+++ b/src/hooks/useLobbySync.ts
@@ -4,10 +4,16 @@ import { useEffect, useCallback } from 'react';
import { useRouter } from 'next/navigation';
import { useLobby, LobbyState } from '@/hooks/useMultiplayer';
import { useMultiplayerStore } from '@/store/multiplayerStore';
-import { useGameSetupStore, PlayerSlot, StartingResources, GameSpeed } from '@/store/gameSetupStore';
+import {
+ useGameSetupStore,
+ PlayerSlot,
+ StartingResources,
+ GameSpeed,
+} from '@/store/gameSetupStore';
import { ALL_MAPS } from '@/data/maps';
import { Game } from '@/engine/core/Game';
import { debugInitialization } from '@/utils/debugLogger';
+import { shouldEnableLobbyNetworking } from '@/app/game/setup/lobbySessionPolicy';
export interface UseLobbyOptions {
playerName: string;
@@ -75,16 +81,22 @@ export function useLobbySync({ playerName, isPublicLobby }: UseLobbyOptions): Lo
} = useGameSetupStore();
// Lobby hook callbacks
- const handleGuestJoin = useCallback((guestName: string) => {
- return fillOpenSlotWithGuest(guestName);
- }, [fillOpenSlotWithGuest]);
-
- const handleGuestLeave = useCallback((slotId: string) => {
- removeGuest(slotId);
- }, [removeGuest]);
+ const handleGuestJoin = useCallback(
+ (guestName: string) => {
+ return fillOpenSlotWithGuest(guestName);
+ },
+ [fillOpenSlotWithGuest]
+ );
+
+ const handleGuestLeave = useCallback(
+ (slotId: string) => {
+ removeGuest(slotId);
+ },
+ [removeGuest]
+ );
// Only enable Nostr when multiplayer is needed
- const needsMultiplayer = playerSlots.some(s => s.type === 'open') || isPublicLobby;
+ const needsMultiplayer = shouldEnableLobbyNetworking(playerSlots, isPublicLobby);
const {
status: lobbyStatus,
@@ -110,16 +122,12 @@ export function useLobbySync({ playerName, isPublicLobby }: UseLobbyOptions): Lo
});
// Multiplayer store
- const {
- setMultiplayer,
- setConnected,
- setHost,
- } = useMultiplayerStore();
+ const { setMultiplayer, setConnected, setHost } = useMultiplayerStore();
// Derived state
- const hasOpenSlot = playerSlots.some(s => s.type === 'open');
+ const hasOpenSlot = playerSlots.some((s) => s.type === 'open');
const hasGuests = guests.length > 0;
- const guestSlotCount = playerSlots.filter(s => s.isGuest).length;
+ const guestSlotCount = playerSlots.filter((s) => s.isGuest).length;
const isGuestMode = lobbyStatus === 'connected' && !isHost;
// When connected as guest, set up multiplayer store
@@ -135,7 +143,7 @@ export function useLobbySync({ playerName, isPublicLobby }: UseLobbyOptions): Lo
// When hosting with connected guests, set up multiplayer
// Note: Data channels are set up via addPeer() in useMultiplayer.ts
useEffect(() => {
- if (isHost && guests.some(g => g.dataChannel)) {
+ if (isHost && guests.some((g) => g.dataChannel)) {
setMultiplayer(true);
setConnected(true);
setHost(true);
@@ -145,7 +153,7 @@ export function useLobbySync({ playerName, isPublicLobby }: UseLobbyOptions): Lo
// Send lobby state to guests whenever it changes (host only)
useEffect(() => {
if (!isHost) return;
- const hasConnectedGuests = guests.some(g => g.dataChannel?.readyState === 'open');
+ const hasConnectedGuests = guests.some((g) => g.dataChannel?.readyState === 'open');
if (!hasConnectedGuests) return;
const lobbyState: LobbyState = {
@@ -157,7 +165,16 @@ export function useLobbySync({ playerName, isPublicLobby }: UseLobbyOptions): Lo
};
sendLobbyState(lobbyState);
- }, [isHost, guests, playerSlots, selectedMapId, startingResources, gameSpeed, fogOfWar, sendLobbyState]);
+ }, [
+ isHost,
+ guests,
+ playerSlots,
+ selectedMapId,
+ startingResources,
+ gameSpeed,
+ fogOfWar,
+ sendLobbyState,
+ ]);
// Publish public lobby listing when checkbox is enabled (host only)
useEffect(() => {
@@ -167,8 +184,8 @@ export function useLobbySync({ playerName, isPublicLobby }: UseLobbyOptions): Lo
const map = ALL_MAPS[selectedMapId];
if (!map) return;
- const openSlots = playerSlots.filter(s => s.type === 'open').length;
- const activeSlots = playerSlots.filter(s => s.type === 'human' || s.type === 'ai').length;
+ const openSlots = playerSlots.filter((s) => s.type === 'open').length;
+ const activeSlots = playerSlots.filter((s) => s.type === 'human' || s.type === 'ai').length;
publishPublicListing({
hostName: playerName || 'Unknown Host',
@@ -187,7 +204,16 @@ export function useLobbySync({ playerName, isPublicLobby }: UseLobbyOptions): Lo
const interval = setInterval(publish, 60000);
return () => clearInterval(interval);
- }, [isHost, isPublicLobby, lobbyStatus, lobbyCode, playerSlots, playerName, selectedMapId, publishPublicListing]);
+ }, [
+ isHost,
+ isPublicLobby,
+ lobbyStatus,
+ lobbyCode,
+ playerSlots,
+ playerName,
+ selectedMapId,
+ publishPublicListing,
+ ]);
// Register game start callback (guest only)
useEffect(() => {
@@ -215,14 +241,20 @@ export function useLobbySync({ playerName, isPublicLobby }: UseLobbyOptions): Lo
});
}, [isHost, onGameStart, receivedLobbyState, mySlotId, startGame, router]);
-
// Compute display values based on mode
- const displayPlayerSlots = isGuestMode && receivedLobbyState ? receivedLobbyState.playerSlots : playerSlots;
- const displayMapId = isGuestMode && receivedLobbyState ? receivedLobbyState.selectedMapId : selectedMapId;
- const displayStartingResources = isGuestMode && receivedLobbyState ? receivedLobbyState.startingResources : startingResources;
- const displayGameSpeed = isGuestMode && receivedLobbyState ? receivedLobbyState.gameSpeed : gameSpeed;
- const displayFogOfWar = isGuestMode && receivedLobbyState ? receivedLobbyState.fogOfWar : fogOfWar;
- const displayActivePlayerCount = displayPlayerSlots.filter(s => s.type === 'human' || s.type === 'ai').length;
+ const displayPlayerSlots =
+ isGuestMode && receivedLobbyState ? receivedLobbyState.playerSlots : playerSlots;
+ const displayMapId =
+ isGuestMode && receivedLobbyState ? receivedLobbyState.selectedMapId : selectedMapId;
+ const displayStartingResources =
+ isGuestMode && receivedLobbyState ? receivedLobbyState.startingResources : startingResources;
+ const displayGameSpeed =
+ isGuestMode && receivedLobbyState ? receivedLobbyState.gameSpeed : gameSpeed;
+ const displayFogOfWar =
+ isGuestMode && receivedLobbyState ? receivedLobbyState.fogOfWar : fogOfWar;
+ const displayActivePlayerCount = displayPlayerSlots.filter(
+ (s) => s.type === 'human' || s.type === 'ai'
+ ).length;
return {
displayPlayerSlots,
@@ -239,7 +271,7 @@ export function useLobbySync({ playerName, isPublicLobby }: UseLobbyOptions): Lo
lobbyCode,
lobbyError,
- guests: guests.map(g => ({ pubkey: g.pubkey, name: g.name, slotId: g.slotId })),
+ guests: guests.map((g) => ({ pubkey: g.pubkey, name: g.name, slotId: g.slotId })),
hasOpenSlot,
hasGuests,
guestSlotCount,
diff --git a/src/hooks/useMultiplayer.ts b/src/hooks/useMultiplayer.ts
index 18459c6d..f9a0f172 100644
--- a/src/hooks/useMultiplayer.ts
+++ b/src/hooks/useMultiplayer.ts
@@ -18,13 +18,19 @@ import { SimplePool, finalizeEvent, generateSecretKey, getPublicKey } from 'nost
import { debugNetworking } from '@/utils/debugLogger';
import type { Filter, NostrEvent } from 'nostr-tools';
import { getRelays } from '@/engine/network/p2p/NostrRelays';
-import type { PlayerSlot, StartingResources, GameSpeed } from '@/store/gameSetupStore';
+import {
+ useGameSetupStore,
+ type PlayerSlot,
+ type StartingResources,
+ type GameSpeed,
+} from '@/store/gameSetupStore';
import { useMultiplayerStore } from '@/store/multiplayerStore';
import {
CommandSigningManager,
getCommandSigningManager,
resetCommandSigningManager,
} from '@/engine/network/CommandSigning';
+import { shouldPreserveLobbySessionOnUnmount } from '@/app/game/setup/lobbySessionPolicy';
// Short code alphabet (no confusing chars)
const CODE_ALPHABET = 'ABCDEFGHJKMNPQRSTUVWXYZ';
@@ -248,6 +254,7 @@ export function useLobby(options: UseLobbyOptions = {}): UseLobbyReturn {
// Store joined lobby info for reconnection
const joinedCodeRef = useRef(null);
const joinedNameRef = useRef(null);
+ const hostPeerIdRef = useRef(null);
// Track when reconnection is in progress to prevent state conflicts with multiplayerStore
const isReconnectingRef = useRef(false);
const [mySlotId, setMySlotId] = useState(null);
@@ -268,6 +275,62 @@ export function useLobby(options: UseLobbyOptions = {}): UseLobbyReturn {
const onGuestLeaveRef = useRef(onGuestLeave);
onGuestLeaveRef.current = onGuestLeave;
+ const cleanupLobbySession = useCallback(() => {
+ try {
+ subRef.current?.close();
+ subRef.current = null;
+ } catch {
+ /* ignore */
+ }
+
+ if (joinTimeoutRef.current) {
+ clearTimeout(joinTimeoutRef.current);
+ joinTimeoutRef.current = null;
+ }
+
+ if (pcRef.current) {
+ try {
+ pcRef.current.close();
+ } catch {
+ /* ignore */
+ }
+ pcRef.current = null;
+ }
+
+ guestsRef.current.forEach((guest) => {
+ try {
+ guest.pc.close();
+ } catch {
+ /* ignore */
+ }
+ });
+
+ // Don't explicitly close the pool - nostr-tools throws unhandled errors
+ // when websockets are already closing. Let browser garbage collect instead.
+ poolRef.current = null;
+ secretKeyRef.current = null;
+ pubkeyRef.current = null;
+ relaysRef.current = [];
+ joinedCodeRef.current = null;
+ joinedNameRef.current = null;
+ hostPeerIdRef.current = null;
+ gameStartCallbackRef.current = null;
+ isReconnectingRef.current = false;
+
+ resetCommandSigningManager();
+ signingManagerRef.current = null;
+ }, []);
+
+ const cleanupLobbyForEffectExit = useCallback(() => {
+ if (shouldPreserveLobbySessionOnUnmount(useGameSetupStore.getState().gameStarted)) {
+ debugNetworking.log('[Lobby] Preserving active session across route transition to /game');
+ return;
+ }
+
+ useMultiplayerStore.getState().setSessionCleanupCallback(null);
+ cleanupLobbySession();
+ }, [cleanupLobbySession]);
+
// Handle incoming messages on the host connection (guest mode)
useEffect(() => {
if (!hostConnection) return;
@@ -303,11 +366,13 @@ export function useLobby(options: UseLobbyOptions = {}): UseLobbyReturn {
// Initialize lobby (host mode) - only when enabled
useEffect(() => {
+ useMultiplayerStore.getState().setSessionCleanupCallback(cleanupLobbySession);
+
// Skip initialization in single-player mode
if (!enabled) {
setStatus('disabled');
setLobbyCode(null);
- return;
+ return cleanupLobbyForEffectExit;
}
let mounted = true;
@@ -546,38 +611,9 @@ export function useLobby(options: UseLobbyOptions = {}): UseLobbyReturn {
return () => {
mounted = false;
- // Cleanup subscriptions - close quietly
- try {
- subRef.current?.close();
- subRef.current = null;
- } catch {
- /* ignore */
- }
- // Clear any pending join timeout to prevent stale state updates
- if (joinTimeoutRef.current) {
- clearTimeout(joinTimeoutRef.current);
- joinTimeoutRef.current = null;
- }
- // Don't explicitly close the pool - nostr-tools throws unhandled errors
- // when websockets are already closing. Let browser garbage collect instead.
- poolRef.current = null;
- // Clear refs
- secretKeyRef.current = null;
- pubkeyRef.current = null;
- relaysRef.current = [];
- // Close peer connections
- guestsRef.current.forEach((g) => {
- try {
- g.pc.close();
- } catch {
- /* ignore */
- }
- });
- // Reset command signing manager
- resetCommandSigningManager();
- signingManagerRef.current = null;
+ cleanupLobbyForEffectExit();
};
- }, [enabled, onGuestJoin]); // Re-initialize when enabled changes or guest handler changes
+ }, [enabled, onGuestJoin, cleanupLobbySession, cleanupLobbyForEffectExit]); // Re-initialize when enabled changes or guest handler changes
const joinLobby = useCallback(async (code: string, playerName: string) => {
try {
@@ -643,6 +679,7 @@ export function useLobby(options: UseLobbyOptions = {}): UseLobbyReturn {
try {
const data = JSON.parse(event.content);
const hostPubkey = event.pubkey;
+ hostPeerIdRef.current = hostPubkey;
// Create peer connection
const pc = new RTCPeerConnection({ iceServers: getIceServersSync() });
@@ -969,7 +1006,10 @@ export function useLobby(options: UseLobbyOptions = {}): UseLobbyReturn {
}
return () => {
- // Clean up on unmount
+ if (shouldPreserveLobbySessionOnUnmount(useGameSetupStore.getState().gameStarted)) {
+ return;
+ }
+
useMultiplayerStore.getState().setReconnectCallback(null);
isReconnectingRef.current = false;
};
@@ -979,12 +1019,12 @@ export function useLobby(options: UseLobbyOptions = {}): UseLobbyReturn {
useEffect(() => {
if (hostConnection && hostConnection.readyState === 'open') {
const store = useMultiplayerStore.getState();
- const hostPubkey = pubkeyRef.current ? `host-${pubkeyRef.current.slice(0, 8)}` : 'host';
+ const hostPeerId = hostPeerIdRef.current ?? 'host';
debugNetworking.log('[Lobby] Syncing host connection to multiplayerStore');
// Use addPeer for consistency with multi-peer architecture
- store.addPeer(hostPubkey, hostConnection);
+ store.addPeer(hostPeerId, hostConnection);
store.setMultiplayer(true);
store.setHost(false);
}
@@ -997,7 +1037,7 @@ export function useLobby(options: UseLobbyOptions = {}): UseLobbyReturn {
}
const store = useMultiplayerStore.getState();
- const hostPubkey = pubkeyRef.current ? `host-${pubkeyRef.current.slice(0, 8)}` : 'host';
+ const hostPeerId = hostPeerIdRef.current ?? 'host';
// Find the host's slot - the first human player that isn't a guest
const hostSlot = receivedLobbyState.playerSlots.find(
@@ -1005,8 +1045,8 @@ export function useLobby(options: UseLobbyOptions = {}): UseLobbyReturn {
);
if (hostSlot) {
- debugNetworking.log(`[Lobby] Setting peer-slot mapping: ${hostPubkey} -> ${hostSlot.id}`);
- store.setPeerSlotMapping(hostPubkey, hostSlot.id);
+ debugNetworking.log(`[Lobby] Setting peer-slot mapping: ${hostPeerId} -> ${hostSlot.id}`);
+ store.setPeerSlotMapping(hostPeerId, hostSlot.id);
}
}, [hostConnection, receivedLobbyState]);
diff --git a/src/store/multiplayerStore.ts b/src/store/multiplayerStore.ts
index 47b6ae70..84c3fb80 100644
--- a/src/store/multiplayerStore.ts
+++ b/src/store/multiplayerStore.ts
@@ -104,6 +104,7 @@ export interface MultiplayerState {
// Reconnection callback (set by lobby hook)
reconnectCallback: (() => Promise) | null;
+ sessionCleanupCallback: (() => void) | null;
// Called after successful reconnection to trigger game-level sync
onReconnectedCallback: (() => void) | null;
@@ -127,6 +128,7 @@ export interface MultiplayerState {
setRemotePeerId: (id: string | null) => void;
setDataChannel: (channel: RTCDataChannel | null) => void;
setReconnectCallback: (callback: (() => Promise) | null) => void;
+ setSessionCleanupCallback: (callback: (() => void) | null) => void;
setOnReconnectedCallback: (callback: (() => void) | null) => void;
// Multi-peer actions
@@ -216,6 +218,7 @@ const initialState = {
dataChannel: null,
peerChannels: new Map(),
reconnectCallback: null,
+ sessionCleanupCallback: null,
onReconnectedCallback: null,
messageHandlers: [] as ((data: unknown) => void)[],
// Latency measurement
@@ -255,6 +258,7 @@ export const useMultiplayerStore = create((set, get) => ({
}
},
setReconnectCallback: (callback) => set({ reconnectCallback: callback }),
+ setSessionCleanupCallback: (callback) => set({ sessionCleanupCallback: callback }),
setOnReconnectedCallback: (callback) => set({ onReconnectedCallback: callback }),
// Multi-peer management for 8-player support
@@ -1021,7 +1025,7 @@ export const useMultiplayerStore = create((set, get) => ({
},
reset: () => {
- const { dataChannel, pingInterval, peerChannels } = get();
+ const { dataChannel, pingInterval, peerChannels, sessionCleanupCallback } = get();
// Close all peer channels with proper cleanup
for (const peer of peerChannels.values()) {
@@ -1053,6 +1057,12 @@ export const useMultiplayerStore = create((set, get) => ({
clearInterval(pingInterval);
}
+ try {
+ sessionCleanupCallback?.();
+ } catch (e) {
+ debugNetworking.error('[Multiplayer] Failed to clean up preserved lobby session:', e);
+ }
+
set({
...initialState,
messageHandlers: [],
diff --git a/tests/app/game/GameLoadingFallback.test.ts b/tests/app/game/GameLoadingFallback.test.ts
new file mode 100644
index 00000000..c470ea9a
--- /dev/null
+++ b/tests/app/game/GameLoadingFallback.test.ts
@@ -0,0 +1,17 @@
+import { createElement } from 'react';
+import { describe, expect, it } from 'vitest';
+import { renderToStaticMarkup } from 'react-dom/server';
+import { GameLoadingFallback } from '@/app/game/GameLoadingFallback';
+
+describe('GameLoadingFallback', () => {
+ it('renders an immediate loading shell with a progress bar', () => {
+ const html = renderToStaticMarkup(
+ createElement(GameLoadingFallback, { status: 'Synchronizing battlefield state' })
+ );
+
+ expect(html).toContain('VOIDSTRIKE');
+ expect(html).toContain('Synchronizing battlefield state');
+ expect(html).toContain('role="progressbar"');
+ expect(html).toContain('Loading progress');
+ });
+});
diff --git a/tests/app/game/setup/lobbySessionPolicy.test.ts b/tests/app/game/setup/lobbySessionPolicy.test.ts
new file mode 100644
index 00000000..97ac8ed6
--- /dev/null
+++ b/tests/app/game/setup/lobbySessionPolicy.test.ts
@@ -0,0 +1,62 @@
+import { describe, expect, it } from 'vitest';
+import {
+ shouldEnableLobbyNetworking,
+ shouldPreserveLobbySessionOnUnmount,
+} from '@/app/game/setup/lobbySessionPolicy';
+import type { PlayerSlot } from '@/store/gameSetupStore';
+
+function createSlot(overrides: Partial): PlayerSlot {
+ return {
+ id: 'player1',
+ type: 'human',
+ faction: 'dominion',
+ colorId: 'blue',
+ aiDifficulty: 'medium',
+ name: 'Player 1',
+ team: 0,
+ ...overrides,
+ };
+}
+
+describe('lobbySessionPolicy', () => {
+ it('enables lobby networking when the host exposes an open slot', () => {
+ expect(
+ shouldEnableLobbyNetworking(
+ [createSlot({ id: 'player1' }), createSlot({ id: 'player2', type: 'open' })],
+ false
+ )
+ ).toBe(true);
+ });
+
+ it('keeps lobby networking enabled after an open slot is filled by a guest', () => {
+ expect(
+ shouldEnableLobbyNetworking(
+ [createSlot({ id: 'player1' }), createSlot({ id: 'player2', isGuest: true })],
+ false
+ )
+ ).toBe(true);
+ });
+
+ it('disables lobby networking for a local-only setup', () => {
+ expect(
+ shouldEnableLobbyNetworking(
+ [createSlot({ id: 'player1' }), createSlot({ id: 'player2', type: 'ai' })],
+ false
+ )
+ ).toBe(false);
+ });
+
+ it('always enables lobby networking for public lobbies', () => {
+ expect(
+ shouldEnableLobbyNetworking(
+ [createSlot({ id: 'player1' }), createSlot({ id: 'player2', type: 'ai' })],
+ true
+ )
+ ).toBe(true);
+ });
+
+ it('preserves the session only during a real game transition', () => {
+ expect(shouldPreserveLobbySessionOnUnmount(true)).toBe(true);
+ expect(shouldPreserveLobbySessionOnUnmount(false)).toBe(false);
+ });
+});
diff --git a/tests/engine/core/multiplayerMessageHandling.test.ts b/tests/engine/core/multiplayerMessageHandling.test.ts
new file mode 100644
index 00000000..0ec0aec1
--- /dev/null
+++ b/tests/engine/core/multiplayerMessageHandling.test.ts
@@ -0,0 +1,31 @@
+import { describe, expect, it } from 'vitest';
+import { shouldHandleMultiplayerMessagesOnMainThread } from '@/engine/core/multiplayerMessageHandling';
+
+describe('shouldHandleMultiplayerMessagesOnMainThread', () => {
+ it('returns false when multiplayer is disabled', () => {
+ expect(
+ shouldHandleMultiplayerMessagesOnMainThread({
+ isMultiplayer: false,
+ multiplayerMessageHandling: 'main-thread',
+ })
+ ).toBe(false);
+ });
+
+ it('returns true for direct main-thread multiplayer handling', () => {
+ expect(
+ shouldHandleMultiplayerMessagesOnMainThread({
+ isMultiplayer: true,
+ multiplayerMessageHandling: 'main-thread',
+ })
+ ).toBe(true);
+ });
+
+ it('returns false when the worker owns multiplayer command handling', () => {
+ expect(
+ shouldHandleMultiplayerMessagesOnMainThread({
+ isMultiplayer: true,
+ multiplayerMessageHandling: 'worker',
+ })
+ ).toBe(false);
+ });
+});
diff --git a/tests/store/multiplayerStore.test.ts b/tests/store/multiplayerStore.test.ts
new file mode 100644
index 00000000..0589ed78
--- /dev/null
+++ b/tests/store/multiplayerStore.test.ts
@@ -0,0 +1,18 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { useMultiplayerStore } from '@/store/multiplayerStore';
+
+describe('multiplayerStore.reset', () => {
+ afterEach(() => {
+ useMultiplayerStore.getState().reset();
+ });
+
+ it('runs the preserved session cleanup callback on reset', () => {
+ const cleanup = vi.fn();
+
+ useMultiplayerStore.getState().setSessionCleanupCallback(cleanup);
+ useMultiplayerStore.getState().reset();
+
+ expect(cleanup).toHaveBeenCalledTimes(1);
+ expect(useMultiplayerStore.getState().sessionCleanupCallback).toBeNull();
+ });
+});