' };
+ }
+ const shipId = args[0];
+ if (window.game && window.game.systems && window.game.systems.ship) {
+ const ship = window.game.systems.ship.ships.find(s => s.id === shipId);
+ if (ship) {
+ ship.status = 'inactive';
+ window.game.systems.ship.renderShips();
+ return { type: 'success', message: `Unlocked ship: ${ship.name}` };
+ } else {
+ return { type: 'error', message: `Ship not found: ${shipId}` };
+ }
+ }
+ return { type: 'error', message: 'Ship system not available' };
+
+ case 'stats':
+ if (window.game && window.game.systems && window.game.systems.player && window.game.systems.economy) {
+ const player = window.game.systems.player;
+ const economy = window.game.systems.economy;
+ return {
+ type: 'info',
+ message: `Player Stats:\nLevel: ${player.stats.level}\nExperience: ${player.stats.experience}/${player.stats.experienceToNext}\nCredits: ${economy.credits}\nGems: ${economy.gems}\nTotal Kills: ${player.stats.totalKills}\nDungeons Cleared: ${player.stats.dungeonsCleared}\nTitle: ${player.info.title}`
+ };
+ }
+ return { type: 'error', message: 'Player or Economy system not available' };
+
+ case 'ships':
+ if (window.game && window.game.systems && window.game.systems.ship) {
+ const ships = window.game.systems.ship.ships;
+ const currentShip = window.game.systems.ship.currentShip;
+ const shipList = ships.map(ship =>
+ `- ${ship.name} (${ship.id}) - Level ${ship.level} - ${ship.status} - ${ship.rarity}${currentShip.id === ship.id ? ' [CURRENT]' : ''}`
+ ).join('\n');
+ return {
+ type: 'info',
+ message: `Available Ships:\n${shipList}`
+ };
+ }
+ return { type: 'error', message: 'Ship system not available' };
+
+ case 'current':
+ if (window.game && window.game.systems && window.game.systems.ship) {
+ const currentShip = window.game.systems.ship.currentShip;
+ if (currentShip) {
+ return {
+ type: 'info',
+ message: `Current Ship:
+- Name: ${currentShip.name}
+- Class: ${currentShip.class}
+- Level: ${currentShip.level}
+- Health: ${currentShip.health}/${currentShip.maxHealth}
+- Attack: ${currentShip.attack}
+- Defense: ${currentShip.defense}
+- Speed: ${currentShip.speed}
+- Rarity: ${currentShip.rarity}`
+ };
+ }
+ }
+ return { type: 'error', message: 'Ship system not available' };
+
+ default:
+ return { type: 'error', message: `Unknown command: ${cmd}. Type 'help' for available commands.` };
+ }
+}
+
+// Keyboard shortcut listener
+document.addEventListener('DOMContentLoaded', function() {
+ console.log('[DEBUG] DOMContentLoaded event fired for keyboard shortcuts');
+ document.addEventListener('keydown', function(event) {
+ // Log all key combinations for debugging
+ if (event.ctrlKey || event.altKey || event.shiftKey) {
+ console.log('[DEBUG] Key pressed:', {
+ key: event.key,
+ ctrlKey: event.ctrlKey,
+ altKey: event.altKey,
+ shiftKey: event.shiftKey,
+ code: event.code
+ });
+ }
+
+ // Ctrl+Alt+Shift+C to toggle console
+ if (event.ctrlKey && event.altKey && event.shiftKey && event.key === 'C') {
+ console.log('[DEBUG] Ctrl+Alt+Shift+C detected!');
+ event.preventDefault();
+
+ // Check if toggleConsole function exists
+ if (typeof toggleConsole === 'function') {
+ console.log('[DEBUG] toggleConsole function exists, calling it');
+ toggleConsole();
+ } else {
+ console.error('[DEBUG] toggleConsole function not found!');
+ }
+ }
+
+ // Escape to close console
+ if (event.key === 'Escape') {
+ const consoleWindow = document.getElementById('consoleWindow');
+ if (consoleWindow && consoleWindow.style.display === 'flex') {
+ consoleWindow.style.display = 'none';
+ }
+ }
+ });
+});
+
+// Initialize console output with welcome message
+document.addEventListener('DOMContentLoaded', function() {
+ const output = document.getElementById('consoleOutput');
+ if (output) {
+ const welcomeLine = document.createElement('div');
+ welcomeLine.className = 'console-line console-info';
+ welcomeLine.textContent = 'Developer Console ready. Type "help" for available commands.';
+ output.appendChild(welcomeLine);
+ }
+});
diff --git a/Client-Server/js/systems/BaseSystem.js b/Client-Server/js/systems/BaseSystem.js
new file mode 100644
index 0000000..b5acea3
--- /dev/null
+++ b/Client-Server/js/systems/BaseSystem.js
@@ -0,0 +1,2188 @@
+/**
+ * Galaxy Strike Online - Base System
+ * Manages player base building and customization
+ */
+
+class BaseSystem {
+ constructor(gameEngine) {
+ const debugLogger = window.debugLogger;
+
+ if (debugLogger) debugLogger.startStep('BaseSystem.constructor', {
+ gameEngineProvided: !!gameEngine
+ });
+
+ this.game = gameEngine;
+
+ // Base configuration
+ this.base = {
+ name: 'Command Center Alpha',
+ level: 1,
+ experience: 0,
+ experienceToNext: 500,
+ rooms: [],
+ decorations: [],
+ power: 100,
+ maxPower: 100,
+ storage: 1000,
+ maxStorage: 1000
+ };
+
+ if (debugLogger) debugLogger.logStep('Base configuration initialized', {
+ baseName: this.base.name,
+ baseLevel: this.base.level,
+ initialPower: this.base.power,
+ maxPower: this.base.maxPower,
+ initialStorage: this.base.storage,
+ maxStorage: this.base.maxStorage
+ });
+
+ // Room types
+ this.roomTypes = {
+ command_center: {
+ name: 'Command Center',
+ description: 'Central control room for your operations',
+ size: 'large',
+ powerCost: 20,
+ storageBonus: 0,
+ buildCost: 0,
+ requiredLevel: 1,
+ maxLevel: 1,
+ icon: 'fa-satellite-dish'
+ },
+ barracks: {
+ name: 'Barracks',
+ description: 'Housing for crew and allies',
+ size: 'medium',
+ powerCost: 10,
+ storageBonus: 100,
+ buildCost: 500,
+ requiredLevel: 2,
+ maxLevel: 5,
+ icon: 'fa-home'
+ },
+ laboratory: {
+ name: 'Laboratory',
+ description: 'Research facility for new technologies',
+ size: 'medium',
+ powerCost: 15,
+ storageBonus: 50,
+ buildCost: 1000,
+ requiredLevel: 3,
+ maxLevel: 5,
+ icon: 'fa-flask'
+ },
+ workshop: {
+ name: 'Workshop',
+ description: 'Crafting and equipment modification station',
+ size: 'medium',
+ powerCost: 12,
+ storageBonus: 80,
+ buildCost: 800,
+ requiredLevel: 2,
+ maxLevel: 5,
+ icon: 'fa-hammer'
+ },
+ storage_bay: {
+ name: 'Storage Bay',
+ description: 'Additional storage for resources and items',
+ size: 'large',
+ powerCost: 5,
+ storageBonus: 500,
+ buildCost: 300,
+ requiredLevel: 1,
+ maxLevel: 10,
+ icon: 'fa-warehouse'
+ },
+ power_generator: {
+ name: 'Power Generator',
+ description: 'Generates power for base operations',
+ size: 'small',
+ powerCost: -25,
+ storageBonus: 0,
+ buildCost: 600,
+ requiredLevel: 2,
+ maxLevel: 5,
+ icon: 'fa-bolt'
+ },
+ defense_turret: {
+ name: 'Defense Turret',
+ description: 'Automated defense system',
+ size: 'small',
+ powerCost: 8,
+ storageBonus: 0,
+ buildCost: 400,
+ requiredLevel: 3,
+ maxLevel: 8,
+ icon: 'fa-crosshairs'
+ },
+ communication_array: {
+ name: 'Communication Array',
+ description: 'Long-range communication and scanning',
+ size: 'medium',
+ powerCost: 10,
+ storageBonus: 20,
+ buildCost: 700,
+ requiredLevel: 4,
+ maxLevel: 3,
+ icon: 'fa-broadcast-tower'
+ },
+ medical_bay: {
+ name: 'Medical Bay',
+ description: 'Health restoration and crew recovery',
+ size: 'medium',
+ powerCost: 12,
+ storageBonus: 30,
+ buildCost: 900,
+ requiredLevel: 3,
+ maxLevel: 4,
+ icon: 'fa-medkit'
+ },
+ recreation_room: {
+ name: 'Recreation Room',
+ description: 'Crew morale and relaxation facilities',
+ size: 'small',
+ powerCost: 6,
+ storageBonus: 10,
+ buildCost: 350,
+ requiredLevel: 2,
+ maxLevel: 3,
+ icon: 'fa-gamepad'
+ }
+ };
+
+ // Base upgrades
+ this.upgrades = {
+ power_efficiency: {
+ name: 'Power Efficiency',
+ description: 'Reduces power consumption of all rooms',
+ cost: 1000,
+ effect: { powerReduction: 0.1 },
+ maxLevel: 5,
+ currentLevel: 0
+ },
+ storage_expansion: {
+ name: 'Storage Expansion',
+ description: 'Increases inventory slots for item storage',
+ cost: 5000,
+ maxLevel: 10,
+ currentLevel: 0,
+ icon: 'fa-boxes',
+ slotBonus: 5 // +5 slots per level
+ },
+ automation_systems: {
+ name: 'Automation Systems',
+ description: 'Automated resource collection and processing',
+ cost: 1500,
+ effect: {
+ productionBonus: 0.2 // +20% production
+ },
+ maxLevel: 5,
+ currentLevel: 0
+ },
+ advanced_defenses: {
+ name: 'Advanced Defenses',
+ description: 'Improved base defense systems',
+ cost: 2000,
+ effect: { defenseBonus: 10 },
+ maxLevel: 3,
+ currentLevel: 0
+ }
+ };
+
+ // Base grid layout (10x10)
+ this.gridSize = 10;
+ this.grid = [];
+
+ if (debugLogger) debugLogger.logStep('Grid configuration initialized', {
+ gridSize: this.gridSize,
+ gridInitialized: false
+ });
+
+ // Initialize grid
+ this.initializeGrid();
+
+ if (debugLogger) debugLogger.endStep('BaseSystem.constructor', {
+ roomTypesCount: Object.keys(this.roomTypes).length,
+ upgradesCount: Object.keys(this.upgrades).length,
+ gridSize: this.gridSize,
+ gridInitialized: !!this.grid,
+ baseConfiguration: this.base
+ });
+ }
+
+ initializeBaseData() {
+ const debugLogger = window.debugLogger;
+
+ if (debugLogger) debugLogger.startStep('BaseSystem.initializeBaseData', {
+ oldBaseName: this.base.name,
+ oldBaseLevel: this.base.level
+ });
+
+ // Initialize base with default values
+ this.base = {
+ name: 'Command Center Alpha',
+ level: 1,
+ experience: 0,
+ experienceToNext: 500,
+ rooms: [],
+ decorations: [],
+ power: 100,
+ maxPower: 100,
+ storage: 1000,
+ maxStorage: 1000
+ };
+
+ // Initialize resources
+ this.resources = {
+ energy: 100,
+ materials: 50,
+ research: 0
+ };
+
+ if (debugLogger) debugLogger.endStep('BaseSystem.initializeBaseData', {
+ newBaseName: this.base.name,
+ newBaseLevel: this.base.level,
+ roomsCount: this.base.rooms.length,
+ decorationsCount: this.base.decorations.length,
+ resourcesInitialized: this.resources
+ });
+ }
+
+ initialize() {
+ const debugLogger = window.debugLogger;
+
+ if (debugLogger) debugLogger.startStep('BaseSystem.initialize', {
+ currentBaseLevel: this.base.level,
+ roomsCount: this.base.rooms.length
+ });
+
+ // Initialize base data
+ if (debugLogger) debugLogger.logStep('Initializing base data');
+ this.initializeBaseData();
+
+ // Initialize inventory bonus slots on game start
+ if (debugLogger) debugLogger.logStep('Updating inventory bonus slots');
+ this.updateInventoryBonusSlots();
+
+ if (debugLogger) debugLogger.endStep('BaseSystem.initialize', {
+ baseDataInitialized: true,
+ inventoryBonusSlotsUpdated: true
+ });
+ }
+
+ async initialize() {
+ const debugLogger = window.debugLogger;
+
+ if (debugLogger) debugLogger.startStep('BaseSystem.asyncInitialize', {
+ currentBaseLevel: this.base.level,
+ roomsCount: this.base.rooms.length
+ });
+
+ // Start with command center
+ if (debugLogger) debugLogger.logStep('Adding command center room');
+ this.addRoom('command_center', 5, 5);
+
+ // Set up base navigation
+ if (debugLogger) debugLogger.logStep('Setting up base navigation');
+ this.setupBaseNavigation();
+
+ // Initialize ship gallery
+ if (debugLogger) debugLogger.logStep('Initializing ship gallery');
+ this.initializeShipGallery();
+
+ // Initialize starbase system
+ if (debugLogger) debugLogger.logStep('Initializing starbase system');
+ this.initializeStarbaseSystem();
+
+ if (debugLogger) debugLogger.endStep('BaseSystem.asyncInitialize', {
+ commandCenterAdded: true,
+ navigationSetup: true,
+ shipGalleryInitialized: true,
+ starbaseSystemInitialized: true
+ });
+ }
+
+ initializeGrid() {
+ const debugLogger = window.debugLogger;
+
+ if (debugLogger) debugLogger.startStep('BaseSystem.initializeGrid', {
+ gridSize: this.gridSize
+ });
+
+ this.grid = [];
+ for (let y = 0; y < this.gridSize; y++) {
+ this.grid[y] = [];
+ for (let x = 0; x < this.gridSize; x++) {
+ this.grid[y][x] = null;
+ }
+ }
+
+ if (debugLogger) debugLogger.endStep('BaseSystem.initializeGrid', {
+ gridSize: this.gridSize,
+ gridCreated: true,
+ totalCells: this.gridSize * this.gridSize
+ });
+ }
+
+ // Room management
+ getRoomAt(x, y) {
+ const debugLogger = window.debugLogger;
+
+ if (debugLogger) debugLogger.log('BaseSystem.getRoomAt called', {
+ x: x,
+ y: y,
+ gridSize: this.gridSize
+ });
+
+ // Check if coordinates are within grid bounds
+ if (x < 0 || x >= this.gridSize || y < 0 || y >= this.gridSize) {
+ if (debugLogger) debugLogger.log('Coordinates out of bounds', {
+ x: x,
+ y: y,
+ gridSize: this.gridSize
+ });
+ return null;
+ }
+
+ // Ensure grid exists
+ if (!this.grid || !this.grid[y]) {
+ console.log('[BASE SYSTEM] Grid not properly initialized in getRoomAt');
+ if (debugLogger) debugLogger.log('Grid not properly initialized', {
+ gridExists: !!this.grid,
+ gridRowExists: !!(this.grid && this.grid[y]),
+ y: y
+ });
+ return null;
+ }
+
+ // Get room ID from grid
+ const roomId = this.grid[y][x];
+ if (!roomId) {
+ if (debugLogger) debugLogger.log('No room at coordinates', {
+ x: x,
+ y: y,
+ roomId: roomId
+ });
+ return null;
+ }
+
+ // Find room by ID
+ const room = this.base.rooms.find(r => r.id === roomId) || null;
+
+ if (debugLogger) debugLogger.log('Room found at coordinates', {
+ x: x,
+ y: y,
+ roomId: roomId,
+ roomFound: !!room,
+ roomName: room ? room.name : null,
+ roomType: room ? room.type : null
+ });
+
+ return room;
+ }
+
+ canBuildRoom(roomType, x, y) {
+ const debugLogger = window.debugLogger;
+
+ if (debugLogger) debugLogger.startStep('BaseSystem.canBuildRoom', {
+ roomType: roomType,
+ x: x,
+ y: y,
+ currentBaseLevel: this.base.level,
+ currentCredits: this.game.systems.economy.credits,
+ currentRooms: this.base.rooms.length
+ });
+
+ const roomTemplate = this.roomTypes[roomType];
+ if (!roomTemplate) {
+ if (debugLogger) debugLogger.endStep('BaseSystem.canBuildRoom', {
+ success: false,
+ reason: 'Room template not found',
+ roomType: roomType
+ });
+ return false;
+ }
+
+ if (debugLogger) debugLogger.logStep('Room template found', {
+ roomName: roomTemplate.name,
+ requiredLevel: roomTemplate.requiredLevel,
+ buildCost: roomTemplate.buildCost,
+ powerCost: roomTemplate.powerCost,
+ maxLevel: roomTemplate.maxLevel
+ });
+
+ // Check player level
+ if (this.game.systems.player.stats.level < roomTemplate.requiredLevel) {
+ if (debugLogger) debugLogger.endStep('BaseSystem.canBuildRoom', {
+ success: false,
+ reason: 'Player level too low',
+ playerLevel: this.game.systems.player.stats.level,
+ requiredLevel: roomTemplate.requiredLevel
+ });
+ return false;
+ }
+
+ // Check resources
+ if (this.game.systems.economy.credits < roomTemplate.buildCost) {
+ if (debugLogger) debugLogger.endStep('BaseSystem.canBuildRoom', {
+ success: false,
+ reason: 'Insufficient credits',
+ currentCredits: this.game.systems.economy.credits,
+ requiredCredits: roomTemplate.buildCost
+ });
+ return false;
+ }
+
+ // Check if room already exists at max level
+ const existingRoom = this.base.rooms.find(r => r.type === roomType);
+ if (existingRoom && existingRoom.level >= roomTemplate.maxLevel) {
+ if (debugLogger) debugLogger.endStep('BaseSystem.canBuildRoom', {
+ success: false,
+ reason: 'Room already at max level',
+ roomType: roomType,
+ currentLevel: existingRoom.level,
+ maxLevel: roomTemplate.maxLevel
+ });
+ return false;
+ }
+
+ // Check grid placement
+ const roomSize = this.getRoomSize(roomTemplate.size);
+ if (!this.canPlaceRoom(x, y, roomSize.width, roomSize.height)) {
+ if (debugLogger) debugLogger.endStep('BaseSystem.canBuildRoom', {
+ success: false,
+ reason: 'Cannot place room at location',
+ x: x,
+ y: y,
+ roomSize: roomSize
+ });
+ return false;
+ }
+
+ // Check power availability
+ const powerRequirement = roomTemplate.powerCost;
+ if (this.base.power + powerRequirement > this.base.maxPower) {
+ if (debugLogger) debugLogger.endStep('BaseSystem.canBuildRoom', {
+ success: false,
+ reason: 'Insufficient power',
+ currentPower: this.base.power,
+ powerRequirement: powerRequirement,
+ maxPower: this.base.maxPower,
+ totalPowerNeeded: this.base.power + powerRequirement
+ });
+ return false;
+ }
+
+ if (debugLogger) debugLogger.endStep('BaseSystem.canBuildRoom', {
+ success: true,
+ roomType: roomType,
+ roomName: roomTemplate.name,
+ x: x,
+ y: y,
+ isUpgrade: !!existingRoom,
+ currentLevel: existingRoom ? existingRoom.level : 0
+ });
+
+ return true;
+ }
+
+ getRoomSize(size) {
+ const sizes = {
+ small: { width: 1, height: 1 },
+ medium: { width: 2, height: 2 },
+ large: { width: 3, height: 3 }
+ };
+ return sizes[size] || sizes.medium;
+ }
+
+ canPlaceRoom(x, y, width, height) {
+ // Check bounds
+ if (x < 0 || y < 0 || x + width > this.gridSize || y + height > this.gridSize) {
+ return false;
+ }
+
+ // Check for collisions
+ for (let dy = 0; dy < height; dy++) {
+ for (let dx = 0; dx < width; dx++) {
+ if (this.grid[y + dy][x + dx] !== null) {
+ return false;
+ }
+ }
+ }
+
+ return true;
+ }
+
+ addRoom(roomType, x, y) {
+ const debugLogger = window.debugLogger;
+
+ if (debugLogger) debugLogger.startStep('BaseSystem.addRoom', {
+ roomType: roomType,
+ x: x,
+ y: y,
+ currentRoomsCount: this.base.rooms.length,
+ currentCredits: this.game.systems.economy.credits
+ });
+
+ if (!this.canBuildRoom(roomType, x, y)) {
+ if (debugLogger) debugLogger.endStep('BaseSystem.addRoom', {
+ success: false,
+ reason: 'Cannot build room - failed validation',
+ roomType: roomType,
+ x: x,
+ y: y
+ });
+ return false;
+ }
+
+ const roomTemplate = this.roomTypes[roomType];
+ const roomSize = this.getRoomSize(roomTemplate.size);
+
+ if (debugLogger) debugLogger.logStep('Room validation passed', {
+ roomName: roomTemplate.name,
+ roomSize: roomSize,
+ buildCost: roomTemplate.buildCost
+ });
+
+ // Check if upgrading existing room
+ const existingRoom = this.base.rooms.find(r => r.type === roomType);
+ const isUpgrade = !!existingRoom;
+
+ if (isUpgrade) {
+ if (debugLogger) debugLogger.logStep('Upgrading existing room', {
+ roomId: existingRoom.id,
+ currentLevel: existingRoom.level,
+ newLevel: existingRoom.level + 1
+ });
+
+ // Upgrade existing room
+ existingRoom.level++;
+ existingRoom.powerCost = roomTemplate.powerCost * existingRoom.level;
+ existingRoom.storageBonus = roomTemplate.storageBonus * existingRoom.level;
+ } else {
+ if (debugLogger) debugLogger.logStep('Creating new room', {
+ roomType: roomType,
+ roomName: roomTemplate.name,
+ x: x,
+ y: y,
+ roomSize: roomSize
+ });
+
+ // Create new room
+ const room = {
+ id: Date.now().toString(),
+ type: roomType,
+ name: roomTemplate.name,
+ level: 1,
+ x: x,
+ y: y,
+ width: roomSize.width,
+ height: roomSize.height,
+ powerCost: roomTemplate.powerCost,
+ storageBonus: roomTemplate.storageBonus,
+ icon: roomTemplate.icon,
+ description: roomTemplate.description
+ };
+
+ this.base.rooms.push(room);
+
+ // Place on grid
+ for (let dy = 0; dy < roomSize.height; dy++) {
+ for (let dx = 0; dx < roomSize.width; dx++) {
+ this.grid[y + dy][x + dx] = room.id;
+ }
+ }
+
+ if (debugLogger) debugLogger.logStep('New room placed on grid', {
+ roomId: room.id,
+ gridPositions: roomSize.width * roomSize.height
+ });
+ }
+
+ // Update base stats
+ if (debugLogger) debugLogger.logStep('Updating base stats');
+ this.updateBaseStats();
+
+ // Deduct cost
+ const oldCredits = this.game.systems.economy.credits;
+ this.game.systems.economy.removeCredits(roomTemplate.buildCost);
+
+ if (debugLogger) debugLogger.logStep('Build cost deducted', {
+ buildCost: roomTemplate.buildCost,
+ oldCredits: oldCredits,
+ newCredits: this.game.systems.economy.credits
+ });
+
+ this.game.showNotification(`${roomTemplate.name} ${isUpgrade ? 'upgraded' : 'built'}!`, 'success', 3000);
+
+ if (debugLogger) debugLogger.endStep('BaseSystem.addRoom', {
+ success: true,
+ roomType: roomType,
+ roomName: roomTemplate.name,
+ isUpgrade: isUpgrade,
+ roomId: isUpgrade ? existingRoom.id : this.base.rooms[this.base.rooms.length - 1].id,
+ newLevel: isUpgrade ? existingRoom.level : 1,
+ finalRoomsCount: this.base.rooms.length,
+ buildCost: roomTemplate.buildCost,
+ finalCredits: this.game.systems.economy.credits
+ });
+
+ return true;
+ }
+
+ removeRoom(roomId) {
+ const debugLogger = window.debugLogger;
+
+ if (debugLogger) debugLogger.startStep('BaseSystem.removeRoom', {
+ roomId: roomId,
+ currentRoomsCount: this.base.rooms.length
+ });
+
+ const roomIndex = this.base.rooms.findIndex(r => r.id === roomId);
+ if (roomIndex === -1) {
+ if (debugLogger) debugLogger.endStep('BaseSystem.removeRoom', {
+ success: false,
+ reason: 'Room not found',
+ roomId: roomId
+ });
+ return false;
+ }
+
+ const room = this.base.rooms[roomIndex];
+
+ if (debugLogger) debugLogger.logStep('Room found for removal', {
+ roomId: room.id,
+ roomName: room.name,
+ roomType: room.type,
+ roomLevel: room.level,
+ roomPosition: { x: room.x, y: room.y }
+ });
+
+ // Don't allow removing command center
+ if (room.type === 'command_center') {
+ this.game.showNotification('Cannot remove Command Center', 'error', 3000);
+
+ if (debugLogger) debugLogger.endStep('BaseSystem.removeRoom', {
+ success: false,
+ reason: 'Cannot remove command center',
+ roomId: roomId,
+ roomType: room.type
+ });
+ return false;
+ }
+
+ // Remove from grid
+ let gridCellsCleared = 0;
+ for (let dy = 0; dy < room.height; dy++) {
+ for (let dx = 0; dx < room.width; dx++) {
+ this.grid[room.y + dy][room.x + dx] = null;
+ gridCellsCleared++;
+ }
+ }
+
+ if (debugLogger) debugLogger.logStep('Room removed from grid', {
+ gridCellsCleared: gridCellsCleared,
+ roomSize: { width: room.width, height: room.height }
+ });
+
+ // Remove from rooms array
+ this.base.rooms.splice(roomIndex, 1);
+
+ if (debugLogger) debugLogger.logStep('Room removed from rooms array', {
+ removedIndex: roomIndex,
+ remainingRoomsCount: this.base.rooms.length
+ });
+
+ // Update base stats
+ if (debugLogger) debugLogger.logStep('Updating base stats after removal');
+ this.updateBaseStats();
+
+ // Refund some resources
+ const refundAmount = Math.floor(this.roomTypes[room.type].buildCost * 0.5);
+ const oldCredits = this.game.systems.economy.credits;
+ this.game.systems.economy.addCredits(refundAmount, 'room_refund');
+
+ if (debugLogger) debugLogger.logStep('Refund processed', {
+ refundAmount: refundAmount,
+ oldCredits: oldCredits,
+ newCredits: this.game.systems.economy.credits,
+ originalBuildCost: this.roomTypes[room.type].buildCost,
+ refundPercentage: 0.5
+ });
+
+ this.game.showNotification(`${room.name} removed. Refunded ${refundAmount} credits`, 'info', 3000);
+
+ if (debugLogger) debugLogger.endStep('BaseSystem.removeRoom', {
+ success: true,
+ roomId: roomId,
+ roomName: room.name,
+ roomType: room.type,
+ refundAmount: refundAmount,
+ finalRoomsCount: this.base.rooms.length,
+ finalCredits: this.game.systems.economy.credits
+ });
+
+ return true;
+ }
+
+ calculateBaseStats() {
+ const debugLogger = window.debugLogger;
+
+ if (debugLogger) debugLogger.startStep('BaseSystem.calculateBaseStats', {
+ currentRoomsCount: this.base.rooms.length,
+ currentPower: this.base.power,
+ currentMaxPower: this.base.maxPower,
+ currentStorage: this.base.storage,
+ currentMaxStorage: this.base.maxStorage
+ });
+
+ let totalPowerCost = 0;
+ let totalStorageBonus = 0;
+
+ // Calculate power cost and storage bonus from rooms
+ this.base.rooms.forEach(room => {
+ const roomType = this.roomTypes[room.type];
+ const roomPowerCost = roomType.powerCost * room.level;
+ const roomStorageBonus = roomType.storageBonus * room.level;
+
+ totalPowerCost += roomPowerCost;
+ totalStorageBonus += roomStorageBonus;
+
+ if (debugLogger) debugLogger.logStep('Room contribution calculated', {
+ roomId: room.id,
+ roomType: room.type,
+ roomName: room.name,
+ roomLevel: room.level,
+ powerCost: roomPowerCost,
+ storageBonus: roomStorageBonus
+ });
+ });
+
+ // Add upgrade bonuses
+ const storageExpansion = (this.upgrades.storage_expansion?.currentLevel || 0) * (this.upgrades.storage_expansion?.slotBonus || 5);
+ totalStorageBonus += storageExpansion;
+
+ if (debugLogger) debugLogger.logStep('Upgrade bonuses calculated', {
+ storageExpansionLevel: this.upgrades.storage_expansion?.currentLevel || 0,
+ storageExpansionBonus: storageExpansion,
+ totalStorageBonusWithUpgrades: totalStorageBonus
+ });
+
+ const oldPower = this.base.power;
+ const oldMaxPower = this.base.maxPower;
+ const oldStorage = this.base.storage;
+ const oldMaxStorage = this.base.maxStorage;
+
+ this.base.power = Math.max(0, totalPowerCost);
+ this.base.maxPower = 100 + ((this.upgrades.power_efficiency?.currentLevel || 0) * 20);
+
+ // Update inventory base slots with storage upgrades
+ if (this.game.systems.inventory) {
+ const newBaseSlots = 30 + totalStorageBonus; // 30 base + storage bonuses
+ const oldBaseSlots = this.game.systems.inventory.baseMaxSlots;
+
+ this.game.systems.inventory.baseMaxSlots = newBaseSlots;
+ this.game.systems.inventory.updateStarbaseBonusSlots(this.game.systems.inventory.starbaseBonusSlots);
+
+ if (debugLogger) debugLogger.logStep('Inventory slots updated', {
+ oldBaseSlots: oldBaseSlots,
+ newBaseSlots: newBaseSlots,
+ starbaseBonusSlots: this.game.systems.inventory.starbaseBonusSlots,
+ finalMaxSlots: this.game.systems.inventory.maxSlots
+ });
+ }
+
+ // Keep legacy storage for backward compatibility
+ this.base.storage = 1000 + (totalStorageBonus * 100);
+ this.base.maxStorage = this.base.storage;
+
+ if (debugLogger) debugLogger.endStep('BaseSystem.calculateBaseStats', {
+ powerChanges: {
+ oldPower: oldPower,
+ newPower: this.base.power,
+ oldMaxPower: oldMaxPower,
+ newMaxPower: this.base.maxPower
+ },
+ storageChanges: {
+ oldStorage: oldStorage,
+ newStorage: this.base.storage,
+ oldMaxStorage: oldMaxStorage,
+ newMaxStorage: this.base.maxStorage
+ },
+ totals: {
+ totalPowerCost: totalPowerCost,
+ totalStorageBonus: totalStorageBonus,
+ storageExpansionBonus: storageExpansion
+ },
+ roomsProcessed: this.base.rooms.length
+ });
+ }
+
+ // Base upgrades
+ upgradeBase(upgradeId) {
+ const debugLogger = window.debugLogger;
+
+ if (debugLogger) debugLogger.startStep('BaseSystem.upgradeBase', {
+ upgradeId: upgradeId,
+ currentCredits: this.game.systems.economy.credits,
+ currentUpgradeLevel: this.upgrades[upgradeId] ? this.upgrades[upgradeId].currentLevel : null
+ });
+
+ const upgrade = this.upgrades[upgradeId];
+ if (!upgrade) {
+ if (debugLogger) debugLogger.endStep('BaseSystem.upgradeBase', {
+ success: false,
+ reason: 'Upgrade not found',
+ upgradeId: upgradeId
+ });
+ return false;
+ }
+
+ if (debugLogger) debugLogger.logStep('Upgrade found', {
+ upgradeName: upgrade.name,
+ currentLevel: upgrade.currentLevel,
+ maxLevel: upgrade.maxLevel,
+ baseCost: upgrade.cost
+ });
+
+ if (upgrade.currentLevel >= upgrade.maxLevel) {
+ this.game.showNotification('Upgrade at maximum level', 'warning', 3000);
+
+ if (debugLogger) debugLogger.endStep('BaseSystem.upgradeBase', {
+ success: false,
+ reason: 'Upgrade at maximum level',
+ upgradeId: upgradeId,
+ currentLevel: upgrade.currentLevel,
+ maxLevel: upgrade.maxLevel
+ });
+ return false;
+ }
+
+ const cost = upgrade.cost * (upgrade.currentLevel + 1);
+ if (this.game.systems.economy.credits < cost) {
+ this.game.showNotification('Not enough credits', 'error', 3000);
+
+ if (debugLogger) debugLogger.endStep('BaseSystem.upgradeBase', {
+ success: false,
+ reason: 'Insufficient credits',
+ upgradeId: upgradeId,
+ requiredCredits: cost,
+ currentCredits: this.game.systems.economy.credits
+ });
+ return false;
+ }
+
+ if (debugLogger) debugLogger.logStep('Upgrade validation passed', {
+ upgradeId: upgradeId,
+ currentLevel: upgrade.currentLevel,
+ newLevel: upgrade.currentLevel + 1,
+ cost: cost
+ });
+
+ // Apply upgrade
+ const oldCredits = this.game.systems.economy.credits;
+ this.game.systems.economy.removeCredits(cost);
+ upgrade.currentLevel++;
+
+ if (debugLogger) debugLogger.logStep('Upgrade applied', {
+ oldCredits: oldCredits,
+ newCredits: this.game.systems.economy.credits,
+ costDeducted: cost,
+ newUpgradeLevel: upgrade.currentLevel
+ });
+
+ // Apply effects
+ let statsUpdated = false;
+ if (upgrade.effect.powerReduction) {
+ if (debugLogger) debugLogger.logStep('Applying power reduction effect');
+ this.updateBaseStats();
+ statsUpdated = true;
+ }
+
+ if (upgrade.effect.storageBonus) {
+ if (debugLogger) debugLogger.logStep('Applying storage bonus effect');
+ this.updateBaseStats();
+ statsUpdated = true;
+ }
+
+ if (upgrade.effect.productionBonus) {
+ if (debugLogger) debugLogger.logStep('Applying production bonus effect', {
+ productionBonus: upgrade.effect.productionBonus
+ });
+ statsUpdated = true;
+ }
+
+ if (upgrade.effect.defenseBonus) {
+ if (debugLogger) debugLogger.logStep('Applying defense bonus effect', {
+ defenseBonus: upgrade.effect.defenseBonus
+ });
+ statsUpdated = true;
+ }
+
+ if (!statsUpdated) {
+ // For upgrades like storage_expansion that don't have effects in the effect object
+ if (debugLogger) debugLogger.logStep('Updating base stats for upgrade');
+ this.updateBaseStats();
+ }
+
+ this.game.showNotification(`${upgrade.name} upgraded to level ${upgrade.currentLevel}!`, 'success', 3000);
+
+ if (debugLogger) debugLogger.endStep('BaseSystem.upgradeBase', {
+ success: true,
+ upgradeId: upgradeId,
+ upgradeName: upgrade.name,
+ oldLevel: upgrade.currentLevel - 1,
+ newLevel: upgrade.currentLevel,
+ cost: cost,
+ finalCredits: this.game.systems.economy.credits,
+ effectsApplied: statsUpdated
+ });
+
+ return true;
+ }
+
+ // Base production
+ update(deltaTime) {
+ if (this.game.state.paused) {
+ return;
+ }
+
+ // Auto production from automation systems
+ const autoProductionRate = (this.upgrades.automation_systems?.currentLevel || 0) * 0.05;
+ if (autoProductionRate > 0) {
+ // Use real computer time delta
+ const production = (deltaTime / 1000) * autoProductionRate * 10; // 10 credits per second per level
+
+ this.game.systems.economy.addCredits(Math.floor(production), 'base_production');
+ }
+
+ // Power generation from power generators
+ const powerGenerators = this.base.rooms.filter(r => r.type === 'power_generator');
+ if (powerGenerators.length > 0) {
+ const powerGeneration = powerGenerators.reduce((total, gen) => total + Math.abs(gen.powerCost), 0);
+
+ // Power generation would affect other systems
+ }
+
+ // Research production
+ if ((this.upgrades.research_lab?.currentLevel || 0) > 0) {
+ const researchRate = (this.upgrades.research_lab?.currentLevel || 0) * 0.1;
+ // Research points generation would go here
+ }
+
+ // Resource processing
+ if ((this.upgrades.resource_processor?.currentLevel || 0) > 0) {
+ const processingRate = (this.upgrades.resource_processor?.currentLevel || 0) * 0.05;
+ // Resource processing would go here
+ }
+ }
+
+ // UI updates
+ updateUI() {
+ this.setupBaseNavigation();
+ this.updateBaseDisplay();
+ this.updateUpgradesList();
+ this.updateShipGallery();
+ this.updateStarbaseList();
+ }
+
+ // Base Navigation
+ setupBaseNavigation() {
+ const navButtons = document.querySelectorAll('.base-nav-btn');
+ navButtons.forEach(button => {
+ button.addEventListener('click', () => {
+ const view = button.dataset.view;
+ this.switchBaseView(view);
+ });
+ });
+ }
+
+ switchBaseView(view) {
+ // Hide all views
+ document.querySelectorAll('.base-view-content').forEach(content => {
+ content.classList.add('hidden');
+ });
+
+ // Remove active class from all buttons
+ document.querySelectorAll('.base-nav-btn').forEach(btn => {
+ btn.classList.remove('active');
+ });
+
+ // Show selected view
+ const selectedView = document.getElementById(`base-${view}`);
+ if (selectedView) {
+ selectedView.classList.remove('hidden');
+ }
+
+ // Add active class to clicked button
+ const activeBtn = document.querySelector(`[data-view="${view}"]`);
+ if (activeBtn) {
+ activeBtn.classList.add('active');
+ }
+
+ // Initialize view-specific content
+ if (view === 'visualization') {
+ this.initializeBaseVisualization();
+ } else if (view === 'ships') {
+ this.updateShipGallery();
+ } else if (view === 'starbases') {
+ this.updateStarbaseList();
+ this.updateStarbasePurchaseList();
+ }
+ }
+
+ // Base Visualization
+ initializeBaseVisualization() {
+ const canvas = document.getElementById('baseCanvas');
+ if (!canvas) return;
+
+ const ctx = canvas.getContext('2d');
+
+ // Clear canvas
+ ctx.clearRect(0, 0, canvas.width, canvas.height);
+
+ // Draw base grid
+ this.drawBaseVisualization(ctx, canvas);
+
+ // Update info overlay
+ this.updateBaseInfoOverlay();
+ }
+
+ drawBaseVisualization(ctx, canvas) {
+ const cellSize = 40;
+ const offsetX = (canvas.width - this.gridSize * cellSize) / 2;
+ const offsetY = (canvas.height - this.gridSize * cellSize) / 2;
+
+ // Draw grid
+ ctx.strokeStyle = '#333';
+ ctx.lineWidth = 1;
+
+ for (let y = 0; y <= this.gridSize; y++) {
+ ctx.beginPath();
+ ctx.moveTo(offsetX, offsetY + y * cellSize);
+ ctx.lineTo(offsetX + this.gridSize * cellSize, offsetY + y * cellSize);
+ ctx.stroke();
+ }
+
+ for (let x = 0; x <= this.gridSize; x++) {
+ ctx.beginPath();
+ ctx.moveTo(offsetX + x * cellSize, offsetY);
+ ctx.lineTo(offsetX + x * cellSize, offsetY + this.gridSize * cellSize);
+ ctx.stroke();
+ }
+
+ // Draw rooms
+ for (let y = 0; y < this.gridSize; y++) {
+ for (let x = 0; x < this.gridSize; x++) {
+ const roomId = this.grid[y][x];
+ if (roomId) {
+ const room = this.base.rooms.find(r => r.id === roomId);
+ if (room) {
+ this.drawRoom(ctx, room, x, y, cellSize, offsetX, offsetY);
+ }
+ }
+ }
+ }
+ }
+
+ drawRoom(ctx, room, gridX, gridY, cellSize, offsetX, offsetY) {
+ const x = offsetX + gridX * cellSize;
+ const y = offsetY + gridY * cellSize;
+
+ // Room colors by type
+ const roomColors = {
+ command_center: '#4CAF50',
+ power_generator: '#FFC107',
+ defense_turret: '#F44336',
+ storage: '#2196F3',
+ research_lab: '#9C27B0',
+ factory: '#FF9800',
+ medical_bay: '#00BCD4',
+ hangar: '#795548'
+ };
+
+ const color = roomColors[room.type] || '#666';
+
+ // Draw room
+ ctx.fillStyle = color;
+ ctx.fillRect(x + 2, y + 2, cellSize - 4, cellSize - 4);
+
+ // Draw room border
+ ctx.strokeStyle = '#fff';
+ ctx.lineWidth = 2;
+ ctx.strokeRect(x + 2, y + 2, cellSize - 4, cellSize - 4);
+
+ // Draw room icon/initial
+ ctx.fillStyle = '#fff';
+ ctx.font = 'bold 16px Arial';
+ ctx.textAlign = 'center';
+ ctx.textBaseline = 'middle';
+ ctx.fillText(room.name.charAt(0), x + cellSize/2, y + cellSize/2);
+ }
+
+ updateBaseInfoOverlay() {
+ const infoDisplay = document.getElementById('baseInfoDisplay');
+ if (!infoDisplay) return;
+
+ const totalRooms = this.base.rooms.length;
+ const powerUsage = this.base.power;
+ const maxPower = this.base.maxPower;
+ const storage = this.base.storage;
+ const maxStorage = this.base.maxStorage;
+
+ infoDisplay.innerHTML = `
+
+ Base Name: ${this.base.name}
+
+
+ Level: ${this.base.level}
+
+
+ Total Rooms: ${totalRooms}
+
+
+ Power Usage: ${powerUsage}/${maxPower}
+
+
+ Storage: ${storage}/${maxStorage}
+
+ `;
+ }
+
+ // Ship Gallery
+ initializeShipGallery() {
+ // Initialize purchased ships array
+ if (!this.purchasedShips) {
+ this.purchasedShips = [];
+
+ // Add current ship to gallery with proper timestamp ID
+ const player = this.game.systems.player;
+ if (player.ship) {
+ this.purchasedShips.push({
+ id: Date.now().toString(), // Use timestamp instead of hardcoded 'current_ship'
+ name: player.ship.name || 'Default Ship',
+ class: player.ship.class || 'fighter',
+ level: player.ship.level || 1,
+ stats: { ...player.attributes },
+ isCurrent: true
+ });
+ }
+ }
+ }
+
+ updateShipGallery() {
+ const shipGrid = document.getElementById('shipGrid');
+ if (!shipGrid) {
+ return;
+ }
+
+ if (!this.purchasedShips) {
+ this.initializeShipGallery();
+ }
+
+ if (!this.purchasedShips || this.purchasedShips.length === 0) {
+ shipGrid.innerHTML = 'No ships purchased yet. Visit the shop to buy ships!
';
+ return;
+ }
+
+ shipGrid.innerHTML = '';
+
+ this.purchasedShips.forEach(ship => {
+ const shipElement = document.createElement('div');
+ shipElement.className = `ship-card ${ship.isCurrent ? 'current-ship' : ''}`;
+
+ shipElement.innerHTML = `
+
+
+
Class: ${ship.class}
+
Level: ${ship.level}
+
+
Attack: ${ship.stats.attack || 0}
+
Speed: ${ship.stats.speed || 0}
+
Defense: ${ship.stats.defense || 0}
+
Equip Ship
+ ` : ''}
+ `;
+
+ shipGrid.appendChild(shipElement);
+ });
+ }
+
+ equipShip(shipId) {
+ const ship = this.purchasedShips.find(s => s.id === shipId);
+ if (!ship) {
+ this.game.showNotification('Ship not found!', 'error', 3000);
+ return;
+ }
+
+ if (ship.isCurrent) {
+ this.game.showNotification('This ship is already equipped!', 'info', 3000);
+ return;
+ }
+
+ const player = this.game.systems.player;
+
+ player.ship.name = ship.name;
+ player.ship.class = ship.class;
+ player.ship.level = ship.level;
+ player.ship.texture = ship.texture; // Copy texture for image display
+
+ // Apply ship-specific stats (not just attributes)
+ if (ship.stats.health || ship.stats.hull) {
+ const healthValue = ship.stats.health || ship.stats.hull || 100;
+ player.ship.maxHealth = healthValue;
+ player.ship.health = healthValue;
+ }
+ if (ship.stats.attack) {
+ player.ship.attack = ship.stats.attack;
+ }
+ if (ship.stats.defense) {
+ player.ship.defense = ship.stats.defense;
+ }
+ if (ship.stats.speed) {
+ player.ship.speed = ship.stats.speed;
+ }
+ if (ship.stats.criticalChance) {
+ player.ship.criticalChance = ship.stats.criticalChance;
+ }
+ if (ship.stats.criticalDamage) {
+ player.ship.criticalDamage = ship.stats.criticalDamage;
+ }
+
+ // Also update player attributes for compatibility
+ player.attributes.attack = ship.stats.attack || player.attributes.attack;
+ player.attributes.speed = ship.stats.speed || player.attributes.speed;
+ player.attributes.defense = ship.stats.defense || player.attributes.defense;
+ if (ship.stats.health || ship.stats.hull) {
+ const healthValue = ship.stats.health || ship.stats.hull || 100;
+ player.attributes.maxHealth = healthValue;
+ player.attributes.health = healthValue;
+ }
+
+ // Update isCurrent flags
+ this.purchasedShips.forEach(s => s.isCurrent = false);
+ ship.isCurrent = true;
+
+ // Force immediate gallery update after flag changes
+ const shipGrid = document.getElementById('shipGrid');
+ if (shipGrid) {
+ shipGrid.innerHTML = '';
+ this.updateShipGallery();
+ }
+
+ // Also update ShipSystem's currentShip to keep systems synchronized
+ if (this.game.systems.ship) {
+ // Find or create a ship object in ShipSystem format
+ const shipSystemShip = {
+ id: ship.id,
+ name: ship.name,
+ image: ship.texture || `assets/textures/ships/${ship.class.toLowerCase()}.png`,
+ class: ship.class,
+ level: ship.level,
+ stats: ship.stats,
+ status: 'active',
+ rarity: 'Common'
+ };
+
+ // Update ShipSystem's current ship
+ this.game.systems.ship.currentShip = shipSystemShip;
+
+ // Update the ships array in ShipSystem if needed
+ const existingShipIndex = this.game.systems.ship.ships.findIndex(s => s.id === ship.id);
+ if (existingShipIndex >= 0) {
+ this.game.systems.ship.ships[existingShipIndex].status = 'active';
+ this.game.systems.ship.ships[existingShipIndex] = shipSystemShip;
+ } else {
+ // Add to ships array if not present
+ this.game.systems.ship.ships.push(shipSystemShip);
+ }
+
+ // Mark all other ships as inactive
+ this.game.systems.ship.ships.forEach(s => {
+ if (s.id !== ship.id) s.status = 'inactive';
+ });
+ }
+
+ // Only update player UI if in multiplayer mode or game is actively running
+ if (this.game.shouldUpdateGUI()) {
+ player.updateUI();
+ }
+
+ this.updateShipGallery();
+
+ // Also update ShipSystem display
+ if (this.game.systems.ship && this.game.systems.ship.updateCurrentShipDisplay) {
+ this.game.systems.ship.updateCurrentShipDisplay();
+ } else {
+ this.updateCurrentShipDisplayDirect();
+ }
+
+ // Force save the game to persist the ship change
+ this.game.save().then(() => {
+ // Force complete gallery refresh after save completes
+ const shipGrid = document.getElementById('shipGrid');
+ if (shipGrid) {
+ shipGrid.innerHTML = ''; // Clear completely
+ this.updateShipGallery(); // Rebuild from scratch
+ }
+
+ // Force ShipSystem to sync with new current ship
+ if (this.game.systems.ship && this.game.systems.ship.syncWithPlayerShip) {
+ this.game.systems.ship.syncWithPlayerShip();
+ }
+ });
+
+ this.game.showNotification(`Equipped ${ship.name}!`, 'success', 3000);
+ }
+
+ updateCurrentShipDisplayDirect() {
+ const player = this.game.systems.player;
+ if (!player || !player.ship) {
+ return;
+ }
+
+ const elements = {
+ currentShipImage: document.getElementById('currentShipImage'),
+ currentShipName: document.getElementById('currentShipName'),
+ currentShipClass: document.getElementById('currentShipClass'),
+ currentShipLevel: document.getElementById('currentShipLevel'),
+ currentShipHealth: document.getElementById('currentShipHealth'),
+ currentShipAttack: document.getElementById('currentShipAttack'),
+ currentShipDefense: document.getElementById('currentShipDefense'),
+ currentShipSpeed: document.getElementById('currentShipSpeed')
+ };
+
+ const ship = player.ship;
+
+ if (elements.currentShipImage) {
+ const imagePath = ship.texture || `assets/textures/ships/${ship.class.toLowerCase()}.png`;
+ console.log(`[DEBUG] Ship image path: ${imagePath}, texture: ${ship.texture}, class: ${ship.class}`);
+ elements.currentShipImage.src = imagePath;
+
+ // Add error handling for image loading
+ elements.currentShipImage.onerror = function() {
+ console.error(`[DEBUG] Failed to load image: ${imagePath}`);
+ // Fallback to default ship image
+ this.src = 'assets/textures/ships/starter_cruiser.png';
+ };
+ }
+
+ if (elements.currentShipName) elements.currentShipName.textContent = ship.name || 'Unknown Ship';
+ if (elements.currentShipClass) elements.currentShipClass.textContent = ship.class || 'Unknown';
+ if (elements.currentShipLevel) elements.currentShipLevel.textContent = ship.level || 1;
+ if (elements.currentShipHealth) elements.currentShipHealth.textContent = `${ship.health}/${ship.maxHealth}`;
+ if (elements.currentShipAttack) elements.currentShipAttack.textContent = ship.attack || 0;
+ if (elements.currentShipDefense) elements.currentShipDefense.textContent = ship.defense || ship.defence || 0;
+ if (elements.currentShipSpeed) elements.currentShipSpeed.textContent = ship.speed || 0;
+ }
+
+ addShipToGallery(shipData) {
+ this.purchasedShips.push({
+ id: Date.now().toString(),
+ name: shipData.name,
+ class: shipData.type,
+ level: 1,
+ stats: { ...shipData.stats },
+ texture: shipData.texture, // Include texture for image display
+ isCurrent: false
+ });
+
+ this.updateShipGallery();
+ }
+
+ // Starbase System
+ initializeStarbaseSystem() {
+ // Initialize starbase collection
+ if (!this.starbases) {
+ this.starbases = [
+ {
+ id: 'main_base',
+ name: 'Command Center Alpha',
+ type: 'command',
+ level: 1,
+ location: 'Sector Alpha-1',
+ isMain: true
+ }
+ ];
+ }
+
+ // Define available starbase types
+ this.starbaseTypes = {
+ mining: {
+ name: 'Mining Outpost',
+ description: 'Automated mining facility for resource extraction',
+ price: 25000,
+ currency: 'credits',
+ icon: 'fa-hammer',
+ benefits: ['+500 credits/hour', '+50 gems/day', '+5 inventory slots'],
+ requiredLevel: 5,
+ inventoryBonus: 5
+ },
+ research: {
+ name: 'Research Station',
+ description: 'Advanced research facility for technology development',
+ price: 50000,
+ currency: 'credits',
+ icon: 'fa-flask',
+ benefits: ['+100 experience/hour', '+10% skill progression', '+10 inventory slots'],
+ requiredLevel: 10,
+ inventoryBonus: 10
+ },
+ defense: {
+ name: 'Defense Platform',
+ description: 'Military installation for sector protection',
+ price: 40000,
+ currency: 'credits',
+ icon: 'fa-shield-alt',
+ benefits: ['+15% combat effectiveness', '+100 defense rating'],
+ requiredLevel: 8,
+ inventoryBonus: 8
+ },
+ trading: {
+ name: 'Trading Hub',
+ description: 'Commercial center for trade and commerce',
+ price: 75000,
+ currency: 'credits',
+ icon: 'fa-store',
+ benefits: ['+20% shop discounts', '+200 gems/day'],
+ requiredLevel: 12,
+ inventoryBonus: 15
+ }
+ };
+ }
+
+ updateStarbaseList() {
+ const starbaseList = document.getElementById('starbaseList');
+ if (!starbaseList) return;
+
+ starbaseList.innerHTML = '';
+
+ // Initialize starbases if not exists
+ if (!this.starbases) {
+ this.initializeStarbaseSystem();
+ }
+
+ if (!this.starbases || this.starbases.length === 0) {
+ starbaseList.innerHTML = 'No starbases owned yet.
';
+ return;
+ }
+
+ this.starbases.forEach(starbase => {
+ const starbaseElement = document.createElement('div');
+ starbaseElement.className = `starbase-card ${starbase.isMain ? 'main-starbase' : ''}`;
+
+ starbaseElement.innerHTML = `
+
+
+
Type: ${starbase.type}
+
Level: ${starbase.level}
+
Location: ${starbase.location}
+
+
+ View Details
+
+ ${!starbase.isMain ? `
+
+ Decommission
+
+ ` : ''}
+
+ `;
+
+ starbaseList.appendChild(starbaseElement);
+ });
+ }
+
+ updateStarbasePurchaseList() {
+ const purchaseList = document.getElementById('starbasePurchaseItems');
+ if (!purchaseList) return;
+
+ purchaseList.innerHTML = '';
+
+ const player = this.game.systems.player;
+
+ Object.entries(this.starbaseTypes).forEach(([type, starbase]) => {
+ const starbaseElement = document.createElement('div');
+ starbaseElement.className = 'starbase-purchase-card';
+
+ const canAfford = this.game.systems.economy.credits >= starbase.price;
+ const meetsLevel = player.stats.level >= starbase.requiredLevel;
+ const canPurchase = canAfford && meetsLevel;
+
+ starbaseElement.innerHTML = `
+
+
+ ${starbase.description}
+
+
+
Benefits:
+
+ ${starbase.benefits.map(benefit => `${benefit} `).join('')}
+
+
+
+ Cost: ${starbase.price} ${starbase.currency}
+
+
+ Required Level: ${starbase.requiredLevel}
+
+
+
+ ${!meetsLevel ? 'Level Required' : !canAfford ? 'Insufficient Funds' : 'Purchase Starbase'}
+
+
+ `;
+
+ purchaseList.appendChild(starbaseElement);
+ });
+ }
+
+ purchaseStarbase(type) {
+ const starbaseTemplate = this.starbaseTypes[type];
+ if (!starbaseTemplate) {
+ this.game.showNotification('Invalid starbase type!', 'error', 3000);
+ return;
+ }
+
+ const player = this.game.systems.player;
+ const economy = this.game.systems.economy;
+
+ // Check requirements
+ if (player.stats.level < starbaseTemplate.requiredLevel) {
+ this.game.showNotification(`Level ${starbaseTemplate.requiredLevel} required!`, 'error', 3000);
+ return;
+ }
+
+ if (economy.credits < starbaseTemplate.price) {
+ this.game.showNotification('Insufficient credits!', 'error', 3000);
+ return;
+ }
+
+ // Process payment
+ economy.credits -= starbaseTemplate.price;
+
+ // Create new starbase
+ const newStarbase = {
+ id: Date.now().toString(),
+ name: `${starbaseTemplate.name} ${this.starbases.length}`,
+ type: type,
+ level: 1,
+ location: `Sector ${String.fromCharCode(65 + this.starbases.length)}-${this.starbases.length}`,
+ isMain: false,
+ benefits: starbaseTemplate.benefits
+ };
+
+ this.starbases.push(newStarbase);
+
+ // Apply benefits
+ this.applyStarbaseBenefits(newStarbase);
+
+ // Only update UI if in multiplayer mode or game is actively running
+ if (this.game.shouldUpdateGUI()) {
+ economy.updateUI();
+ this.updateStarbaseList();
+ this.updateStarbasePurchaseList();
+ }
+
+ this.game.showNotification(`Purchased ${starbaseTemplate.name}!`, 'success', 4000);
+ }
+
+ applyStarbaseBenefits(starbase) {
+ // Apply passive benefits based on starbase type
+ switch (starbase.type) {
+ case 'mining':
+ // Start passive credit generation
+ this.startMiningProduction(starbase);
+ // Apply inventory bonus
+ this.updateInventoryBonusSlots();
+ break;
+ case 'research':
+ // Apply experience bonus
+ this.game.systems.player.experienceMultiplier = (this.game.systems.player.experienceMultiplier || 1) + 0.1;
+ // Apply inventory bonus
+ this.updateInventoryBonusSlots();
+ break;
+ case 'defense':
+ // Apply defense bonus
+ this.game.systems.player.attributes.defense = Math.floor(this.game.systems.player.attributes.defense * 1.2);
+ // Apply inventory bonus
+ this.updateInventoryBonusSlots();
+ break;
+ case 'trading':
+ // Apply shop discount
+ this.game.systems.economy.discountMultiplier = 0.85;
+ // Apply inventory bonus
+ this.updateInventoryBonusSlots();
+ break;
+ }
+ }
+
+ updateInventoryBonusSlots() {
+ // Calculate total inventory bonus from all owned starbases
+ let totalBonusSlots = 0;
+
+ if (this.starbases && this.starbases.length > 0) {
+ this.starbases.forEach(starbase => {
+ const starbaseType = this.starbaseTypes[starbase.type];
+ if (starbaseType && starbaseType.inventoryBonus) {
+ totalBonusSlots += starbaseType.inventoryBonus;
+ }
+ });
+ }
+
+ // Update inventory system with new bonus slots
+ if (this.game.systems.inventory) {
+ this.game.systems.inventory.updateStarbaseBonusSlots(totalBonusSlots);
+ }
+ }
+
+ startMiningProduction(starbase) {
+ // Only start mining if in multiplayer mode or game is actively running
+ const shouldStartMining = window.smartSaveManager?.isMultiplayer || this.game?.isRunning;
+
+ if (shouldStartMining && !this.miningInterval) {
+ // Set up passive credit generation
+ this.miningInterval = setInterval(() => {
+ this.game.systems.economy.addCredits(500, 'mining_outpost');
+ }, 3600000); // 1 hour
+
+ console.log('[BASE SYSTEM] Mining production started');
+ } else if (!shouldStartMining) {
+ console.log('[BASE SYSTEM] Skipping mining production - not in multiplayer mode');
+ }
+ }
+
+ viewStarbaseDetails(starbaseId) {
+ const starbase = this.starbases.find(s => s.id === starbaseId);
+ if (!starbase) return;
+
+ const details = `
+ ${starbase.name}
+ Type: ${starbase.type}
+ Level: ${starbase.level}
+ Location: ${starbase.location}
+ ${starbase.benefits ? `
+ Active Benefits:
+
+ ${starbase.benefits.map(benefit => `${benefit} `).join('')}
+
+ ` : ''}
+ `;
+
+ if (this.game && this.game.systems && this.game.systems.ui) {
+ this.game.systems.ui.showModal('Starbase Details', details);
+ }
+ }
+
+ decommissionStarbase(starbaseId) {
+ if (!confirm('Are you sure you want to decommission this starbase? You will receive 50% of its value back.')) {
+ return;
+ }
+
+ const starbaseIndex = this.starbases.findIndex(s => s.id === starbaseId);
+ if (starbaseIndex === -1) return;
+
+ const starbase = this.starbases[starbaseIndex];
+ const refundAmount = Math.floor(this.starbaseTypes[starbase.type].price * 0.5);
+
+ // Remove starbase
+ this.starbases.splice(starbaseIndex, 1);
+
+ // Give refund
+ this.game.systems.economy.addCredits(refundAmount, 'starbase_refund');
+
+ // Update inventory bonus slots after removal
+ this.updateInventoryBonusSlots();
+
+ // Update UI
+ this.updateStarbaseList();
+ this.updateStarbasePurchaseList();
+
+ this.game.showNotification(`Decommissioned ${starbase.name}. Refunded ${refundAmount} credits.`, 'info', 4000);
+ }
+
+ updateBaseDisplay() {
+ const baseRoomsElement = document.getElementById('baseRooms');
+ if (!baseRoomsElement) return;
+
+ // Ensure grid is initialized
+ if (!this.grid || this.grid.length === 0) {
+ console.log('[BASE SYSTEM] Grid not initialized, initializing now');
+ this.initializeGrid();
+ }
+
+ baseRoomsElement.innerHTML = '';
+
+ // Create grid container
+ const gridContainer = document.createElement('div');
+ gridContainer.className = 'base-grid';
+
+ // Create grid cells
+ for (let y = 0; y < this.gridSize; y++) {
+ for (let x = 0; x < this.gridSize; x++) {
+ const cell = document.createElement('div');
+ cell.className = 'base-cell';
+ cell.dataset.x = x;
+ cell.dataset.y = y;
+
+ const room = this.getRoomAt(x, y);
+ if (room) {
+ // Check if this is the main cell of the room
+ if (room.x === x && room.y === y) {
+ cell.className += ` room ${room.type}`;
+ cell.innerHTML = `
+
+
+ L${room.level}
+ `;
+ cell.title = `${room.name} (Level ${room.level})`;
+ } else {
+ // Other cells of the same room are just filled
+ cell.innerHTML = '';
+ }
+ cell.title = `${room.name} (Level ${room.level})`;
+ } else {
+ cell.className += ' empty';
+ cell.addEventListener('click', () => this.showRoomBuildMenu(x, y));
+ }
+
+ gridContainer.appendChild(cell);
+ }
+ }
+
+ baseRoomsElement.appendChild(gridContainer);
+
+ // Add base info with connected inventory storage
+ const baseInfo = document.createElement('div');
+ baseInfo.className = 'base-info';
+
+ // Get inventory information
+ const inventoryInfo = this.game.systems.inventory ? this.game.systems.inventory.getInventoryInfo() : null;
+
+ baseInfo.innerHTML = `
+ ${this.base.name}
+
+
Level: ${this.base.level}
+
Power: ${this.base.power}/${this.base.maxPower}
+
Storage: ${inventoryInfo ? `${inventoryInfo.currentSlots}/${inventoryInfo.totalMaxSlots}` : `${this.base.storage}/${this.base.maxStorage}`} slots
+ ${inventoryInfo ? `
+ Base: ${inventoryInfo.baseMaxSlots} | Starbase Bonus: +${inventoryInfo.starbaseBonusSlots}
+
` : ''}
+
${upgrade.name}
+ ${upgrade.description}
+ Level: ${upgrade.currentLevel}/${upgrade.maxLevel}
+ Cost: ${cost} credits
+
+ ${isMaxLevel ? 'MAX' : 'Upgrade'}
+
+ `;
+
+ upgradesElement.appendChild(upgradeElement);
+ });
+}
+
+showRoomBuildMenu(x, y) {
+ const availableRooms = Object.entries(this.roomTypes)
+ .filter(([roomType, template]) =>
+ template.requiredLevel <= this.game.systems.player.stats.level
+ )
+ .filter(([roomType, template]) => this.canBuildRoom(roomType, x, y));
+
+ if (availableRooms.length === 0) {
+ this.game.showNotification('No rooms available for this location', 'warning', 3000);
+ return;
+ }
+
+ let menuContent = 'Build Room ';
+
+ availableRooms.forEach(([roomType, template]) => {
+ const roomSize = this.getRoomSize(template.size);
+ menuContent += `
+
+
+
+
Size: ${roomSize.width}x${roomSize.height}
+
Power: ${template.powerCost > 0 ? '+' : ''}${template.powerCost}
+
Cost: ${template.buildCost} credits
+
+
${template.description}
+
+ `;
+ });
+
+ menuContent += '
${upgrade.name}
+ ${upgrade.description}
+ Level: ${upgrade.currentLevel}/${upgrade.maxLevel}
+ Cost: ${cost} credits
+
+ ${isMaxLevel ? 'MAX' : 'Upgrade'}
+
+ `;
+
+ upgradesElement.appendChild(upgradeElement);
+ });
+ }
+
+ showRoomBuildMenu(x, y) {
+ const availableRooms = Object.entries(this.roomTypes)
+ .filter(([roomType, template]) =>
+ template.requiredLevel <= this.game.systems.player.stats.level
+ )
+ .filter(([roomType, template]) => this.canBuildRoom(roomType, x, y));
+
+ if (availableRooms.length === 0) {
+ this.game.showNotification('No rooms available for this location', 'warning', 3000);
+ return;
+ }
+
+ let menuContent = 'Build Room ';
+
+ availableRooms.forEach(([roomType, template]) => {
+ const roomSize = this.getRoomSize(template.size);
+ menuContent += `
+
+
+
+
Size: ${roomSize.width}x${roomSize.height}
+
Power: ${template.powerCost > 0 ? '+' : ''}${template.powerCost}
+
Cost: ${template.buildCost} credits
+
+
${template.description}
+
+ `;
+ });
+
+ menuContent += '
No recipes available in this category
';
+ return;
+ }
+
+ recipes.forEach(recipe => {
+ const recipeElement = document.createElement('div');
+ recipeElement.className = 'recipe-item';
+ recipeElement.dataset.recipeId = recipe.id;
+
+ const canCraft = this.canCraftRecipe(recipe.id);
+ const missingMaterials = this.getMissingMaterials(recipe.id);
+
+ // Check if recipe is unlocked (skill requirements met)
+ const skillSystem = this.game.systems.skillSystem;
+ let skillRequirementsMet = true;
+ if (recipe.requirements && skillSystem) {
+ for (const [skillName, requiredLevel] of Object.entries(recipe.requirements)) {
+ const skillLevel = skillSystem.getSkillLevel(skillName);
+ if (skillLevel < requiredLevel) {
+ skillRequirementsMet = false;
+ break;
+ }
+ }
+ }
+
+ // Apply styling based on status
+ if (!skillRequirementsMet) {
+ recipeElement.classList.add('locked');
+ } else if (!canCraft) {
+ recipeElement.classList.add('missing-materials');
+ } else {
+ recipeElement.classList.add('can-craft');
+ }
+
+ // Generate requirements text
+ const requirementsText = recipe.requirements ?
+ Object.entries(recipe.requirements).map(([skill, level]) => `${skill}: ${level}`).join(', ') : 'None';
+
+ // Generate materials with missing status
+ const materialsHtml = recipe.materials ? recipe.materials.map(mat => {
+ const missing = missingMaterials.find(m => m.id === mat.id);
+ const currentCount = missing ? missing.current : 0;
+ const requiredCount = mat.quantity || 0;
+
+ if (missing) {
+ return `
+ ${mat.id}
+ ${currentCount}/${requiredCount}
+
`;
+ } else {
+ return `
+ ${mat.id}
+ ${currentCount}/${requiredCount}
+
`;
+ }
+ }).join('') : '';
+
+ recipeElement.innerHTML = `
+
+ ${recipe.description}
+
+ ${materialsHtml}
+
+ ${missingMaterials.length > 0 ? `
+
+
+ ` : ''}
+
+ ${recipe.craftingTime / 1000}s
+
+ `;
+
+ recipeElement.addEventListener('click', () => {
+ this.selectRecipe(recipe.id);
+ this.updateCraftingDetails();
+ });
+
+ recipeListElement.appendChild(recipeElement);
+ });
+ }
+
+ updateCraftingDetails() {
+ const detailsElement = document.getElementById('craftingDetails');
+ if (!detailsElement) return;
+
+ if (!this.selectedRecipe) {
+ detailsElement.innerHTML = `
+
+
Select a Recipe
+
Choose a recipe from the list to see details and craft items.
+
+
${recipe.name}
+
${recipe.description}
+
+
+
Requirements:
+ ${recipe.requirements ? Object.entries(recipe.requirements).map(([skill, level]) =>
+ `
+ ${skill}
+ Level ${level}
+
`
+ ).join('') : '
No special requirements
'}
+
+
+
+
Materials Needed:
+ ${recipe.materials ? recipe.materials.map(mat =>
+ `
+ ${mat.id}
+ x${mat.quantity}
+ Have: ${this.game.systems.inventory?.getItemCount(mat.id) || 0}
+
`
+ ).join('') : '
No materials needed
'}
+
+
+
+
Results:
+ ${recipe.results ? recipe.results.map(result =>
+ `
+ ${result.id}
+ x${result.quantity}
+
`
+ ).join('') : ''}
+
+
+
+
+ ${recipe.experience} XP
+
+
+ ${recipe.craftingTime / 1000} seconds
+
+
+
+
+ ${canCraft ? 'Craft Item' : 'Cannot Craft'}
+
+
${dungeon.name}
+ ${dungeon.difficulty.toUpperCase()}
+ ${statusText ? `${statusText}
` : ''}
+ ${dungeon.description}
+ Rewards: ${dungeon.rewardMultiplier}x
+ Energy Cost: ${dungeon.energyCost || this.getEnergyCost(key)}
+ `;
+
+ dungeonElement.addEventListener('click', () => {
+ if (isCompleted) {
+ this.game.showNotification('Tutorial dungeon has already been completed!', 'warning', 3000);
+ } else {
+ this.selectDungeon(key);
+ }
+ });
+
+ dungeonListElement.appendChild(dungeonElement);
+ });
+
+ }
+
+ selectDungeon(type) {
+
+ // Check energy cost
+ const energyCost = this.getEnergyCost(type);
+ const player = this.game.systems.player;
+
+
+ if (!player.useEnergy(energyCost)) {
+ this.game.showNotification(`Not enough energy! Need ${energyCost} energy`, 'error', 3000);
+ return;
+ }
+
+
+ // Ensure we're on the Dungeons tab so the user can see the dungeon
+ if (this.game.ui && this.game.ui.currentTab !== 'dungeons') {
+ this.game.ui.switchTab('dungeons');
+ }
+
+ // Remove previous selection
+ document.querySelectorAll('.dungeon-item').forEach(item => {
+ item.classList.remove('selected');
+ });
+
+ // Add selection to clicked dungeon
+ const selectedElement = document.querySelector(`[data-dungeon-type="${type}"]`);
+ if (selectedElement) {
+ selectedElement.classList.add('selected');
+ }
+
+
+ // Generate dungeon
+ this.generateDungeon(type);
+ this.displayDungeon();
+
+
+ this.game.showNotification(`Entered dungeon! -${energyCost} energy`, 'info', 3000);
+ }
+
+ getEnergyCost(type) {
+ const costs = {
+ tutorial: 0,
+ alien_ruins: 20,
+ pirate_lair: 15,
+ corrupted_vault: 25,
+ asteroid_mine: 10,
+ nebula_anomaly: 30
+ };
+ return costs[type] || 15;
+ }
+
+ calculateDungeonRewards(type, difficulty) {
+ const dungeonTemplate = this.dungeonTypes[type];
+ const baseRewards = {
+ credits: 50,
+ experience: 25,
+ items: []
+ };
+
+ // Apply difficulty multiplier
+ const difficultyMultipliers = {
+ tutorial: 0.5,
+ easy: 1.0,
+ medium: 1.5,
+ hard: 2.0
+ };
+
+ const multiplier = difficultyMultipliers[difficulty] || 1.0;
+ const rewardMultiplier = dungeonTemplate.rewardMultiplier || 1.0;
+
+ baseRewards.credits = Math.floor(baseRewards.credits * multiplier * rewardMultiplier);
+ baseRewards.experience = Math.floor(baseRewards.experience * multiplier * rewardMultiplier);
+
+ return baseRewards;
+ }
+
+ generateDungeon(type) {
+
+ const dungeonTemplate = this.dungeonTypes[type];
+
+ // Check if tutorial dungeon has already been completed
+ if (type === 'tutorial' && this.game.systems.player.stats.tutorialDungeonCompleted) {
+ this.game.showNotification('Tutorial dungeon has already been completed!', 'warning', 3000);
+ return;
+ }
+
+
+ this.currentDungeon = {
+ type: type,
+ name: dungeonTemplate.name,
+ description: dungeonTemplate.description,
+ difficulty: dungeonTemplate.difficulty,
+ healthType: dungeonTemplate.healthType,
+ enemyTypes: dungeonTemplate.enemyTypes,
+ rewardMultiplier: dungeonTemplate.rewardMultiplier,
+ rooms: [],
+ currentRoomIndex: 0,
+ startTime: Date.now(),
+ completed: false
+ };
+
+
+ // Generate rooms - ensure minimum of 3 rooms (entrance, at least 1 middle, boss)
+ const roomCount = Math.max(3, this.game.getRandomInt(5, 8));
+ this.currentDungeon.rooms = this.generateRoomLayout(roomCount, dungeonTemplate);
+
+ // Set current room
+ this.currentRoom = this.currentDungeon.rooms[0];
+ this.dungeonProgress = 0;
+
+
+ // Show dungeon view and hide list
+ this.showDungeonView();
+
+ }
+
+ generateRoomLayout(roomCount, dungeonTemplate) {
+ const rooms = [];
+
+
+ // Always start with entrance
+ rooms.push(this.createRoom('entrance', dungeonTemplate));
+
+ // Generate middle rooms (subtract 2 for entrance and boss room)
+ const middleRoomCount = roomCount - 2;
+
+ for (let i = 0; i < middleRoomCount; i++) {
+ const roomType = this.getRandomRoomType();
+ const room = this.createRoom(roomType, dungeonTemplate);
+ rooms.push(room);
+ }
+
+ // Always end with boss room (exit is handled by completing the boss room)
+ rooms.push(this.createRoom('boss', dungeonTemplate));
+
+
+ // Verify room accessibility
+ for (let i = 0; i < rooms.length; i++) {
+ }
+
+ return rooms;
+ }
+
+ getRandomRoomType() {
+ const weights = {
+ corridor: 40,
+ chamber: 30,
+ treasure: 0, // Temporarily disabled
+ entrance: 5,
+ boss: 5,
+ exit: 0
+ };
+
+ const totalWeight = Object.values(weights).reduce((sum, weight) => sum + weight, 0);
+ let random = Math.random() * totalWeight;
+
+ for (const [type, weight] of Object.entries(weights)) {
+ random -= weight;
+ if (random <= 0) {
+ return type;
+ }
+ }
+
+ return 'corridor';
+ }
+
+ createRoom(roomType, dungeonTemplate) {
+ const template = this.roomTypes[roomType];
+ const room = {
+ type: roomType,
+ name: template.name,
+ enemies: [],
+ rewards: null,
+ explored: false,
+ completed: false
+ };
+
+ // Generate enemies
+ if (template.enemies > 0) {
+ for (let i = 0; i < template.enemies; i++) {
+ const enemyType = dungeonTemplate.enemyTypes[
+ Math.floor(Math.random() * dungeonTemplate.enemyTypes.length)
+ ];
+ room.enemies.push(this.createEnemy(enemyType, template.isBoss));
+ }
+ }
+
+ // Generate rewards
+ if (template.rewards) {
+ room.rewards = this.generateRoomRewards(dungeonTemplate.difficulty, template.isBoss);
+ }
+
+ return room;
+ }
+
+ createEnemy(enemyType, isBoss = false) {
+ const template = this.enemyTemplates[enemyType];
+ const bossMultiplier = isBoss ? 2.5 : 1.0;
+
+ return {
+ id: Date.now() + Math.random().toString(36).substr(2, 9),
+ type: enemyType,
+ name: isBoss ? `Boss ${template.name}` : template.name,
+ health: Math.floor(template.health * bossMultiplier),
+ maxHealth: Math.floor(template.health * bossMultiplier),
+ attack: Math.floor(template.attack * bossMultiplier),
+ defense: Math.floor(template.defense * bossMultiplier),
+ experience: Math.floor(template.experience * bossMultiplier),
+ credits: Math.floor(template.credits * bossMultiplier),
+ isBoss: isBoss
+ };
+ }
+
+ generateRoomRewards(difficulty, isBoss = false) {
+ const baseRewards = this.game.systems.economy.generateRewards(difficulty, 'dungeon');
+ const multiplier = isBoss ? 2.0 : 1.0;
+
+ const rewards = {
+ credits: Math.floor(baseRewards.credits * multiplier),
+ experience: Math.floor(baseRewards.experience * multiplier),
+ materials: []
+ };
+
+ // Add crafting materials based on chance and difficulty
+ const materialChance = isBoss ? 0.9 : 0.4;
+ if (Math.random() < materialChance) {
+ const materialCount = isBoss ? this.game.getRandomInt(3, 6) : this.game.getRandomInt(1, 3);
+
+ // Define material pools with weights for better balance
+ const materialPools = {
+ tutorial: [
+ { id: 'iron_ore', weight: 40 },
+ { id: 'copper_wire', weight: 30 },
+ { id: 'herbs', weight: 20 },
+ { id: 'bandages', weight: 10 }
+ ],
+ easy: [
+ { id: 'iron_ore', weight: 30 },
+ { id: 'copper_wire', weight: 25 },
+ { id: 'energy_crystal', weight: 15 },
+ { id: 'leather', weight: 15 },
+ { id: 'herbs', weight: 10 },
+ { id: 'bandages', weight: 5 }
+ ],
+ medium: [
+ { id: 'iron_ore', weight: 25 },
+ { id: 'steel_plate', weight: 20 },
+ { id: 'energy_crystal', weight: 20 },
+ { id: 'copper_wire', weight: 15 },
+ { id: 'rare_metal', weight: 5 },
+ { id: 'bandages', weight: 15 }
+ ],
+ hard: [
+ { id: 'steel_plate', weight: 30 },
+ { id: 'energy_crystal', weight: 25 },
+ { id: 'rare_metal', weight: 15 },
+ { id: 'battery', weight: 20 },
+ { id: 'bandages', weight: 10 }
+ ],
+ extreme: [
+ { id: 'rare_metal', weight: 30 },
+ { id: 'energy_crystal', weight: 25 },
+ { id: 'battery', weight: 25 },
+ { id: 'advanced_components', weight: 20 }
+ ]
+ };
+
+ const pool = materialPools[difficulty] || materialPools.easy;
+
+ // Helper function to get weighted random material
+ function getWeightedRandomMaterial(materialPool) {
+ const totalWeight = materialPool.reduce((sum, mat) => sum + mat.weight, 0);
+ let random = Math.random() * totalWeight;
+
+ for (const material of materialPool) {
+ random -= material.weight;
+ if (random <= 0) {
+ return material.id;
+ }
+ }
+ return materialPool[0].id; // Fallback
+ }
+
+ for (let i = 0; i < materialCount; i++) {
+ const material = getWeightedRandomMaterial(pool);
+ const quantity = this.game.getRandomInt(1, isBoss ? 3 : 2);
+
+ rewards.materials.push({
+ id: material,
+ quantity: quantity
+ });
+ }
+ }
+
+ return rewards;
+ }
+
+ displayDungeon() {
+
+ const dungeonViewElement = document.getElementById('dungeonView');
+
+ if (!dungeonViewElement) {
+ const allElements = document.querySelectorAll('[id*="dungeon"]');
+ return;
+ }
+
+ if (!this.currentDungeon) {
+ return;
+ }
+
+ const room = this.currentRoom;
+ if (room) {
+ // Room exists, continue processing
+ }
+
+ const progress = Math.floor((this.currentDungeon.currentRoomIndex / this.currentDungeon.rooms.length) * 100);
+
+
+ let content = `
+
+
+
+
+ ${this.getHealthDisplay()}
+
+
+
+
${room.name}
+ ${this.getRoomDescription(room)}
+
+
+
+ ${this.getRoomContent(room)}
+
+
+
+ ${this.getRoomActions(room)}
+
+
+
Ship Health
+
+
${shipHealth} / ${shipMaxHealth}
+
+
Player Health
+
+
${playerHealth} / ${playerMaxHealth}
+
${descriptions[room.type] || 'You continue exploring...'}
`;
+ }
+
+ getRoomContent(room) {
+ if (room.completed) {
+ return 'This room has been cleared.
';
+ }
+
+ if (room.enemies.length > 0) {
+ const enemiesHtml = room.enemies.map(enemy => `
+
+
${enemy.name}
+
+
+
${enemy.health} / ${enemy.maxHealth}
+
+
ATK: ${enemy.attack} | DEF: ${enemy.defense}
+
${enemiesHtml}
`;
+ }
+
+ if (room.rewards && !room.completed) {
+ return '';
+ }
+
+ return 'The room is empty and quiet.
';
+ }
+
+ getRoomActions(room) {
+
+ if (room.completed) {
+ if (this.currentDungeon.currentRoomIndex < this.currentDungeon.rooms.length - 1) {
+ return 'Continue to Next Room ';
+ } else {
+ return 'Complete Dungeon ';
+ }
+ }
+
+ if (room.enemies.length > 0) {
+ const buttonHtml = 'Start Combat ';
+ return buttonHtml;
+ }
+
+ if (room.rewards) {
+ return 'Claim Rewards ';
+ }
+
+ // Check if this is the final room
+ if (this.currentDungeon.currentRoomIndex >= this.currentDungeon.rooms.length - 1) {
+ return 'Complete Dungeon ';
+ }
+
+ return 'Move Forward ';
+ }
+ async startCombat() {
+
+ if (this.isExploring) {
+ return;
+ }
+
+ this.isExploring = true;
+ const room = this.currentRoom;
+ const enemies = room.enemies.filter(e => e.health > 0);
+
+
+ if (enemies.length === 0) {
+ this.completeRoom();
+ return;
+ }
+
+ // Simulate combat
+ await this.simulateCombat(enemies);
+ }
+
+ async simulateCombat(enemies) {
+
+ try {
+ const player = this.game.systems.player;
+
+ const healthType = this.currentDungeon.healthType;
+
+ let combatLog = [];
+
+ // Handle case where there are no enemies
+ if (enemies.length === 0) {
+ combatLog.push('Room was empty - no enemies found');
+ this.completeRoom();
+ return;
+ }
+
+ for (const [index, enemy] of enemies.entries()) {
+
+ // Player attacks
+ const playerDamage = player.calculateDamage(this.currentDungeon.difficulty);
+
+ const actualDamage = Math.max(1, playerDamage.damage - enemy.defense);
+ enemy.health = Math.max(0, enemy.health - actualDamage);
+
+ combatLog.push(`You dealt ${actualDamage} damage to ${enemy.name}${playerDamage.isCritical ? ' (CRITICAL!)' : ''}`);
+
+ // Update UI after player attack to show enemy health change
+ this.displayDungeon();
+ // Also update global player UI to ensure health bars are updated only if in multiplayer mode or game is actively running
+ const shouldUpdateUI = window.smartSaveManager?.isMultiplayer || this.game?.isRunning;
+
+ if (shouldUpdateUI && player.updateUI) {
+ player.updateUI();
+ }
+
+ // Small delay to make the combat visible
+ await new Promise(resolve => setTimeout(resolve, 500));
+
+ // Enemy attacks if still alive
+ if (enemy.health > 0) {
+ let enemyDamage, damageTarget;
+
+ if (healthType === 'ship') {
+ // Space missions: higher damage, target ship health
+ enemyDamage = Math.max(1, Math.floor(enemy.attack * 1.5) - player.ship.defense);
+ damageTarget = 'ship';
+ this.applyShipDamage(enemyDamage);
+ combatLog.push(`${enemy.name} dealt ${enemyDamage} damage to your ship`);
+ } else {
+ // Ground missions: normal damage, target player health
+ enemyDamage = Math.max(1, enemy.attack - player.attributes.defense);
+ damageTarget = 'player';
+ player.takeDamage(enemyDamage);
+ combatLog.push(`${enemy.name} dealt ${enemyDamage} damage to you`);
+ }
+
+ // Update UI after enemy attack to show player health change
+ this.displayDungeon();
+ // Also update global player UI to ensure health bars are updated
+ if (player.updateUI) {
+ player.updateUI();
+ }
+
+ // Small delay to make the combat visible
+ await new Promise(resolve => setTimeout(resolve, 500));
+
+ // Check for destruction
+ if (healthType === 'ship' && player.ship.health <= 0) {
+ this.handleShipDestruction();
+ } else if (healthType === 'player' && player.attributes.health <= 0) {
+ this.handlePlayerDefeat();
+ }
+ } else {
+ // Enemy defeated
+ player.addExperience(enemy.experience);
+ this.game.systems.economy.addCredits(enemy.credits, 'dungeon');
+ player.incrementKills();
+ this.stats.totalEnemiesDefeated++;
+
+ // Update quest progress for combat objectives
+ if (this.game.systems.questSystem) {
+ this.game.systems.questSystem.onEnemyDefeated();
+ }
+
+ combatLog.push(`${enemy.name} defeated! +${enemy.experience} XP, +${enemy.credits} credits`);
+
+ // Update UI after enemy defeat
+ this.displayDungeon();
+ // Also update global player UI to ensure health bars are updated
+ if (player.updateUI) {
+ player.updateUI();
+ }
+
+ // Small delay to make the combat visible
+ await new Promise(resolve => setTimeout(resolve, 500));
+ }
+ }
+
+ // Show combat results
+ this.game.showNotification('Combat completed!', 'success', 3000);
+ combatLog.forEach(message => this.game.showNotification(message, 'info', 2000));
+
+ // Check if all enemies defeated
+ const remainingEnemies = this.currentRoom.enemies.filter(e => e.health > 0);
+ if (remainingEnemies.length === 0) {
+ this.completeRoom();
+ }
+
+ this.isExploring = false;
+ this.displayDungeon();
+ } catch (error) {
+ console.error('[DUNGEON] Error in simulateCombat:', error);
+ console.error('[DUNGEON] Error stack:', error.stack);
+ this.isExploring = false;
+ }
+ }
+
+ // Health system methods
+ applyShipDamage(amount) {
+ const player = this.game.systems.player;
+ player.ship.health = Math.max(0, player.ship.health - amount);
+
+ // Only update player UI if in multiplayer mode or game is actively running
+ if (this.game.shouldUpdateGUI()) {
+ player.updateUI();
+ }
+
+ // Check for ship destruction
+ if (player.ship.health <= 0) {
+ this.handleShipDestruction();
+ }
+ }
+
+ handleShipDestruction() {
+ const player = this.game.systems.player;
+
+ // Show destruction message
+ this.game.showNotification('Your ship has been destroyed!', 'error', 5000);
+ this.game.showNotification('Dungeon failed - all progress lost.', 'warning', 4000);
+
+ // Remove the current ship from inventory
+ if (this.game.systems.inventory) {
+ this.game.systems.inventory.removeItem(player.ship);
+ }
+
+ // Reset to a basic ship if available in inventory
+ const availableShips = this.game.systems.inventory.getItemsByType('ship');
+ if (availableShips.length > 0) {
+ player.ship = availableShips[0];
+ this.game.showNotification(`Switched to ${player.ship.name}`, 'info', 3000);
+ } else {
+ // No ships available - create a basic one
+ player.ship = {
+ name: 'Basic Fighter',
+ health: 1000,
+ maxHealth: 1000,
+ defense: 5,
+ attack: 10,
+ type: 'ship'
+ };
+ this.game.showNotification('No ships available - using emergency fighter', 'warning', 3000);
+ }
+
+ // Apply dungeon failure penalty
+ this.applyDungeonFailurePenalty();
+
+ // Exit dungeon
+ this.exitDungeon();
+ }
+
+ applyDungeonFailurePenalty() {
+ const player = this.game.systems.player;
+
+ // Lose some credits as penalty
+ const creditPenalty = Math.floor(this.game.systems.economy.credits * 0.1); // 10% credit loss
+ this.game.systems.economy.removeCredits(creditPenalty);
+
+ // Lose some experience
+ const expPenalty = Math.floor(player.experience * 0.05); // 5% exp loss
+ player.experience = Math.max(0, player.experience - expPenalty);
+
+ // Update failure statistics
+ this.stats.dungeonsFailed++;
+
+ this.game.showNotification(`Dungeon penalty: -${creditPenalty} credits, -${expPenalty} XP`, 'warning', 4000);
+ }
+
+ handlePlayerDefeat() {
+ this.game.showNotification('You have been defeated!', 'error', 5000);
+ this.game.showNotification('You\'ve been forced to retreat from the dungeon.', 'warning', 4000);
+
+ // Heal player to prevent death loop
+ const player = this.game.systems.player;
+ player.attributes.health = Math.floor(player.attributes.maxHealth * 0.5);
+
+ // Exit dungeon
+ this.exitDungeon();
+ }
+
+ exitDungeon() {
+ this.currentDungeon = null;
+ this.currentRoom = null;
+ this.dungeonProgress = 0;
+ this.isExploring = false;
+
+ // Return to main view
+ this.generateDungeonList();
+ }
+
+ claimRewards() {
+ const room = this.currentRoom;
+ if (!room.rewards || room.completed) return;
+
+ // Give all rewards including materials
+ this.game.systems.economy.giveRewards(room.rewards, 'dungeon');
+
+ room.rewards = null; // Remove rewards after claiming
+
+ this.game.showNotification('Rewards claimed!', 'success', 3000);
+
+ // Use the proper completeRoom method to ensure consistent behavior
+ this.completeRoom();
+ }
+
+ completeRoom() {
+ const room = this.currentRoom;
+ room.completed = true;
+ room.explored = true;
+
+ // Reset exploring flag when completing a room
+ this.isExploring = false;
+
+
+ // Auto-claim rewards if available
+ if (room.rewards) {
+ // Give credits and experience
+ this.game.systems.economy.giveRewards(room.rewards, 'dungeon');
+
+ // Add crafting materials to inventory
+ if (room.rewards.materials && room.rewards.materials.length > 0) {
+ let materialText = '';
+ room.rewards.materials.forEach(material => {
+ this.game.systems.inventory.addItem(material.id, material.quantity);
+ materialText += `${material.quantity}x ${material.id}, `;
+ });
+
+ materialText = materialText.slice(0, -2);
+
+ this.game.showNotification(`Materials found: ${materialText}`, 'success', 4000);
+ }
+
+ room.rewards = null;
+ }
+
+ this.game.showNotification(`${room.name} completed!`, 'success', 3000);
+
+ // Check if this is a boss room - if so, automatically complete the dungeon
+ if (room.type === 'boss') {
+ setTimeout(() => {
+ this.completeDungeon();
+ }, 2000); // Small delay to show the completion message first
+ } else {
+ this.displayDungeon();
+ }
+
+ }
+
+ nextRoom() {
+
+ // Log all rooms for debugging
+ this.currentDungeon.rooms.forEach((room, index) => {
+ });
+
+ if (this.currentDungeon.currentRoomIndex >= this.currentDungeon.rooms.length - 1) {
+ return;
+ }
+
+ const oldIndex = this.currentDungeon.currentRoomIndex;
+ this.currentDungeon.currentRoomIndex++;
+ this.currentRoom = this.currentDungeon.rooms[this.currentDungeon.currentRoomIndex];
+
+
+ this.displayDungeon();
+ }
+
+ completeDungeon() {
+ if (!this.currentDungeon) {
+ return;
+ }
+
+ const completionTime = Date.now() - this.currentDungeon.startTime;
+ const player = this.game.systems.player;
+ const economy = this.game.systems.economy;
+
+ // Generate proper rewards including materials
+ const baseRewards = this.generateRoomRewards(this.currentDungeon.difficulty, false);
+
+ // Apply time bonus
+ const timeBonus = Math.floor(completionTime < 300000 ? 50 : 0); // Bonus for completing in under 5 minutes
+ baseRewards.credits += timeBonus;
+ baseRewards.experience += Math.floor(timeBonus / 2);
+
+ // Give rewards
+ economy.giveRewards(baseRewards, 'dungeon');
+ player.addExperience(baseRewards.experience);
+
+ // Update statistics
+ this.stats.dungeonsCompleted++;
+ this.stats.totalTimeInDungeons += completionTime;
+
+ // Update player dungeons cleared stat
+ player.stats.dungeonsCleared++;
+
+ // Update quest progress for dungeon objectives
+ if (this.game.systems.questSystem) {
+ // Check if this is a tutorial dungeon
+ if (this.currentDungeon.type === 'tutorial') {
+ // Mark tutorial dungeon as completed in player stats
+ player.stats.tutorialDungeonCompleted = true;
+ // Update tutorial dungeon quest progress
+ this.game.systems.questSystem.updateTutorialDungeonProgress();
+ } else {
+ // Update regular dungeon quest progress using the standard method
+ this.game.systems.questSystem.onDungeonCompleted();
+ }
+ }
+
+ // Show completion message
+ this.game.showNotification(`Dungeon completed! Time: ${this.game.formatTime(completionTime)}`, 'success', 5000);
+ if (timeBonus > 0) {
+ this.game.showNotification(`Time bonus: +${timeBonus} credits!`, 'info', 3000);
+ }
+
+ // Reset dungeon state
+ this.currentDungeon = null;
+ this.currentRoom = null;
+ this.isExploring = false;
+
+ // Return to dungeon list view
+ this.showDungeonList();
+ this.generateDungeonList();
+
+ // Only force UI refresh if in multiplayer mode or game is actively running
+ if (this.game.shouldUpdateGUI()) {
+ this.updateUI();
+ }
+ }
+
+ showDungeonList() {
+ const dungeonListElement = document.getElementById('dungeonList');
+ const dungeonViewElement = document.getElementById('dungeonView');
+
+ if (dungeonListElement) {
+ dungeonListElement.style.display = 'flex';
+ }
+
+ if (dungeonViewElement) {
+ dungeonViewElement.style.display = 'none';
+ // Clear the dungeon view content to prevent frozen display
+ dungeonViewElement.innerHTML = '';
+ }
+ }
+
+ showDungeonView() {
+
+ const dungeonListElement = document.getElementById('dungeonList');
+ const dungeonViewElement = document.getElementById('dungeonView');
+
+
+ if (dungeonListElement) {
+ dungeonListElement.style.display = 'none';
+ }
+
+ if (dungeonViewElement) {
+ dungeonViewElement.style.display = 'flex';
+ }
+
+
+ // Display the current dungeon
+ this.displayDungeon();
+
+ }
+
+ // UI updates
+ updateUI() {
+ // Update dungeon statistics if elements exist
+ const dungeonsClearedElement = document.getElementById('dungeonsCleared');
+ if (dungeonsClearedElement) {
+ dungeonsClearedElement.textContent = this.stats.dungeonsCompleted;
+ }
+ }
+
+ // Save/Load
+ save() {
+ return {
+ stats: this.stats,
+ currentDungeon: this.currentDungeon,
+ currentRoom: this.currentRoom,
+ dungeonProgress: this.dungeonProgress
+ };
+ }
+
+ load(data) {
+ if (data.stats) this.stats = { ...this.stats, ...data.stats };
+ if (data.currentDungeon) this.currentDungeon = data.currentDungeon;
+ if (data.currentRoom) this.currentRoom = data.currentRoom;
+ if (data.dungeonProgress !== undefined) this.dungeonProgress = data.dungeonProgress;
+ }
+}
diff --git a/Client-Server/js/systems/IdleSystem.js b/Client-Server/js/systems/IdleSystem.js
new file mode 100644
index 0000000..0eec3bd
--- /dev/null
+++ b/Client-Server/js/systems/IdleSystem.js
@@ -0,0 +1,357 @@
+/**
+ * Galaxy Strike Online - Idle System
+ * Manages offline progression and idle mechanics
+ */
+
+class IdleSystem {
+ constructor(gameEngine) {
+ this.game = gameEngine;
+
+ // Idle settings
+ this.maxOfflineTime = 7 * 24 * 60 * 60 * 1000; // 7 days in milliseconds
+ this.lastActiveTime = Date.now();
+ this.accumulatedTime = 0; // Track time for resource generation
+
+ // Idle production rates
+ this.productionRates = {
+ credits: 10, // credits per second (increased for better gameplay)
+ experience: 1, // experience per second (increased for better progression)
+ energy: 0.5 // energy regeneration per second
+ };
+
+ // Offline rewards
+ this.offlineRewards = {
+ credits: 0,
+ experience: 0,
+ energy: 0,
+ items: []
+ };
+
+ // Idle bonuses
+ this.bonuses = {
+ premium: 1.0,
+ guild: 1.0,
+ research: 1.0
+ };
+
+ // Idle achievements
+ this.achievements = {
+ totalOfflineTime: 0,
+ maxOfflineSession: 0,
+ totalIdleCredits: 0,
+ totalIdleExperience: 0
+ };
+ }
+
+ async initialize() {
+ // Calculate offline progress if returning
+ this.calculateOfflineProgress();
+}
+
+ calculateOfflineProgress(offlineTime = null) {
+ const currentTime = Date.now();
+ const actualOfflineTime = offlineTime || (currentTime - this.lastActiveTime);
+
+ // Cap offline time to maximum
+ const cappedOfflineTime = Math.min(actualOfflineTime, this.maxOfflineTime);
+
+ if (cappedOfflineTime < 60000) { // Less than 1 minute
+ return;
+ }
+
+ // Calculate production
+ const totalBonus = this.getTotalBonus();
+ const productionSeconds = cappedOfflineTime / 1000;
+
+ this.offlineRewards = {
+ credits: Math.floor(this.productionRates.credits * productionSeconds * totalBonus),
+ experience: Math.floor(this.productionRates.experience * productionSeconds * totalBonus),
+ energy: Math.min(
+ this.game.systems.player.attributes.maxEnergy,
+ Math.floor(this.productionRates.energy * productionSeconds)
+ ),
+ items: this.generateIdleItems(cappedOfflineTime)
+ };
+
+ // Update achievements
+ this.achievements.totalOfflineTime += cappedOfflineTime;
+ this.achievements.maxOfflineSession = Math.max(this.achievements.maxOfflineSession, cappedOfflineTime);
+ this.achievements.totalIdleCredits += this.offlineRewards.credits;
+ this.achievements.totalIdleExperience += this.offlineRewards.experience;
+
+ // Show offline rewards notification
+ this.showOfflineRewards(cappedOfflineTime);
+}
+
+ getTotalBonus() {
+ return this.bonuses.premium * this.bonuses.guild * this.bonuses.research;
+ }
+
+ generateIdleItems(offlineTime) {
+ const items = [];
+ const hours = offlineTime / (1000 * 60 * 60);
+
+ // Chance to find items based on offline time
+ const itemChance = Math.min(0.5, hours * 0.05);
+
+ if (Math.random() < itemChance) {
+ const itemCount = Math.floor(hours / 2) + 1;
+
+ for (let i = 0; i < itemCount; i++) {
+ const rarity = this.getRandomItemRarity();
+ const item = this.game.systems.inventory.generateItem('consumable', rarity);
+ items.push(item);
+ }
+ }
+
+ return items;
+ }
+
+ getRandomItemRarity() {
+ const roll = Math.random();
+ if (roll < 0.05) return 'legendary';
+ if (roll < 0.15) return 'epic';
+ if (roll < 0.35) return 'rare';
+ if (roll < 0.65) return 'uncommon';
+ return 'common';
+ }
+
+ showOfflineRewards(offlineTime) {
+ const timeString = this.game.formatTime(offlineTime);
+
+ this.game.showNotification(
+ `Welcome back! You were offline for ${timeString}`,
+ 'info',
+ 5000
+ );
+
+ // Format rewards message
+ let rewardsMessage = 'Offline Rewards:\n';
+ if (this.offlineRewards.credits > 0) {
+ rewardsMessage += `+${this.game.formatNumber(this.offlineRewards.credits)} credits\n`;
+ }
+ if (this.offlineRewards.experience > 0) {
+ rewardsMessage += `+${this.game.formatNumber(this.offlineRewards.experience)} XP\n`;
+ }
+ if (this.offlineRewards.energy > 0) {
+ rewardsMessage += `+${this.game.formatNumber(this.offlineRewards.energy)} energy\n`;
+ }
+ if (this.offlineRewards.items.length > 0) {
+ rewardsMessage += `+${this.offlineRewards.items.length} items\n`;
+ }
+
+ this.game.showNotification(rewardsMessage, 'success', 5000);
+ }
+
+ claimOfflineRewards() {
+ if (this.offlineRewards.credits === 0 &&
+ this.offlineRewards.experience === 0 &&
+ this.offlineRewards.items.length === 0) {
+ this.game.showNotification('No offline rewards to claim', 'info', 3000);
+ return;
+ }
+
+ // Give rewards
+ if (this.offlineRewards.credits > 0) {
+ this.game.systems.economy.addCredits(this.offlineRewards.credits, 'offline');
+ }
+
+ if (this.offlineRewards.experience > 0) {
+ this.game.systems.player.addExperience(this.offlineRewards.experience);
+ }
+
+ if (this.offlineRewards.energy > 0) {
+ this.game.systems.player.restoreEnergy(this.offlineRewards.energy);
+ }
+
+ // Add items to inventory
+ if (this.offlineRewards.items.length > 0) {
+ const inventory = this.game.systems.inventory;
+ this.offlineRewards.items.forEach(item => {
+ inventory.addItem(item);
+ });
+ }
+
+ // Reset offline rewards
+ this.offlineRewards = {
+ credits: 0,
+ experience: 0,
+ energy: 0,
+ items: []
+ };
+
+ this.game.showNotification('Offline rewards claimed!', 'success', 3000);
+ }
+
+ // Active idle production
+ update(deltaTime) {
+ if (this.game.state.paused) return;
+
+ // Use real computer time delta
+ const seconds = deltaTime / 1000;
+ const totalBonus = this.getTotalBonus();
+
+ // Only add resources once per second, not every frame
+ this.accumulatedTime += seconds;
+
+ if (this.accumulatedTime >= 1.0) {
+ // Calculate active production
+ const activeCredits = Math.floor(this.productionRates.credits * totalBonus);
+ const activeExperience = Math.floor(this.productionRates.experience * totalBonus);
+ // const activeEnergy = this.productionRates.energy * totalBonus * 0.1; // Energy is handled differently
+
+ // Add resources
+ if (activeCredits > 0) {
+ this.game.systems.economy.addCredits(activeCredits, 'idle');
+ }
+ if (activeExperience > 0) {
+ this.game.systems.player.addExperience(activeExperience);
+ }
+
+ // Regenerate energy
+ this.game.systems.player.restoreEnergy(this.productionRates.energy);
+
+ // Reset accumulated time, keeping any remainder
+ this.accumulatedTime -= 1.0;
+
+ // Debugging: Log when resources are added
+ // console.debug(`[IDLE] Added ${activeCredits} credits and ${activeExperience} XP. Accumulated time: ${this.accumulatedTime.toFixed(2)}s`);
+ }
+
+ // Update last active time for offline calculations
+ this.lastActiveTime = Date.now();
+ }
+
+ // Upgrade production rates
+ upgradeProduction(type) {
+ const upgradeCosts = {
+ credits: 100,
+ experience: 150,
+ energy: 80
+ };
+
+ const cost = upgradeCosts[type];
+ if (!cost || this.game.systems.economy.credits < cost) {
+ return false;
+ }
+
+ this.game.systems.economy.removeCredits(cost);
+
+ switch (type) {
+ case 'credits':
+ this.productionRates.credits += 2;
+ break;
+ case 'experience':
+ this.productionRates.experience += 1;
+ break;
+ case 'energy':
+ this.productionRates.energy += 0.2;
+ break;
+ }
+
+ this.game.showNotification(`Production upgraded: ${type}!`, 'success', 3000);
+return true;
+ }
+
+ // Bonus management
+ setBonus(type, value) {
+ if (this.bonuses[type] !== undefined) {
+ this.bonuses[type] = value;
+ this.game.showNotification(`${type} bonus set to ${value}x`, 'info', 3000);
+ }
+ }
+
+ // Achievement checking
+ checkAchievements() {
+ const achievements = [
+ {
+ id: 'idle_warrior',
+ name: 'Idle Warrior',
+ description: 'Earn 1,000,000 credits from idle',
+ condition: () => this.achievements.totalIdleCredits >= 1000000,
+ reward: { gems: 50, experience: 1000 }
+ },
+ {
+ id: 'time_master',
+ name: 'Time Master',
+ description: 'Accumulate 24 hours of offline time',
+ condition: () => this.achievements.totalOfflineTime >= 24 * 60 * 60 * 1000,
+ reward: { gems: 25, experience: 500 }
+ },
+ {
+ id: 'marathon_idle',
+ name: 'Marathon Idle',
+ description: 'Be offline for more than 12 hours at once',
+ condition: () => this.achievements.maxOfflineSession >= 12 * 60 * 60 * 1000,
+ reward: { gems: 100, experience: 2000 }
+ }
+ ];
+
+ achievements.forEach(achievement => {
+ if (achievement.condition()) {
+ this.unlockAchievement(achievement);
+ }
+ });
+ }
+
+ unlockAchievement(achievement) {
+ this.game.showNotification(`Achievement Unlocked: ${achievement.name}!`, 'success', 5000);
+ this.game.showNotification(achievement.description, 'info', 3000);
+
+ // Give rewards
+ if (achievement.reward.gems) {
+ this.game.systems.economy.addGems(achievement.reward.gems, 'achievement');
+ }
+
+ if (achievement.reward.experience) {
+ this.game.systems.player.addExperience(achievement.reward.experience);
+ }
+ }
+
+ // UI updates
+ updateUI() {
+ const offlineTimeElement = document.getElementById('offlineTime');
+ const offlineResourcesElement = document.getElementById('offlineResources');
+ const claimOfflineBtn = document.getElementById('claimOfflineBtn');
+
+ if (offlineTimeElement) {
+ const totalRewards = this.offlineRewards.credits +
+ this.offlineRewards.experience +
+ (this.offlineRewards.items.length * 100);
+ offlineTimeElement.textContent = totalRewards > 0 ? 'Available' : 'None';
+ }
+
+ if (offlineResourcesElement) {
+ const totalRewards = this.offlineRewards.credits +
+ this.offlineRewards.experience +
+ (this.offlineRewards.items.length * 100);
+ offlineResourcesElement.textContent = this.game.formatNumber(totalRewards);
+ }
+
+ if (claimOfflineBtn) {
+ const hasRewards = this.offlineRewards.credits > 0 ||
+ this.offlineRewards.experience > 0 ||
+ this.offlineRewards.items.length > 0;
+ claimOfflineBtn.disabled = !hasRewards;
+ }
+ }
+
+ // Save/Load
+ save() {
+ return {
+ lastActiveTime: this.lastActiveTime,
+ productionRates: this.productionRates,
+ bonuses: this.bonuses,
+ achievements: this.achievements,
+ offlineRewards: this.offlineRewards
+ };
+ }
+
+ load(data) {
+ if (data.lastActiveTime) this.lastActiveTime = data.lastActiveTime;
+ if (data.productionRates) this.productionRates = { ...this.productionRates, ...data.productionRates };
+ if (data.bonuses) this.bonuses = { ...this.bonuses, ...data.bonuses };
+ if (data.achievements) this.achievements = { ...this.achievements, ...data.achievements };
+ if (data.offlineRewards) this.offlineRewards = data.offlineRewards;
+}
+}
diff --git a/Client-Server/js/systems/QuestSystem.js b/Client-Server/js/systems/QuestSystem.js
new file mode 100644
index 0000000..3e01127
--- /dev/null
+++ b/Client-Server/js/systems/QuestSystem.js
@@ -0,0 +1,2726 @@
+/**
+ * Galaxy Strike Online - Quest System
+ * Manages hand-crafted and procedural quests
+ */
+
+class QuestSystem {
+ constructor(gameEngine) {
+ const debugLogger = window.debugLogger;
+
+ if (debugLogger) debugLogger.startStep('QuestSystem.constructor', {
+ gameEngineProvided: !!gameEngine
+ });
+
+ this.game = gameEngine;
+
+ // Quest types
+ this.questTypes = {
+ main: 'Main Story',
+ daily: 'Daily',
+ weekly: 'Weekly',
+ completed: 'Completed',
+ failed: 'Failed Quests'
+ };
+
+ // Quest status
+ this.questStatus = {
+ available: 'available',
+ active: 'active',
+ completed: 'completed',
+ failed: 'failed'
+ };
+
+ if (debugLogger) debugLogger.logStep('Quest system configuration initialized', {
+ questTypes: Object.keys(this.questTypes),
+ questStatus: Object.keys(this.questStatus)
+ });
+
+ // Main story quests
+ this.mainQuests = [
+ {
+ id: 'tutorial_complete',
+ name: 'First Steps',
+ description: 'Complete the tutorial dungeon and learn the basics',
+ type: 'main',
+ status: 'available',
+ requirements: { level: 1 },
+ objectives: [
+ { id: 'clear_tutorial_dungeon', description: 'Complete the tutorial dungeon', target: 1, current: 0, type: 'tutorial_dungeon' },
+ { id: 'reach_level_2', description: 'Reach level 2', target: 2, current: 0, type: 'level' }
+ ],
+ rewards: { credits: 500, experience: 100, gems: 5 },
+ nextQuest: 'first_ship_upgrade'
+ },
+ {
+ id: 'first_ship_upgrade',
+ name: 'Ship Enhancement',
+ description: 'Upgrade your ship for better performance',
+ type: 'main',
+ status: 'available',
+ requirements: { quest: 'tutorial_complete' },
+ objectives: [
+ { id: 'upgrade_weapon', description: 'Upgrade ship weapons', target: 1, current: 0, type: 'upgrade' },
+ { id: 'upgrade_shield', description: 'Upgrade ship shields', target: 1, current: 0, type: 'upgrade' }
+ ],
+ rewards: { credits: 1000, experience: 200, gems: 10 },
+ nextQuest: 'join_guild'
+ },
+ {
+ id: 'join_guild',
+ name: 'Guild Recruitment',
+ description: 'Join a guild and participate in guild activities',
+ type: 'main',
+ status: 'available',
+ requirements: { quest: 'first_ship_upgrade', level: 5 },
+ objectives: [
+ { id: 'join_guild', description: 'Join a guild', target: 1, current: 0, type: 'guild' },
+ { id: 'guild_contribution', description: 'Contribute to guild', target: 100, current: 0, type: 'contribution' }
+ ],
+ rewards: { credits: 2000, experience: 500, gems: 20 },
+ nextQuest: 'master_commander'
+ },
+ {
+ id: 'master_commander',
+ name: 'Master Commander',
+ description: 'Become a master commander and lead your fleet to victory',
+ type: 'main',
+ status: 'available',
+ requirements: { quest: 'join_guild', level: 10 },
+ objectives: [
+ { id: 'reach_level_10', description: 'Reach level 10', target: 10, current: 0, type: 'level' },
+ { id: 'clear_10_dungeons', description: 'Clear 10 dungeons', target: 10, current: 0, type: 'dungeon' },
+ { id: 'max_skill', description: 'Max out one skill', target: 10, current: 0, type: 'skill' }
+ ],
+ rewards: { credits: 5000, experience: 1000, gems: 50, item: 'legendary_weapon' }
+ }
+ ];
+
+ // All possible daily quests (20 total)
+ this.allDailyQuests = [
+ // Easy quests (difficulty: 1)
+ {
+ id: 'daily_dungeon_easy',
+ name: 'Quick Dungeon Run',
+ description: 'Complete any dungeon',
+ type: 'daily',
+ difficulty: 1,
+ status: 'available',
+ objectives: [
+ { id: 'clear_dungeon', description: 'Clear 1 dungeon', target: 1, current: 0, type: 'dungeon' }
+ ],
+ rewards: { credits: 100, experience: 25, gems: 1 }
+ },
+ {
+ id: 'daily_combat_easy',
+ name: 'Light Combat',
+ description: 'Defeat a few enemies',
+ type: 'daily',
+ difficulty: 1,
+ status: 'available',
+ objectives: [
+ { id: 'defeat_enemies', description: 'Defeat 10 enemies', target: 10, current: 0, type: 'combat' }
+ ],
+ rewards: { credits: 80, experience: 20, gems: 1 }
+ },
+ {
+ id: 'daily_crafting_easy',
+ name: 'Basic Crafting',
+ description: 'Craft some items',
+ type: 'daily',
+ difficulty: 1,
+ status: 'available',
+ objectives: [
+ { id: 'craft_items', description: 'Craft 2 items', target: 2, current: 0, type: 'crafting' }
+ ],
+ rewards: { credits: 90, experience: 22, gems: 1 }
+ },
+ {
+ id: 'daily_level_easy',
+ name: 'Level Up',
+ description: 'Gain experience and level up',
+ type: 'daily',
+ difficulty: 1,
+ status: 'available',
+ objectives: [
+ { id: 'gain_level', description: 'Gain 1 level', target: 1, current: 0, type: 'level' }
+ ],
+ rewards: { credits: 120, experience: 30, gems: 2 }
+ },
+ {
+ id: 'daily_energy_easy',
+ name: 'Energy Management',
+ description: 'Use energy efficiently',
+ type: 'daily',
+ difficulty: 1,
+ status: 'available',
+ objectives: [
+ { id: 'use_energy', description: 'Use 50 energy', target: 50, current: 0, type: 'energy' }
+ ],
+ rewards: { credits: 70, experience: 18, gems: 1 }
+ },
+ // Medium quests (difficulty: 2)
+ {
+ id: 'daily_dungeon_medium',
+ name: 'Dungeon Explorer',
+ description: 'Complete multiple dungeons',
+ type: 'daily',
+ difficulty: 2,
+ status: 'available',
+ objectives: [
+ { id: 'clear_dungeons', description: 'Clear 3 dungeons', target: 3, current: 0, type: 'dungeon' }
+ ],
+ rewards: { credits: 300, experience: 75, gems: 3 }
+ },
+ {
+ id: 'daily_combat_medium',
+ name: 'Combat Training',
+ description: 'Defeat enemies in combat',
+ type: 'daily',
+ difficulty: 2,
+ status: 'available',
+ objectives: [
+ { id: 'defeat_enemies', description: 'Defeat 20 enemies', target: 20, current: 0, type: 'combat' }
+ ],
+ rewards: { credits: 150, experience: 40, gems: 1 }
+ },
+ {
+ id: 'daily_combat_hard',
+ name: 'Combat Veteran',
+ description: 'Defeat many enemies',
+ type: 'daily',
+ difficulty: 2,
+ status: 'available',
+ objectives: [
+ { id: 'defeat_enemies', description: 'Defeat 50 enemies', target: 50, current: 0, type: 'combat' }
+ ],
+ rewards: { credits: 250, experience: 60, gems: 3 }
+ },
+ {
+ id: 'daily_crafting_medium',
+ name: 'Master Crafter',
+ description: 'Craft many items',
+ type: 'daily',
+ difficulty: 2,
+ status: 'available',
+ objectives: [
+ { id: 'craft_items', description: 'Craft 5 items', target: 5, current: 0, type: 'crafting' }
+ ],
+ rewards: { credits: 280, experience: 70, gems: 3 }
+ },
+ {
+ id: 'daily_upgrade_medium',
+ name: 'Equipment Upgrade',
+ description: 'Upgrade your equipment',
+ type: 'daily',
+ difficulty: 2,
+ status: 'available',
+ objectives: [
+ { id: 'upgrade_items', description: 'Upgrade 3 items', target: 3, current: 0, type: 'upgrade' }
+ ],
+ rewards: { credits: 320, experience: 80, gems: 4 }
+ },
+ {
+ id: 'daily_wealth_medium',
+ name: 'Wealth Accumulator',
+ description: 'Earn credits',
+ type: 'daily',
+ difficulty: 2,
+ status: 'available',
+ objectives: [
+ { id: 'earn_credits', description: 'Earn 1000 credits', target: 1000, current: 0, type: 'credits' }
+ ],
+ rewards: { credits: 400, experience: 50, gems: 3 }
+ },
+ // Hard quests (difficulty: 3)
+ {
+ id: 'daily_dungeon_hard',
+ name: 'Dungeon Master',
+ description: 'Complete many dungeons',
+ type: 'daily',
+ difficulty: 3,
+ status: 'available',
+ objectives: [
+ { id: 'clear_dungeons', description: 'Clear 5 dungeons', target: 5, current: 0, type: 'dungeon' }
+ ],
+ rewards: { credits: 600, experience: 150, gems: 6 }
+ },
+ {
+ id: 'daily_combat_hard',
+ name: 'Combat Master',
+ description: 'Defeat many powerful enemies',
+ type: 'daily',
+ difficulty: 3,
+ status: 'available',
+ objectives: [
+ { id: 'defeat_enemies', description: 'Defeat 100 enemies', target: 100, current: 0, type: 'combat' }
+ ],
+ rewards: { credits: 500, experience: 120, gems: 5 }
+ },
+ {
+ id: 'daily_level_hard',
+ name: 'Power Leveling',
+ description: 'Gain multiple levels',
+ type: 'daily',
+ difficulty: 3,
+ status: 'available',
+ objectives: [
+ { id: 'gain_levels', description: 'Gain 3 levels', target: 3, current: 0, type: 'level' }
+ ],
+ rewards: { credits: 700, experience: 200, gems: 7 }
+ },
+ {
+ id: 'daily_boss_hard',
+ name: 'Boss Hunter',
+ description: 'Defeat boss enemies',
+ type: 'daily',
+ difficulty: 3,
+ status: 'available',
+ objectives: [
+ { id: 'defeat_bosses', description: 'Defeat 3 bosses', target: 3, current: 0, type: 'boss' }
+ ],
+ rewards: { credits: 800, experience: 180, gems: 8 }
+ },
+ {
+ id: 'daily_collection_hard',
+ name: 'Master Collector',
+ description: 'Collect rare items',
+ type: 'daily',
+ difficulty: 3,
+ status: 'available',
+ objectives: [
+ { id: 'collect_rare', description: 'Collect 10 rare items', target: 10, current: 0, type: 'collection' }
+ ],
+ rewards: { credits: 650, experience: 140, gems: 6 }
+ },
+ // Special quests (difficulty: 4)
+ {
+ id: 'daily_speedrun',
+ name: 'Speed Runner',
+ description: 'Complete dungeons quickly',
+ type: 'daily',
+ difficulty: 4,
+ status: 'available',
+ objectives: [
+ { id: 'fast_dungeon', description: 'Complete 2 dungeons under 5 minutes', target: 2, current: 0, type: 'speedrun' }
+ ],
+ rewards: { credits: 1000, experience: 250, gems: 10 }
+ },
+ {
+ id: 'daily_perfection',
+ name: 'Perfectionist',
+ description: 'Complete objectives without taking damage',
+ type: 'daily',
+ difficulty: 4,
+ status: 'available',
+ objectives: [
+ { id: 'perfect_runs', description: '3 perfect dungeon runs', target: 3, current: 0, type: 'perfect' }
+ ],
+ rewards: { credits: 1200, experience: 300, gems: 12 }
+ },
+ {
+ id: 'daily_multitask',
+ name: 'Multitask Master',
+ description: 'Complete multiple quest types',
+ type: 'daily',
+ difficulty: 4,
+ status: 'available',
+ objectives: [
+ { id: 'dungeon_task', description: 'Clear 2 dungeons', target: 2, current: 0, type: 'dungeon' },
+ { id: 'combat_task', description: 'Defeat 30 enemies', target: 30, current: 0, type: 'combat' },
+ { id: 'craft_task', description: 'Craft 2 items', target: 2, current: 0, type: 'crafting' }
+ ],
+ rewards: { credits: 1500, experience: 400, gems: 15 }
+ },
+ {
+ id: 'daily_endurance',
+ name: 'Endurance Test',
+ description: 'Complete long activities',
+ type: 'daily',
+ difficulty: 4,
+ status: 'available',
+ objectives: [
+ { id: 'long_dungeon', description: 'Complete 1 dungeon without healing', target: 1, current: 0, type: 'endurance' }
+ ],
+ rewards: { credits: 1100, experience: 280, gems: 11 }
+ },
+ {
+ id: 'daily_legendary',
+ name: 'Legendary Challenge',
+ description: 'Complete legendary difficulty content',
+ type: 'daily',
+ difficulty: 4,
+ status: 'available',
+ objectives: [
+ { id: 'legendary_content', description: 'Complete 1 legendary dungeon', target: 1, current: 0, type: 'legendary' }
+ ],
+ rewards: { credits: 2000, experience: 500, gems: 20, item: 'rare_material' }
+ }
+ ];
+
+ // Weekly quests (25 total quests with varied objectives)
+ this.allWeeklyQuests = [
+ // Combat-focused weekly quests
+ {
+ id: 'weekly_combat_basic',
+ name: 'Weekly Combat Duty',
+ description: 'Complete combat objectives throughout the week',
+ type: 'weekly',
+ difficulty: 1,
+ status: 'available',
+ objectives: [
+ { id: 'defeat_enemies', description: 'Defeat 100 enemies', target: 100, current: 0, type: 'combat' }
+ ],
+ rewards: { credits: 800, experience: 200, gems: 8 }
+ },
+ {
+ id: 'weekly_combat_elite',
+ name: 'Elite Hunter Weekly',
+ description: 'Hunt down elite enemies',
+ type: 'weekly',
+ difficulty: 3,
+ status: 'available',
+ objectives: [
+ { id: 'defeat_elites', description: 'Defeat 25 elite enemies', target: 25, current: 0, type: 'elite_combat' }
+ ],
+ rewards: { credits: 1500, experience: 400, gems: 15 }
+ },
+ {
+ id: 'weekly_boss_hunter',
+ name: 'Boss Hunter Weekly',
+ description: 'Defeat powerful boss enemies',
+ type: 'weekly',
+ difficulty: 4,
+ status: 'available',
+ objectives: [
+ { id: 'defeat_bosses', description: 'Defeat 10 bosses', target: 10, current: 0, type: 'boss' }
+ ],
+ rewards: { credits: 2500, experience: 600, gems: 25, item: 'boss_material' }
+ },
+
+ // Dungeon-focused weekly quests
+ {
+ id: 'weekly_dungeon_explorer',
+ name: 'Weekly Dungeon Explorer',
+ description: 'Explore various dungeons',
+ type: 'weekly',
+ difficulty: 2,
+ status: 'available',
+ objectives: [
+ { id: 'clear_dungeons', description: 'Clear 15 dungeons', target: 15, current: 0, type: 'dungeon' }
+ ],
+ rewards: { credits: 1200, experience: 300, gems: 12 }
+ },
+ {
+ id: 'weekly_dungeon_master',
+ name: 'Weekly Dungeon Master',
+ description: 'Master difficult dungeons',
+ type: 'weekly',
+ difficulty: 3,
+ status: 'available',
+ objectives: [
+ { id: 'clear_hard_dungeons', description: 'Clear 10 hard dungeons', target: 10, current: 0, type: 'hard_dungeon' }
+ ],
+ rewards: { credits: 2000, experience: 500, gems: 20 }
+ },
+ {
+ id: 'weekly_dungeon_extreme',
+ name: 'Extreme Dungeon Challenge',
+ description: 'Conquer extreme difficulty dungeons',
+ type: 'weekly',
+ difficulty: 4,
+ status: 'available',
+ objectives: [
+ { id: 'clear_extreme_dungeons', description: 'Clear 5 extreme dungeons', target: 5, current: 0, type: 'extreme_dungeon' }
+ ],
+ rewards: { credits: 3500, experience: 800, gems: 35, item: 'extreme_material' }
+ },
+
+ // Crafting and upgrade weekly quests
+ {
+ id: 'weekly_crafting_basic',
+ name: 'Weekly Crafting Session',
+ description: 'Craft items throughout the week',
+ type: 'weekly',
+ difficulty: 1,
+ status: 'available',
+ objectives: [
+ { id: 'craft_items', description: 'Craft 20 items', target: 20, current: 0, type: 'crafting' }
+ ],
+ rewards: { credits: 600, experience: 150, gems: 6 }
+ },
+ {
+ id: 'weekly_crafting_master',
+ name: 'Master Crafter Weekly',
+ description: 'Craft advanced items',
+ type: 'weekly',
+ difficulty: 3,
+ status: 'available',
+ objectives: [
+ { id: 'craft_advanced', description: 'Craft 10 advanced items', target: 10, current: 0, type: 'advanced_crafting' }
+ ],
+ rewards: { credits: 1800, experience: 450, gems: 18 }
+ },
+ {
+ id: 'weekly_upgrade_specialist',
+ name: 'Weekly Upgrade Specialist',
+ description: 'Upgrade equipment and systems',
+ type: 'weekly',
+ difficulty: 2,
+ status: 'available',
+ objectives: [
+ { id: 'upgrade_items', description: 'Upgrade 15 items', target: 15, current: 0, type: 'upgrade' }
+ ],
+ rewards: { credits: 1400, experience: 350, gems: 14 }
+ },
+
+ // Progression weekly quests
+ {
+ id: 'weekly_level_up',
+ name: 'Weekly Level Up Challenge',
+ description: 'Gain levels throughout the week',
+ type: 'weekly',
+ difficulty: 2,
+ status: 'available',
+ objectives: [
+ { id: 'gain_levels', description: 'Gain 5 levels', target: 5, current: 0, type: 'level' }
+ ],
+ rewards: { credits: 1000, experience: 250, gems: 10 }
+ },
+ {
+ id: 'weekly_skill_master',
+ name: 'Weekly Skill Mastery',
+ description: 'Improve your skills',
+ type: 'weekly',
+ difficulty: 3,
+ status: 'available',
+ objectives: [
+ { id: 'improve_skills', description: 'Gain 20 skill points', target: 20, current: 0, type: 'skill' }
+ ],
+ rewards: { credits: 1600, experience: 400, gems: 16 }
+ },
+
+ // Resource and wealth weekly quests
+ {
+ id: 'weekly_wealth_collector',
+ name: 'Weekly Wealth Collector',
+ description: 'Accumulate wealth',
+ type: 'weekly',
+ difficulty: 2,
+ status: 'available',
+ objectives: [
+ { id: 'earn_credits', description: 'Earn 5000 credits', target: 5000, current: 0, type: 'credits' }
+ ],
+ rewards: { credits: 2000, experience: 300, gems: 12 }
+ },
+ {
+ id: 'weekly_resource_gatherer',
+ name: 'Weekly Resource Gathering',
+ description: 'Collect valuable resources',
+ type: 'weekly',
+ difficulty: 2,
+ status: 'available',
+ objectives: [
+ { id: 'collect_resources', description: 'Collect 500 resources', target: 500, current: 0, type: 'collection' }
+ ],
+ rewards: { credits: 1200, experience: 320, gems: 13 }
+ },
+
+ // Special activity weekly quests
+ {
+ id: 'weekly_energy_management',
+ name: 'Weekly Energy Management',
+ description: 'Use energy efficiently',
+ type: 'weekly',
+ difficulty: 1,
+ status: 'available',
+ objectives: [
+ { id: 'use_energy', description: 'Use 500 energy', target: 500, current: 0, type: 'energy' }
+ ],
+ rewards: { credits: 800, experience: 180, gems: 8 }
+ },
+ {
+ id: 'weekly_speed_demon',
+ name: 'Weekly Speed Demon',
+ description: 'Complete activities quickly',
+ type: 'weekly',
+ difficulty: 3,
+ status: 'available',
+ objectives: [
+ { id: 'speed_runs', description: 'Complete 10 speed runs', target: 10, current: 0, type: 'speedrun' }
+ ],
+ rewards: { credits: 2200, experience: 550, gems: 22 }
+ },
+ {
+ id: 'weekly_perfectionist',
+ name: 'Weekly Perfectionist',
+ description: 'Complete flawless runs',
+ type: 'weekly',
+ difficulty: 4,
+ status: 'available',
+ objectives: [
+ { id: 'perfect_runs', description: 'Complete 8 perfect runs', target: 8, current: 0, type: 'perfect' }
+ ],
+ rewards: { credits: 3000, experience: 700, gems: 30, item: 'perfection_material' }
+ },
+
+ // Multi-objective weekly quests
+ {
+ id: 'weekly_all_rounder',
+ name: 'Weekly All-Rounder',
+ description: 'Complete various activities',
+ type: 'weekly',
+ difficulty: 3,
+ status: 'available',
+ objectives: [
+ { id: 'dungeon_task', description: 'Clear 8 dungeons', target: 8, current: 0, type: 'dungeon' },
+ { id: 'combat_task', description: 'Defeat 50 enemies', target: 50, current: 0, type: 'combat' },
+ { id: 'craft_task', description: 'Craft 5 items', target: 5, current: 0, type: 'crafting' }
+ ],
+ rewards: { credits: 2500, experience: 600, gems: 25 }
+ },
+ {
+ id: 'weekly_specialist',
+ name: 'Weekly Specialist',
+ description: 'Focus on specialized activities',
+ type: 'weekly',
+ difficulty: 3,
+ status: 'available',
+ objectives: [
+ { id: 'special_dungeons', description: 'Clear 5 themed dungeons', target: 5, current: 0, type: 'themed_dungeon' },
+ { id: 'special_crafting', description: 'Craft 8 themed items', target: 8, current: 0, type: 'themed_crafting' }
+ ],
+ rewards: { credits: 2300, experience: 580, gems: 23 }
+ },
+
+ // Exploration and discovery weekly quests
+ {
+ id: 'weekly_explorer',
+ name: 'Weekly Explorer',
+ description: 'Explore new areas and content',
+ type: 'weekly',
+ difficulty: 2,
+ status: 'available',
+ objectives: [
+ { id: 'explore_areas', description: 'Explore 20 new areas', target: 20, current: 0, type: 'exploration' }
+ ],
+ rewards: { credits: 1300, experience: 340, gems: 13 }
+ },
+ {
+ id: 'weekly_discovery',
+ name: 'Weekly Discovery',
+ description: 'Discover hidden secrets',
+ type: 'weekly',
+ difficulty: 3,
+ status: 'available',
+ objectives: [
+ { id: 'discover_secrets', description: 'Discover 15 secrets', target: 15, current: 0, type: 'discovery' }
+ ],
+ rewards: { credits: 1900, experience: 480, gems: 19 }
+ },
+
+ // Endurance and challenge weekly quests
+ {
+ id: 'weekly_endurance',
+ name: 'Weekly Endurance Test',
+ description: 'Complete long-form challenges',
+ type: 'weekly',
+ difficulty: 3,
+ status: 'available',
+ objectives: [
+ { id: 'endurance_runs', description: 'Complete 5 endurance runs', target: 5, current: 0, type: 'endurance' }
+ ],
+ rewards: { credits: 2100, experience: 530, gems: 21 }
+ },
+ {
+ id: 'weekly_survivor',
+ name: 'Weekly Survivor',
+ description: 'Survive challenging conditions',
+ type: 'weekly',
+ difficulty: 4,
+ status: 'available',
+ objectives: [
+ { id: 'survival_runs', description: 'Complete 3 survival runs', target: 3, current: 0, type: 'survival' }
+ ],
+ rewards: { credits: 3200, experience: 750, gems: 32, item: 'survival_material' }
+ },
+
+ // Social and community weekly quests
+ {
+ id: 'weekly_helper',
+ name: 'Weekly Helper',
+ description: 'Assist other players',
+ type: 'weekly',
+ difficulty: 2,
+ status: 'available',
+ objectives: [
+ { id: 'assist_players', description: 'Assist 10 players', target: 10, current: 0, type: 'assist' }
+ ],
+ rewards: { credits: 1100, experience: 280, gems: 11 }
+ },
+ {
+ id: 'weekly_leader',
+ name: 'Weekly Leader',
+ description: 'Lead group activities',
+ type: 'weekly',
+ difficulty: 3,
+ status: 'available',
+ objectives: [
+ { id: 'lead_activities', description: 'Lead 5 group activities', target: 5, current: 0, type: 'leadership' }
+ ],
+ rewards: { credits: 1700, experience: 430, gems: 17 }
+ },
+
+ // Legendary weekly quests
+ {
+ id: 'weekly_legendary',
+ name: 'Weekly Legendary Challenge',
+ description: 'Complete legendary difficulty content',
+ type: 'weekly',
+ difficulty: 5,
+ status: 'available',
+ objectives: [
+ { id: 'legendary_content', description: 'Complete 3 legendary dungeons', target: 3, current: 0, type: 'legendary' }
+ ],
+ rewards: { credits: 5000, experience: 1200, gems: 50, item: 'legendary_material' }
+ },
+ {
+ id: 'weekly_mythic',
+ name: 'Weekly Mythic Trial',
+ description: 'Face mythic level challenges',
+ type: 'weekly',
+ difficulty: 5,
+ status: 'available',
+ objectives: [
+ { id: 'mythic_trials', description: 'Complete 2 mythic trials', target: 2, current: 0, type: 'mythic' }
+ ],
+ rewards: { credits: 6000, experience: 1500, gems: 60, item: 'mythic_material' }
+ }
+ ];
+
+ // Currently active daily quests (3 random from allDailyQuests)
+ this.dailyQuests = [];
+ this.selectedDailyQuests = [];
+
+ // Currently active weekly quests (5 random from allWeeklyQuests)
+ this.weeklyQuests = [];
+ this.selectedWeeklyQuests = [];
+
+ // Current active quests
+ this.activeQuests = [];
+ this.completedQuests = [];
+ this.failedQuests = [];
+ this.completedDailyQuests = []; // History of completed daily quests
+ this.completedWeeklyQuests = []; // History of completed weekly quests
+
+ // Initialize daily quests with safety check
+ try {
+ if (this.allDailyQuests && Array.isArray(this.allDailyQuests)) {
+ console.log('[QUEST SYSTEM] Initializing daily quests...');
+ this.randomizeDailyQuests();
+ } else {
+ console.warn('[QUEST SYSTEM] allDailyQuests not properly initialized, skipping daily quest initialization');
+ this.dailyQuests = [];
+ this.selectedDailyQuests = [];
+ }
+ } catch (error) {
+ console.error('[QUEST SYSTEM] Error initializing daily quests:', error);
+ // Fallback to empty arrays to prevent crash
+ this.dailyQuests = [];
+ this.selectedDailyQuests = [];
+ this.activeQuests = [];
+ }
+
+ // Initialize weekly quests with safety check
+ try {
+ if (this.allWeeklyQuests && Array.isArray(this.allWeeklyQuests)) {
+ console.log('[QUEST SYSTEM] Initializing weekly quests...');
+ this.randomizeWeeklyQuests();
+ } else {
+ console.warn('[QUEST SYSTEM] allWeeklyQuests not properly initialized, skipping weekly quest initialization');
+ this.weeklyQuests = [];
+ this.selectedWeeklyQuests = [];
+ }
+ } catch (error) {
+ console.error('[QUEST SYSTEM] Error initializing weekly quests:', error);
+ // Fallback to empty arrays to prevent crash
+ this.weeklyQuests = [];
+ this.selectedWeeklyQuests = [];
+ this.activeQuests = [];
+ }
+
+ // Procedural quest templates
+ this.proceduralTemplates = {
+ bounty: {
+ name: 'Bounty Hunt',
+ description: 'Hunt down dangerous targets in the galaxy',
+ objectives: [
+ { id: 'defeat_targets', description: 'Defeat {target} targets', target: 5, current: 0, type: 'combat' }
+ ],
+ rewards: { credits: 300, experience: 75 }
+ },
+ exploration: {
+ name: 'Exploration Mission',
+ description: 'Explore uncharted regions of space',
+ objectives: [
+ { id: 'explore_areas', description: 'Explore {target} areas', target: 3, current: 0, type: 'exploration' }
+ ],
+ rewards: { credits: 250, experience: 60 }
+ },
+ collection: {
+ name: 'Resource Collection',
+ description: 'Collect valuable resources',
+ objectives: [
+ { id: 'collect_resources', description: 'Collect {target} resources', target: 100, current: 0, type: 'collection' }
+ ],
+ rewards: { credits: 200, experience: 50 }
+ },
+ escort: {
+ name: 'Escort Mission',
+ description: 'Escort valuable cargo through dangerous space',
+ objectives: [
+ { id: 'escort_complete', description: 'Complete escort mission', target: 1, current: 0, type: 'escort' }
+ ],
+ rewards: { credits: 400, experience: 100 }
+ }
+ };
+
+ // Quest generation settings
+ this.maxProceduralQuests = 3;
+ this.proceduralQuestRefresh = 30 * 60 * 1000; // 30 minutes
+
+ // Statistics
+ this.stats = {
+ questsCompleted: 0,
+ dailyQuestsCompleted: 0,
+ weeklyQuestsCompleted: 0,
+ totalRewardsEarned: { credits: 0, experience: 0, gems: 0 },
+ lastDailyReset: Date.now(),
+ lastWeeklyReset: Date.now()
+ };
+
+ // Initialize daily quests
+ this.randomizeDailyQuests();
+
+ // Initialize weekly quests
+ this.randomizeWeeklyQuests();
+
+ if (debugLogger) debugLogger.endStep('QuestSystem.constructor', {
+ mainQuestsCount: this.mainQuests.length,
+ allDailyQuestsCount: this.allDailyQuests.length,
+ allWeeklyQuestsCount: this.allWeeklyQuests.length,
+ maxProceduralQuests: this.maxProceduralQuests,
+ proceduralQuestRefresh: this.proceduralQuestRefresh,
+ initialStats: this.stats,
+ dailyQuestsInitialized: this.dailyQuests.length,
+ weeklyQuestsInitialized: this.weeklyQuests.length
+ });
+ }
+
+ async initialize() {
+ const debugLogger = window.debugLogger;
+
+ if (debugLogger) debugLogger.startStep('QuestSystem.initialize', {
+ mainQuestsCount: this.mainQuests.length,
+ activeQuestsCount: this.activeQuests.length,
+ dailyQuestsCount: this.dailyQuests.length
+ });
+
+ // Initialize main quests
+ if (debugLogger) debugLogger.logStep('Initializing main quests');
+ this.initializeMainQuests();
+
+ // Check for daily reset
+ if (debugLogger) debugLogger.logStep('Checking for daily reset');
+ this.checkDailyReset();
+
+ // Check for weekly reset
+ if (debugLogger) debugLogger.logStep('Checking for weekly reset');
+ this.checkWeeklyReset();
+
+ // Start daily countdown timer
+ if (debugLogger) debugLogger.logStep('Starting daily countdown timer');
+ this.startDailyCountdown();
+
+ // Start weekly countdown timer
+ if (debugLogger) debugLogger.logStep('Starting weekly countdown timer');
+ this.startWeeklyCountdown();
+
+ // Update UI
+ this.updateQuestList();
+
+ if (debugLogger) debugLogger.endStep('QuestSystem.initialize', {
+ mainQuestsInitialized: true,
+ dailyResetChecked: true,
+ weeklyResetChecked: true,
+ countdownStarted: true,
+ weeklyQuestsInitialized: true,
+ uiUpdated: true
+ });
+ }
+
+ initializeMainQuests() {
+ const debugLogger = window.debugLogger;
+
+ if (debugLogger) debugLogger.startStep('QuestSystem.initializeMainQuests', {
+ mainQuestsCount: this.mainQuests.length
+ });
+
+ // Set all quests to locked initially, then unlock based on requirements
+ this.mainQuests.forEach(quest => {
+ quest.status = 'locked';
+ });
+
+ if (debugLogger) debugLogger.logStep('All main quests set to locked status');
+
+ // Unlock first quest
+ if (this.mainQuests.length > 0) {
+ const firstQuest = this.mainQuests[0];
+ firstQuest.status = 'available';
+
+ if (debugLogger) debugLogger.logStep('First quest unlocked', {
+ questId: firstQuest.id,
+ questName: firstQuest.name
+ });
+ }
+
+ // Check quest availability based on requirements
+ if (debugLogger) debugLogger.logStep('Checking quest availability based on requirements');
+ this.checkQuestAvailability();
+
+ if (debugLogger) debugLogger.endStep('QuestSystem.initializeMainQuests', {
+ questsProcessed: this.mainQuests.length,
+ availableQuests: this.mainQuests.filter(q => q.status === 'available').length,
+ lockedQuests: this.mainQuests.filter(q => q.status === 'locked').length
+ });
+ }
+
+ checkQuestAvailability() {
+ const debugLogger = window.debugLogger;
+ const player = this.game.systems.player;
+
+ if (debugLogger) debugLogger.startStep('QuestSystem.checkQuestAvailability', {
+ playerLevel: player.stats.level,
+ mainQuestsCount: this.mainQuests.length
+ });
+
+ const availabilityChanges = [];
+
+ this.mainQuests.forEach(quest => {
+ const oldStatus = quest.status;
+ const requirementsMet = this.checkQuestRequirements(quest);
+
+ if (quest.status === 'locked' && requirementsMet) {
+ quest.status = 'available';
+ availabilityChanges.push({
+ questId: quest.id,
+ questName: quest.name,
+ oldStatus: oldStatus,
+ newStatus: 'available',
+ reason: 'Requirements met'
+ });
+ this.game.showNotification(`New quest available: ${quest.name}`, 'info', 5000);
+ } else if (quest.status === 'available' && !requirementsMet) {
+ // Hide quests that were available but no longer meet requirements
+ quest.status = 'locked';
+ availabilityChanges.push({
+ questId: quest.id,
+ questName: quest.name,
+ oldStatus: oldStatus,
+ newStatus: 'locked',
+ reason: 'Requirements no longer met'
+ });
+ }
+ });
+
+ if (debugLogger) debugLogger.endStep('QuestSystem.checkQuestAvailability', {
+ availabilityChanges: availabilityChanges,
+ questsProcessed: this.mainQuests.length,
+ availableQuests: this.mainQuests.filter(q => q.status === 'available').length,
+ lockedQuests: this.mainQuests.filter(q => q.status === 'locked').length
+ });
+ }
+
+ // Quest management
+ startQuest(questId) {
+ const debugLogger = window.debugLogger;
+
+ if (debugLogger) debugLogger.startStep('QuestSystem.startQuest', {
+ questId: questId,
+ currentActiveQuests: this.activeQuests.length
+ });
+
+ const quest = this.findQuest(questId);
+ if (!quest) {
+ console.log('Quest not found:', questId);
+
+ if (debugLogger) debugLogger.endStep('QuestSystem.startQuest', {
+ success: false,
+ reason: 'Quest not found',
+ questId: questId
+ });
+ return false;
+ }
+
+ console.log('Attempting to start quest:', questId, 'status:', quest.status);
+
+ if (debugLogger) debugLogger.logStep('Quest found', {
+ questId: quest.id,
+ questName: quest.name,
+ questType: quest.type,
+ currentStatus: quest.status,
+ requirements: quest.requirements
+ });
+
+ if (quest.status !== 'available') {
+ console.log('Quest not available, status:', quest.status);
+ this.game.showNotification('Quest is not available', 'error', 3000);
+
+ if (debugLogger) debugLogger.endStep('QuestSystem.startQuest', {
+ success: false,
+ reason: 'Quest not available',
+ questId: questId,
+ questName: quest.name,
+ currentStatus: quest.status
+ });
+ return false;
+ }
+
+ // Check requirements
+ const requirementsMet = this.checkQuestRequirements(quest);
+ console.log('Requirements met:', requirementsMet, 'for quest:', questId);
+
+ if (debugLogger) debugLogger.logStep('Requirements check', {
+ requirements: quest.requirements,
+ requirementsMet: requirementsMet
+ });
+
+ if (!requirementsMet) {
+ this.game.showNotification('Requirements not met', 'error', 3000);
+
+ if (debugLogger) debugLogger.endStep('QuestSystem.startQuest', {
+ success: false,
+ reason: 'Requirements not met',
+ questId: questId,
+ questName: quest.name,
+ requirements: quest.requirements
+ });
+ return false;
+ }
+
+ console.log('Before status change - quest status:', quest.status);
+ quest.status = 'active';
+ console.log('After status change - quest status:', quest.status);
+
+ // Also update the quest in the main quests array to ensure consistency
+ const mainQuest = this.mainQuests.find(q => q.id === questId);
+ if (mainQuest) {
+ mainQuest.status = 'active';
+ console.log('Updated mainQuest status to:', mainQuest.status);
+
+ if (debugLogger) debugLogger.logStep('Main quest status updated', {
+ questId: mainQuest.id,
+ newStatus: mainQuest.status
+ });
+ }
+
+ this.activeQuests.push(quest);
+
+ // Check initial progress for existing player stats
+ if (debugLogger) debugLogger.logStep('Checking initial quest progress');
+ this.checkInitialQuestProgress(quest);
+
+ // Update the UI to reflect the status change
+ this.updateQuestList();
+
+ this.game.showNotification(`Quest started: ${quest.name}`, 'success', 3000);
+
+ if (debugLogger) debugLogger.endStep('QuestSystem.startQuest', {
+ success: true,
+ questId: questId,
+ questName: quest.name,
+ questType: quest.type,
+ objectives: quest.objectives.map(obj => ({
+ id: obj.id,
+ description: obj.description,
+ target: obj.target,
+ current: obj.current
+ })),
+ activeQuestsCount: this.activeQuests.length
+ });
+
+ return true;
+ }
+
+ completeQuest(questId) {
+ const debugLogger = window.debugLogger;
+
+ if (debugLogger) debugLogger.startStep('QuestSystem.completeQuest', {
+ questId: questId,
+ currentActiveQuests: this.activeQuests.length,
+ completedQuestsCount: this.completedQuests.length
+ });
+
+ const quest = this.findQuest(questId);
+ if (!quest) {
+ if (debugLogger) debugLogger.endStep('QuestSystem.completeQuest', {
+ success: false,
+ reason: 'Quest not found',
+ questId: questId
+ });
+ return false;
+ }
+
+ if (debugLogger) debugLogger.logStep('Quest found for completion', {
+ questId: quest.id,
+ questName: quest.name,
+ questType: quest.type,
+ currentStatus: quest.status,
+ objectives: quest.objectives.map(obj => ({
+ id: obj.id,
+ description: obj.description,
+ target: obj.target,
+ current: obj.current,
+ completed: obj.current >= obj.target
+ }))
+ });
+
+ if (quest.status !== 'active') {
+ this.game.showNotification('Quest is not active', 'error', 3000);
+
+ if (debugLogger) debugLogger.endStep('QuestSystem.completeQuest', {
+ success: false,
+ reason: 'Quest not active',
+ questId: questId,
+ questName: quest.name,
+ currentStatus: quest.status
+ });
+ return false;
+ }
+
+ // Check if all objectives are completed
+ const allObjectivesComplete = quest.objectives.every(obj => obj.current >= obj.target);
+ if (!allObjectivesComplete) {
+ this.game.showNotification('Not all objectives completed', 'warning', 3000);
+
+ if (debugLogger) debugLogger.endStep('QuestSystem.completeQuest', {
+ success: false,
+ reason: 'Not all objectives completed',
+ questId: questId,
+ questName: quest.name,
+ objectives: quest.objectives.map(obj => ({
+ id: obj.id,
+ current: obj.current,
+ target: obj.target,
+ completed: obj.current >= obj.target
+ }))
+ });
+ return false;
+ }
+
+ // Complete quest
+ quest.status = 'completed';
+ quest.completedAt = Date.now();
+ this.completedQuests.push(quest);
+
+ if (debugLogger) debugLogger.logStep('Quest marked as completed', {
+ questId: quest.id,
+ questName: quest.name,
+ completedAt: quest.completedAt,
+ rewards: quest.rewards
+ });
+
+ // Save completed daily quests to history
+ if (quest.type === 'daily') {
+ const questCopy = { ...quest, completedAt: Date.now() };
+ this.completedDailyQuests.push(questCopy);
+
+ if (debugLogger) debugLogger.logStep('Daily quest added to history', {
+ questId: quest.id,
+ questName: quest.name,
+ completedDailyQuestsCount: this.completedDailyQuests.length
+ });
+ }
+
+ // Save completed weekly quests to history
+ if (quest.type === 'weekly') {
+ const questCopy = { ...quest, completedAt: Date.now() };
+ this.completedWeeklyQuests.push(questCopy);
+
+ if (debugLogger) debugLogger.logStep('Weekly quest added to history', {
+ questId: quest.id,
+ questName: quest.name,
+ completedWeeklyQuestsCount: this.completedWeeklyQuests.length
+ });
+ }
+
+ // Remove from active quests
+ const activeIndex = this.activeQuests.findIndex(q => q.id === questId);
+ if (activeIndex !== -1) {
+ this.activeQuests.splice(activeIndex, 1);
+
+ if (debugLogger) debugLogger.logStep('Quest removed from active list', {
+ questId: questId,
+ removedIndex: activeIndex,
+ remainingActiveQuests: this.activeQuests.length
+ });
+ }
+
+ // Give rewards
+ if (debugLogger) debugLogger.logStep('Giving quest rewards');
+ this.giveQuestRewards(quest);
+
+ // Update statistics
+ const oldStats = { ...this.stats };
+ this.stats.questsCompleted++;
+ if (quest.type === 'daily') {
+ this.stats.dailyQuestsCompleted++;
+ }
+ if (quest.type === 'weekly') {
+ this.stats.weeklyQuestsCompleted++;
+ }
+
+ if (debugLogger) debugLogger.logStep('Quest statistics updated', {
+ oldStats: oldStats,
+ newStats: this.stats,
+ questsCompletedIncrement: this.stats.questsCompleted - oldStats.questsCompleted,
+ dailyQuestsCompletedIncrement: this.stats.dailyQuestsCompleted - oldStats.dailyQuestsCompleted,
+ weeklyQuestsCompletedIncrement: this.stats.weeklyQuestsCompleted - oldStats.weeklyQuestsCompleted
+ });
+
+ // Unlock next quest if it's a main quest
+ if (quest.nextQuest) {
+ if (debugLogger) debugLogger.logStep('Unlocking next quest', {
+ nextQuestId: quest.nextQuest
+ });
+ this.unlockNextQuest(quest.nextQuest);
+ }
+
+ // Check for other quests that might now be available
+ if (debugLogger) debugLogger.logStep('Checking for newly available quests');
+ this.checkQuestAvailability();
+
+ this.game.showNotification(`Quest completed: ${quest.name}!`, 'success', 5000);
+
+ if (debugLogger) debugLogger.endStep('QuestSystem.completeQuest', {
+ success: true,
+ questId: questId,
+ questName: quest.name,
+ questType: quest.type,
+ rewardsGiven: quest.rewards,
+ nextQuestUnlocked: quest.nextQuest || null,
+ finalActiveQuestsCount: this.activeQuests.length,
+ completedQuestsCount: this.completedQuests.length
+ });
+
+ return true;
+ }
+
+ giveQuestRewards(quest) {
+ const debugLogger = window.debugLogger;
+
+ if (quest.rewards.credits) {
+ this.game.systems.economy.addCredits(quest.rewards.credits, 'quest');
+ this.stats.totalRewardsEarned.credits += quest.rewards.credits;
+ rewardsGiven.credits = quest.rewards.credits;
+
+ if (debugLogger) debugLogger.logStep('Credits reward given', {
+ amount: quest.rewards.credits,
+ oldCredits: oldPlayerStats.credits,
+ newCredits: this.game.systems.economy.credits
+ });
+ }
+
+ if (quest.rewards.experience) {
+ this.game.systems.player.addExperience(quest.rewards.experience);
+ this.stats.totalRewardsEarned.experience += quest.rewards.experience;
+ rewardsGiven.experience = quest.rewards.experience;
+
+ if (debugLogger) debugLogger.logStep('Experience reward given', {
+ amount: quest.rewards.experience,
+ oldExperience: oldPlayerStats.experience,
+ newExperience: this.game.systems.player.stats.experience,
+ oldLevel: oldPlayerStats.level,
+ newLevel: this.game.systems.player.stats.level,
+ leveledUp: this.game.systems.player.stats.level > oldPlayerStats.level
+ });
+ }
+
+ if (quest.rewards.gems) {
+ this.game.systems.economy.addGems(quest.rewards.gems, 'quest');
+ this.stats.totalRewardsEarned.gems += quest.rewards.gems;
+ rewardsGiven.gems = quest.rewards.gems;
+
+ if (debugLogger) debugLogger.logStep('Gems reward given', {
+ amount: quest.rewards.gems,
+ oldGems: oldPlayerStats.gems,
+ newGems: this.game.systems.economy.gems
+ });
+ }
+
+ if (quest.rewards.item) {
+ const item = this.game.systems.inventory.generateItem('weapon', 'legendary');
+ this.game.systems.inventory.addItem(item);
+ rewardsGiven.item = item;
+
+ if (debugLogger) debugLogger.logStep('Item reward given', {
+ itemGenerated: item,
+ itemType: item.type,
+ itemRarity: item.rarity,
+ itemName: item.name
+ });
+ }
+
+ if (debugLogger) debugLogger.endStep('QuestSystem.giveQuestRewards', {
+ questId: quest.id,
+ questName: quest.name,
+ rewardsGiven: rewardsGiven,
+ playerChanges: {
+ credits: { old: oldPlayerStats.credits, new: this.game.systems.economy.credits },
+ gems: { old: oldPlayerStats.gems, new: this.game.systems.economy.gems },
+ experience: { old: oldPlayerStats.experience, new: this.game.systems.player.stats.experience },
+ level: { old: oldPlayerStats.level, new: this.game.systems.player.stats.level }
+ },
+ totalRewardsEarnedUpdated: this.stats.totalRewardsEarned
+ });
+ }
+
+ // Objective progress
+ updateObjectiveProgress(type, amount, context = {}) {
+ const debugLogger = window.debugLogger;
+
+ if (debugLogger) debugLogger.startStep('QuestSystem.updateObjectiveProgress', {
+ type: type,
+ amount: amount,
+ context: context,
+ activeQuestsCount: this.activeQuests.length
+ });
+
+ const progressUpdates = [];
+
+ // Update all active quests
+ this.activeQuests.forEach(quest => {
+ const questProgress = [];
+
+ quest.objectives.forEach(objective => {
+ if (objective.type === type && objective.current < objective.target) {
+ const oldProgress = objective.current;
+ objective.current = Math.min(objective.current + amount, objective.target);
+ const actualProgress = objective.current - oldProgress;
+
+ if (actualProgress > 0) {
+ questProgress.push({
+ objectiveId: objective.id,
+ description: objective.description,
+ oldProgress: oldProgress,
+ newProgress: objective.current,
+ target: objective.target,
+ progressMade: actualProgress,
+ completed: objective.current >= objective.target
+ });
+ }
+ }
+ });
+
+ if (questProgress.length > 0) {
+ progressUpdates.push({
+ questId: quest.id,
+ questName: quest.name,
+ questType: quest.type,
+ objectivesUpdated: questProgress
+ });
+
+ // Check if quest is completed
+ if (quest.objectives.every(obj => obj.current >= obj.target)) {
+ this.game.showNotification(`Quest ready to turn in: ${quest.name}`, 'success', 4000);
+
+ if (debugLogger) debugLogger.logStep('Quest completed via progress update', {
+ questId: quest.id,
+ questName: quest.name,
+ allObjectivesCompleted: true
+ });
+ }
+ }
+ });
+
+ if (debugLogger) debugLogger.endStep('QuestSystem.updateObjectiveProgress', {
+ type: type,
+ amount: amount,
+ progressUpdates: progressUpdates,
+ questsUpdated: progressUpdates.length
+ });
+ }
+
+ // Event listeners for quest progress
+ onDungeonCompleted() {
+ const debugLogger = window.debugLogger;
+
+ if (debugLogger) debugLogger.log('QuestSystem.onDungeonCompleted triggered', {
+ activeQuestsCount: this.activeQuests.length
+ });
+
+ this.updateObjectiveProgress('dungeon', 1);
+ }
+
+ onEnemyDefeated() {
+ const debugLogger = window.debugLogger;
+
+ if (debugLogger) debugLogger.log('QuestSystem.onEnemyDefeated triggered', {
+ activeQuestsCount: this.activeQuests.length
+ });
+
+ this.updateObjectiveProgress('combat', 1);
+ }
+
+ onLevelUp(newLevel) {
+ const debugLogger = window.debugLogger;
+
+ if (debugLogger) debugLogger.log('QuestSystem.onLevelUp triggered', {
+ newLevel: newLevel,
+ activeQuestsCount: this.activeQuests.length
+ });
+
+ this.updateObjectiveProgress('level', 1);
+ }
+
+ onItemCrafted() {
+ const debugLogger = window.debugLogger;
+
+ if (debugLogger) debugLogger.log('QuestSystem.onItemCrafted triggered', {
+ activeQuestsCount: this.activeQuests.length
+ });
+
+ this.updateObjectiveProgress('crafting', 1);
+ }
+
+ // Procedural quest generation (deprecated - replaced by weekly quests)
+ /*
+ generateProceduralQuests() {
+ const debugLogger = window.debugLogger;
+
+ if (debugLogger) debugLogger.startStep('QuestSystem.generateProceduralQuests', {
+ currentActiveQuests: this.activeQuests.length,
+ maxProceduralQuests: this.maxProceduralQuests,
+ proceduralTemplatesCount: Object.keys(this.proceduralTemplates).length,
+ proceduralQuestRefresh: this.proceduralQuestRefresh
+ });
+
+ // Clear existing procedural quests
+ const oldProceduralQuests = this.activeQuests.filter(q => q.type === 'procedural');
+ this.activeQuests = this.activeQuests.filter(q => q.type !== 'procedural');
+
+ if (debugLogger) debugLogger.logStep('Cleared existing procedural quests', {
+ oldProceduralQuestsCount: oldProceduralQuests.length,
+ oldProceduralQuests: oldProceduralQuests.map(q => ({ id: q.id, name: q.name }))
+ });
+
+ // Generate new procedural quests
+ const templates = Object.keys(this.proceduralTemplates);
+ const questCount = Math.min(this.maxProceduralQuests, templates.length);
+ const generatedQuests = [];
+
+ for (let i = 0; i < questCount; i++) {
+ const templateKey = templates[Math.floor(Math.random() * templates.length)];
+ const template = this.proceduralTemplates[templateKey];
+
+ const quest = {
+ id: `procedural_${Date.now()}_${i}`,
+ name: template.name,
+ description: template.description.replace('{target}', template.objectives[0].target),
+ type: 'procedural',
+ status: 'available',
+ objectives: template.objectives.map(obj => ({ ...obj })),
+ rewards: { ...template.rewards },
+ expiresAt: Date.now() + this.proceduralQuestRefresh
+ };
+
+ this.activeQuests.push(quest);
+ generatedQuests.push(quest);
+
+ if (debugLogger) debugLogger.logStep('Procedural quest generated', {
+ templateKey: templateKey,
+ questId: quest.id,
+ questName: quest.name,
+ questDescription: quest.description,
+ objectives: quest.objectives,
+ rewards: quest.rewards,
+ expiresAt: quest.expiresAt
+ });
+ }
+
+ // Schedule next refresh
+ setTimeout(() => this.generateProceduralQuests(), this.proceduralQuestRefresh);
+
+ if (debugLogger) debugLogger.endStep('QuestSystem.generateProceduralQuests', {
+ oldProceduralQuestsRemoved: oldProceduralQuests.length,
+ newProceduralQuestsGenerated: generatedQuests.length,
+ generatedQuests: generatedQuests.map(q => ({ id: q.id, name: q.name, type: q.type })),
+ nextRefreshScheduled: true,
+ refreshInterval: this.proceduralQuestRefresh
+ });
+ }
+ */
+
+ randomizeDailyQuests() {
+ const debugLogger = window.debugLogger;
+
+ console.log('[QUEST SYSTEM] randomizeDailyQuests called');
+
+ // Safety check for allDailyQuests
+ if (!this.allDailyQuests || !Array.isArray(this.allDailyQuests)) {
+ console.error('[QUEST SYSTEM] allDailyQuests is not available or not an array');
+ return;
+ }
+
+ console.log(`[QUEST SYSTEM] allDailyQuests count: ${this.allDailyQuests.length}`);
+
+ if (debugLogger) debugLogger.startStep('QuestSystem.randomizeDailyQuests', {
+ allDailyQuestsCount: this.allDailyQuests.length,
+ currentDailyQuestsCount: this.dailyQuests.length,
+ currentSelectedDailyQuestsCount: this.selectedDailyQuests.length
+ });
+
+ // Clear current daily quests
+ this.dailyQuests = [];
+ this.selectedDailyQuests = [];
+
+ if (debugLogger) debugLogger.logStep('Cleared current daily quests');
+
+ // Select 3 random quests from allDailyQuests
+ const shuffled = [...this.allDailyQuests].sort(() => Math.random() - 0.5);
+ this.selectedDailyQuests = shuffled.slice(0, 3);
+
+ console.log(`[QUEST SYSTEM] Selected ${this.selectedDailyQuests.length} random daily quests`);
+
+ if (debugLogger) debugLogger.logStep('Selected random daily quests', {
+ selectedQuests: this.selectedDailyQuests.map(q => ({
+ id: q.id,
+ name: q.name,
+ difficulty: q.difficulty
+ }))
+ });
+
+ // Create deep copies for active quests and automatically start them
+ this.selectedDailyQuests.forEach(questTemplate => {
+ try {
+ const quest = {
+ ...questTemplate,
+ id: `${questTemplate.id}_${Date.now()}`,
+ status: 'active', // Auto-start daily quests
+ objectives: questTemplate.objectives.map(obj => ({ ...obj, current: 0 }))
+ };
+ this.dailyQuests.push(quest);
+ this.activeQuests.push(quest); // Add to active quests for progress tracking
+
+ console.log(`[QUEST SYSTEM] Created daily quest: ${quest.id}, name: ${quest.name}, status: ${quest.status}`);
+ } catch (error) {
+ console.error('[QUEST SYSTEM] Error creating daily quest from template:', error);
+ }
+ });
+
+ if (debugLogger) debugLogger.endStep('QuestSystem.randomizeDailyQuests', {
+ dailyQuestsCreated: this.dailyQuests.length,
+ activeQuestsCount: this.activeQuests.length,
+ selectedDailyQuestsCount: this.selectedDailyQuests.length
+ });
+ }
+
+ // Daily reset
+ reset() {
+ const debugLogger = window.debugLogger;
+ const oldState = {
+ activeQuestsCount: this.activeQuests.length,
+ completedQuestsCount: this.completedQuests.length,
+ dailyQuestsCount: this.dailyQuests.length,
+ selectedDailyQuestsCount: this.selectedDailyQuests.length
+ };
+
+ if (debugLogger) debugLogger.startStep('QuestSystem.reset', {
+ oldState: oldState
+ });
+
+ this.activeQuests = [];
+ this.completedQuests = [];
+ this.dailyQuests = [];
+ this.selectedDailyQuests = [];
+ this.lastDailyReset = Date.now();
+
+ // Reset main quest statuses
+ this.mainQuests.forEach(quest => {
+ quest.status = quest.id === 'tutorial_complete' ? 'available' : 'locked';
+ });
+
+ if (debugLogger) debugLogger.endStep('QuestSystem.reset', {
+ oldState: oldState,
+ newState: {
+ activeQuestsCount: this.activeQuests.length,
+ completedQuestsCount: this.completedQuests.length,
+ dailyQuestsCount: this.dailyQuests.length,
+ selectedDailyQuestsCount: this.selectedDailyQuests.length,
+ mainQuestsReset: true
+ }
+ });
+ }
+
+ clear() {
+ const debugLogger = window.debugLogger;
+
+ if (debugLogger) debugLogger.startStep('QuestSystem.clear');
+
+ this.reset();
+
+ if (debugLogger) debugLogger.endStep('QuestSystem.clear', {
+ resetCompleted: true
+ });
+ }
+
+ checkDailyReset() {
+ const debugLogger = window.debugLogger;
+ const now = Date.now();
+ const lastReset = this.lastDailyReset;
+ const daysSinceReset = Math.floor((now - lastReset) / (24 * 60 * 60 * 1000));
+
+ if (debugLogger) debugLogger.startStep('QuestSystem.checkDailyReset', {
+ now: now,
+ lastReset: lastReset,
+ daysSinceReset: daysSinceReset,
+ threshold: 1
+ });
+
+ if (daysSinceReset >= 1) {
+ if (debugLogger) debugLogger.logStep('Daily reset triggered', {
+ daysSinceReset: daysSinceReset
+ });
+
+ this.resetDailyQuests();
+ this.stats.lastDailyReset = now;
+ this.stats.dailyQuestsCompleted = 0;
+
+ this.game.showNotification('Daily quests refreshed!', 'success', 4000);
+
+ if (debugLogger) debugLogger.logStep('Daily reset completed', {
+ newLastDailyReset: this.stats.lastDailyReset,
+ dailyQuestsCompletedReset: this.stats.dailyQuestsCompleted
+ });
+ }
+
+ // Remove only COMPLETED daily quests from active list, not all daily quests
+ const oldActiveQuestsCount = this.activeQuests.length;
+ this.activeQuests = this.activeQuests.filter(q => q.type !== 'daily' || q.status !== 'completed');
+ const removedDailyQuests = oldActiveQuestsCount - this.activeQuests.length;
+
+ if (debugLogger) debugLogger.endStep('QuestSystem.checkDailyReset', {
+ resetTriggered: daysSinceReset >= 1,
+ removedDailyQuests: removedDailyQuests,
+ finalActiveQuestsCount: this.activeQuests.length
+ });
+ }
+
+ resetDailyQuests() {
+ // Remove old daily quests from active list first
+ this.activeQuests = this.activeQuests.filter(q => q.type !== 'daily');
+
+ // Generate new random daily quests
+ this.randomizeDailyQuests();
+ }
+
+ startDailyCountdown() {
+ console.log('[QUEST SYSTEM] Starting daily countdown timer');
+
+ // Update countdown immediately
+ this.updateDailyCountdown();
+
+ // Only start timer if in multiplayer mode or game is actively running
+ const shouldStartTimer = window.smartSaveManager?.isMultiplayer || this.game?.isRunning;
+
+ if (shouldStartTimer) {
+ // Update every second
+ this.dailyCountdownInterval = setInterval(() => {
+ this.updateDailyCountdown();
+ }, 1000);
+
+ console.log('[QUEST SYSTEM] Daily countdown timer started with interval:', this.dailyCountdownInterval);
+ } else {
+ console.log('[QUEST SYSTEM] Skipping daily countdown timer - not in multiplayer mode');
+ }
+ }
+
+ updateDailyCountdown() {
+ // Always update countdown so it's ready when user switches to daily tab
+ const now = new Date();
+ const tomorrow = new Date(now);
+ tomorrow.setDate(tomorrow.getDate() + 1);
+ tomorrow.setHours(0, 0, 0, 0); // Set to midnight
+
+ const timeUntilReset = tomorrow - now;
+ const hours = Math.floor(timeUntilReset / (1000 * 60 * 60));
+ const minutes = Math.floor((timeUntilReset % (1000 * 60 * 60)) / (1000 * 60));
+ const seconds = Math.floor((timeUntilReset % (1000 * 60)) / 1000);
+
+ // Update countdown display
+ const countdownElement = document.getElementById('dailyCountdown');
+ if (countdownElement) {
+ countdownElement.textContent = `Daily quests reset in: ${hours.toString().padStart(2, '0')}:${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}`;
+ console.log('[QUEST SYSTEM] Daily countdown updated:', countdownElement.textContent);
+ } else {
+ console.log('[QUEST SYSTEM] Daily countdown element not found');
+ }
+ }
+
+ // Weekly quest management functions
+ randomizeWeeklyQuests() {
+ const debugLogger = window.debugLogger;
+
+ console.log('[QUEST SYSTEM] randomizeWeeklyQuests called');
+
+ // Safety check for allWeeklyQuests
+ if (!this.allWeeklyQuests || !Array.isArray(this.allWeeklyQuests)) {
+ console.error('[QUEST SYSTEM] allWeeklyQuests not properly initialized');
+ this.weeklyQuests = [];
+ this.selectedWeeklyQuests = [];
+ return;
+ }
+
+ console.log(`[QUEST SYSTEM] allWeeklyQuests count: ${this.allWeeklyQuests.length}`);
+
+ if (debugLogger) debugLogger.startStep('QuestSystem.randomizeWeeklyQuests', {
+ allWeeklyQuestsCount: this.allWeeklyQuests.length,
+ currentWeeklyQuestsCount: this.weeklyQuests.length,
+ currentSelectedWeeklyQuestsCount: this.selectedWeeklyQuests.length
+ });
+
+ // Clear existing weekly quests from active quests
+ this.activeQuests = this.activeQuests.filter(q => q.type !== 'weekly');
+
+ // Select 5 random weekly quests
+ const shuffled = [...this.allWeeklyQuests].sort(() => Math.random() - 0.5);
+ this.selectedWeeklyQuests = shuffled.slice(0, 5);
+ this.weeklyQuests = this.selectedWeeklyQuests.map(quest => ({ ...quest }));
+
+ // Add weekly quests to active quests
+ this.weeklyQuests.forEach(quest => {
+ if (quest.status === 'available') {
+ this.activeQuests.push(quest);
+ }
+ });
+
+ console.log(`[QUEST SYSTEM] Created ${this.weeklyQuests.length} weekly quests`);
+
+ if (debugLogger) debugLogger.endStep('QuestSystem.randomizeWeeklyQuests', {
+ weeklyQuestsCreated: this.weeklyQuests.length,
+ activeQuestsCount: this.activeQuests.length,
+ selectedWeeklyQuestsCount: this.selectedWeeklyQuests.length
+ });
+ }
+
+ checkWeeklyReset() {
+ const debugLogger = window.debugLogger;
+ const now = Date.now();
+ const lastReset = this.lastWeeklyReset || 0;
+
+ // Calculate if we need to reset based on Saturday midnight
+ const currentDateTime = new Date();
+ const dayOfWeek = currentDateTime.getDay(); // 0 = Sunday, 1 = Monday, ..., 6 = Saturday
+ const currentHour = currentDateTime.getHours();
+ const currentMinute = currentDateTime.getMinutes();
+ const currentSecond = currentDateTime.getSeconds();
+
+ let shouldReset = false;
+ let resetTime;
+
+ if (dayOfWeek === 6) { // Today is Saturday
+ resetTime = new Date(currentDateTime);
+ resetTime.setHours(0, 0, 0, 0); // Set to midnight
+
+ // Reset at exactly midnight on Saturday
+ if (currentHour === 0 && currentMinute === 0 && currentSecond === 0 && lastReset < resetTime.getTime()) {
+ shouldReset = true;
+ }
+ } else {
+ // Calculate last Saturday's reset time (midnight)
+ const daysSinceLastSaturday = (dayOfWeek + 1) % 7 || 7;
+ const lastSaturday = new Date(currentDateTime);
+ lastSaturday.setDate(currentDateTime.getDate() - daysSinceLastSaturday);
+ lastSaturday.setHours(0, 0, 0, 0);
+ resetTime = lastSaturday;
+
+ if (lastReset < resetTime.getTime()) {
+ shouldReset = true;
+ }
+ }
+
+ if (debugLogger) debugLogger.startStep('QuestSystem.checkWeeklyReset', {
+ now: now,
+ lastReset: lastReset,
+ currentDayOfWeek: dayOfWeek,
+ currentHour: currentHour,
+ currentMinute: currentMinute,
+ resetTime: resetTime ? resetTime.getTime() : null,
+ shouldReset: shouldReset
+ });
+
+ if (shouldReset) {
+ console.log('[QUEST SYSTEM] Weekly reset triggered');
+
+ // Reset weekly quests
+ this.lastWeeklyReset = now;
+
+ // Remove completed weekly quests from active quests
+ const oldActiveQuestsCount = this.activeQuests.length;
+ this.activeQuests = this.activeQuests.filter(q => q.type !== 'weekly' || q.status !== 'completed');
+ const removedWeeklyQuests = oldActiveQuestsCount - this.activeQuests.length;
+
+ if (debugLogger) debugLogger.endStep('QuestSystem.checkWeeklyReset', {
+ resetTriggered: true,
+ removedWeeklyQuests: removedWeeklyQuests,
+ finalActiveQuestsCount: this.activeQuests.length
+ });
+
+ // Clear weekly quest history and generate new ones
+ this.completedWeeklyQuests = [];
+ this.activeQuests = this.activeQuests.filter(q => q.type !== 'weekly');
+
+ // Generate new random weekly quests
+ this.randomizeWeeklyQuests();
+
+ // Update UI to show new weekly quests
+ this.updateQuestList();
+
+ // Show notification to player
+ this.game.showNotification('Weekly quests have been reset! New quests available.', 'info', 5000);
+ }
+ }
+
+ startWeeklyCountdown() {
+ console.log('[QUEST SYSTEM] Starting weekly countdown timer');
+
+ // Update countdown immediately
+ this.updateWeeklyCountdown();
+
+ // Only start timer if in multiplayer mode or game is actively running
+ const shouldStartTimer = window.smartSaveManager?.isMultiplayer || this.game?.isRunning;
+
+ if (shouldStartTimer) {
+ // Update every minute (weekly changes less frequently)
+ this.weeklyCountdownInterval = setInterval(() => {
+ this.updateWeeklyCountdown();
+ // Check for weekly reset every minute
+ this.checkWeeklyReset();
+ }, 60000); // 1 minute
+
+ console.log('[QUEST SYSTEM] Weekly countdown timer started with interval:', this.weeklyCountdownInterval);
+ } else {
+ console.log('[QUEST SYSTEM] Skipping weekly countdown timer - not in multiplayer mode');
+ }
+ }
+
+ updateWeeklyCountdown() {
+ const now = new Date();
+ const dayOfWeek = now.getDay(); // 0 = Sunday, 1 = Monday, ..., 6 = Saturday
+ const currentHour = now.getHours();
+ const currentMinute = now.getMinutes();
+ const currentSecond = now.getSeconds();
+
+ console.log('[QUEST SYSTEM] Weekly countdown debug:', {
+ now: now.toString(),
+ dayOfWeek: dayOfWeek,
+ dayName: ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'][dayOfWeek],
+ currentHour: currentHour,
+ currentMinute: currentMinute,
+ currentSecond: currentSecond
+ });
+
+ // Calculate days until Saturday midnight (00:00:00)
+ let daysUntilSaturday;
+ if (dayOfWeek === 6) { // Today is Saturday
+ // Check if it's before midnight
+ if (now.getHours() < 0 || (now.getHours() === 0 && now.getMinutes() === 0 && now.getSeconds() === 0)) {
+ daysUntilSaturday = 0;
+ } else {
+ // It's after midnight on Saturday, next reset is next Saturday
+ daysUntilSaturday = 7;
+ }
+ } else {
+ // Simple calculation: days until Saturday = 6 - current day
+ // Sunday (0) -> 6 days, Monday (1) -> 5 days, ..., Friday (5) -> 1 day
+ daysUntilSaturday = 6 - dayOfWeek;
+ if (daysUntilSaturday <= 0) daysUntilSaturday += 7; // Ensure positive
+ }
+
+ console.log('[QUEST SYSTEM] Days until Saturday:', daysUntilSaturday);
+
+ // Create the target reset time (Saturday midnight)
+ const nextSaturday = new Date(now);
+ nextSaturday.setDate(now.getDate() + daysUntilSaturday);
+ nextSaturday.setHours(0, 0, 0, 0); // Set to midnight
+
+ console.log('[QUEST SYSTEM] Next Saturday reset time:', nextSaturday.toString());
+
+ let timeUntilReset = nextSaturday.getTime() - now.getTime();
+
+ // Ensure timeUntilReset is positive (handle edge cases)
+ if (timeUntilReset <= 0) {
+ console.log('[QUEST SYSTEM] Time until reset is negative or zero, adding 7 days');
+ nextSaturday.setDate(nextSaturday.getDate() + 7);
+ timeUntilReset = nextSaturday.getTime() - now.getTime();
+ }
+
+ console.log('[QUEST SYSTEM] Time until reset (ms):', timeUntilReset);
+
+ // Convert to days, hours, minutes, seconds
+ const totalSeconds = Math.floor(timeUntilReset / 1000);
+ const days = Math.floor(totalSeconds / (24 * 60 * 60));
+ const hours = Math.floor((totalSeconds % (24 * 60 * 60)) / (60 * 60));
+ const minutes = Math.floor((totalSeconds % (60 * 60)) / 60);
+ const seconds = totalSeconds % 60;
+
+ console.log('[QUEST SYSTEM] Time breakdown:', {
+ timeUntilReset: timeUntilReset,
+ totalSeconds: totalSeconds,
+ days: days,
+ hours: hours,
+ minutes: minutes,
+ seconds: seconds,
+ daysUntilSaturday: daysUntilSaturday,
+ nextSaturdayDate: nextSaturday.toString(),
+ currentDate: now.toString()
+ });
+
+ // Update countdown display
+ const countdownElement = document.getElementById('weeklyCountdown');
+ if (countdownElement) {
+ // Use the calculated days from timeUntilReset, not daysUntilSaturday
+ if (days > 0) {
+ countdownElement.textContent = `Weekly quests reset in: ${days}d ${hours.toString().padStart(2, '0')}:${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}`;
+ } else if (hours > 0) {
+ countdownElement.textContent = `Weekly quests reset in: ${hours.toString().padStart(2, '0')}:${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}`;
+ } else {
+ countdownElement.textContent = `Weekly quests reset in: ${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}`;
+ }
+ console.log('[QUEST SYSTEM] Weekly countdown updated:', countdownElement.textContent, `(${days}d ${hours}h ${minutes}m ${seconds}s)`);
+ } else {
+ console.log('[QUEST SYSTEM] Weekly countdown element not found');
+ }
+ }
+
+// ... (rest of the code remains the same)
+ // Quest requirements and unlocking
+ checkQuestRequirements(quest) {
+ console.log('Checking requirements for quest:', quest.id, quest.requirements);
+
+ if (!quest.requirements) {
+ console.log('No requirements, returning true');
+ return true;
+ }
+
+ const player = this.game.systems.player;
+ const dungeonSystem = this.game.systems.dungeonSystem;
+
+ if (quest.requirements.level) {
+ console.log('Level requirement:', quest.requirements.level, 'Player level:', player.stats.level);
+ if (player.stats.level < quest.requirements.level) {
+ console.log('Level requirement not met');
+ return false;
+ }
+ }
+
+ if (quest.requirements.quest) {
+ const requiredQuest = this.findQuest(quest.requirements.quest);
+ console.log('Required quest:', quest.requirements.quest, 'Found:', requiredQuest ? requiredQuest.id : 'null', 'Status:', requiredQuest ? requiredQuest.status : 'null');
+ if (!requiredQuest || requiredQuest.status !== 'completed') {
+ console.log('Quest requirement not met');
+ return false;
+ }
+ }
+
+ if (quest.requirements.guild) {
+ // Check if player is in a guild
+ if (!player.stats.guildJoined) {
+ return false;
+ }
+ }
+
+ if (quest.requirements.dungeons) {
+ const dungeonsCleared = player.stats.dungeonsCleared || 0;
+ if (dungeonsCleared < quest.requirements.dungeons) {
+ return false;
+ }
+ }
+
+ if (quest.requirements.upgrades) {
+ // Check ship upgrade requirements
+ const upgradesCompleted = this.checkUpgradeProgress(quest);
+ if (upgradesCompleted < quest.requirements.upgrades) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ checkUpgradeProgress(quest) {
+ const player = this.game.systems.player;
+ let upgradesCompleted = 0;
+
+ quest.objectives.forEach(objective => {
+ if (objective.type === 'upgrade') {
+ if (player.stats[`upgraded_${objective.id}`]) {
+ upgradesCompleted++;
+ }
+ }
+ });
+
+ return upgradesCompleted;
+ }
+
+ getMaxSkillLevel(player) {
+ // Get the highest skill level from player
+ if (!player.skills) return 0;
+
+ let maxLevel = 0;
+ Object.values(player.skills).forEach(skill => {
+ if (skill.level > maxLevel) {
+ maxLevel = skill.level;
+ }
+ });
+
+ return maxLevel;
+ }
+
+ unlockNextQuest(nextQuestId) {
+ const nextQuest = this.findQuest(nextQuestId);
+ if (nextQuest && nextQuest.status === 'locked') {
+ nextQuest.status = 'available';
+ this.game.showNotification(`New quest available: ${nextQuest.name}`, 'info', 4000);
+ }
+ }
+
+ findQuest(questId) {
+ // Search in all quest arrays including failed quests with safety checks
+ const allQuests = [
+ ...(this.mainQuests || []),
+ ...(this.dailyQuests || []),
+ ...(this.activeQuests || []),
+ ...(this.completedQuests || []),
+ ...(this.failedQuests || [])
+ ];
+
+ return allQuests.find(q => q.id === questId);
+ }
+
+ getQuestsByType(type) {
+ console.log(`[QUEST SYSTEM] getQuestsByType called with type: ${type}`);
+
+ switch (type) {
+ case 'main':
+ const mainQuests = (this.mainQuests || []).filter(q => q.status === 'available' || q.status === 'active');
+ console.log(`[QUEST SYSTEM] Main quests found: ${mainQuests.length}`);
+ return mainQuests;
+ case 'daily':
+ // Ensure daily quests are initialized
+ if (!this.dailyQuests || this.dailyQuests.length === 0) {
+ console.log('[QUEST SYSTEM] Daily quests not initialized, forcing initialization');
+ this.randomizeDailyQuests();
+ }
+
+ const dailyQuests = (this.dailyQuests || []).filter(q => q.status !== 'failed');
+ console.log(`[QUEST SYSTEM] Daily quests found: ${dailyQuests.length}`);
+ console.log(`[QUEST SYSTEM] All daily quests array:`, this.dailyQuests);
+ dailyQuests.forEach(quest => {
+ console.log(`[QUEST SYSTEM] Daily quest: ${quest.id}, status: ${quest.status}, name: ${quest.name}`);
+ });
+ return dailyQuests;
+ case 'weekly':
+ const weeklyQuests = (this.weeklyQuests || []).filter(q => q.status !== 'failed');
+ console.log(`[QUEST SYSTEM] Weekly quests found: ${weeklyQuests.length}`);
+ return weeklyQuests;
+ case 'completed':
+ return this.getCompletedQuests();
+ case 'failed':
+ return (this.failedQuests || []);
+ default:
+ console.log(`[QUEST SYSTEM] Unknown quest type: ${type}`);
+ return [];
+ }
+ }
+
+ getCompletedQuests() {
+ const completed = [];
+
+ // Add completed main quests
+ if (this.mainQuests) {
+ completed.push(...this.mainQuests.filter(q => q.status === 'completed'));
+ }
+
+ // Add completed daily quests (from history)
+ if (this.completedDailyQuests) {
+ completed.push(...this.completedDailyQuests);
+ }
+
+ // Add completed weekly quests
+ if (this.weeklyQuests) {
+ completed.push(...this.weeklyQuests.filter(q => q.status === 'completed'));
+ }
+
+ // Sort by completion time (most recent first)
+ return completed.sort((a, b) => (b.completedAt || 0) - (a.completedAt || 0));
+ }
+
+ // UI updates
+ updateUI() {
+ this.updateQuestList();
+ this.updateQuestStats();
+ }
+
+ updateQuestList() {
+ console.log('[QUEST SYSTEM] updateQuestList called');
+ const questListElement = document.getElementById('questList');
+ if (!questListElement) {
+ console.log('[QUEST SYSTEM] questListElement not found');
+ return;
+ }
+
+ const activeType = document.querySelector('.quest-tab-btn.active')?.dataset.type || 'main';
+ console.log(`[QUEST SYSTEM] Active quest tab type: ${activeType}`);
+
+ const quests = this.getQuestsByType(activeType);
+ console.log(`[QUEST SYSTEM] Getting quests for type: ${activeType}, found: ${quests.length} quests`);
+
+ questListElement.innerHTML = '';
+
+ if (quests.length === 0) {
+ console.log(`[QUEST SYSTEM] No quests found for type: ${activeType}`);
+ questListElement.innerHTML = 'No quests available
';
+ return;
+ }
+
+ console.log(`[QUEST SYSTEM] Rendering ${quests.length} quests for type: ${activeType}`);
+ quests.forEach(quest => {
+ console.log(`[QUEST SYSTEM] Rendering quest: ${quest.id}, status: ${quest.status}`);
+ const questElement = document.createElement('div');
+ questElement.className = `quest-item ${quest.status}`;
+
+ // Add difficulty indicator for daily quests
+ const difficultyIndicator = quest.type === 'daily' && quest.difficulty ?
+ `
+ ${'★'.repeat(quest.difficulty)}
+
` : '';
+
+ // Handle completed quests differently
+ const isCompleted = quest.status === 'completed';
+ const progressPercent = isCompleted ? 100 : (quest.objectives.length > 0 ?
+ (quest.objectives.reduce((sum, obj) => sum + (obj.current / obj.target), 0) / quest.objectives.length) * 100 : 0);
+
+ const objectivesHtml = isCompleted ?
+ '✓ All objectives completed
' :
+ quest.objectives.map(obj => `
+
+
${obj.description}
+
${obj.current}/${obj.target}
+
+
`;
+ }).join('');
+
+ // Add completion time for completed quests
+ const completionTime = isCompleted && quest.completedAt ?
+ `Completed: ${new Date(quest.completedAt).toLocaleDateString()}
` : '';
+
+ questElement.innerHTML = `
+
+ ${quest.description}
+
+ ${objectivesHtml}
+
+ ${completionTime}
+
+
+
${isCompleted ? 'Completed' : Math.round(progressPercent) + '% Complete'}
+
+ ${quest.status === 'available' ?
+ `
Start Quest ` :
+ quest.status === 'active' ?
+ `
+
+ Cancel Quest
+
+
+ Turn In
+
+
` :
+ quest.status === 'completed' ?
+ '
Completed ' :
+ quest.status === 'failed' ?
+ `
+ Failed: ${quest.failureReason || 'Cancelled'}
+
+ Retry Quest
+
+
` :
+ '
Available '
+ }
+
+
+ ${ship.status === 'active' ? 'ACTIVE' : 'SWITCH'}
+
+
+ `;
+
+ return card;
+ }
+
+ updateCurrentShipDisplay() {
+ // Use player's ship data instead of this.currentShip
+ const player = this.game.systems.player;
+ if (!player || !player.ship) {
+ return;
+ }
+
+ const elements = {
+ currentShipImage: document.getElementById('currentShipImage'),
+ currentShipName: document.getElementById('currentShipName'),
+ currentShipClass: document.getElementById('currentShipClass'),
+ currentShipLevel: document.getElementById('currentShipLevel'),
+ currentShipHealth: document.getElementById('currentShipHealth'),
+ currentShipAttack: document.getElementById('currentShipAttack'),
+ currentShipDefense: document.getElementById('currentShipDefense'),
+ currentShipSpeed: document.getElementById('currentShipSpeed')
+ };
+
+ // Use player's ship data
+ const ship = player.ship;
+
+ if (elements.currentShipImage) {
+ // Use the ship's texture if available, otherwise fallback
+ const imagePath = ship.texture || `assets/textures/ships/starter_cruiser.png`;
+ elements.currentShipImage.src = imagePath;
+ elements.currentShipImage.alt = ship.name;
+ }
+ if (elements.currentShipName) elements.currentShipName.textContent = ship.name;
+ if (elements.currentShipClass) elements.currentShipClass.textContent = ship.class || 'Unknown';
+ if (elements.currentShipLevel) elements.currentShipLevel.textContent = ship.level || 1;
+ if (elements.currentShipHealth) elements.currentShipHealth.textContent = `${ship.health}/${ship.maxHealth}`;
+ if (elements.currentShipAttack) elements.currentShipAttack.textContent = ship.attack || 0;
+ if (elements.currentShipDefense) elements.currentShipDefense.textContent = ship.defence || ship.defense || 0;
+ if (elements.currentShipSpeed) elements.currentShipSpeed.textContent = ship.speed || 0;
+ }
+
+ switchShip(shipId) {
+ const ship = this.ships.find(s => s.id === shipId);
+ if (!ship || ship.status === 'active') return;
+
+ // Deactivate current ship
+ if (this.currentShip) {
+ this.currentShip.status = 'inactive';
+ }
+
+ // Activate new ship
+ ship.status = 'active';
+ this.currentShip = ship;
+
+ // Update displays
+ this.renderShips();
+ this.updateCurrentShipDisplay();
+
+ // Show notification
+ this.game.showNotification(`Switched to ${ship.name}!`, 'success', 3000);
+ }
+
+ upgradeShip(shipId) {
+ const ship = this.ships.find(s => s.id === shipId);
+ if (!ship) return;
+
+ const upgradeCost = ship.level * 1000;
+
+ if (this.game.systems.economy.getCredits() < upgradeCost) {
+ this.game.showNotification(`Not enough credits! Need ${upgradeCost} credits.`, 'error', 3000);
+ return;
+ }
+
+ // Upgrade ship
+ this.game.systems.economy.removeCredits(upgradeCost);
+ ship.level++;
+ ship.maxHealth += 10;
+ ship.health = ship.maxHealth; // Full heal on upgrade
+ ship.attack += 2;
+ ship.defense += 1;
+ ship.speed += 1;
+ ship.requiredExp = ship.level * 100;
+
+ // Update displays
+ this.renderShips();
+ this.updateCurrentShipDisplay();
+
+ this.game.showNotification(`${ship.name} upgraded to level ${ship.level}!`, 'success', 3000);
+ }
+
+ repairShip(shipId) {
+ const ship = this.ships.find(s => s.id === shipId);
+ if (!ship || ship.health >= ship.maxHealth) return;
+
+ const repairCost = Math.floor((ship.maxHealth - ship.health) * 0.5);
+
+ if (this.game.systems.economy.getCredits() < repairCost) {
+ this.game.showNotification(`Not enough credits! Need ${repairCost} credits.`, 'error', 3000);
+ return;
+ }
+
+ // Repair ship
+ this.game.systems.economy.removeCredits(repairCost);
+ ship.health = ship.maxHealth;
+
+ // Update displays
+ this.renderShips();
+ this.updateCurrentShipDisplay();
+
+ this.game.showNotification(`${ship.name} fully repaired!`, 'success', 3000);
+ }
+
+ addExperience(shipId, amount) {
+ const ship = this.ships.find(s => s.id === shipId);
+ if (!ship) return;
+
+ ship.experience += amount;
+
+ // Check for level up
+ while (ship.experience >= ship.requiredExp) {
+ ship.experience -= ship.requiredExp;
+ this.upgradeShip(shipId);
+ }
+
+ this.renderShips();
+ if (this.currentShip && this.currentShip.id === shipId) {
+ this.updateCurrentShipDisplay();
+ }
+ }
+
+ getShip(shipId) {
+ return this.ships.find(s => s.id === shipId);
+ }
+
+ getCurrentShip() {
+ return this.currentShip;
+ }
+
+ getAllShips() {
+ return this.ships;
+ }
+}
diff --git a/Client-Server/js/systems/SkillSystem.js b/Client-Server/js/systems/SkillSystem.js
new file mode 100644
index 0000000..1148052
--- /dev/null
+++ b/Client-Server/js/systems/SkillSystem.js
@@ -0,0 +1,596 @@
+/**
+ * Galaxy Strike Online - Skill System
+ * Manages skills, progression, and specialization
+ */
+
+class SkillSystem {
+ constructor(gameEngine) {
+ this.game = gameEngine;
+
+ // Skill categories
+ this.categories = {
+ combat: 'Combat',
+ science: 'Science',
+ crafting: 'Crafting'
+ };
+
+ // Skill definitions
+ this.skills = {
+ combat: {
+ weapons_mastery: {
+ name: 'Weapons Mastery',
+ description: 'Increases weapon damage and critical chance',
+ maxLevel: 10,
+ currentLevel: 0,
+ experience: 0,
+ experienceToNext: 100,
+ effects: {
+ attack: 2,
+ criticalChance: 0.01
+ },
+ icon: 'fa-sword',
+ unlocked: true
+ },
+ shield_techniques: {
+ name: 'Shield Techniques',
+ description: 'Improves defense and energy efficiency',
+ maxLevel: 10,
+ currentLevel: 0,
+ experience: 0,
+ experienceToNext: 100,
+ effects: {
+ defense: 2,
+ maxEnergy: 5
+ },
+ icon: 'fa-shield-alt',
+ unlocked: true
+ },
+ piloting: {
+ name: 'Piloting',
+ description: 'Enhances speed and evasion',
+ maxLevel: 10,
+ currentLevel: 0,
+ experience: 0,
+ experienceToNext: 100,
+ effects: {
+ speed: 2,
+ criticalChance: 0.005
+ },
+ icon: 'fa-rocket',
+ unlocked: true
+ },
+ tactical_analysis: {
+ name: 'Tactical Analysis',
+ description: 'Reveals enemy weaknesses and improves accuracy',
+ maxLevel: 10,
+ currentLevel: 0,
+ experience: 0,
+ experienceToNext: 100,
+ effects: {
+ criticalDamage: 0.05,
+ attack: 1
+ },
+ icon: 'fa-brain',
+ unlocked: false,
+ requiredLevel: 5
+ }
+ },
+ science: {
+ engineering: {
+ name: 'Engineering',
+ description: 'Technical skills for ship components and machinery',
+ maxLevel: 10,
+ currentLevel: 0,
+ experience: 0,
+ experienceToNext: 100,
+ effects: {
+ craftingBonus: 0.08,
+ shipStats: 0.03
+ },
+ icon: 'fa-wrench',
+ unlocked: true
+ },
+ energy_manipulation: {
+ name: 'Energy Manipulation',
+ description: 'Better energy control and regeneration',
+ maxLevel: 10,
+ currentLevel: 0,
+ experience: 0,
+ experienceToNext: 100,
+ effects: {
+ maxEnergy: 10,
+ energyRegeneration: 0.1
+ },
+ icon: 'fa-bolt',
+ unlocked: true
+ },
+ alien_technology: {
+ name: 'Alien Technology',
+ description: 'Understanding and using alien artifacts',
+ maxLevel: 10,
+ currentLevel: 0,
+ experience: 0,
+ experienceToNext: 100,
+ effects: {
+ findRarity: 0.05,
+ itemValue: 0.1
+ },
+ icon: 'fa-atom',
+ unlocked: false,
+ requiredLevel: 3
+ },
+ quantum_physics: {
+ name: 'Quantum Physics',
+ description: 'Advanced quantum mechanics for better equipment',
+ maxLevel: 10,
+ currentLevel: 0,
+ experience: 0,
+ experienceToNext: 100,
+ effects: {
+ criticalDamage: 0.1,
+ attack: 3
+ },
+ icon: 'fa-microscope',
+ unlocked: false,
+ requiredLevel: 8
+ },
+ bio_engineering: {
+ name: 'Bio-Engineering',
+ description: 'Biological enhancements and healing',
+ maxLevel: 10,
+ currentLevel: 0,
+ experience: 0,
+ experienceToNext: 100,
+ effects: {
+ maxHealth: 15,
+ healthRegeneration: 0.05
+ },
+ icon: 'fa-dna',
+ unlocked: false,
+ requiredLevel: 6
+ }
+ },
+ crafting: {
+ crafting: {
+ name: 'General Crafting',
+ description: 'Basic crafting skills for all items',
+ maxLevel: 10,
+ currentLevel: 0,
+ experience: 0,
+ experienceToNext: 100,
+ effects: {
+ craftingBonus: 0.05
+ },
+ icon: 'fa-hammer',
+ unlocked: true
+ },
+ weapon_crafting: {
+ name: 'Weapon Crafting',
+ description: 'Create and upgrade weapons',
+ maxLevel: 10,
+ currentLevel: 0,
+ experience: 0,
+ experienceToNext: 100,
+ effects: {
+ craftingBonus: 0.1,
+ weaponStats: 0.05
+ },
+ icon: 'fa-hammer',
+ unlocked: true
+ },
+ armor_forging: {
+ name: 'Armor Forging',
+ description: 'Forge protective armor and shields',
+ maxLevel: 10,
+ currentLevel: 0,
+ experience: 0,
+ experienceToNext: 100,
+ effects: {
+ craftingBonus: 0.1,
+ armorStats: 0.05
+ },
+ icon: 'fa-anvil',
+ unlocked: true
+ },
+ resource_extraction: {
+ name: 'Resource Extraction',
+ description: 'Better resource gathering and efficiency',
+ maxLevel: 10,
+ currentLevel: 0,
+ experience: 0,
+ experienceToNext: 100,
+ effects: {
+ resourceBonus: 0.15,
+ findResources: 0.1
+ },
+ icon: 'fa-gem',
+ unlocked: false,
+ requiredLevel: 4
+ },
+ engineering: {
+ name: 'Engineering',
+ description: 'Advanced ship modifications and systems',
+ maxLevel: 10,
+ currentLevel: 0,
+ experience: 0,
+ experienceToNext: 100,
+ effects: {
+ shipUpgrades: 0.2,
+ systemEfficiency: 0.1
+ },
+ icon: 'fa-cogs',
+ unlocked: false,
+ requiredLevel: 7
+ }
+ }
+ };
+
+ // Skill experience rates
+ this.experienceRates = {
+ combat: 1.0,
+ science: 0.8,
+ crafting: 0.6
+ };
+
+ // Active buffs from skills
+ this.activeBuffs = {};
+ }
+
+ async initialize() {
+}
+
+ // Skill management
+ addSkillExperience(category, skillId, amount) {
+ const skill = this.skills[category]?.[skillId];
+ if (!skill || skill.currentLevel >= skill.maxLevel) {
+ return false;
+ }
+
+ skill.experience += amount;
+
+ // Check for level up
+ while (skill.experience >= skill.experienceToNext && skill.currentLevel < skill.maxLevel) {
+ this.levelUpSkill(category, skillId);
+ }
+
+ this.applySkillEffects();
+return true;
+ }
+
+ levelUpSkill(category, skillId) {
+ const skill = this.skills[category][skillId];
+
+ // Handle excess experience
+ const excessExperience = skill.experience - skill.experienceToNext;
+
+ skill.currentLevel++;
+ skill.experienceToNext = Math.floor(skill.experienceToNext * 1.5);
+
+ // Set experience to excess (minimum 0)
+ skill.experience = Math.max(0, excessExperience);
+
+ // Apply skill effects
+ this.applySkillEffects();
+
+ this.game.showNotification(`${skill.name} leveled up to ${skill.currentLevel}!`, 'success', 4000);
+ this.game.showNotification('Skill effects applied!', 'info', 3000);
+ }
+
+ upgradeSkill(category, skillId) {
+ const skill = this.skills[category]?.[skillId];
+ const player = this.game.systems.player;
+
+ if (!skill) {
+ this.game.showNotification('Skill not found', 'error', 3000);
+ return false;
+ }
+
+ if (!skill.unlocked) {
+ this.game.showNotification('Skill is locked', 'error', 3000);
+ return false;
+ }
+
+ if (skill.currentLevel >= skill.maxLevel) {
+ this.game.showNotification('Skill is at maximum level', 'warning', 3000);
+ return false;
+ }
+
+ if (player.stats.skillPoints < 1) {
+ this.game.showNotification('Not enough skill points', 'error', 3000);
+ return false;
+ }
+
+ // Use skill point and level up
+ player.stats.skillPoints--;
+ this.levelUpSkill(category, skillId);
+
+ // Update UI to refresh skill points display only if in multiplayer mode or game is actively running
+ const shouldUpdateUI = window.smartSaveManager?.isMultiplayer || this.game?.isRunning;
+
+ if (shouldUpdateUI) {
+ this.updateUI();
+ }
+
+ return true;
+ }
+
+ unlockSkill(category, skillId) {
+ const skill = this.skills[category]?.[skillId];
+ const player = this.game.systems.player;
+
+ if (!skill) {
+ this.game.showNotification('Skill not found', 'error', 3000);
+ return false;
+ }
+
+ if (skill.unlocked) {
+ this.game.showNotification('Skill is already unlocked', 'warning', 3000);
+ return false;
+ }
+
+ if (skill.requiredLevel && player.stats.level < skill.requiredLevel) {
+ this.game.showNotification(`Requires level ${skill.requiredLevel}`, 'error', 3000);
+ return false;
+ }
+
+ if (player.stats.skillPoints < 2) {
+ this.game.showNotification('Requires 2 skill points to unlock', 'error', 3000);
+ return false;
+ }
+
+ // Unlock skill
+ player.stats.skillPoints -= 2;
+ skill.unlocked = true;
+ skill.currentLevel = 1;
+
+ this.applySkillEffects();
+
+ // Update UI to refresh skill points display only if in multiplayer mode or game is actively running
+ const shouldUpdateUI = window.smartSaveManager?.isMultiplayer || this.game?.isRunning;
+
+ if (shouldUpdateUI) {
+ this.updateUI();
+ }
+
+ this.game.showNotification(`${skill.name} unlocked!`, 'success', 4000);
+ return true;
+ }
+
+ applySkillEffects() {
+ const player = this.game.systems.player;
+
+ // Reset to base stats first
+ this.resetToBaseStats();
+
+ // Apply all skill effects
+ Object.values(this.skills).forEach(skill => {
+ if (skill.level > 0) {
+ const skillData = this.skillData[skill.id];
+ if (skillData && skillData.effects) {
+ Object.entries(skillData.effects).forEach(([effect, value]) => {
+ const totalEffect = value * skill.level;
+
+ switch (effect) {
+ case 'attack':
+ player.attributes.attack += totalEffect;
+ break;
+ case 'defense':
+ player.attributes.defense += totalEffect;
+ break;
+ case 'speed':
+ player.attributes.speed += totalEffect;
+ break;
+ case 'maxHealth':
+ player.attributes.maxHealth += totalEffect;
+ break;
+ case 'maxEnergy':
+ player.attributes.maxEnergy += totalEffect;
+ break;
+ case 'criticalChance':
+ player.attributes.criticalChance += totalEffect;
+ break;
+ case 'criticalDamage':
+ player.attributes.criticalDamage += totalEffect;
+ break;
+ case 'energyRegeneration':
+ case 'healthRegeneration':
+ case 'craftingBonus':
+ case 'weaponStats':
+ case 'armorStats':
+ case 'resourceBonus':
+ case 'shipUpgrades':
+ case 'systemEfficiency':
+ case 'findRarity':
+ case 'itemValue':
+ case 'findResources':
+ // Store these for other systems to use
+ if (!this.activeBuffs[effect]) {
+ this.activeBuffs[effect] = 0;
+ }
+ this.activeBuffs[effect] += totalEffect;
+ break;
+ }
+ });
+ }
+ }
+ });
+
+ player.updateUI();
+ }
+
+ resetToBaseStats() {
+ const player = this.game.systems.player;
+
+ // Reset to base values (would need to store base stats separately)
+ // For now, we'll use initial values
+ const baseStats = {
+ attack: 10 + (player.stats.level - 1) * 2,
+ defense: 5 + (player.stats.level - 1) * 1,
+ speed: 10,
+ maxHealth: 100 + (player.stats.level - 1) * 10,
+ maxEnergy: 100 + (player.stats.level - 1) * 5,
+ criticalChance: 0.05,
+ criticalDamage: 1.5
+ };
+
+ Object.assign(player.attributes, baseStats);
+ this.activeBuffs = {};
+ }
+
+ // Skill experience from actions
+ awardCombatExperience(amount) {
+ this.addSkillExperience('combat', 'weapons_mastery', amount);
+ this.addSkillExperience('combat', 'tactical_analysis', amount * 0.5);
+ }
+
+ awardScienceExperience(amount) {
+ this.addSkillExperience('science', 'energy_manipulation', amount);
+ this.addSkillExperience('science', 'alien_technology', amount * 0.3);
+ }
+
+ awardCraftingExperience(amount) {
+ this.addSkillExperience('crafting', 'weapon_crafting', amount);
+ this.addSkillExperience('crafting', 'armor_forging', amount * 0.5);
+ }
+
+ // Skill checks
+ getSkillLevel(category, skillId) {
+ return this.skills[category]?.[skillId]?.currentLevel || 0;
+ }
+
+ hasSkill(category, skillId, minimumLevel = 1) {
+ const skill = this.skills[category]?.[skillId];
+ return skill && skill.unlocked && skill.currentLevel >= minimumLevel;
+ }
+
+ getSkillBonus(effect) {
+ return this.activeBuffs[effect] || 0;
+ }
+
+ // UI updates
+ updateUI() {
+ this.updateSkillsGrid();
+ this.updateSkillPointsDisplay();
+ }
+
+ updateSkillsGrid() {
+ const skillsGridElement = document.getElementById('skillsGrid');
+ if (!skillsGridElement) return;
+
+ const activeCategory = document.querySelector('.skill-cat-btn.active')?.dataset.category || 'combat';
+ const skills = this.skills[activeCategory] || {};
+
+ skillsGridElement.innerHTML = '';
+
+ Object.entries(skills).forEach(([skillId, skill]) => {
+ const skillElement = document.createElement('div');
+ skillElement.className = `skill-item ${!skill.unlocked ? 'locked' : ''}`;
+
+ const progressPercent = skill.currentLevel > 0 ?
+ (skill.experience / skill.experienceToNext) * 100 : 0;
+
+ // Use texture manager for icon fallback
+ const iconClass = this.game.systems.textureManager ?
+ this.game.systems.textureManager.getIcon(skill.icon) :
+ (skill.icon || 'fa-question');
+
+ skillElement.innerHTML = `
+
+ ${skill.description}
+ ${skill.currentLevel > 0 && skill.currentLevel < skill.maxLevel ? `
+
+
+
${skill.experience}/${skill.experienceToNext} XP
+
+ MAX LEVEL
+
+ ` : ''}
+
+ ${!skill.unlocked ? `
+
+ Unlock (2 Points)
+
+ ` : skill.currentLevel < skill.maxLevel ? `
+
+ Upgrade (1 Point)
+
+ ` : `
+ MAX LEVEL
+ `}
+
+ ${skill.requiredLevel && !skill.unlocked ? `
+ Requires Level ${skill.requiredLevel}
+ ` : ''}
+ `;
+
+ skillsGridElement.appendChild(skillElement);
+ });
+ }
+
+ updateSkillPointsDisplay() {
+ const player = this.game.systems.player;
+ // Update skill points display if element exists
+ const skillPointsElements = document.querySelectorAll('.skill-points');
+ skillPointsElements.forEach(element => {
+ element.textContent = `Skill Points: ${player.stats.skillPoints}`;
+ });
+ }
+
+ // Save/Load
+ save() {
+ return {
+ skills: this.skills,
+ activeBuffs: this.activeBuffs
+ };
+ }
+
+ load(data) {
+ if (data.skills) {
+ // Deep merge to preserve structure
+ for (const [category, skills] of Object.entries(data.skills)) {
+ if (this.skills[category]) {
+ for (const [skillId, skillData] of Object.entries(skills)) {
+ if (this.skills[category][skillId]) {
+ Object.assign(this.skills[category][skillId], skillData);
+ }
+ }
+ }
+ }
+ }
+
+ if (data.activeBuffs) {
+ this.activeBuffs = data.activeBuffs;
+ }
+
+ this.applySkillEffects();
+}
+
+reset() {
+ this.skillPoints = 0;
+ this.unlockedSkills = [];
+ this.activeBuffs = [];
+ // Skills are already defined in constructor, just reset levels
+ Object.values(this.skills).forEach(category => {
+ Object.values(category).forEach(skill => {
+ skill.currentLevel = 0;
+ skill.experience = 0;
+ });
+ });
+}
+
+clear() {
+ this.reset();
+}
+}
diff --git a/Client-Server/js/ui/LiveMainMenu.js b/Client-Server/js/ui/LiveMainMenu.js
new file mode 100644
index 0000000..b18d573
--- /dev/null
+++ b/Client-Server/js/ui/LiveMainMenu.js
@@ -0,0 +1,1202 @@
+/**
+ * Live Main Menu System
+ * Handles server authentication, server browser, and multiplayer game initialization
+ */
+
+console.log('[LIVE MAIN MENU] LiveMainMenu.js script loaded');
+
+class LiveMainMenu {
+ constructor() {
+ console.log('[LIVE MAIN MENU] Constructor called');
+
+ // Check if DOM is ready
+ if (document.readyState === 'loading') {
+ console.warn('[LIVE MAIN MENU] DOM not ready yet, elements may not be found');
+ } else {
+ console.log('[LIVE MAIN MENU] DOM is ready');
+ }
+
+ this.mainMenu = document.getElementById('mainMenu');
+ console.log('[LIVE MAIN MENU] Main menu element found:', !!this.mainMenu);
+
+ this.selectedServer = null;
+ this.authToken = null;
+ this.currentUser = null;
+ this.servers = []; // Renamed from serverList to avoid conflict with DOM element
+ this.apiBaseUrl = 'https://api.korvarix.com/api'; // API Server URL
+ this.gameServerUrl = 'https://dev.gameserver.galaxystrike.online'; // Game Server URL for Socket.IO (local dev server)
+ this.localGameServerUrl = 'http://localhost:3002'; // Local Game Server URL
+ this.isLocalMode = false; // Track if we're in local mode
+
+ console.log('[LIVE MAIN MENU] Initializing elements');
+ this.initializeElements();
+
+ console.log('[LIVE MAIN MENU] Initializing event listeners');
+ this.bindEvents();
+
+ // Check for existing auth token
+ this.checkExistingAuth();
+
+ // DISABLE local server check - always use remote multiplayer server
+ // this.checkForLocalServer();
+ console.log('[LIVE MAIN MENU] Local server check disabled - using remote multiplayer server only');
+ console.log('[LIVE MAIN MENU] Using remote API:', this.apiBaseUrl);
+ console.log('[LIVE MAIN MENU] Using remote game server:', this.gameServerUrl);
+
+ // Initialize SmartSaveManager to singleplayer mode by default
+ if (window.smartSaveManager) {
+ window.smartSaveManager.setMultiplayerMode(false);
+ }
+
+ console.log('[LIVE MAIN MENU] Constructor completed');
+ }
+
+ initializeElements() {
+ // Menu sections
+ this.loginSection = document.getElementById('loginSection');
+ this.serverSection = document.getElementById('serverSection');
+ this.serverConfirmSection = document.getElementById('serverConfirmSection');
+ this.optionsSection = document.getElementById('optionsSection');
+
+ // Login form elements
+ this.emailInput = document.getElementById('emailInput');
+ this.passwordInput = document.getElementById('passwordInput');
+ this.loginBtn = document.getElementById('loginBtn');
+ this.registerBtn = document.getElementById('registerBtn');
+ this.loginNotice = document.getElementById('loginNotice');
+
+ // Server browser elements
+ this.createServerBtn = document.getElementById('createServerBtn');
+ this.refreshServersBtn = document.getElementById('refreshServersBtn');
+ this.regionFilter = document.getElementById('regionFilter');
+ this.typeFilter = document.getElementById('typeFilter');
+ this.serverList = document.getElementById('serverList');
+ this.serverLoading = document.getElementById('serverLoading');
+ this.serverEmpty = document.getElementById('serverEmpty');
+
+ // Server confirmation elements
+ this.joinServerBtn = document.getElementById('joinServerBtn');
+ this.serverInfoBtn = document.getElementById('serverInfoBtn');
+ this.leaveServerBtn = document.getElementById('leaveServerBtn');
+
+ // Server detail elements
+ this.selectedServerName = document.getElementById('selectedServerName');
+ this.selectedServerType = document.getElementById('selectedServerType');
+ this.selectedServerRegion = document.getElementById('selectedServerRegion');
+ this.selectedServerPlayers = document.getElementById('selectedServerPlayers');
+ this.selectedServerOwner = document.getElementById('selectedServerOwner');
+
+ // Navigation buttons
+ this.backToLoginBtn = document.getElementById('backToLoginBtn');
+ this.backToServersBtn = document.getElementById('backToServersBtn');
+
+ console.log('[LIVE MAIN MENU] All elements initialized');
+ }
+
+ bindEvents() {
+ console.log('[LIVE MAIN MENU] Binding events...');
+
+ // Login events
+ if (this.loginBtn) {
+ this.loginBtn.addEventListener('click', () => this.handleLogin());
+ console.log('[LIVE MAIN MENU] Login button event bound');
+ } else {
+ console.warn('[LIVE MAIN MENU] Login button not found');
+ }
+
+ if (this.registerBtn) {
+ this.registerBtn.addEventListener('click', () => this.handleRegister());
+ console.log('[LIVE MAIN MENU] Register button event bound');
+ } else {
+ console.warn('[LIVE MAIN MENU] Register button not found');
+ }
+
+ // Enter key login
+ if (this.passwordInput) {
+ this.passwordInput.addEventListener('keypress', (e) => {
+ if (e.key === 'Enter') this.handleLogin();
+ });
+ console.log('[LIVE MAIN MENU] Password input event bound');
+ } else {
+ console.warn('[LIVE MAIN MENU] Password input not found');
+ }
+
+ // Server browser events
+ if (this.createServerBtn) {
+ this.createServerBtn.addEventListener('click', () => this.startLocalServer());
+ console.log('[LIVE MAIN MENU] Create server button event bound (now starts local server)');
+ } else {
+ console.warn('[LIVE MAIN MENU] Create server button not found');
+ }
+
+ if (this.refreshServersBtn) {
+ this.refreshServersBtn.addEventListener('click', () => this.refreshServerListWithoutAnimation());
+ console.log('[LIVE MAIN MENU] Refresh servers button event bound');
+ } else {
+ console.warn('[LIVE MAIN MENU] Refresh servers button not found');
+ }
+
+ if (this.regionFilter) {
+ this.regionFilter.addEventListener('change', () => this.filterServers());
+ console.log('[LIVE MAIN MENU] Region filter event bound');
+ } else {
+ console.warn('[LIVE MAIN MENU] Region filter not found');
+ }
+
+ if (this.typeFilter) {
+ this.typeFilter.addEventListener('change', () => this.filterServers());
+ console.log('[LIVE MAIN MENU] Type filter event bound');
+ } else {
+ console.warn('[LIVE MAIN MENU] Type filter not found');
+ }
+
+ // Server confirmation events
+ if (this.joinServerBtn) {
+ this.joinServerBtn.addEventListener('click', () => this.joinServer());
+ console.log('[LIVE MAIN MENU] Join server button event bound');
+ } else {
+ console.warn('[LIVE MAIN MENU] Join server not found');
+ }
+
+ // Navigation events
+ if (this.backToLoginBtn) {
+ this.backToLoginBtn.addEventListener('click', () => this.showLoginSection());
+ console.log('[LIVE MAIN MENU] Back to login button event bound');
+ } else {
+ console.warn('[LIVE MAIN MENU] Back to login button not found');
+ }
+
+ if (this.backToServersBtn) {
+ this.backToServersBtn.addEventListener('click', () => this.showServerSection());
+ console.log('[LIVE MAIN MENU] Back to servers button event bound');
+ } else {
+ console.warn('[LIVE MAIN MENU] Back to servers button not found');
+ }
+
+ console.log('[LIVE MAIN MENU] All events bound (with warnings for missing elements)');
+ }
+
+ checkExistingAuth() {
+ const token = localStorage.getItem('authToken');
+ const user = localStorage.getItem('currentUser');
+
+ if (token && user) {
+ this.authToken = token;
+ this.currentUser = JSON.parse(user);
+ console.log('[LIVE MAIN MENU] Found existing auth token, validating...');
+ this.validateToken();
+ } else {
+ console.log('[LIVE MAIN MENU] No existing auth found');
+ this.showLoginSection();
+ }
+ }
+
+ async validateToken() {
+ try {
+ const response = await fetch(`${this.apiBaseUrl}/auth/verify`, {
+ method: 'GET',
+ headers: {
+ 'Authorization': `Bearer ${this.authToken}`,
+ 'Content-Type': 'application/json'
+ }
+ });
+
+ if (response.ok) {
+ const data = await response.json();
+ this.currentUser = data.user;
+ localStorage.setItem('currentUser', JSON.stringify(this.currentUser));
+ console.log('[LIVE MAIN MENU] Token validated successfully');
+ this.showServerSection();
+ } else {
+ console.log('[LIVE MAIN MENU] Token invalid, clearing auth');
+ this.clearAuth();
+ this.showLoginSection();
+ }
+ } catch (error) {
+ console.error('[LIVE MAIN MENU] Token validation failed:', error);
+ this.clearAuth();
+ this.showLoginSection();
+ }
+ }
+
+ clearAuth() {
+ this.authToken = null;
+ this.currentUser = null;
+ localStorage.removeItem('authToken');
+ localStorage.removeItem('currentUser');
+ }
+
+ showSection(sectionName, animate = true) {
+ // Don't re-animate if we're showing the same section
+ if (this.currentSection === sectionName) {
+ animate = false;
+ }
+
+ // Hide all sections
+ this.loginSection?.classList.add('hidden');
+ this.serverSection?.classList.add('hidden');
+ this.serverConfirmSection?.classList.add('hidden');
+ this.optionsSection?.classList.add('hidden');
+
+ // Show selected section
+ const section = document.getElementById(`${sectionName}Section`);
+ if (section) {
+ section.classList.remove('hidden');
+
+ // Control animation
+ if (animate) {
+ section.style.animation = 'fadeInUp 0.5s ease-out';
+ } else {
+ section.style.animation = 'none';
+ }
+
+ this.currentSection = sectionName;
+ }
+ }
+
+ showLoginSection() {
+ this.showSection('login');
+ this.clearLoginForm();
+ }
+
+ showServerSection(refreshServers = true, animate = true) {
+ this.showSection('server', animate);
+ if (refreshServers) {
+ this.refreshServerList();
+ }
+ }
+
+ showServerConfirmSection() {
+ this.showSection('serverConfirm');
+ this.updateServerConfirmSection();
+ }
+
+ clearLoginForm() {
+ if (this.emailInput) this.emailInput.value = '';
+ if (this.passwordInput) this.passwordInput.value = '';
+ this.clearLoginNotice();
+ }
+
+ clearLoginNotice() {
+ if (this.loginNotice) {
+ this.loginNotice.innerHTML = `
+
+
+ Note: You need an internet connection to play Galaxy Strike Online.
+
+ `;
+ }
+ }
+
+ showLoginNotice(message, type = 'info') {
+ if (this.loginNotice) {
+ const iconClass = type === 'error' ? 'fa-exclamation-triangle' :
+ type === 'success' ? 'fa-check-circle' : 'fa-info-circle';
+ this.loginNotice.innerHTML = `
`;
+ this.loginNotice.className = `login-notice ${type}`;
+ this.loginNotice.style.display = 'block';
+ }
+ }
+
+ hideLoginNotice() {
+ if (this.loginNotice) {
+ this.loginNotice.style.display = 'none';
+ }
+ }
+
+ async handleLogin() {
+ const email = this.emailInput?.value?.trim();
+ const password = this.passwordInput?.value?.trim();
+
+ if (!email || !password) {
+ this.showLoginNotice('Please enter email and password', 'error');
+ return;
+ }
+
+ // Disable login button
+ if (this.loginBtn) {
+ this.loginBtn.disabled = true;
+ this.loginBtn.innerHTML = '
+
+
${server.name}
+
+
+ ${server.region || 'Unknown'}
+
+
+ ${createdDate}
+
+
+
+
+ ${server.type}
+ ${playerCount}
+
+
+
+
+
+ Server Name:
+
+
+ Server Type:
+
+ Public
+ Private
+
+
+
+ Region:
+
+ US East
+ US West
+ Europe
+ Asia
+
+
+
+ Max Players:
+
+
+
+
${saveInfoText} `;
+
+ // Has save data - always show Continue, hide New Game
+ this.confirmContinueBtn.style.display = 'block';
+ this.confirmContinueBtn.disabled = false;
+ this.confirmDeleteBtn.style.display = 'block';
+ this.confirmDeleteBtn.disabled = false;
+ this.confirmSettingsBtn.style.display = 'block';
+ this.confirmSettingsBtn.disabled = false;
+ this.confirmNewGameBtn.style.display = 'none';
+ this.confirmNewGameBtn.disabled = true;
+ } else {
+ // No save data - show new game option
+ this.confirmLevel.textContent = 'New';
+ this.confirmShip.textContent = 'New Adventure';
+ this.confirmPlayTime.textContent = '0h 0m';
+ this.confirmLastPlayed.textContent = 'Never';
+
+ // Show new game and settings buttons, hide continue and delete
+ this.confirmNewGameBtn.style.display = 'block';
+ this.confirmNewGameBtn.disabled = false;
+ this.confirmSettingsBtn.style.display = 'block';
+ this.confirmSettingsBtn.disabled = false;
+ this.confirmContinueBtn.style.display = 'none';
+ this.confirmDeleteBtn.style.display = 'none';
+ }
+ }
+
+ showOptionsSection() {
+ this.showSection('options');
+ // Clear any previous data to prevent contamination
+ this.clearOptionsSectionData();
+ this.updateGameOptions();
+ }
+
+ clearConfirmSectionData() {
+ // Clear individual text content elements
+ if (this.confirmLevel) this.confirmLevel.textContent = '';
+ if (this.confirmShip) this.confirmShip.textContent = '';
+ if (this.confirmPlayTime) this.confirmPlayTime.textContent = '';
+ if (this.confirmLastPlayed) this.confirmLastPlayed.textContent = '';
+
+ // Clear the save details display
+ if (this.confirmSaveDetails) {
+ this.confirmSaveDetails.innerHTML = '';
+ }
+ }
+
+ clearOptionsSectionData() {
+ // Clear the save info details display
+ const saveInfoDetails = document.getElementById('saveInfoDetails');
+ if (saveInfoDetails) {
+ saveInfoDetails.innerHTML = '';
+ }
+ }
+
+ handleSSOLogin() {
+ // Placeholder for SSO login
+ console.log('[MAIN MENU] SSO login requested (placeholder)');
+
+ // Show loading state
+ this.ssoLoginBtn.disabled = true;
+ this.ssoLoginBtn.innerHTML = '${saveInfoText} `;
+ } else {
+ saveInfoDetails.innerHTML = `
+
+
Slot: ${this.selectedSlot || 'None'}
+
Status: Empty
+
Ready for new adventure
+
${message}
+
+ `;
+
+ // Set modal type class
+ modal.className = `modal alert-modal ${type}`;
+
+ // Show modal
+ modalOverlay.classList.remove('hidden');
+
+ // Add click outside to close
+ modalOverlay.onclick = (e) => {
+ if (e.target === modalOverlay) {
+ this.closeAlert();
+ }
+ };
+
+ // Add escape key to close
+ const handleEscape = (e) => {
+ if (e.key === 'Escape') {
+ this.closeAlert();
+ document.removeEventListener('keydown', handleEscape);
+ }
+ };
+ document.addEventListener('keydown', handleEscape);
+ }
+
+ closeAlert() {
+ const modalOverlay = document.getElementById('modalOverlay');
+ if (modalOverlay) {
+ modalOverlay.classList.add('hidden');
+ }
+ }
+
+ // Custom confirmation function to replace browser confirm()
+ showConfirm(message, onConfirm, onCancel = null) {
+ const modalOverlay = document.getElementById('modalOverlay');
+ const modal = document.getElementById('modal');
+ const modalTitle = document.getElementById('modalTitle');
+ const modalBody = document.getElementById('modalBody');
+
+ console.log('[MAIN MENU] showConfirm called', {
+ modalOverlay: !!modalOverlay,
+ modal: !!modal,
+ modalTitle: !!modalTitle,
+ modalBody: !!modalBody
+ });
+
+ if (!modalOverlay || !modal || !modalTitle || !modalBody) {
+ console.warn('[MAIN MENU] Modal elements not found, falling back to browser confirm');
+ // Fallback to browser confirm if modal elements aren't found
+ const result = confirm(message);
+ if (result && onConfirm) onConfirm();
+ if (!result && onCancel) onCancel();
+ return;
+ }
+
+ // Set modal content
+ modalTitle.textContent = 'Confirm Action';
+ modalBody.innerHTML = `
+ ${message}
+
+ `;
+
+ // Set modal type class
+ modal.className = 'modal confirmation-modal';
+
+ // Store callbacks
+ this._confirmCallback = onConfirm;
+ this._cancelCallback = onCancel;
+
+ // Show modal
+ modalOverlay.classList.remove('hidden');
+
+ // Add click outside to close
+ modalOverlay.onclick = (e) => {
+ if (e.target === modalOverlay) {
+ this.closeConfirm();
+ }
+ };
+
+ // Add escape key to close
+ const handleEscape = (e) => {
+ if (e.key === 'Escape') {
+ this.closeConfirm();
+ document.removeEventListener('keydown', handleEscape);
+ }
+ };
+ document.addEventListener('keydown', handleEscape);
+ }
+
+ executeConfirm() {
+ console.log('[MAIN MENU] executeConfirm called', {
+ hasCallback: !!this._confirmCallback
+ });
+
+ const modalOverlay = document.getElementById('modalOverlay');
+ if (modalOverlay) {
+ modalOverlay.classList.add('hidden');
+ }
+
+ if (this._confirmCallback) {
+ console.log('[MAIN MENU] Executing confirmation callback');
+ this._confirmCallback();
+ } else {
+ console.warn('[MAIN MENU] No confirmation callback found');
+ }
+
+ // Clear callbacks
+ this._confirmCallback = null;
+ this._cancelCallback = null;
+ }
+
+ closeConfirm() {
+ const modalOverlay = document.getElementById('modalOverlay');
+ if (modalOverlay) {
+ modalOverlay.classList.add('hidden');
+ }
+
+ if (this._cancelCallback) {
+ this._cancelCallback();
+ }
+
+ // Clear callbacks
+ this._confirmCallback = null;
+ this._cancelCallback = null;
+ }
+}
+
+// Initialize main menu when DOM is ready
+document.addEventListener('DOMContentLoaded', () => {
+ console.log('[MAIN MENU] DOMContentLoaded event fired');
+ window.mainMenu = new MainMenu();
+});
+
+// Also try immediate initialization if DOM is already loaded
+if (document.readyState === 'loading') {
+ console.log('[MAIN MENU] DOM still loading, waiting for DOMContentLoaded');
+} else {
+ console.log('[MAIN MENU] DOM already loaded, initializing immediately');
+ window.mainMenu = new MainMenu();
+}
diff --git a/Client-Server/js/ui/UIManager.js b/Client-Server/js/ui/UIManager.js
new file mode 100644
index 0000000..b1bd8b7
--- /dev/null
+++ b/Client-Server/js/ui/UIManager.js
@@ -0,0 +1,2459 @@
+/**
+ * Galaxy Strike Online - UI Manager
+ * Handles all user interface interactions and updates
+ */
+
+class UIManager {
+ constructor(gameEngine) {
+ const debugLogger = window.debugLogger;
+
+ if (debugLogger) debugLogger.startStep('UIManager.constructor', {
+ gameEngineProvided: !!gameEngine
+ });
+
+ this.game = gameEngine;
+
+ // UI state
+ this.currentTab = 'dashboard';
+ this.modalOpen = false;
+ this.notifications = [];
+
+ // Note: setupEventListeners() called in proceedWithInitialization() to prevent duplicates
+
+ if (debugLogger) debugLogger.endStep('UIManager.constructor', {
+ currentTab: this.currentTab,
+ modalOpen: this.modalOpen,
+ notificationsCount: this.notifications.length,
+ gameEngineSet: !!this.game,
+ eventListenersSetup: true
+ });
+ }
+
+ async initialize() {
+ const debugLogger = window.debugLogger;
+
+ if (debugLogger) debugLogger.startStep('UIManager.initialize', {
+ currentTab: this.currentTab,
+ modalOpen: this.modalOpen,
+ notificationsCount: this.notifications.length
+ });
+
+ // Wait for DOM to be ready and game interface to be visible
+ const waitForDOM = () => {
+ const gameInterface = document.getElementById('gameInterface');
+ const navButtons = document.querySelectorAll('.nav-btn');
+
+ if (debugLogger) debugLogger.logStep('DOM Check', {
+ gameInterfaceExists: !!gameInterface,
+ gameInterfaceHidden: gameInterface?.classList.contains('hidden'),
+ navButtonsFound: navButtons.length,
+ documentReady: document.readyState
+ });
+
+ if (gameInterface && !gameInterface.classList.contains('hidden') && navButtons.length > 0) {
+ this.proceedWithInitialization();
+ } else {
+ setTimeout(waitForDOM, 100);
+ }
+ };
+
+ // Start the DOM check
+ waitForDOM();
+ }
+
+ proceedWithInitialization() {
+ const debugLogger = window.debugLogger;
+
+ // Setup navigation
+ // if (debugLogger) debugLogger.logStep('Setting up navigation');
+ this.setupNavigation();
+
+ // Setup event listeners
+ // if (debugLogger) debugLogger.logStep('Setting up event listeners');
+ this.setupEventListeners();
+
+ // Setup resource display
+ // if (debugLogger) debugLogger.logStep('Setting up resource display');
+ this.setupResourceDisplay();
+
+ if (debugLogger) debugLogger.endStep('UIManager.initialize', {
+ currentTab: this.currentTab,
+ modalOpen: this.modalOpen,
+ notificationsCount: this.notifications.length,
+ navigationSetup: true,
+ eventListenersSetup: true,
+ resourceDisplaySetup: true
+ });
+ }
+
+ setupNavigation() {
+ const debugLogger = window.debugLogger;
+
+ if (debugLogger) debugLogger.startStep('UIManager.setupNavigation');
+
+ // Navigation setup moved to setupEventListeners to fix scope issues
+
+ if (debugLogger) debugLogger.endStep('UIManager.setupNavigation', {
+ success: true
+ });
+
+ const craftingCatButtons = document.querySelectorAll('.crafting-cat-btn');
+ if (debugLogger) debugLogger.logStep('Setting up crafting category navigation', {
+ craftingCatButtonsCount: craftingCatButtons.length
+ });
+
+ craftingCatButtons.forEach(btn => {
+ btn.addEventListener('click', (e) => {
+ const category = e.currentTarget.dataset.category;
+
+ if (debugLogger) debugLogger.log('Crafting category button clicked', {
+ buttonElement: btn.tagName,
+ buttonText: btn.textContent,
+ category: category
+ });
+
+ this.switchCraftingCategory(category);
+ });
+ });
+
+ if (debugLogger) debugLogger.endStep('UIManager.setupNavigation', {
+ navButtonsSetup: navButtons.length,
+ skillCatButtonsSetup: skillCatButtons.length,
+ shopCatButtonsSetup: shopCatButtons.length,
+ questTabButtonsSetup: questTabButtons.length,
+ craftingCatButtonsSetup: craftingCatButtons.length
+ });
+ }
+
+ setupEventListeners() {
+ const debugLogger = window.debugLogger;
+
+ if (debugLogger) debugLogger.startStep('UIManager.setupEventListeners');
+
+ // Setup tab navigation here to fix scope issues with endStep
+ const navButtons = document.querySelectorAll('.nav-btn');
+ console.log(`[UIManager] Found ${navButtons.length} navigation buttons`);
+ if (debugLogger) debugLogger.logStep('Setting up tab navigation', {
+ navButtonsCount: navButtons.length
+ });
+
+ if (navButtons.length === 0) {
+ console.warn('[UIManager] No navigation buttons found!');
+ if (debugLogger) debugLogger.logStep('No navigation buttons found');
+ }
+
+ navButtons.forEach((btn, index) => {
+ console.log(`[UIManager] Setting up button ${index}:`, btn.dataset.tab);
+ // Check if button already has a listener to prevent duplicates
+ if (btn.getAttribute('data-has-listener') === 'true') {
+ console.log(`[UIManager] Button ${btn.dataset.tab} already has listener, skipping`);
+ return;
+ }
+
+ btn.addEventListener('click', (e) => {
+ console.log(`[UIManager] Navigation button clicked: ${btn.dataset.tab}`);
+ const tab = btn.dataset.tab;
+ if (tab) {
+ this.switchTab(tab);
+ }
+ });
+
+ // Mark button as having a listener
+ btn.setAttribute('data-has-listener', 'true');
+ console.log(`[UIManager] Button ${btn.dataset.tab} setup complete`);
+ });
+
+ // Set up UI update event listener from GameEngine
+ if (this.game) {
+ this.game.addEventListener('uiUpdate', (event) => {
+ this.handleUIUpdate(event.detail);
+ });
+
+ // if (debugLogger) debugLogger.logStep('UI update event listener set up');
+ }
+
+ // Modal controls
+ const modalClose = document.getElementById('modalClose');
+ const modalOverlay = document.getElementById('modalOverlay');
+
+ if (debugLogger) debugLogger.logStep('Setting up modal controls', {
+ modalCloseExists: !!modalClose,
+ modalOverlayExists: !!modalOverlay
+ });
+
+ if (modalClose) {
+ // Check if already has listener
+ if (modalClose.getAttribute('data-has-listener') === 'true') {
+ if (debugLogger) debugLogger.log('Modal close button already has listener, skipping');
+ } else {
+ modalClose.addEventListener('click', () => {
+ if (debugLogger) debugLogger.log('Modal close button clicked');
+ this.closeModal();
+ });
+ modalClose.setAttribute('data-has-listener', 'true');
+ }
+ }
+
+ if (modalOverlay) {
+ // Check if already has listener
+ if (modalOverlay.getAttribute('data-has-listener') === 'true') {
+ if (debugLogger) debugLogger.log('Modal overlay already has listener, skipping');
+ } else {
+ modalOverlay.addEventListener('click', (e) => {
+ if (e.target === modalOverlay) {
+ if (debugLogger) debugLogger.log('Modal overlay clicked - closing modal');
+ this.closeModal();
+ }
+ });
+ modalOverlay.setAttribute('data-has-listener', 'true');
+ }
+ }
+
+ // Quick action buttons
+ const claimOfflineBtn = document.getElementById('claimOfflineBtn');
+ if (claimOfflineBtn) {
+ // Check if already has listener
+ if (claimOfflineBtn.getAttribute('data-has-listener') === 'true') {
+ if (debugLogger) debugLogger.log('Claim offline button already has listener, skipping');
+ } else {
+ // if (debugLogger) debugLogger.logStep('Setting up claim offline rewards button');
+ claimOfflineBtn.addEventListener('click', () => {
+ if (debugLogger) debugLogger.log('Claim offline rewards button clicked');
+ this.game.systems.idleSystem.claimOfflineRewards();
+ });
+ claimOfflineBtn.setAttribute('data-has-listener', 'true');
+ }
+ }
+
+ const quickDungeonBtn = document.getElementById('quickDungeonBtn');
+ if (quickDungeonBtn) {
+ // if (debugLogger) debugLogger.logStep('Setting up quick dungeon button');
+ quickDungeonBtn.addEventListener('click', () => {
+ if (debugLogger) debugLogger.log('Quick dungeon button clicked', {
+ currentTab: this.currentTab,
+ targetTab: 'dungeons'
+ });
+ this.switchTab('dungeons');
+ });
+ }
+
+ // Settings and Discord buttons
+ const settingsBtn = document.getElementById('settingsBtn');
+ if (settingsBtn) {
+ // Check if already has listener
+ if (settingsBtn.getAttribute('data-has-listener') === 'true') {
+ if (debugLogger) debugLogger.log('Settings button already has listener, skipping');
+ } else {
+ // if (debugLogger) debugLogger.logStep('Setting up settings button');
+ settingsBtn.addEventListener('click', () => {
+ if (debugLogger) debugLogger.log('Settings button clicked');
+ this.showSettingsMenu();
+ });
+ settingsBtn.setAttribute('data-has-listener', 'true');
+ }
+ }
+
+ const discordBtn = document.getElementById('discordBtn');
+ if (discordBtn) {
+ // if (debugLogger) debugLogger.logStep('Setting up Discord button');
+ discordBtn.addEventListener('click', () => {
+ if (debugLogger) debugLogger.log('Discord button clicked');
+ this.showDiscordIntegration();
+ });
+ }
+
+ // Local Server button
+ const localServerBtn = document.getElementById('localServerBtn');
+ if (localServerBtn) {
+ // if (debugLogger) debugLogger.logStep('Setting up local server button');
+ localServerBtn.addEventListener('click', () => {
+ if (debugLogger) debugLogger.log('Local server button clicked');
+ this.showLocalServerControls();
+ });
+ }
+
+ // Return to Main Menu button
+ const returnToMenuBtn = document.getElementById('returnToMenuBtn');
+ if (returnToMenuBtn) {
+ // Check if button already has a listener to prevent duplicates
+ if (returnToMenuBtn.getAttribute('data-has-listener') === 'true') {
+ if (debugLogger) debugLogger.log('Return to menu button already has listener, skipping');
+ return;
+ }
+
+ // if (debugLogger) debugLogger.logStep('Setting up return to menu button');
+ returnToMenuBtn.addEventListener('click', () => {
+ if (debugLogger) debugLogger.log('Return to menu button clicked');
+ this.showReturnToMainMenuModal();
+ });
+
+ // Mark as having listener
+ returnToMenuBtn.setAttribute('data-has-listener', 'true');
+ }
+
+ // Setup sub-panel category buttons
+ const skillCatButtons = document.querySelectorAll('.skill-cat-btn');
+ if (debugLogger) debugLogger.logStep('Setting up skill category navigation', {
+ skillCatButtonsCount: skillCatButtons.length
+ });
+
+ skillCatButtons.forEach(btn => {
+ // Check if button already has a listener to prevent duplicates
+ if (btn.getAttribute('data-has-listener') === 'true') {
+ return;
+ }
+
+ btn.addEventListener('click', (e) => {
+ const category = btn.dataset.category;
+ if (debugLogger) debugLogger.log('Skill category button clicked', {
+ buttonElement: btn.tagName,
+ buttonText: btn.textContent,
+ category: category
+ });
+
+ this.switchSkillCategory(category);
+ });
+
+ // Mark button as having a listener
+ btn.setAttribute('data-has-listener', 'true');
+ });
+
+ const questTabButtons = document.querySelectorAll('.quest-tab-btn');
+ if (debugLogger) debugLogger.logStep('Setting up quest tab navigation', {
+ questTabButtonsCount: questTabButtons.length
+ });
+
+ questTabButtons.forEach(btn => {
+ // Check if button already has a listener to prevent duplicates
+ if (btn.getAttribute('data-has-listener') === 'true') {
+ return;
+ }
+
+ btn.addEventListener('click', (e) => {
+ const type = btn.dataset.type;
+ if (debugLogger) debugLogger.log('Quest tab button clicked', {
+ buttonElement: btn.tagName,
+ buttonText: btn.textContent,
+ type: type
+ });
+
+ this.switchQuestType(type);
+ });
+
+ // Mark button as having a listener
+ btn.setAttribute('data-has-listener', 'true');
+ });
+
+ const craftingCatButtons = document.querySelectorAll('.crafting-cat-btn');
+ if (debugLogger) debugLogger.logStep('Setting up crafting category navigation', {
+ craftingCatButtonsCount: craftingCatButtons.length
+ });
+
+ craftingCatButtons.forEach(btn => {
+ // Check if button already has a listener to prevent duplicates
+ if (btn.getAttribute('data-has-listener') === 'true') {
+ return;
+ }
+
+ btn.addEventListener('click', (e) => {
+ const category = e.currentTarget.dataset.category;
+
+ if (debugLogger) debugLogger.log('Crafting category button clicked', {
+ buttonElement: btn.tagName,
+ buttonText: btn.textContent,
+ category: category
+ });
+
+ this.switchCraftingCategory(category);
+ });
+
+ // Mark button as having a listener
+ btn.setAttribute('data-has-listener', 'true');
+ });
+
+ const shopCatButtons = document.querySelectorAll('.shop-cat-btn');
+ if (debugLogger) debugLogger.logStep('Setting up shop category navigation', {
+ shopCatButtonsCount: shopCatButtons.length
+ });
+
+ shopCatButtons.forEach(btn => {
+ // Check if button already has a listener to prevent duplicates
+ if (btn.getAttribute('data-has-listener') === 'true') {
+ return;
+ }
+
+ btn.addEventListener('click', (e) => {
+ const category = btn.dataset.category;
+ if (debugLogger) debugLogger.log('Shop category button clicked', {
+ buttonElement: btn.tagName,
+ buttonText: btn.textContent,
+ category: category
+ });
+
+ this.switchShopCategory(category);
+ });
+
+ // Mark button as having a listener
+ btn.setAttribute('data-has-listener', 'true');
+ });
+
+ // Keyboard shortcuts for tab switching removed
+
+ if (debugLogger) debugLogger.endStep('UIManager.setupEventListeners', {
+ modalControlsSetup: !!(modalClose || modalOverlay),
+ quickActionButtonsSetup: !!(claimOfflineBtn || quickDungeonBtn),
+ settingsButtonsSetup: !!(settingsBtn || discordBtn),
+ returnMenuButtonSetup: !!returnToMenuBtn,
+ navigationButtonsSetup: navButtons.length > 0,
+ navigationButtonsCount: navButtons.length,
+ skillCategoryButtonsSetup: skillCatButtons.length,
+ questTabButtonsSetup: questTabButtons.length,
+ craftingCategoryButtonsSetup: craftingCatButtons.length,
+ shopCategoryButtonsSetup: shopCatButtons.length
+ });
+ }
+
+ async saveGame() {
+ const debugLogger = window.debugLogger;
+
+ // if (debugLogger) debugLogger.startStep('UIManager.saveGame');
+
+ try {
+
+ // Show saving notification
+ // this.game.showNotification('Saving game...', 'info', 2000);
+
+ // Call the game engine's save method
+ await this.game.save();
+
+ // Show success notification
+ // this.game.showNotification('Game saved successfully!', 'success', 3000);
+
+
+ // if (debugLogger) debugLogger.endStep('UIManager.saveGame', {
+ // success: true
+ // });
+
+ } catch (error) {
+
+ // Show error notification
+ this.game.showNotification('Failed to save game!', 'error', 3000);
+
+ if (debugLogger) debugLogger.errorEvent(error, 'UIManager.saveGame');
+ }
+ }
+
+ showLocalServerControls() {
+ const debugLogger = window.debugLogger;
+
+ if (debugLogger) debugLogger.startStep('UIManager.showLocalServerControls');
+
+
+ // Get current server status
+ const serverInfo = window.localServerManager ? window.localServerManager.getServerInfo() : {
+ isRunning: false,
+ status: 'Unknown',
+ port: null,
+ url: null,
+ connectedClients: 0,
+ uptime: 0
+ };
+
+ let content = '';
+ content += '
';
+ content += `
Status: ${serverInfo.status}
`;
+
+ if (serverInfo.isRunning) {
+ content += `
Port: ${serverInfo.port}
`;
+ content += `
URL: ${serverInfo.url}
`;
+ content += `
Connected Clients: ${serverInfo.connectedClients}
`;
+ content += `
Uptime: ${Math.floor(serverInfo.uptime)}s
`;
+ }
+ content += '
';
+
+ // Control buttons
+ content += '
';
+
+ if (serverInfo.isRunning) {
+ content += '';
+ content += ' ';
+
+ content += '';
+ content += ' ';
+ } else {
+ content += '';
+ content += ' ';
+ }
+
+ content += '
';
+
+ // Information section
+ content += '
';
+ content += '
The local server enables singleplayer mode when external servers are unavailable. Save data is stored locally on your computer. No internet connection required for local gameplay.
';
+ content += '
';
+
+ content += '
';
+ content += '
Are you sure you want to return to the main menu?
';
+ content += '
Warning: Any unsaved progress will be lost.
';
+ content += '
';
+
+ // Check if using fallback GameEngine
+ if (window.game && window.game.isFallback) {
+ content += 'Return to Menu ';
+ content += 'Cancel ';
+ } else {
+ content += 'Return to Menu ';
+ content += 'Cancel ';
+ }
+
+ content += '
';
+ content += '
+ 
`;
+ }
+
+ return ``;
+ }
+
+ // Preload common textures
+ async preloadTextures() {
+ const commonTextures = [
+ 'ship_fighter',
+ 'ship_cruiser',
+ 'room_command_center',
+ 'room_power_core',
+ 'item_weapon',
+ 'item_shield'
+ ];
+
+ const loadPromises = commonTextures.map(textureId => {
+ const url = `assets/textures/${textureId}.png`;
+ return this.loadTexture(textureId, url);
+ });
+
+ try {
+ await Promise.all(loadPromises);
+ console.log('Common textures preloaded');
+ } catch (error) {
+ console.warn('Some textures failed to preload:', error);
+ }
+ }
+
+ // Clean up unused textures
+ cleanup() {
+ // Keep only essential textures in memory
+ const essentialTextures = ['missing'];
+ for (const [textureId, texture] of this.textures) {
+ if (!essentialTextures.includes(textureId)) {
+ this.textures.delete(textureId);
+ }
+ }
+ }
+}
diff --git a/Client-Server/js/data/GameData.js b/Client-Server/js/data/GameData.js
new file mode 100644
index 0000000..9ce79d7
--- /dev/null
+++ b/Client-Server/js/data/GameData.js
@@ -0,0 +1,570 @@
+/**
+ * Galaxy Strike Online - Game Data
+ * Static game data, constants, and configuration
+ */
+
+// Game configuration
+const GAME_CONFIG = {
+ version: '1.0.0',
+ name: 'Galaxy Strike Online',
+ maxLevel: 100,
+ saveInterval: 30000, // 30 seconds
+ notificationDuration: 3000,
+ maxNotifications: 5
+};
+
+// Player defaults
+const PLAYER_DEFAULTS = {
+ level: 1,
+ experience: 0,
+ skillPoints: 0,
+ credits: 1000,
+ gems: 10,
+ health: 100,
+ maxHealth: 100,
+ energy: 100,
+ maxEnergy: 100,
+ attack: 10,
+ defense: 5,
+ speed: 10,
+ criticalChance: 0.05,
+ criticalDamage: 1.5
+};
+
+// Experience requirements
+const EXPERIENCE_TABLE = [];
+for (let i = 1; i <= 100; i++) {
+ EXPERIENCE_TABLE[i] = Math.floor(100 * Math.pow(1.5, i - 1));
+}
+
+// Item rarities with colors and multipliers
+const ITEM_RARITIES = {
+ common: {
+ name: 'Common',
+ color: '#888888',
+ multiplier: 1.0,
+ dropChance: 0.60
+ },
+ uncommon: {
+ name: 'Uncommon',
+ color: '#00ff00',
+ multiplier: 1.2,
+ dropChance: 0.25
+ },
+ rare: {
+ name: 'Rare',
+ color: '#0088ff',
+ multiplier: 1.5,
+ dropChance: 0.10
+ },
+ epic: {
+ name: 'Epic',
+ color: '#8833ff',
+ multiplier: 2.0,
+ dropChance: 0.04
+ },
+ legendary: {
+ name: 'Legendary',
+ color: '#ff8800',
+ multiplier: 3.0,
+ dropChance: 0.01
+ }
+};
+
+// Enemy types and stats
+const ENEMY_TEMPLATES = {
+ space_pirate: {
+ name: 'Space Pirate',
+ health: 25,
+ attack: 10,
+ defense: 3,
+ speed: 8,
+ experience: 15,
+ credits: 12,
+ rarity: 'common'
+ },
+ alien_guardian: {
+ name: 'Alien Guardian',
+ health: 50,
+ attack: 8,
+ defense: 5,
+ speed: 6,
+ experience: 25,
+ credits: 15,
+ rarity: 'common'
+ },
+ mining_drone: {
+ name: 'Mining Drone',
+ health: 20,
+ attack: 8,
+ defense: 3,
+ speed: 5,
+ experience: 12,
+ credits: 8,
+ rarity: 'common'
+ },
+ security_drone: {
+ name: 'Security Drone',
+ health: 35,
+ attack: 14,
+ defense: 4,
+ speed: 10,
+ experience: 22,
+ credits: 15,
+ rarity: 'uncommon'
+ },
+ pirate_captain: {
+ name: 'Pirate Captain',
+ health: 40,
+ attack: 15,
+ defense: 6,
+ speed: 12,
+ experience: 30,
+ credits: 20,
+ rarity: 'uncommon'
+ },
+ crystal_golem: {
+ name: 'Crystal Golem',
+ health: 80,
+ attack: 6,
+ defense: 10,
+ speed: 4,
+ experience: 35,
+ credits: 25,
+ rarity: 'rare'
+ },
+ corrupted_ai: {
+ name: 'Corrupted AI',
+ health: 60,
+ attack: 20,
+ defense: 2,
+ speed: 15,
+ experience: 40,
+ credits: 30,
+ rarity: 'rare'
+ },
+ energy_being: {
+ name: 'Energy Being',
+ health: 55,
+ attack: 22,
+ defense: 3,
+ speed: 18,
+ experience: 45,
+ credits: 35,
+ rarity: 'epic'
+ },
+ quantum_entity: {
+ name: 'Quantum Entity',
+ health: 70,
+ attack: 35,
+ defense: 5,
+ speed: 20,
+ experience: 60,
+ credits: 50,
+ rarity: 'legendary'
+ }
+};
+
+// Dungeon configurations
+const DUNGEON_CONFIGS = {
+ alien_ruins: {
+ name: 'Alien Ruins',
+ description: 'Ancient alien structures filled with mysterious technology',
+ difficulty: 'medium',
+ minLevel: 3,
+ roomCount: [5, 8],
+ enemyTypes: ['alien_guardian', 'ancient_drone', 'crystal_golem'],
+ rewardMultiplier: 1.2,
+ energyCost: 20
+ },
+ pirate_lair: {
+ name: 'Pirate Lair',
+ description: 'Dangerous pirate hideouts with valuable loot',
+ difficulty: 'easy',
+ minLevel: 1,
+ roomCount: [4, 6],
+ enemyTypes: ['space_pirate', 'pirate_captain', 'defense_turret'],
+ rewardMultiplier: 1.0,
+ energyCost: 15
+ },
+ corrupted_vault: {
+ name: 'Corrupted AI Vault',
+ description: 'Malfunctioning AI facilities with corrupted security',
+ difficulty: 'hard',
+ minLevel: 5,
+ roomCount: [6, 9],
+ enemyTypes: ['security_drone', 'corrupted_ai', 'virus_program'],
+ rewardMultiplier: 1.5,
+ energyCost: 25
+ },
+ asteroid_mine: {
+ name: 'Asteroid Mine',
+ description: 'Abandoned mining facilities in asteroid fields',
+ difficulty: 'easy',
+ minLevel: 2,
+ roomCount: [4, 7],
+ enemyTypes: ['mining_drone', 'rock_creature', 'explosive_asteroid'],
+ rewardMultiplier: 0.8,
+ energyCost: 10
+ },
+ nebula_anomaly: {
+ name: 'Nebula Anomaly',
+ description: 'Strange energy anomalies in deep space',
+ difficulty: 'extreme',
+ minLevel: 8,
+ roomCount: [7, 10],
+ enemyTypes: ['energy_being', 'phase_shifter', 'quantum_entity'],
+ rewardMultiplier: 2.0,
+ energyCost: 30
+ }
+};
+
+// Skill definitions
+const SKILL_DEFINITIONS = {
+ combat: {
+ weapons_mastery: {
+ name: 'Weapons Mastery',
+ description: 'Increases weapon damage and critical chance',
+ maxLevel: 10,
+ experiencePerLevel: 100,
+ effects: {
+ attack: 2,
+ criticalChance: 0.01
+ },
+ icon: 'fa-sword'
+ },
+ shield_techniques: {
+ name: 'Shield Techniques',
+ description: 'Improves defense and energy efficiency',
+ maxLevel: 10,
+ experiencePerLevel: 100,
+ effects: {
+ defense: 2,
+ maxEnergy: 5
+ },
+ icon: 'fa-shield-alt'
+ },
+ piloting: {
+ name: 'Piloting',
+ description: 'Enhances speed and evasion',
+ maxLevel: 10,
+ experiencePerLevel: 100,
+ effects: {
+ speed: 2,
+ criticalChance: 0.005
+ },
+ icon: 'fa-rocket'
+ }
+ },
+ science: {
+ energy_manipulation: {
+ name: 'Energy Manipulation',
+ description: 'Better energy control and regeneration',
+ maxLevel: 10,
+ experiencePerLevel: 100,
+ effects: {
+ maxEnergy: 10,
+ energyRegeneration: 0.1
+ },
+ icon: 'fa-bolt'
+ },
+ alien_technology: {
+ name: 'Alien Technology',
+ description: 'Understanding and using alien artifacts',
+ maxLevel: 10,
+ experiencePerLevel: 150,
+ effects: {
+ findRarity: 0.05,
+ itemValue: 0.1
+ },
+ icon: 'fa-atom'
+ }
+ },
+ crafting: {
+ weapon_crafting: {
+ name: 'Weapon Crafting',
+ description: 'Create and upgrade weapons',
+ maxLevel: 10,
+ experiencePerLevel: 100,
+ effects: {
+ craftingBonus: 0.1,
+ weaponStats: 0.05
+ },
+ icon: 'fa-hammer'
+ },
+ armor_forging: {
+ name: 'Armor Forging',
+ description: 'Forge protective armor and shields',
+ maxLevel: 10,
+ experiencePerLevel: 100,
+ effects: {
+ craftingBonus: 0.1,
+ armorStats: 0.05
+ },
+ icon: 'fa-anvil'
+ }
+ }
+};
+
+// Shop items
+const SHOP_ITEMS = {
+ ships: [
+ {
+ id: 'fighter_mk1',
+ name: 'Fighter Mk. I',
+ type: 'ship',
+ rarity: 'common',
+ price: 5000,
+ currency: 'credits',
+ description: 'Fast and agile fighter ship',
+ stats: { attack: 15, speed: 20, defense: 8 }
+ },
+ {
+ id: 'cruiser_mk1',
+ name: 'Cruiser Mk. I',
+ type: 'ship',
+ rarity: 'uncommon',
+ price: 15000,
+ currency: 'credits',
+ description: 'Well-balanced cruiser for combat',
+ stats: { attack: 20, speed: 10, defense: 15 }
+ }
+ ],
+ upgrades: [
+ {
+ id: 'weapon_upgrade_1',
+ name: 'Weapon Upgrade I',
+ type: 'upgrade',
+ rarity: 'common',
+ price: 500,
+ currency: 'credits',
+ description: 'Increases weapon damage by 10%',
+ effect: { attackMultiplier: 1.1 }
+ },
+ {
+ id: 'shield_upgrade_1',
+ name: 'Shield Upgrade I',
+ type: 'upgrade',
+ rarity: 'common',
+ price: 400,
+ currency: 'credits',
+ description: 'Increases defense by 5 points',
+ effect: { defense: 5 }
+ }
+ ],
+ cosmetics: [
+ {
+ id: 'blue_paint',
+ name: 'Blue Paint Job',
+ type: 'cosmetic',
+ rarity: 'common',
+ price: 100,
+ currency: 'gems',
+ description: 'Custom blue paint for your ship'
+ },
+ {
+ id: 'golden_trim',
+ name: 'Golden Trim',
+ type: 'cosmetic',
+ rarity: 'rare',
+ price: 500,
+ currency: 'gems',
+ description: 'Luxurious golden trim for your ship'
+ }
+ ],
+ consumables: [
+ {
+ id: 'mega_health_kit',
+ name: 'Mega Health Kit',
+ type: 'consumable',
+ rarity: 'uncommon',
+ price: 50,
+ currency: 'credits',
+ description: 'Restores full health',
+ effect: { heal: 999 }
+ },
+ {
+ id: 'energy_boost',
+ name: 'Energy Boost',
+ type: 'consumable',
+ rarity: 'common',
+ price: 25,
+ currency: 'credits',
+ description: 'Restores 50 energy',
+ effect: { energy: 50 }
+ }
+ ]
+};
+
+// Starter equipment for new players
+const STARTER_EQUIPMENT = {
+ starter_blaster: {
+ id: 'starter_blaster',
+ name: 'Common Blaster',
+ type: 'weapon',
+ rarity: 'common',
+ description: 'A reliable basic blaster for new pilots',
+ stats: { attack: 5, criticalChance: 0.02 },
+ equipable: true,
+ slot: 'weapon',
+ value: 100,
+ stackable: false
+ },
+ basic_armor: {
+ id: 'basic_armor',
+ name: 'Basic Armor',
+ type: 'armor',
+ rarity: 'common',
+ description: 'Standard issue armor for basic protection',
+ stats: { defense: 3, health: 10 },
+ equipable: true,
+ slot: 'armor',
+ value: 150,
+ stackable: false
+ }
+};
+
+// Achievement definitions
+const ACHIEVEMENTS = {
+ first_victory: {
+ name: 'First Victory',
+ description: 'Win your first dungeon',
+ requirement: { dungeonsCompleted: 1 },
+ reward: { gems: 10, experience: 100 },
+ icon: 'fa-trophy'
+ },
+ dungeon_master: {
+ name: 'Dungeon Master',
+ description: 'Complete 50 dungeons',
+ requirement: { dungeonsCompleted: 50 },
+ reward: { gems: 100, experience: 1000 },
+ icon: 'fa-dungeon'
+ },
+ level_master: {
+ name: 'Level Master',
+ description: 'Reach level 50',
+ requirement: { level: 50 },
+ reward: { gems: 200, experience: 5000 },
+ icon: 'fa-level-up-alt'
+ },
+ wealthy_commander: {
+ name: 'Wealthy Commander',
+ description: 'Accumulate 1,000,000 credits',
+ requirement: { credits: 1000000 },
+ reward: { gems: 150, experience: 2000 },
+ icon: 'fa-coins'
+ },
+ skill_expert: {
+ name: 'Skill Expert',
+ description: 'Max out any skill',
+ requirement: { maxSkillLevel: 10 },
+ reward: { gems: 75, experience: 1500 },
+ icon: 'fa-graduation-cap'
+ }
+};
+
+// Game messages and notifications
+const GAME_MESSAGES = {
+ welcome: 'Welcome to Galaxy Strike Online, Commander!',
+ levelUp: 'Level Up! You are now level {level}!',
+ questCompleted: 'Quest completed: {questName}!',
+ dungeonCompleted: 'Dungeon completed! Time: {time}',
+ achievementUnlocked: 'Achievement Unlocked: {achievementName}!',
+ insufficientCredits: 'Not enough credits!',
+ insufficientGems: 'Not enough gems!',
+ insufficientEnergy: 'Not enough energy!',
+ inventoryFull: 'Inventory is full!',
+ skillPointsAvailable: 'You have {points} skill points available!',
+ dailyReward: 'Daily reward claimed! Day {day}',
+ offlineRewards: 'Welcome back! You were offline for {time}'
+};
+
+// Utility functions
+const GameUtils = {
+ // Get random item from array
+ getRandomItem(array) {
+ return array[Math.floor(Math.random() * array.length)];
+ },
+
+ // Get random integer between min and max (inclusive)
+ getRandomInt(min, max) {
+ return Math.floor(Math.random() * (max - min + 1)) + min;
+ },
+
+ // Get random float between min and max
+ getRandomFloat(min, max) {
+ return Math.random() * (max - min) + min;
+ },
+
+ // Check if chance succeeds
+ checkChance(chance) {
+ return Math.random() < chance;
+ },
+
+ // Format large numbers with suffixes
+ formatNumber(num) {
+ if (num >= 1000000) return (num / 1000000).toFixed(1) + 'M';
+ if (num >= 1000) return (num / 1000).toFixed(1) + 'K';
+ return Math.floor(num).toString();
+ },
+
+ // Format time in milliseconds to readable string
+ formatTime(milliseconds) {
+ const seconds = Math.floor(milliseconds / 1000);
+ const minutes = Math.floor(seconds / 60);
+ const hours = Math.floor(minutes / 60);
+ const days = Math.floor(hours / 24);
+
+ if (days > 0) return `${days}d ${hours % 24}h`;
+ if (hours > 0) return `${hours}h ${minutes % 60}m`;
+ if (minutes > 0) return `${minutes}m ${seconds % 60}s`;
+ return `${seconds}s`;
+ },
+
+ // Calculate experience needed for level
+ getExperienceForLevel(level) {
+ return EXPERIENCE_TABLE[level] || 0;
+ },
+
+ // Get item rarity by chance
+ getItemRarity() {
+ const roll = Math.random();
+ let cumulative = 0;
+
+ for (const [rarity, data] of Object.entries(ITEM_RARITIES)) {
+ cumulative += data.dropChance;
+ if (roll <= cumulative) {
+ return rarity;
+ }
+ }
+
+ return 'common';
+ },
+
+ // Deep clone object
+ deepClone(obj) {
+ return JSON.parse(JSON.stringify(obj));
+ },
+
+ // Generate unique ID
+ generateId() {
+ return Date.now().toString() + Math.random().toString(36).substr(2, 9);
+ }
+};
+
+// Export for use in other modules
+if (typeof module !== 'undefined' && module.exports) {
+ module.exports = {
+ GAME_CONFIG,
+ PLAYER_DEFAULTS,
+ EXPERIENCE_TABLE,
+ ITEM_RARITIES,
+ ENEMY_TEMPLATES,
+ DUNGEON_CONFIGS,
+ SKILL_DEFINITIONS,
+ SHOP_ITEMS,
+ ACHIEVEMENTS,
+ GAME_MESSAGES,
+ GameUtils
+ };
+}
diff --git a/Client-Server/js/main.js b/Client-Server/js/main.js
new file mode 100644
index 0000000..e9275fa
--- /dev/null
+++ b/Client-Server/js/main.js
@@ -0,0 +1,718 @@
+/**
+ * Galaxy Strike Online - Main Entry Point
+ * Initializes and starts the game
+ */
+
+console.log('[MAIN] main.js script loaded');
+
+// Wait for DOM to be loaded
+document.addEventListener('DOMContentLoaded', async () => {
+ const debugLogger = window.debugLogger;
+
+ if (debugLogger) debugLogger.startStep('main.domContentLoaded', {
+ timestamp: new Date().toISOString(),
+ userAgent: navigator.userAgent,
+ url: window.location.href
+ });
+
+ const loadingIndicator = document.getElementById('loadingIndicator');
+ const loadingStatus = document.getElementById('loadingStatus');
+
+ if (debugLogger) debugLogger.logStep('DOM elements found', {
+ loadingIndicator: !!loadingIndicator,
+ loadingStatus: !!loadingStatus
+ });
+
+ try {
+ // Start debug logging
+ if (window.debugLogger) {
+ window.debugLogger.startStep('domLoad');
+ window.debugLogger.logStep('DOM loaded, starting initialization');
+ }
+
+ // Show loading indicator
+ if (loadingIndicator) loadingIndicator.classList.remove('hidden');
+ if (loadingStatus) {
+ loadingStatus.textContent = 'Initializing application...';
+ loadingStatus.classList.remove('hidden');
+ }
+
+ if (debugLogger) debugLogger.logStep('Loading indicator shown');
+
+ // Initialize title bar controls immediately (don't wait for DOMContentLoaded)
+ console.log('[MAIN] Initializing title bar controls immediately');
+
+ if (debugLogger) debugLogger.logStep('Initializing title bar controls');
+ initializeTitleBar();
+
+ // Wait for DOM to be ready
+ document.addEventListener('DOMContentLoaded', async () => {
+ if (debugLogger) debugLogger.startStep('main.secondDOMContentLoaded', {
+ timestamp: new Date().toISOString()
+ });
+
+ window.debugLogger.startStep('domLoad');
+ window.debugLogger.logStep('DOM loaded, starting initialization');
+
+ // Auto-start local server for singleplayer mode (DISABLED to prevent auto-start after multiplayer disconnect)
+ console.log('[MAIN] Skipping local server auto-start to prevent conflicts with multiplayer mode');
+ /*
+ if (window.localServerManager) {
+ try {
+ const serverResult = await window.localServerManager.autoStartIfSingleplayer();
+ if (serverResult.success) {
+ console.log('[MAIN] Local server started successfully:', serverResult);
+ if (debugLogger) debugLogger.logStep('Local server auto-started', {
+ port: serverResult.port,
+ url: serverResult.url
+ });
+ } else {
+ console.log('[MAIN] Local server not started:', serverResult.reason || serverResult.error);
+ if (debugLogger) debugLogger.logStep('Local server not started', {
+ reason: serverResult.reason || serverResult.error
+ });
+ }
+ } catch (error) {
+ console.error('[MAIN] Error starting local server:', error);
+ if (debugLogger) debugLogger.errorEvent(error, 'Local server startup');
+ }
+ } else {
+ console.warn('[MAIN] LocalServerManager not available');
+ }
+ */
+
+ // Title bar is already initialized, just log it
+ console.log('[MAIN] DOM loaded - title bar should already be working');
+
+ if (debugLogger) debugLogger.logStep('DOM loaded - title bar should be working');
+
+ // Show main menu instead of directly loading game
+ if (loadingStatus) {
+ loadingStatus.textContent = 'Ready';
+ loadingStatus.classList.add('hidden');
+ }
+
+ if (debugLogger) debugLogger.logStep('Loading status updated to Ready');
+
+ // Hide loading screen and show main menu
+ const loadingScreen = document.getElementById('loadingScreen');
+ const mainMenu = document.getElementById('mainMenu');
+
+ if (loadingScreen) loadingScreen.classList.add('hidden');
+ if (mainMenu) mainMenu.classList.remove('hidden');
+
+ if (debugLogger) debugLogger.logStep('Loading screen hidden, main menu shown', {
+ loadingScreenFound: !!loadingScreen,
+ mainMenuFound: !!mainMenu,
+ liveMainMenuReady: !!window.liveMainMenu
+ });
+
+ // The LiveMainMenu will initialize itself and handle authentication
+ console.log('[MAIN] Main menu displayed - LiveMainMenu will handle authentication and server browsing');
+
+ if (debugLogger) debugLogger.endStep('main.secondDOMContentLoaded', {
+ success: true,
+ mainMenuDisplayed: !!mainMenu
+ });
+ });
+
+ if (debugLogger) debugLogger.endStep('main.domContentLoaded', {
+ success: true,
+ titleBarInitialized: true
+ });
+ } catch (error) {
+ console.error('Failed to initialize game:', error);
+
+ if (debugLogger) debugLogger.errorEvent('main.domContentLoaded', error, {
+ phase: 'initialization',
+ timestamp: new Date().toISOString()
+ });
+
+ if (window.debugLogger) {
+ window.debugLogger.log('CRITICAL ERROR: Initialization failed', {
+ error: error.message,
+ stack: error.stack,
+ timestamp: new Date().toISOString()
+ });
+ }
+
+ // Show error state
+ if (loadingIndicator) loadingIndicator.classList.add('error');
+ if (loadingStatus) {
+ loadingStatus.textContent = 'Failed to load application';
+ loadingStatus.classList.add('error');
+ }
+
+ if (debugLogger) debugLogger.logStep('Error state displayed');
+
+ const logger = window.logger;
+ if (logger) {
+ await logger.errorEvent(error, 'Main.js Initialization');
+ }
+
+ if (debugLogger) debugLogger.endStep('main.domContentLoaded', {
+ success: false,
+ error: error.message
+ });
+ }
+});
+
+// Initialize title bar controls
+function initializeTitleBar() {
+ const debugLogger = window.debugLogger;
+
+ if (debugLogger) debugLogger.startStep('main.initializeTitleBar', {
+ timestamp: new Date().toISOString(),
+ electronAPIAvailable: !!window.electronAPI
+ });
+
+ console.log('[TITLE BAR] Starting title bar initialization');
+
+ // Wait for both electronAPI and DOM elements to be available
+ const checkReady = () => {
+ const hasElectronAPI = !!window.electronAPI;
+ const hasMinimizeBtn = !!document.getElementById('minimizeBtn');
+ const hasCloseBtn = !!document.getElementById('closeBtn');
+ const hasFullscreenBtn = !!document.getElementById('fullscreenBtn');
+
+ const readyState = {
+ hasElectronAPI,
+ hasMinimizeBtn,
+ hasCloseBtn,
+ hasFullscreenBtn
+ };
+
+ console.log(`[TITLE BAR] electronAPI: ${hasElectronAPI}, minimizeBtn: ${hasMinimizeBtn}, closeBtn: ${hasCloseBtn}, fullscreenBtn: ${hasFullscreenBtn}`);
+
+ if (debugLogger) debugLogger.logStep('Title bar readiness check', readyState);
+
+ if (hasElectronAPI && hasMinimizeBtn && hasCloseBtn && hasFullscreenBtn) {
+ console.log('[TITLE BAR] All elements ready, setting up events');
+
+ if (debugLogger) debugLogger.logStep('All title bar elements ready, setting up events');
+ setupTitleBarEvents();
+
+ // Hide the "Initializing application..." text since title bar is now working
+ const loadingStatus = document.getElementById('loadingStatus');
+ if (loadingStatus && loadingStatus.textContent === 'Initializing application...') {
+ console.log('[TITLE BAR] Hiding initializing text');
+ loadingStatus.classList.add('hidden');
+
+ if (debugLogger) debugLogger.logStep('Hiding initializing text');
+ }
+
+ if (debugLogger) debugLogger.endStep('main.initializeTitleBar', {
+ success: true,
+ allElementsReady: true
+ });
+ } else {
+ if (debugLogger) debugLogger.logStep('Not all elements ready, retrying in 50ms', {
+ missingElements: Object.keys(readyState).filter(key => !readyState[key])
+ });
+ setTimeout(checkReady, 50);
+ }
+ };
+
+ checkReady();
+}
+
+function setupTitleBarEvents() {
+ const debugLogger = window.debugLogger;
+
+ if (debugLogger) debugLogger.startStep('main.setupTitleBarEvents');
+
+ const minimizeBtn = document.getElementById('minimizeBtn');
+ const closeBtn = document.getElementById('closeBtn');
+ const fullscreenBtn = document.getElementById('fullscreenBtn');
+
+ console.log('[TITLE BAR] Setting up event listeners');
+
+ if (debugLogger) debugLogger.logStep('Title bar buttons found', {
+ minimizeBtn: !!minimizeBtn,
+ closeBtn: !!closeBtn,
+ fullscreenBtn: !!fullscreenBtn
+ });
+
+ let eventsSetup = 0;
+
+ if (minimizeBtn) {
+ console.log('[TITLE BAR] Adding minimize button listener');
+
+ if (debugLogger) debugLogger.logStep('Setting up minimize button listener');
+ minimizeBtn.addEventListener('click', (e) => {
+ console.log('[TITLE BAR] Minimize button clicked');
+
+ if (debugLogger) debugLogger.log('Title bar minimize button clicked');
+
+ e.preventDefault();
+ e.stopPropagation();
+ if (window.electronAPI && window.electronAPI.minimize) {
+ window.electronAPI.minimize();
+
+ if (debugLogger) debugLogger.logStep('Window minimized via electronAPI');
+ } else {
+ console.error('[TITLE BAR] electronAPI not available when minimize clicked');
+
+ if (debugLogger) debugLogger.log('electronAPI not available for minimize');
+ }
+ });
+ eventsSetup++;
+ } else {
+ console.error('[TITLE BAR] Minimize button not found during setup');
+
+ if (debugLogger) debugLogger.log('Minimize button not found');
+ }
+
+ if (closeBtn) {
+ console.log('[TITLE BAR] Adding close button listener');
+
+ if (debugLogger) debugLogger.logStep('Setting up close button listener');
+ closeBtn.addEventListener('click', (e) => {
+ console.log('[TITLE BAR] Close button clicked');
+
+ if (debugLogger) debugLogger.log('Title bar close button clicked');
+
+ e.preventDefault();
+ // ... rest of the code remains the same ...
+ e.stopPropagation();
+ if (window.electronAPI && window.electronAPI.closeWindow) {
+ window.electronAPI.closeWindow();
+
+ if (debugLogger) debugLogger.logStep('Window closed via electronAPI');
+ } else {
+ console.error('[TITLE BAR] electronAPI not available when close clicked');
+
+ if (debugLogger) debugLogger.log('electronAPI not available for close');
+ }
+ });
+ eventsSetup++;
+ } else {
+ console.error('[TITLE BAR] Close button not found during setup');
+
+ if (debugLogger) debugLogger.log('Close button not found');
+ }
+
+ if (fullscreenBtn) {
+ console.log('[TITLE BAR] Adding fullscreen button listener');
+
+ if (debugLogger) debugLogger.logStep('Setting up fullscreen button listener');
+ fullscreenBtn.addEventListener('click', (e) => {
+ console.log('[TITLE BAR] Fullscreen button clicked');
+
+ if (debugLogger) debugLogger.log('Title bar fullscreen button clicked');
+
+ e.preventDefault();
+ e.stopPropagation();
+ if (window.electronAPI && window.electronAPI.toggleFullscreen) {
+ window.electronAPI.toggleFullscreen();
+
+ if (debugLogger) debugLogger.logStep('Fullscreen toggled via electronAPI');
+
+ // Toggle fullscreen class on body
+ document.body.classList.toggle('fullscreen');
+ document.body.classList.toggle('fullscreen');
+ // Update icon
+ const icon = fullscreenBtn.querySelector('i');
+ if (document.body.classList.contains('fullscreen')) {
+ icon.className = 'fas fa-compress';
+
+ if (debugLogger) debugLogger.logStep('Fullscreen mode activated, icon changed to compress');
+ } else {
+ icon.className = 'fas fa-expand';
+
+ if (debugLogger) debugLogger.logStep('Fullscreen mode deactivated, icon changed to expand');
+ }
+ } else {
+ console.error('[TITLE BAR] electronAPI not available when fullscreen clicked');
+
+ if (debugLogger) debugLogger.log('electronAPI not available for fullscreen');
+ }
+ });
+ eventsSetup++;
+ } else {
+ console.error('[TITLE BAR] Fullscreen button not found during setup');
+
+ if (debugLogger) debugLogger.log('Fullscreen button not found');
+ }
+
+ console.log('[TITLE BAR] Event listeners setup complete');
+
+ if (debugLogger) debugLogger.endStep('main.setupTitleBarEvents', {
+ eventsSetup: eventsSetup,
+ totalExpectedEvents: 3
+ });
+}
+
+// Global utility functions for onclick handlers
+window.game = null;
+
+// Error handling
+window.addEventListener('error', (event) => {
+ console.error('Game error:', event.error);
+ if (window.game) {
+ window.game.showNotification('An error occurred. Please refresh the page.', 'error', 5000);
+ }
+});
+
+// Shutdown handler for debug logging
+window.addEventListener('beforeunload', async () => {
+ if (window.debugLogger) {
+ try {
+ await window.debugLogger.shutdown();
+ } catch (error) {
+ console.error('[MAIN] Failed to shutdown debug logger:', error);
+ }
+ }
+});
+
+// Performance monitoring
+if (window.performance && window.performance.memory) {
+ setInterval(() => {
+ if (window.game && window.game.isRunning) {
+ const stats = window.game.getPerformanceStats();
+ if (stats.memory && stats.memory.used / stats.memory.limit > 0.8) {
+ console.warn('High memory usage detected:', stats.memory);
+ }
+ }
+ }, 30000); // Check every 30 seconds
+}
+
+// Global console functions
+function toggleConsole() {
+ console.log('[DEBUG] toggleConsole called');
+ const consoleWindow = document.getElementById('consoleWindow');
+ const consoleInput = document.getElementById('consoleInput');
+
+ console.log('[DEBUG] consoleWindow element:', consoleWindow);
+ console.log('[DEBUG] consoleInput element:', consoleInput);
+
+ if (!consoleWindow) {
+ console.error('[DEBUG] consoleWindow element not found!');
+ return;
+ }
+
+ if (consoleWindow.style.display === 'flex') {
+ consoleWindow.style.display = 'none';
+ console.log('[DEBUG] Console hidden');
+ } else {
+ consoleWindow.style.display = 'flex';
+ console.log('[DEBUG] Console shown');
+ if (consoleInput) {
+ consoleInput.focus();
+ }
+ }
+}
+
+function handleConsoleInput(event) {
+ if (event.key === 'Enter') {
+ const input = event.target;
+ const command = input.value.trim();
+
+ if (command) {
+ executeConsoleCommand(command);
+ input.value = '';
+ }
+ }
+}
+
+function executeConsoleCommand(command) {
+ const output = document.getElementById('consoleOutput');
+ const commandLine = document.createElement('div');
+ commandLine.className = 'console-line';
+ commandLine.textContent = `> ${command}`;
+ output.appendChild(commandLine);
+
+ // Log command to file and browser console
+ console.log(`[CONSOLE] Command: ${command}`);
+ if (window.logger) {
+ window.logger.playerAction('Console Command', { command: command });
+ }
+
+ try {
+ const result = processCommand(command);
+ const resultLine = document.createElement('div');
+ resultLine.className = `console-line ${result.type || 'success'}`;
+ // Convert line breaks to HTML for proper rendering
+ resultLine.innerHTML = result.message.replace(/\n/g, '