721 lines
29 KiB
JavaScript
721 lines
29 KiB
JavaScript
/**
|
|
* Game Initializer
|
|
* Handles initialization of multiplayer game modes
|
|
*/
|
|
|
|
console.log('[GAME INITIALIZER] GameInitializer.js script loaded');
|
|
|
|
class GameInitializer {
|
|
constructor() {
|
|
console.log('[GAME INITIALIZER] Constructor called');
|
|
this.gameMode = 'multiplayer';
|
|
this.serverData = null;
|
|
this.authToken = null;
|
|
this.currentUser = null;
|
|
this.socket = null;
|
|
this.apiBaseUrl = 'https://api.korvarix.com/api'; // API Server
|
|
this.gameServerUrl = 'https://dev.gameserver.galaxystrike.online'; // Game Server for Socket.IO (local dev server)
|
|
|
|
console.log('[GAME INITIALIZER] Constructor - gameServerUrl set to:', this.gameServerUrl);
|
|
}
|
|
|
|
updateServerUrls(apiUrl, gameUrl) {
|
|
console.log('[GAME INITIALIZER] Updating server URLs:', { apiUrl: apiUrl, gameUrl: gameUrl });
|
|
console.log('[GAME INITIALIZER] Previous gameServerUrl:', this.gameServerUrl);
|
|
this.apiBaseUrl = apiUrl;
|
|
this.gameServerUrl = gameUrl;
|
|
console.log('[GAME INITIALIZER] New gameServerUrl:', this.gameServerUrl);
|
|
}
|
|
|
|
initializeMultiplayer(server, serverData, authToken, currentUser) {
|
|
console.log('[GAME INITIALIZER] Initializing multiplayer game mode');
|
|
this.gameMode = 'multiplayer';
|
|
this.serverData = { ...server, ...serverData };
|
|
this.authToken = authToken;
|
|
this.currentUser = currentUser;
|
|
|
|
// Initialize Socket.IO connection
|
|
this.initializeSocketConnection();
|
|
|
|
// Set SmartSaveManager to multiplayer mode
|
|
if (window.smartSaveManager) {
|
|
window.smartSaveManager.setMultiplayerMode(true, this);
|
|
}
|
|
|
|
// Update UI for multiplayer mode
|
|
this.updateUIForMultiplayerMode();
|
|
|
|
console.log('[GAME INITIALIZER] Multiplayer game initialized');
|
|
}
|
|
|
|
initializeSocketConnection() {
|
|
if (!this.serverData) {
|
|
console.error('[GAME INITIALIZER] No server data for socket connection');
|
|
return;
|
|
}
|
|
|
|
console.log('[GAME INITIALIZER] Initializing Socket.IO connection');
|
|
console.log('[GAME INITIALIZER] Using gameServerUrl:', this.gameServerUrl);
|
|
|
|
// Check if we're in local mode and should use mock socket
|
|
if (this.gameServerUrl.includes('localhost') && window.localServerManager && window.localServerManager.localServer) {
|
|
console.log('[GAME INITIALIZER] Using mock socket for local mode');
|
|
this.socket = window.localServerManager.localServer.createMockSocket();
|
|
|
|
// Trigger connected event immediately since mock socket auto-connects
|
|
setTimeout(() => {
|
|
this.onSocketConnected();
|
|
}, 200);
|
|
|
|
return;
|
|
}
|
|
|
|
// FORCE THE URL - Override any undefined issues
|
|
const FORCED_URL = 'https://dev.gameserver.galaxystrike.online';
|
|
console.log('[GAME INITIALIZER] FORCING URL to:', FORCED_URL);
|
|
console.log('[GAME INITIALIZER] Original this.gameServerUrl:', this.gameServerUrl);
|
|
|
|
// Connect to the game server with FORCED URL
|
|
this.socket = io(FORCED_URL, {
|
|
auth: {
|
|
token: this.authToken,
|
|
serverId: this.serverData.id
|
|
}
|
|
});
|
|
|
|
console.log('[GAME INITIALIZER] Socket.IO connection initiated to FORCED URL:', FORCED_URL);
|
|
|
|
// Socket event handlers
|
|
this.socket.on('connect', () => {
|
|
console.log('[GAME INITIALIZER] Connected to server');
|
|
this.onSocketConnected();
|
|
});
|
|
|
|
this.socket.on('disconnect', () => {
|
|
console.log('[GAME INITIALIZER] Disconnected from server');
|
|
this.onSocketDisconnected();
|
|
});
|
|
|
|
this.socket.on('error', (error) => {
|
|
console.error('[GAME INITIALIZER] Socket error:', error);
|
|
});
|
|
|
|
this.socket.on('force_disconnect', (data) => {
|
|
console.warn('[GAME INITIALIZER] Force disconnected:', data);
|
|
this.onForceDisconnect(data);
|
|
});
|
|
|
|
// Game-specific events
|
|
this.socket.on('playerJoined', (data) => {
|
|
console.log('[GAME INITIALIZER] Player joined:', data);
|
|
this.onPlayerJoined(data);
|
|
});
|
|
|
|
this.socket.on('playerLeft', (data) => {
|
|
console.log('[GAME INITIALIZER] Player left:', data);
|
|
this.onPlayerLeft(data);
|
|
});
|
|
|
|
this.socket.on('gameUpdate', (data) => {
|
|
console.log('[GAME INITIALIZER] Game update:', data);
|
|
this.onGameUpdate(data);
|
|
});
|
|
|
|
this.socket.on('chatMessage', (data) => {
|
|
console.log('[GAME INITIALIZER] Chat message:', data);
|
|
this.onChatMessage(data);
|
|
});
|
|
|
|
// Server data events
|
|
this.socket.on('authenticated', (data) => {
|
|
console.log('[GAME INITIALIZER] Authentication response:', data);
|
|
this.onAuthenticated(data);
|
|
});
|
|
|
|
this.socket.on('gameDataLoaded', (data) => {
|
|
console.log('[GAME INITIALIZER] Game data loaded:', data);
|
|
this.onGameDataLoaded(data);
|
|
});
|
|
|
|
this.socket.on('updatePlayerStats', (data) => {
|
|
console.log('[GAME INITIALIZER] Player stats updated on server:', data);
|
|
this.onGameDataSaved(data);
|
|
});
|
|
|
|
this.socket.on('gameDataSaved', (data) => {
|
|
console.log('[GAME INITIALIZER] Game data saved:', data);
|
|
this.onGameDataSaved(data);
|
|
});
|
|
}
|
|
|
|
onSocketConnected() {
|
|
// Join the server room
|
|
this.socket.emit('joinServer', {
|
|
serverId: this.serverData.id,
|
|
userId: this.currentUser.userId,
|
|
username: this.currentUser.username
|
|
});
|
|
|
|
// Authenticate with server to get player data
|
|
this.authenticateWithServer();
|
|
|
|
// Show connected status
|
|
this.showConnectionStatus('Connected', 'success');
|
|
}
|
|
|
|
onSocketDisconnected() {
|
|
console.log('[GAME INITIALIZER] Socket disconnected - switching to singleplayer mode');
|
|
|
|
// Show disconnected status
|
|
this.showConnectionStatus('Disconnected', 'error');
|
|
|
|
// Switch SmartSaveManager back to singleplayer mode
|
|
if (window.smartSaveManager) {
|
|
window.smartSaveManager.setMultiplayerMode(false);
|
|
console.log('[GAME INITIALIZER] SmartSaveManager set to singleplayer mode');
|
|
}
|
|
|
|
// Clear socket reference
|
|
this.socket = null;
|
|
console.log('[GAME INITIALIZER] Socket reference cleared');
|
|
}
|
|
|
|
// Force disconnect from multiplayer server
|
|
forceDisconnect() {
|
|
console.log('[GAME INITIALIZER] Force disconnect called');
|
|
|
|
if (this.socket) {
|
|
console.log('[GAME INITIALIZER] Disconnecting socket...');
|
|
this.socket.disconnect();
|
|
this.socket = null;
|
|
}
|
|
|
|
// Switch to singleplayer mode
|
|
if (window.smartSaveManager) {
|
|
window.smartSaveManager.setMultiplayerMode(false);
|
|
console.log('[GAME INITIALIZER] Force switched to singleplayer mode');
|
|
}
|
|
|
|
this.showConnectionStatus('Disconnected', 'error');
|
|
console.log('[GAME INITIALIZER] Force disconnect completed');
|
|
}
|
|
|
|
onPlayerJoined(data) {
|
|
// Handle player joining
|
|
this.updatePlayerList();
|
|
this.showNotification(`${data.username} joined the server`, 'info');
|
|
}
|
|
|
|
onPlayerLeft(data) {
|
|
// Handle player leaving
|
|
this.updatePlayerList();
|
|
this.showNotification(`${data.username} left the server`, 'info');
|
|
}
|
|
|
|
onGameUpdate(data) {
|
|
// Handle game state updates
|
|
if (window.game && window.game.handleServerUpdate) {
|
|
window.game.handleServerUpdate(data);
|
|
}
|
|
}
|
|
|
|
onChatMessage(data) {
|
|
// Handle chat messages
|
|
if (window.game && window.game.handleChatMessage) {
|
|
window.game.handleChatMessage(data);
|
|
}
|
|
}
|
|
|
|
onAuthenticated(data) {
|
|
console.log('[GAME INITIALIZER] Authentication successful:', data);
|
|
|
|
if (data.success && data.playerData) {
|
|
// Store server player data from authentication (this is our primary source)
|
|
this.serverPlayerData = data.playerData;
|
|
console.log('[GAME INITIALIZER] Using authentication data as primary source:', this.serverPlayerData);
|
|
|
|
// NOW create GameEngine AFTER authentication is successful
|
|
if (!window.game) {
|
|
console.log('[GAME INITIALIZER] Creating GameEngine after successful authentication');
|
|
this.createGameEngineForMultiplayer();
|
|
}
|
|
|
|
// Set SmartSaveManager to multiplayer mode
|
|
if (window.smartSaveManager) {
|
|
window.smartSaveManager.setMultiplayerMode(true, this);
|
|
console.log('[GAME INITIALIZER] SmartSaveManager set to multiplayer mode');
|
|
|
|
// Apply authentication data immediately
|
|
window.smartSaveManager.applyServerDataToGame(data.playerData);
|
|
}
|
|
|
|
// Fallback: Apply authentication data to game if game is running
|
|
if (window.game && window.game.loadServerPlayerData) {
|
|
console.log('[GAME INITIALIZER] Applying authentication data to GameEngine:', data.playerData);
|
|
window.game.loadServerPlayerData(data.playerData);
|
|
console.log('[GAME INITIALIZER] Authentication data applied to GameEngine');
|
|
|
|
// Force UI refresh when authentication data is applied
|
|
if (window.game.systems && window.game.systems.ui && window.game.systems.ui.forceRefreshAllUI) {
|
|
console.log('[GAME INITIALIZER] Forcing UI refresh after authentication data application');
|
|
window.game.systems.ui.forceRefreshAllUI();
|
|
}
|
|
}
|
|
|
|
this.showNotification(`Welcome back! Level ${data.playerData.stats?.level || 1}`, 'success');
|
|
} else {
|
|
this.showNotification(data.error || 'Authentication failed', 'error');
|
|
}
|
|
}
|
|
|
|
createGameEngineForMultiplayer() {
|
|
console.log('[GAME INITIALIZER] Creating GameEngine for multiplayer mode');
|
|
console.log('[GAME INITIALIZER] Server player data available:', !!this.serverPlayerData);
|
|
|
|
try {
|
|
// Create GameEngine instance
|
|
window.game = new GameEngine();
|
|
|
|
// Initialize the game engine
|
|
console.log('[GAME INITIALIZER] About to call window.game.init()');
|
|
const initPromise = window.game.init();
|
|
console.log('[GAME INITIALIZER] GameEngine.init() returned:', typeof initPromise, initPromise);
|
|
|
|
initPromise.then(() => {
|
|
console.log('[GAME INITIALIZER] GameEngine initialized successfully for multiplayer');
|
|
|
|
// Apply server data immediately after initialization
|
|
if (this.serverPlayerData && window.game.loadServerPlayerData) {
|
|
console.log('[GAME INITIALIZER] Applying server player data to GameEngine:', this.serverPlayerData);
|
|
window.game.loadServerPlayerData(this.serverPlayerData);
|
|
console.log('[GAME INITIALIZER] Server player data applied to GameEngine');
|
|
|
|
// Force UI refresh
|
|
if (window.game.systems && window.game.systems.ui && window.game.systems.ui.forceRefreshAllUI) {
|
|
console.log('[GAME INITIALIZER] Forcing UI refresh after data application');
|
|
window.game.systems.ui.forceRefreshAllUI();
|
|
}
|
|
} else {
|
|
console.warn('[GAME INITIALIZER] No server player data or loadServerPlayerData method available');
|
|
}
|
|
|
|
// Start the game
|
|
if (window.game.start) {
|
|
window.game.start();
|
|
}
|
|
|
|
}).catch((error) => {
|
|
console.error('[GAME INITIALIZER] GameEngine init failed:', error);
|
|
console.error('[GAME INITIALIZER] Error details:', error.stack);
|
|
this.showNotification('Failed to initialize game engine', 'error');
|
|
});
|
|
|
|
} catch (error) {
|
|
console.error('[GAME INITIALIZER] Error creating GameEngine:', error);
|
|
this.showNotification('Error creating game engine', 'error');
|
|
}
|
|
}
|
|
|
|
onGameDataLoaded(data) {
|
|
console.log('[GAME INITIALIZER] Server game data loaded:', data);
|
|
console.log('[GAME INITIALIZER] Data success:', data.success);
|
|
console.log('[GAME INITIALIZER] Data content:', data.data);
|
|
console.log('[GAME INITIALIZER] Data keys:', data.data ? Object.keys(data.data) : 'No data object');
|
|
|
|
if (data.success && data.data && Object.keys(data.data).length > 0) {
|
|
// Store server player data
|
|
this.serverPlayerData = data.data;
|
|
|
|
console.log('[GAME INITIALIZER] Applying server data to game systems');
|
|
// Apply server data to game if game is running
|
|
if (window.game && window.game.loadServerPlayerData) {
|
|
window.game.loadServerPlayerData(data.data);
|
|
|
|
// Force UI refresh when server data is applied
|
|
if (window.game.systems && window.game.systems.ui && window.game.systems.ui.forceRefreshAllUI) {
|
|
window.game.systems.ui.forceRefreshAllUI();
|
|
}
|
|
} else {
|
|
console.warn('[GAME INITIALIZER] No game or loadServerPlayerData method available');
|
|
}
|
|
} else {
|
|
console.log('[GAME INITIALIZER] Ignoring empty game data - no player data to load');
|
|
console.log('[GAME INITIALIZER] Data analysis:', {
|
|
success: data.success,
|
|
hasData: !!data.data,
|
|
dataKeys: data.data ? Object.keys(data.data) : [],
|
|
dataLength: data.data ? JSON.stringify(data.data).length : 0
|
|
});
|
|
}
|
|
}
|
|
|
|
onGameDataSaved(data) {
|
|
console.log('[GAME INITIALIZER] Server game data saved:', data);
|
|
|
|
if (data.success) {
|
|
this.showNotification('Game saved to server!', 'success');
|
|
} else {
|
|
this.showNotification(data.error || 'Failed to save to server', 'error');
|
|
}
|
|
}
|
|
|
|
onForceDisconnect(data) {
|
|
// Handle forced disconnection from server
|
|
console.warn('[GAME INITIALIZER] Force disconnected by server:', data);
|
|
|
|
// Show notification to user
|
|
if (window.game && window.game.showNotification) {
|
|
window.game.showNotification(
|
|
`Disconnected: ${data.reason}`,
|
|
'warning',
|
|
10000
|
|
);
|
|
}
|
|
|
|
// Disconnect the socket
|
|
if (this.socket) {
|
|
this.socket.disconnect();
|
|
}
|
|
|
|
// Clean up multiplayer mode
|
|
if (window.game) {
|
|
window.game.setMultiplayerMode(false);
|
|
}
|
|
|
|
// Return to main menu after a delay
|
|
setTimeout(() => {
|
|
if (window.liveMainMenu) {
|
|
window.liveMainMenu.showLoginSection();
|
|
}
|
|
}, 2000);
|
|
}
|
|
|
|
initializeGameSystems() {
|
|
console.log('[GAME INITIALIZER] Initializing game systems');
|
|
|
|
// Wait for the main game script to be ready
|
|
if (typeof window.game !== 'undefined') {
|
|
console.log('[GAME INITIALIZER] window.game is available, calling setupGameSystems');
|
|
this.setupGameSystems();
|
|
} else {
|
|
console.log('[GAME INITIALIZER] window.game not available, waiting 100ms');
|
|
// Wait for the game to be initialized
|
|
setTimeout(() => this.initializeGameSystems(), 100);
|
|
}
|
|
}
|
|
|
|
setupGameSystems() {
|
|
if (!window.game) {
|
|
console.error('[GAME INITIALIZER] Game not available');
|
|
return;
|
|
}
|
|
|
|
console.log('[GAME INITIALIZER] Setting up game systems for multiplayer mode');
|
|
|
|
// Configure game for multiplayer mode
|
|
console.log('[GAME INITIALIZER] Configuring for multiplayer mode');
|
|
window.game.setMultiplayerMode(true, this.socket, this.serverData, this.currentUser);
|
|
window.game.gameInitializer = this; // Store reference for server polling
|
|
|
|
// DISABLE game logic in multiplayer - server is authoritative
|
|
if (window.game) {
|
|
console.log('[GAME INITIALIZER] Disabling client game logic - server is authoritative');
|
|
|
|
// Override game logic methods to do nothing in multiplayer
|
|
const originalUpdateGameLogic = window.game.updateGameLogic;
|
|
window.game.updateGameLogic = function() {
|
|
// In multiplayer mode, client does NO game logic
|
|
// Server is authoritative for ALL game data including credits
|
|
// Client is display-only
|
|
};
|
|
|
|
const originalStart = window.game.start;
|
|
window.game.start = function() {
|
|
console.log('[GAME ENGINE] Multiplayer mode - client does not run game logic, server is authoritative');
|
|
console.log('[GAME ENGINE] GameInitializer reference:', !!this.gameInitializer);
|
|
console.log('[GAME ENGINE] Socket reference:', !!(this.gameInitializer && this.gameInitializer.socket));
|
|
console.log('[GAME ENGINE] Game mode:', this.gameInitializer ? this.gameInitializer.gameMode : 'no gameInitializer');
|
|
|
|
this.isRunning = true;
|
|
|
|
// NO game logic timer - client is display-only
|
|
// Server handles all game logic including credit generation
|
|
|
|
// Start server data polling for UI updates
|
|
if (this.gameInitializer && this.gameInitializer.socket) {
|
|
console.log('[GAME ENGINE] Starting server data polling for UI updates');
|
|
this.serverPollTimer = setInterval(() => {
|
|
console.log('[GAME ENGINE] Polling server for data...');
|
|
this.gameInitializer.loadGameDataFromServer();
|
|
}, 5000); // Request updates every 5 seconds
|
|
} else {
|
|
console.warn('[GAME ENGINE] Cannot start server polling - no gameInitializer or socket');
|
|
}
|
|
|
|
// Only start UI updates that use server data (every second)
|
|
if (this.systems.ui) {
|
|
console.log('[GAME ENGINE] Starting multiplayer UI updates');
|
|
this.uiUpdateTimer = setInterval(() => {
|
|
if (this.systems && this.systems.ui && this.systems.ui.updateUI) {
|
|
console.log('[GAME ENGINE] Updating multiplayer UI with server data');
|
|
this.systems.ui.updateUI();
|
|
}
|
|
}, 1000);
|
|
}
|
|
};
|
|
}
|
|
|
|
// Game is already set up with save data, just start the game loop
|
|
if (window.game.start) {
|
|
// console.log('[GAME INITIALIZER] Calling start() to begin game loop');
|
|
window.game.start();
|
|
} else if (window.game.startGame) {
|
|
// console.log('[GAME INITIALIZER] Calling startGame(false) - save data already applied');
|
|
window.game.startGame(false); // false = don't load again (save data already applied)
|
|
} else {
|
|
console.error('[GAME INITIALIZER] No start method available on window.game');
|
|
}
|
|
|
|
console.log('[GAME INITIALIZER] Game systems configured');
|
|
}
|
|
|
|
updateUIForMultiplayerMode() {
|
|
// Update UI elements to show multiplayer mode
|
|
const playerName = document.getElementById('playerName');
|
|
if (playerName && this.currentUser) {
|
|
playerName.textContent = this.currentUser.username;
|
|
}
|
|
|
|
// Show multiplayer-specific UI elements
|
|
this.showMultiplayerUI();
|
|
|
|
// Show server info
|
|
this.showServerInfo();
|
|
}
|
|
|
|
hideMultiplayerUI() {
|
|
// Hide elements that are only relevant in multiplayer
|
|
const chatContainer = document.getElementById('chatContainer');
|
|
if (chatContainer) {
|
|
chatContainer.classList.add('hidden');
|
|
}
|
|
|
|
const playerList = document.getElementById('playerList');
|
|
if (playerList) {
|
|
playerList.classList.add('hidden');
|
|
}
|
|
}
|
|
|
|
showMultiplayerUI() {
|
|
// Show multiplayer-specific elements
|
|
const chatContainer = document.getElementById('chatContainer');
|
|
if (chatContainer) {
|
|
chatContainer.classList.remove('hidden');
|
|
}
|
|
|
|
const playerList = document.getElementById('playerList');
|
|
if (playerList) {
|
|
playerList.classList.remove('hidden');
|
|
}
|
|
}
|
|
|
|
showServerInfo() {
|
|
// Add server information to the UI
|
|
const header = document.querySelector('.game-header');
|
|
if (header && !header.querySelector('.server-info')) {
|
|
const serverInfo = document.createElement('div');
|
|
serverInfo.className = 'server-info';
|
|
serverInfo.innerHTML = `
|
|
<i class="fas fa-server"></i>
|
|
<span>${this.serverData.name} (${this.serverData.currentPlayers}/${this.serverData.maxPlayers})</span>
|
|
`;
|
|
serverInfo.style.cssText = `
|
|
background: rgba(0, 212, 255, 0.2);
|
|
color: #00d4ff;
|
|
padding: 4px 8px;
|
|
border-radius: 4px;
|
|
font-size: 0.8rem;
|
|
margin-left: 10px;
|
|
`;
|
|
header.appendChild(serverInfo);
|
|
}
|
|
}
|
|
|
|
showConnectionStatus(status, type) {
|
|
// Show connection status in the UI
|
|
const statusElement = document.getElementById('connectionStatus');
|
|
if (statusElement) {
|
|
statusElement.textContent = status;
|
|
statusElement.className = `connection-status ${type}`;
|
|
}
|
|
}
|
|
|
|
updatePlayerList() {
|
|
// Update the player list UI
|
|
if (this.socket && this.serverData) {
|
|
// Request updated player list from server
|
|
this.socket.emit('getPlayerList', { serverId: this.serverData.id });
|
|
}
|
|
}
|
|
|
|
showNotification(message, type = 'info') {
|
|
// Show a notification to the user
|
|
if (window.game && window.game.showNotification) {
|
|
window.game.showNotification(message, type, 3000);
|
|
} else {
|
|
// Fallback to alert
|
|
console.log(`[GAME INITIALIZER] Notification: ${message}`);
|
|
}
|
|
}
|
|
|
|
// Method to send actions to the server
|
|
sendGameAction(actionType, actionData) {
|
|
if (this.socket && this.gameMode === 'multiplayer') {
|
|
this.socket.emit('gameAction', {
|
|
type: actionType,
|
|
data: actionData,
|
|
userId: this.currentUser.userId,
|
|
serverId: this.serverData.id
|
|
});
|
|
}
|
|
}
|
|
|
|
// Method to send chat messages
|
|
sendChatMessage(message) {
|
|
if (this.socket && this.gameMode === 'multiplayer') {
|
|
this.socket.emit('chatMessage', {
|
|
message: message,
|
|
userId: this.currentUser.userId,
|
|
username: this.currentUser.username,
|
|
serverId: this.serverData.id
|
|
});
|
|
}
|
|
}
|
|
|
|
// Method to save game data to server (SECURE: only send specific updates)
|
|
saveGameDataToServer(gameData) {
|
|
if (this.socket && this.gameMode === 'multiplayer') {
|
|
console.log('[GAME INITIALIZER] Sending secure game updates to server');
|
|
|
|
// Only send specific, validated updates - not entire game state
|
|
const secureUpdates = {
|
|
playerStats: {
|
|
credits: gameData.player?.credits || 0,
|
|
level: gameData.player?.level || 1,
|
|
experience: gameData.player?.experience || 0,
|
|
playTime: gameData.player?.playTime || 0
|
|
},
|
|
timestamp: Date.now()
|
|
};
|
|
|
|
// Send only the specific updates for server validation
|
|
this.socket.emit('updatePlayerStats', secureUpdates);
|
|
}
|
|
}
|
|
|
|
// Method to load game data from server
|
|
loadGameDataFromServer() {
|
|
if (this.socket && this.gameMode === 'multiplayer') {
|
|
console.log('[GAME INITIALIZER] Loading game data from server');
|
|
console.log('[GAME INITIALIZER] Socket available:', !!this.socket);
|
|
console.log('[GAME INITIALIZER] Game mode:', this.gameMode);
|
|
console.log('[GAME INITIALIZER] Current user:', this.currentUser);
|
|
console.log('[GAME INITIALIZER] Emitting loadGameData event with username');
|
|
|
|
// Get username from current user or fallback to stored user
|
|
let username = 'anonymous'; // default fallback
|
|
if (this.currentUser?.username) {
|
|
username = this.currentUser.username;
|
|
} else {
|
|
// Try to get from localStorage as fallback
|
|
const storedUser = localStorage.getItem('currentUser');
|
|
if (storedUser) {
|
|
try {
|
|
const user = JSON.parse(storedUser);
|
|
username = user.username || 'anonymous';
|
|
} catch (e) {
|
|
console.warn('[GAME INITIALIZER] Failed to parse stored user, using default');
|
|
}
|
|
}
|
|
}
|
|
|
|
console.log('[GAME INITIALIZER] Using username for data load:', username);
|
|
|
|
// Send the username to load the correct player data
|
|
this.socket.emit('loadGameData', {
|
|
username: username
|
|
});
|
|
} else {
|
|
console.log('[GAME INITIALIZER] Cannot load game data - socket or multiplayer mode not available');
|
|
console.log('[GAME INITIALIZER] Socket available:', !!this.socket);
|
|
console.log('[GAME INITIALIZER] Game mode:', this.gameMode);
|
|
}
|
|
}
|
|
|
|
// Method to authenticate with server
|
|
authenticateWithServer() {
|
|
console.log('[GAME INITIALIZER] authenticateWithServer called');
|
|
console.log('[GAME INITIALIZER] Socket available:', !!this.socket);
|
|
console.log('[GAME INITIALIZER] Game mode:', this.gameMode);
|
|
console.log('[GAME INITIALIZER] Current user:', this.currentUser);
|
|
|
|
if (this.socket && this.currentUser) {
|
|
console.log('[GAME INITIALIZER] Sending authentication to server');
|
|
this.socket.emit('authenticate', {
|
|
userId: this.currentUser.userId,
|
|
username: this.currentUser.username
|
|
});
|
|
} else {
|
|
console.warn('[GAME INITIALIZER] Cannot authenticate - missing socket or user data');
|
|
if (!this.socket) {
|
|
console.warn('[GAME INITIALIZER] Socket is null/undefined');
|
|
}
|
|
if (!this.currentUser) {
|
|
console.warn('[GAME INITIALIZER] Current user is null/undefined');
|
|
}
|
|
}
|
|
}
|
|
|
|
// Cleanup method
|
|
cleanup() {
|
|
console.log('[GAME INITIALIZER] Cleaning up');
|
|
|
|
// Reset SmartSaveManager to singleplayer mode
|
|
if (window.smartSaveManager) {
|
|
window.smartSaveManager.setMultiplayerMode(false);
|
|
}
|
|
|
|
if (this.socket) {
|
|
this.socket.disconnect();
|
|
this.socket = null;
|
|
}
|
|
|
|
this.gameMode = null;
|
|
this.serverData = null;
|
|
this.authToken = null;
|
|
this.currentUser = null;
|
|
this.serverPlayerData = null;
|
|
}
|
|
}
|
|
|
|
// Create global instance
|
|
window.gameInitializer = new GameInitializer();
|
|
|
|
// Make force disconnect available globally for testing
|
|
window.forceDisconnectMultiplayer = function() {
|
|
if (window.gameInitializer && window.gameInitializer.forceDisconnect) {
|
|
window.gameInitializer.forceDisconnect();
|
|
} else {
|
|
console.log('[GAME INITIALIZER] GameInitializer not available for force disconnect');
|
|
}
|
|
};
|
|
|
|
// Debug: Log the global instance immediately
|
|
console.log('[GAME INITIALIZER] Global instance created:', window.gameInitializer);
|
|
console.log('[GAME INITIALIZER] Global instance gameServerUrl:', window.gameInitializer.gameServerUrl);
|
|
|
|
// Export for use in other scripts
|
|
if (typeof module !== 'undefined' && module.exports) {
|
|
module.exports = GameInitializer;
|
|
}
|