function loadScript(url) { return new Promise((resolve, reject) => { // Check if the script is already loaded if (document.querySelector(`script[src="${url}"]`)) { resolve(); return; } var script = document.createElement('script'); script.type = 'text/javascript'; script.src = url; script.onload = () => resolve(); script.onerror = () => reject(new Error('Script loading failed for ' + url)); document.head.appendChild(script); }); } class Example extends Phaser.Scene { constructor() { super(); this.seed = Math.random() * 10000; // Random seed for each generation this.planetGenerated = false; // Add flag to track if planet is generated this.currentYear = 0; // Track the current year this.yearText = null; // Reference to year display text this.globalEventText = null; // Reference to global event text this.activeEvents = []; // Track active events this.currentGlobalEvent = null; // Track current global event this.nextGlobalEventYear = 50; // First global event at year 50 this.eventTimer = null; // Timer for event generation this.currentLayer = 'biome'; // Default layer view this.layers = ['biome', 'Km', 'C°', 'events', 'B+E']; // Planet types definitions this.planetTypes = { volcanic: { baseTemperature: 1200, // °C temperatureRange: 400, // +/- this value heightRange: { min: -0.2, max: 1.0 }, // Mostly mountainous humidityRange: { min: 0.0, max: 0.2 }, // Very dry chemicalComposition: ['silicates', 'iron', 'sulfur'], atmosphereType: 'toxic_thick' // Sulfur dioxide, CO2 }, oceanic: { baseTemperature: 95, // °C - further increased base temperature for more dynamic oceans temperatureRange: 15, // maintain same variability range heightRange: { min: -0.95, // Deep oceans max: 0.6 // Much more surface features allowed }, // More balanced between oceans and land humidityRange: { min: 0.7, max: 1.0 }, // Very humid chemicalComposition: ['water', 'salt', 'minerals'], atmosphereType: 'earth_like' }, icy: { baseTemperature: -60, // °C temperatureRange: 50, heightRange: { min: -0.3, max: 0.7 }, humidityRange: { min: 0.3, max: 0.6 }, // Frozen moisture chemicalComposition: ['water_ice', 'methane', 'nitrogen'], atmosphereType: 'thin_cold' }, desertic: { baseTemperature: 0, // °C (changed to allow for colder base) temperatureRange: 60, // Doubled range for more extreme variations heightRange: { min: 0.1, // Raised minimum to avoid water max: 0.8 }, humidityRange: { min: 0, max: 0.2 }, // Very dry chemicalComposition: ['iron_oxide', 'silicates', 'perchlorate'], atmosphereType: 'thin_cold' // Like Mars } }; this.currentPlanetType = 'volcanic'; // Default planet type this.hexSize = 32 * 0.2; // Size of hexagon (radius) - 80% smaller this.topMargin = 50; // Add top margin this.gridWidth = Math.floor(800 / (this.hexSize * 1.5)); // Number of hexes horizontally this.gridHeight = Math.floor(600 / (this.hexSize * Math.sqrt(3))); // Number of hexes vertically this.hexGrid = []; this.selectedHex = null; this.hoverGraphics = null; // Calculate actual grid dimensions this.totalGridWidth = this.gridWidth * this.hexSize * 1.5; this.totalGridHeight = this.gridHeight * this.hexSize * Math.sqrt(3); } create() { // Set the background color to black this.cameras.main.setBackgroundColor('#000000'); // Initialize hover graphics this.hoverGraphics = this.add.graphics(); // Create main menu (buttons will be created when planet is generated) this.createMainMenu(); } createMainMenu() { // Create semi-transparent dark overlay const menuBg = this.add.graphics(); menuBg.fillStyle(0x000000, 0.8); menuBg.fillRect(0, 0, 800, 600); // Create title text const titleText = this.add.text(400, 150, 'Planet Generator', { fontSize: '48px', color: '#ffffff', fontStyle: 'bold' }).setOrigin(0.5); // Create Generate Planet button const generateButton = this.add.graphics(); generateButton.fillStyle(0x666666); generateButton.fillRoundedRect(300, 250, 200, 50, 10); const buttonText = this.add.text(400, 275, 'Generate Planet', { fontSize: '24px', color: '#ffffff' }).setOrigin(0.5); // Make button interactive const buttonZone = this.add.zone(300, 250, 200, 50); buttonZone.setInteractive(); buttonZone.on('pointerover', () => { generateButton.clear(); generateButton.fillStyle(0x888888); generateButton.fillRoundedRect(300, 250, 200, 50, 10); }); buttonZone.on('pointerout', () => { generateButton.clear(); generateButton.fillStyle(0x666666); generateButton.fillRoundedRect(300, 250, 200, 50, 10); }); buttonZone.on('pointerdown', () => { this.openPlanetSelection(); }); // Store menu elements for later access this.menuElements = [menuBg, titleText, generateButton, buttonText, buttonZone]; } openPlanetSelection() { // If planet is already generated, don't allow new selection if (this.planetGenerated) { return; } // Hide main menu elements this.menuElements.forEach(element => element.setVisible(false)); // Create planet selection window const window = this.add.graphics(); window.fillStyle(0x333333); window.fillRoundedRect(200, 100, 400, 400, 20); const title = this.add.text(400, 130, 'Select Planet Type', { fontSize: '28px', color: '#ffffff' }).setOrigin(0.5); // Create planet type buttons const planetTypes = Object.keys(this.planetTypes); const buttonHeight = 50; const spacing = 10; planetTypes.forEach((type, index) => { const y = 180 + (buttonHeight + spacing) * index; const button = this.add.graphics(); button.fillStyle(0x666666); button.fillRoundedRect(250, y, 300, buttonHeight, 10); const text = this.add.text(400, y + buttonHeight / 2, type.charAt(0).toUpperCase() + type.slice(1), { fontSize: '20px', color: '#ffffff' }).setOrigin(0.5); const zone = this.add.zone(250, y, 300, buttonHeight); zone.setInteractive(); zone.on('pointerover', () => { button.clear(); button.fillStyle(0x888888); button.fillRoundedRect(250, y, 300, buttonHeight, 10); }); zone.on('pointerout', () => { button.clear(); button.fillStyle(0x666666); button.fillRoundedRect(250, y, 300, buttonHeight, 10); }); zone.on('pointerdown', () => { this.startPlanetGeneration(type); }); }); } startPlanetGeneration(planetType) { // Initialize event system with proper delay if (this.eventTimer) { this.eventTimer.destroy(); } this.activeEvents = []; // Setup new event system with shorter delay this.time.addEvent({ delay: 1000, // Check every second callback: this.generateRandomEvent, callbackScope: this, loop: true }); if (this.planetGenerated) { return; } // Create layer buttons before clearing graphics this.createLayerButtons(); // Clear specific types of graphics this.children.list.forEach(child => { if (!child.layerButton && !(child === this.hoverGraphics)) { child.destroy(); } }); // Ensure hover graphics is on top if (this.hoverGraphics) { this.hoverGraphics.setDepth(1000); } // Remove only specific input listeners this.input.off('pointermove'); // Set the planet generation flag this.planetGenerated = true; // Set the selected planet type this.currentPlanetType = planetType; // Create top panel background const topPanel = this.add.graphics(); topPanel.fillStyle(0x333333); topPanel.fillRect(0, 0, 800, this.topMargin); // Create container for UI elements this.uiContainer = this.add.container(0, 0); this.uiContainer.setDepth(900); // Calculate position for info button (after the last layer button) const buttonWidth = 60; const spacing = 5; const infoX = 10 + (buttonWidth + spacing) * this.layers.length; const infoButtonWidth = 40; const infoButtonHeight = 40; // Add info button with larger size const infoButton = this.add.graphics(); infoButton.fillStyle(0x666666); infoButton.fillRoundedRect(infoX, 10, infoButtonWidth, infoButtonHeight, 8); const infoText = this.add.text(infoX + infoButtonWidth / 2, 10 + infoButtonHeight / 2, 'i', { fontSize: '24px', color: '#ffffff', fontStyle: 'bold' }).setOrigin(0.5); // Make info button interactive with larger hit area const infoZone = this.add.zone(infoX - 5, 5, infoButtonWidth + 10, infoButtonHeight + 10); infoZone.setInteractive(); infoZone.on('pointerover', () => { infoButton.clear(); infoButton.fillStyle(0x888888); infoButton.fillRoundedRect(infoX, 10, infoButtonWidth, infoButtonHeight, 8); if (!this.infoWindow || !this.infoWindow.active) { this.showInfoWindow(); } }); infoZone.on('pointerout', () => { infoButton.clear(); infoButton.fillStyle(0x666666); infoButton.fillRoundedRect(infoX, 10, infoButtonWidth, infoButtonHeight, 8); if (this.infoWindow && !this.infoWindow.isHovered) { this.infoWindow.destroy(); this.infoWindow = null; if (this.infoUpdateTimer) { this.infoUpdateTimer.destroy(); this.infoUpdateTimer = null; } } }); // Add all UI elements to the container this.uiContainer.add([infoButton, infoText, infoZone]); // Add year counter to top panel if (this.yearText) { this.yearText.destroy(); } this.yearText = this.add.text(700, 15, 'Year: 0', { fontSize: '14px', // 30% smaller color: '#ffffff', fontStyle: 'bold' }); // Add global event status text this.yearText.setDepth(901); // Ensure it stays above other elements // Destroy existing timer if it exists if (this.yearTimer) { this.yearTimer.destroy(); } // Create year update timer this.yearTimer = this.time.addEvent({ delay: 1000, // 1 second = 1 year callback: () => { if (this.yearText && this.yearText.active) { this.currentYear++; this.yearText.setText(`Year: ${this.currentYear}`); // Check for global events if (this.currentYear >= this.nextGlobalEventYear && !this.currentGlobalEvent) { this.triggerGlobalEvent(); // Next event year will be set in endGlobalEvent when current event ends } // Update current global event if (this.currentGlobalEvent) { if (this.currentYear >= this.currentGlobalEvent.endYear) { this.endGlobalEvent(); } else { this.applyGlobalEventEffects(); } } } }, loop: true }); // Initialize the hex grid this.initializeHexGrid(); // Draw the hexagons this.drawHexGrid(); // Create hover graphics object with high depth this.hoverGraphics = this.add.graphics(); this.hoverGraphics.setDepth(1000); // Ensure it stays on top // Add mouse move listener this.input.on('pointermove', (pointer) => { const hoveredHex = this.getHexFromScreenPosition(pointer.x, pointer.y); this.updateHexHighlight(hoveredHex); }); // Add hex click handler this.input.on('pointerdown', (pointer) => { const clickedHex = this.getHexFromScreenPosition(pointer.x, pointer.y); if (clickedHex) { // Handle hex click - show info or perform action this.handleHexClick(clickedHex); } }); } setupEventSystem() { // Clear any existing event timer and events if (this.eventTimer) { this.eventTimer.destroy(); } this.activeEvents = []; // Allow events for all planet types with different probabilities let eventProbability = 0.5; // Base probability switch (this.currentPlanetType) { case 'volcanic': eventProbability = 0.7; // More frequent events break; case 'oceanic': eventProbability = 0.65; // Ocean planets are quite active break; case 'desertic': case 'icy': case 'iron': eventProbability = 0.6; // Regular event frequency break; default: eventProbability = 0.4; // Less frequent but still possible } // Update event generation chance if (Math.random() > eventProbability) return; // Ensure hex grid is properly initialized if (!this.hexGrid || !this.hexGrid.length || !this.hexGrid[0] || !this.hexGrid[0].length) { console.warn('Hex grid not properly initialized. Events system not started.'); return; } // Start event generation timer (check every second/year) this.eventTimer = this.time.addEvent({ delay: 1000, // 1 second = 1 year callback: this.generateRandomEvent, callbackScope: this, loop: true }); } triggerGlobalEvent() { try { // End current event if exists if (this.currentGlobalEvent) { this.endGlobalEvent(); } // Check if there's a current event and its type if (this.currentGlobalEvent) { console.warn('Attempted to trigger global event while another is active'); return; } // Random selection between glaciation and heat wave (50/50 chance) const isGlaciation = Math.random() < 0.5; // Random duration between 25 and 35 years const eventDuration = Phaser.Math.Between(25, 35); this.currentGlobalEvent = { type: isGlaciation ? 'glaciation' : 'heatwave', startYear: this.currentYear, endYear: this.currentYear + eventDuration, temperature: isGlaciation ? -15 : 20 // Reduced temperature impact for both events }; // Global event triggered - no UI update needed } catch (error) { console.warn('Error in triggerGlobalEvent:', error); } } endGlobalEvent() { this.currentGlobalEvent = null; // Always set next global event to occur 50 years from current year this.nextGlobalEventYear = this.currentYear + 100; console.log(`Next global event scheduled for year ${this.nextGlobalEventYear}`); } applyGlobalEventEffects() { if (!this.currentGlobalEvent) return; // Apply temperature changes to all hexes for (let row = 0; row < this.gridHeight; row++) { for (let col = 0; col < this.gridWidth; col++) { const hex = this.hexGrid[row][col]; // Calculate progress through event (0 to 1) const eventProgress = (this.currentYear - this.currentGlobalEvent.startYear) / (this.currentGlobalEvent.endYear - this.currentGlobalEvent.startYear); // Temperature change follows a bell curve // Reduce temperature change intensity by using sin curve and 50% effectiveness const intensity = Math.sin(eventProgress * Math.PI) * 0.3; // 30% effectiveness for gentler changes const tempChange = this.currentGlobalEvent.temperature * intensity; // Apply temperature change hex.temperature += tempChange; // Recalculate biome based on new temperature hex.biome = this.calculateBiome( hex.elevation, hex.temperature, hex.humidity, hex.chemicalComposition ); } } // Redraw the grid to show changes this.drawHexGrid(); } generateRandomEvent() { // Validate hex grid before generating regular events if (!this.hexGrid || !this.hexGrid.length || !this.hexGrid[0] || !this.hexGrid[0].length) { console.warn('Hex grid not properly initialized. Cannot generate events.'); return; } // Check for planet-specific events let eventTypes; // 50% chance per year for events to make them more frequent if (Math.random() > 0.50) return; const events = { // Cyclic events glaciation: { name: 'Global Glaciation', duration: Phaser.Math.Between(10, 30), // 10-30 years effects: { temperature: -15, // Halved from -30 chemical: { water_ice: 20, nitrogen: 10 } } }, heatWave: { name: 'Global Heat Wave', duration: Phaser.Math.Between(10, 30), // 10-30 years effects: { temperature: 30, chemical: { water: 15, methane: 10 } } }, // Iron planet events crustalFracture: { name: 'Crustal Fracture', duration: Phaser.Math.Between(4, 8), effects: { temperature: 20, elevation: -0.08, // Creates deep canyons chemical: { iron: 15, nickel: 10, silicates: -5 } } }, ironMeteorite: { name: 'Iron Meteorite Impact', duration: 1, effects: { elevation: -0.15, temperature: 50, // Increased temperature effect chemical: { iron: 25, nickel: 15, silicates: -10 } } }, // New oceanic events submarineEruption: { name: 'Submarine Volcanic Eruption', duration: Phaser.Math.Between(5, 10), effects: { temperature: 16, // Doubled temperature effect elevation: 0.70, chemical: { silicates: 25, iron_oxide: 15, dissolved_minerals: 20 } } }, geothermalVent: { name: 'Geothermal Vent Activity', duration: Phaser.Math.Between(8, 15), effects: { temperature: 30, // Doubled temperature effect chemical: { dissolved_minerals: 40, organic_compounds: 35, sulfur: 25 } } }, tropicalStorm: { name: 'Massive Tropical Storm', duration: Phaser.Math.Between(3, 7), effects: { temperature: -2, // Doubled cooling effect elevation: -0.005, // Minimal coastal erosion erosion: 0.03, chemical: { dissolved_minerals: 15, water: 10 } } }, cryogenicStorm: { name: 'Cryogenic Storm', duration: Phaser.Math.Between(3, 8), effects: { temperature: -25, // Reduced cooling (50% less) elevation: 0.006, // Reduced ice deposition (70% less) chemical: { water_ice: 15, nitrogen: 10, methane: 5 } } }, iceCrustFracture: { name: 'Ice Crust Fracture', duration: Phaser.Math.Between(2, 5), effects: { temperature: 5, // Slight warming from exposed lower layers elevation: 0.03, // Formation of ice ridges chemical: { methane: 20, // Release of trapped gases nitrogen: 15, water_ice: -10 // Loss of surface ice } } }, massiveEruption: { name: 'Massive Eruption', duration: Phaser.Math.Between(5, 10), effects: { temperature: 200, elevation: 0.05, chemical: { silicates: 20, iron_oxide: 15, sulfur: 25 } } }, ashfall: { name: 'Volcanic Ashfall', duration: Phaser.Math.Between(5, 10), effects: { temperature: -10, elevation: 0.015, // Halved elevation change chemical: { silicates: 15, iron_oxide: 10, sulfur: 5 } } }, sandstorm: { name: 'Massive Sandstorm', duration: Phaser.Math.Between(5, 10), // 5-10 years for massive eruptions effects: { temperature: -15, // Temperature decrease elevation: 0.02, // Small elevation changes due to sand deposits erosion: 0.01 // Erosion factor } }, meteorite: { name: 'Meteorite Impact', duration: 1, // Immediate event with lasting effects effects: { elevation: -0.10, // Doubled crater formation depth temperature: 30, // Significantly increased local heating chemical: { iron: 20, // Doubled iron content nickel: 10 // Doubled nickel content } } } }; // Select event type based on planet type let eventType; switch (this.currentPlanetType) { case 'volcanic': eventType = Phaser.Math.RND.pick(['massiveEruption', 'ashfall']); break; case 'desertic': eventType = Phaser.Math.RND.pick(['sandstorm', 'meteorite']); break; case 'icy': eventType = Phaser.Math.RND.pick(['cryogenicStorm', 'iceCrustFracture']); break; case 'oceanic': eventType = Phaser.Math.RND.pick(['submarineEruption', 'geothermalVent', 'tropicalStorm']); break; case 'iron': eventType = Phaser.Math.RND.pick(['crustalFracture', 'ironMeteorite']); break; default: return; // No events for other planet types } const event = events[eventType]; // Add event to active events const newEvent = { ...event, type: eventType, startTime: this.time.now, endTime: this.time.now + (event.duration * 1000), affectedHexes: this.getEventAffectedHexes(eventType) }; this.activeEvents.push(newEvent); this.applyEventEffects(newEvent); } getEventAffectedHexes(eventType) { // Validate hex grid before processing if (!this.hexGrid || !this.hexGrid.length || !this.hexGrid[0] || !this.hexGrid[0].length) { console.warn('Hex grid not properly initialized. Cannot determine affected hexes.'); return []; } const affectedHexes = []; // Handle oceanic events if (eventType === 'submarineEruption') { // Find a suitable underwater location let eruptionSite = null; let attempts = 0; while (!eruptionSite && attempts < 10) { const x = Phaser.Math.Between(0, this.gridWidth - 1); const y = Phaser.Math.Between(0, this.gridHeight - 1); const hex = this.hexGrid[y][x]; if (hex.elevation < 0) { // Underwater location eruptionSite = hex; } attempts++; } // If no ideal location found, pick random underwater hex if (!eruptionSite) { const x = Phaser.Math.Between(0, this.gridWidth - 1); const y = Phaser.Math.Between(0, this.gridHeight - 1); eruptionSite = this.hexGrid[y][x]; } // Create underwater eruption pattern const radius = Phaser.Math.Between(2, 4); for (let row = 0; row < this.gridHeight; row++) { for (let col = 0; col < this.gridWidth; col++) { const hex = this.hexGrid[row][col]; const distance = this.getHexDistance(hex.coords, eruptionSite.coords); if (distance <= radius) { affectedHexes.push(hex); } } } } else if (eventType === 'geothermalVent') { // Find deep ocean location let ventSite = null; let attempts = 0; while (!ventSite && attempts < 10) { const x = Phaser.Math.Between(0, this.gridWidth - 1); const y = Phaser.Math.Between(0, this.gridHeight - 1); const hex = this.hexGrid[y][x]; if (hex.elevation < -0.5) { // Deep ocean required ventSite = hex; } attempts++; } // If no ideal location found, pick random deep location if (!ventSite) { const x = Phaser.Math.Between(0, this.gridWidth - 1); const y = Phaser.Math.Between(0, this.gridHeight - 1); ventSite = this.hexGrid[y][x]; } // Create vent effect pattern const radius = Phaser.Math.Between(1, 3); for (let row = 0; row < this.gridHeight; row++) { for (let col = 0; col < this.gridWidth; col++) { const hex = this.hexGrid[row][col]; const distance = this.getHexDistance(hex.coords, ventSite.coords); if (distance <= radius) { affectedHexes.push(hex); } } } } else if (eventType === 'tropicalStorm') { // Create large storm system const centerX = Phaser.Math.Between(0, this.gridWidth - 1); const centerY = Phaser.Math.Between(0, this.gridHeight - 1); // Affect a large area with the storm for (let row = 0; row < this.gridHeight; row++) { for (let col = 0; col < this.gridWidth; col++) { const distance = Phaser.Math.Distance.Between(centerX, centerY, col, row); if (distance < this.gridWidth / 2.8) { // Large storm system affectedHexes.push(this.hexGrid[row][col]); } } } } if (eventType === 'cryogenicStorm') { // Large area affected by the storm const centerX = Phaser.Math.Between(0, this.gridWidth - 1); const centerY = Phaser.Math.Between(0, this.gridHeight - 1); // Affect a large swath of the planet for (let row = 0; row < this.gridHeight; row++) { for (let col = 0; col < this.gridWidth; col++) { const distance = Phaser.Math.Distance.Between(centerX, centerY, col, row); if (distance < this.gridWidth / 2.5) { // Large area of effect affectedHexes.push(this.hexGrid[row][col]); } } } } else if (eventType === 'iceCrustFracture') { // Find a suitable location (preferably with high ice content) let fractureSite = null; let attempts = 0; while (!fractureSite && attempts < 10) { const x = Phaser.Math.Between(0, this.gridWidth - 1); const y = Phaser.Math.Between(0, this.gridHeight - 1); const hex = this.hexGrid[y][x]; if (hex.chemicalComposition.water_ice > 40) { // High ice content area fractureSite = hex; } attempts++; } // If no ideal location found, pick random if (!fractureSite) { const x = Phaser.Math.Between(0, this.gridWidth - 1); const y = Phaser.Math.Between(0, this.gridHeight - 1); fractureSite = this.hexGrid[y][x]; } // Create fracture pattern const radius = Phaser.Math.Between(2, 3); // Smaller area than storms for (let row = 0; row < this.gridHeight; row++) { for (let col = 0; col < this.gridWidth; col++) { const hex = this.hexGrid[row][col]; const distance = this.getHexDistance(hex.coords, fractureSite.coords); if (distance <= radius) { affectedHexes.push(hex); } } } } if (eventType === 'massiveEruption') { // Select an eruption point (preferably at higher elevation) let eruption = null; let attempts = 0; // Try to find a suitable eruption point (high elevation) while (!eruption && attempts < 10) { const x = Phaser.Math.Between(0, this.gridWidth - 1); const y = Phaser.Math.Between(0, this.gridHeight - 1); const hex = this.hexGrid[y][x]; if (hex.elevation > 0.6) { // Prefer high points for eruptions eruption = hex; } attempts++; } // If no high point found, just pick a random point if (!eruption) { const x = Phaser.Math.Between(0, this.gridWidth - 1); const y = Phaser.Math.Between(0, this.gridHeight - 1); eruption = this.hexGrid[y][x]; } // Add eruption point and surrounding hexes const radius = Phaser.Math.Between(4, 8); // Doubled radius: 4-8 hex radius for (let row = 0; row < this.gridHeight; row++) { for (let col = 0; col < this.gridWidth; col++) { const hex = this.hexGrid[row][col]; const distance = this.getHexDistance( hex.coords, eruption.coords ); if (distance <= radius) { affectedHexes.push(hex); } } } } else if (eventType === 'ashfall') { // Affect a large area of the planet with ash const centerX = Phaser.Math.Between(0, this.gridWidth - 1); const centerY = Phaser.Math.Between(0, this.gridHeight - 1); // Add hexes in a large radius (bigger than sandstorm) for (let row = 0; row < this.gridHeight; row++) { for (let col = 0; col < this.gridWidth; col++) { const distance = Phaser.Math.Distance.Between(centerX, centerY, col, row); if (distance < this.gridWidth / 2) { // Affect half of the planet affectedHexes.push(this.hexGrid[row][col]); } } } } else if (eventType === 'sandstorm') { // Affect a large area of the planet const centerX = Phaser.Math.Between(0, this.gridWidth - 1); const centerY = Phaser.Math.Between(0, this.gridHeight - 1); // Add hexes in a large radius for (let row = 0; row < this.gridHeight; row++) { for (let col = 0; col < this.gridWidth; col++) { const distance = Phaser.Math.Distance.Between(centerX, centerY, col, row); if (distance < this.gridWidth / 3) { // Affect 1/3 of the planet affectedHexes.push(this.hexGrid[row][col]); } } } } else if (eventType === 'meteorite') { // Single impact point with small radius const impactX = Phaser.Math.Between(0, this.gridWidth - 1); const impactY = Phaser.Math.Between(0, this.gridHeight - 1); for (let row = 0; row < this.gridHeight; row++) { for (let col = 0; col < this.gridWidth; col++) { const distance = Phaser.Math.Distance.Between(impactX, impactY, col, row); if (distance < 2) { // Small impact radius affectedHexes.push(this.hexGrid[row][col]); } } } } return affectedHexes; } applyEventEffects(event) { event.affectedHexes.forEach(hex => { // Verify event type and effects before applying if (!event || !event.effects) { console.warn('Invalid event or missing effects:', event); return; } // Handle temperature changes if (event.effects.temperature) { hex.temperature += event.effects.temperature; console.log(`Applied temperature change: ${event.effects.temperature}°C, Total: ${hex.temperature}°C`); } // Handle elevation changes separately if (event.type !== 'geothermalVent' && event.effects.elevation) { hex.elevation += event.effects.elevation; } // Apply chemical changes if present in event effects if (event.effects.chemical) { Object.entries(event.effects.chemical).forEach(([element, change]) => { // Initialize chemical if not present if (!hex.chemicalComposition[element]) { hex.chemicalComposition[element] = 0; } // Apply chemical changes hex.chemicalComposition[element] += change; }); } // Apply event-specific chemical changes if (event.type === 'cryogenicStorm') { // Increase ice content and reduce liquid content (temperature effect halved) hex.chemicalComposition.water_ice = (hex.chemicalComposition.water_ice || 0) + 7.5; hex.chemicalComposition.nitrogen = (hex.chemicalComposition.nitrogen || 0) + 5; hex.chemicalComposition.methane = (hex.chemicalComposition.methane || 0) + 2.5; // Reduce liquid water if present if (hex.chemicalComposition.water) { hex.chemicalComposition.water = Math.max(0, (hex.chemicalComposition.water || 0) - 20); } // Force biome changes based on new temperature if (hex.temperature < -150) { hex.biome = hex.elevation <= 0 ? 'nitrogen_ice' : 'nitrogen_ice_field'; } else if (hex.temperature < -50) { hex.biome = hex.elevation <= 0 ? 'methane_ice' : 'methane_ice_field'; } else if (hex.temperature < 0) { hex.biome = hex.elevation <= 0 ? 'frozen_ocean' : 'frozen_terrain'; } } else if (event.type === 'iceCrustFracture') { // Release trapped gases and reduce ice content with doubled temperature effect hex.chemicalComposition.methane = (hex.chemicalComposition.methane || 0) + 40; hex.chemicalComposition.nitrogen = (hex.chemicalComposition.nitrogen || 0) + 30; hex.chemicalComposition.water_ice = Math.max(0, (hex.chemicalComposition.water_ice || 0) - 20); // Force biome changes based on new composition and temperature if (hex.elevation > 0.5) { hex.biome = 'rocky'; // Exposed rocky surface after ice fracture } else if (hex.temperature < -50) { hex.biome = 'methane_ice_field'; // Refrozen methane surface } else { hex.biome = 'frozen_terrain'; // Default to frozen terrain } } else if (event.type === 'sandstorm') { // Increase silicates and iron_oxide due to sand transport hex.chemicalComposition.silicates = (hex.chemicalComposition.silicates || 0) + 10; hex.chemicalComposition.iron_oxide = (hex.chemicalComposition.iron_oxide || 0) + 5; // Apply erosion effect Object.keys(hex.chemicalComposition).forEach(element => { if (this.isMineral(element)) { hex.chemicalComposition[element] *= (1 - event.effects.erosion); } }); } else if (event.type === 'meteorite') { // Apply direct chemical changes from meteorite Object.entries(event.effects.chemical).forEach(([element, value]) => { hex.chemicalComposition[element] = (hex.chemicalComposition[element] || 0) + value; }); // Add extra iron and nickel from meteorite impact hex.chemicalComposition.iron = (hex.chemicalComposition.iron || 0) + 15; hex.chemicalComposition.nickel = (hex.chemicalComposition.nickel || 0) + 8; } else if (event.type === 'massiveEruption') { // Significant volcanic composition changes hex.chemicalComposition.silicates = (hex.chemicalComposition.silicates || 0) + 25; hex.chemicalComposition.sulfur = (hex.chemicalComposition.sulfur || 0) + 15; hex.chemicalComposition.iron_oxide = (hex.chemicalComposition.iron_oxide || 0) + 10; // Add temperature increase instead of setting it hex.temperature += event.effects.temperature; // Reduce water content due to high temperature if (hex.chemicalComposition.water) { hex.chemicalComposition.water = Math.max(0, hex.chemicalComposition.water - 20); } } else if (event.type === 'ashfall') { // Add volcanic ash components hex.chemicalComposition.silicates = (hex.chemicalComposition.silicates || 0) + 20; hex.chemicalComposition.iron_oxide = (hex.chemicalComposition.iron_oxide || 0) + 8; hex.chemicalComposition.sulfur = (hex.chemicalComposition.sulfur || 0) + 5; } // Normalize chemical composition to 100% const total = Object.values(hex.chemicalComposition).reduce((sum, val) => sum + val, 0); Object.keys(hex.chemicalComposition).forEach(key => { hex.chemicalComposition[key] = (hex.chemicalComposition[key] / total) * 100; }); // Special biome handling for cyclic events if (event.type === 'glaciation') { if (hex.temperature < -50) { hex.biome = hex.elevation <= 0 ? 'frozen_ocean' : 'frozen_terrain'; } else if (hex.temperature < -150) { hex.biome = hex.elevation <= 0 ? 'methane_ice' : 'methane_ice_field'; } } else if (event.type === 'heatWave') { if (hex.temperature > 80) { if (hex.biome.includes('frozen') || hex.biome.includes('ice')) { hex.biome = hex.elevation <= 0 ? 'water_ocean' : 'rocky'; } } } // Recalculate biome after applying all effects hex.biome = this.calculateBiome(hex.elevation, hex.temperature, hex.humidity, hex.chemicalComposition); // Additional biome transitions based on new chemical composition const comp = hex.chemicalComposition; if (comp) { // Check for water-ice dominated areas if (comp.water_ice > 60) { if (hex.temperature < -150) { hex.biome = hex.elevation <= 0 ? 'nitrogen_ice' : 'nitrogen_ice_field'; } else if (hex.temperature < -50) { hex.biome = hex.elevation <= 0 ? 'methane_ice' : 'methane_ice_field'; } else if (hex.temperature < 0) { hex.biome = hex.elevation <= 0 ? 'frozen_ocean' : 'frozen_terrain'; } } // Check for liquid water transitions if (comp.water > 60) { if (hex.temperature > 0) { hex.biome = hex.elevation <= 0 ? 'deep_ocean' : 'water_ocean'; } } // Check for methane transitions if (comp.methane > 50) { if (hex.temperature < -160) { hex.biome = 'methane_ice_field'; } } // Check for nitrogen transitions if (comp.nitrogen > 50) { if (hex.temperature < -200) { hex.biome = 'nitrogen_ice_field'; } } } }); // Create or update the timer to update the grid while events are active if (!this.updateTimer) { this.updateTimer = this.time.addEvent({ delay: (event.duration * 1000) / 10, // Spread changes over 10 updates during event duration callback: () => { const hasActiveEvents = this.activeEvents.some(event => event.endTime > this.time.now); if (hasActiveEvents) { // Update all active events this.activeEvents.forEach(event => { if (event.endTime > this.time.now) { event.affectedHexes.forEach(hex => { // Apply continuous effects if (event.effects.chemical) { Object.entries(event.effects.chemical).forEach(([element, change]) => { // Apply gradual chemical changes over time const gradualChange = change / (event.duration * 10); // Divide by duration*10 for smooth transition hex.chemicalComposition[element] = (hex.chemicalComposition[element] || 0) + gradualChange; }); } // Apply other continuous effects if (event.type === 'massiveEruption') { hex.temperature += 1; // Gradual temperature increase over time } else if (event.type === 'ashfall') { hex.elevation = Math.min(hex.elevation + 0.001, hex.elevation + event.effects.elevation); } // Normalize chemical composition const total = Object.values(hex.chemicalComposition).reduce((sum, val) => sum + val, 0); Object.keys(hex.chemicalComposition).forEach(key => { hex.chemicalComposition[key] = (hex.chemicalComposition[key] / total) * 100; }); // Recalculate biome based on current conditions including chemical composition hex.biome = this.calculateBiome(hex.elevation, hex.temperature, hex.humidity, hex.chemicalComposition); }); } }); this.drawHexGrid(); } else { // Clean up when no active events this.updateTimer.destroy(); this.updateTimer = null; this.drawHexGrid(); } }, loop: true }); } } showInfoWindow() { // If info window already exists, just return if (this.infoWindow && this.infoWindow.active) { return; } // Create window background const graphics = this.add.graphics(); graphics.setDepth(1100); graphics.fillStyle(0x000000, 0.8); graphics.fillRect(200, 100, 400, 400); // Collect initial statistics const stats = this.collectPlanetStatistics(); // Create info text const infoText = this.add.text(210, 120, stats, { fontSize: '16px', color: '#ffffff', wordWrap: { width: 380 } }).setDepth(1100); // Group all elements this.infoWindow = this.add.container(0, 0, [graphics, infoText]); this.infoWindow.setDepth(1100); // Add hover detection for the info window const infoZone = this.add.zone(200, 100, 400, 400); infoZone.setInteractive(); infoZone.on('pointerover', () => { this.infoWindow.isHovered = true; }); infoZone.on('pointerout', () => { this.infoWindow.isHovered = false; if (!this.infoButton || !this.infoButton.isHovered) { this.infoWindow.destroy(); this.infoWindow = null; if (this.infoUpdateTimer) { this.infoUpdateTimer.destroy(); this.infoUpdateTimer = null; } } }); this.infoWindow.add(infoZone); // Create update timer that only updates the text content if (this.infoUpdateTimer) { this.infoUpdateTimer.destroy(); } this.infoUpdateTimer = this.time.addEvent({ delay: 1000, callback: () => { if (this.infoWindow && this.infoWindow.active) { // Only update the text content infoText.setText(this.collectPlanetStatistics()); } }, loop: true }); // Make sure the window stays active this.infoWindow.active = true; } collectPlanetStatistics() { // Calculate medium temperature let totalTemp = 0; let hexCount = 0; for (let row = 0; row < this.gridHeight; row++) { for (let col = 0; col < this.gridWidth; col++) { totalTemp += this.hexGrid[row][col].temperature; hexCount++; } } const mediumTemp = Math.round(totalTemp / hexCount); // Global Events Section let globalEventInfo = `Medium Temperature: ${mediumTemp}°C\n\nGlobal Events:\n`; if (this.currentGlobalEvent) { const remainingYears = Math.ceil((this.currentGlobalEvent.endYear - this.currentYear)); globalEventInfo += `Active: ${this.currentGlobalEvent.type} (${remainingYears} years remaining)\n`; } else { globalEventInfo += 'None active\n'; if (this.nextGlobalEventYear) { globalEventInfo += `Next event in ${this.nextGlobalEventYear - this.currentYear} years\n`; } } // Biome Count Section const biomeCounts = {}; let totalChemicals = {}; for (let row = 0; row < this.gridHeight; row++) { for (let col = 0; col < this.gridWidth; col++) { const hex = this.hexGrid[row][col]; // Count biomes biomeCounts[hex.biome] = (biomeCounts[hex.biome] || 0) + 1; // Sum chemicals Object.entries(hex.chemicalComposition).forEach(([chemical, value]) => { totalChemicals[chemical] = (totalChemicals[chemical] || 0) + value; }); } } // Calculate total hexes const totalHexes = this.gridWidth * this.gridHeight; // Format biome counts let biomeInfo = '\nBiome Distribution:\n'; Object.entries(biomeCounts) .sort((a, b) => b[1] - a[1]) .forEach(([biome, count]) => { const percentage = ((count / totalHexes) * 100).toFixed(1); biomeInfo += `${biome.replace(/_/g, ' ')}: ${percentage}%\n`; }); // Calculate average chemical composition let chemicalInfo = '\nAverage Chemical Composition:\n'; Object.entries(totalChemicals) .sort((a, b) => b[1] - a[1]) .forEach(([chemical, total]) => { const average = (total / totalHexes).toFixed(1); if (average > 0.1) { // Only show chemicals with >0.1% presence chemicalInfo += `${chemical.replace(/_/g, ' ')}: ${average}%\n`; } }); return globalEventInfo + biomeInfo + chemicalInfo; } handleHexClick(hex) { // Empty function - no longer needed } initializeHexGrid() { for (let row = 0; row < this.gridHeight; row++) { this.hexGrid[row] = []; for (let col = 0; col < this.gridWidth; col++) { // Generate elevation using noise // Get planet configuration first const planetConfig = this.planetTypes[this.currentPlanetType]; // Generate base elevation const elevation = this.generateNoise(col, row); // Add local variations based on planet type let localVariation = 0; switch (this.currentPlanetType) { case 'volcanic': // Add volcanic features if (elevation > 0.7) { localVariation = Math.random() * 0.2; } break; case 'oceanic': // Add underwater ridges if (elevation < 0.4) { localVariation = Math.sin(col * 0.2) * Math.cos(row * 0.2) * 0.1; } break; case 'icy': // Add crevasses and ice formations localVariation = Math.random() * 0.15 - 0.075; break; case 'iron': // Add impact craters const distanceFromCenter = Math.sqrt(Math.pow(col - this.gridWidth / 2, 2) + Math.pow(row - this.gridHeight / 2, 2)); localVariation = Math.sin(distanceFromCenter * 0.3) * 0.1; break; case 'desertic': // Add sand dunes localVariation = Math.sin((col + row) * 0.2) * 0.1; break; } const finalElevation = Math.max(planetConfig.heightRange.min, Math.min(planetConfig.heightRange.max, elevation + localVariation)); // Generate temperature with latitude variation const latitudeEffect = Math.cos((row / this.gridHeight - 0.5) * Math.PI) * 0.5; const tempNoise = this.generateNoise(col + 1000, row); const temperature = planetConfig.baseTemperature + (tempNoise * 2 - 1) * planetConfig.temperatureRange + latitudeEffect * planetConfig.temperatureRange; // Generate humidity based on planet type const humidityNoise = this.generateNoise(col, row + 1000); const humidity = humidityNoise * (planetConfig.humidityRange.max - planetConfig.humidityRange.min) + planetConfig.humidityRange.min; // Convert offset coordinates to cubic coordinates const x = col; const z = row - (col - (col & 1)) / 2; const y = -x - z; // First calculate base biome without composition const baseBiome = this.calculateBiome(elevation, temperature, humidity, null); // Then calculate composition using the base biome const initialComposition = this.calculateChemicalComposition({ elevation: elevation, temperature: temperature, humidity: humidity, biome: baseBiome }); // Finally, recalculate biome with the composition const finalBiome = this.calculateBiome(elevation, temperature, humidity, initialComposition); this.hexGrid[row][col] = { elevation: elevation, temperature: temperature, humidity: humidity, biome: finalBiome, chemicalComposition: initialComposition, x: (col * this.hexSize * 1.5) + (800 - this.totalGridWidth) / 2 + this.hexSize, y: (row * this.hexSize * Math.sqrt(3) + (col % 2) * (this.hexSize * Math.sqrt(3) / 2)) + (600 - this.totalGridHeight) / 2 + this.hexSize + this.topMargin, // Store cubic coordinates coords: { x: x, // cubic x y: y, // cubic y z: z // cubic z } }; } } } generateSimpleNoise(x, y, scale) { // Use the seed to offset coordinates x = x + this.seed * 13.437; y = y + this.seed * 7.891; // Combine multiple noise patterns let noise = Math.sin(x * scale) * Math.cos(y * scale); noise += Math.sin((x + 31.32) * scale * 2.1) * Math.cos((y + 47.13) * scale * 2.1) * 0.5; noise += Math.sin((x + 127.1) * scale * 4.3) * Math.cos((y + 311.7) * scale * 4.3) * 0.25; // Normalize to 0-1 range return (noise * 0.5 + 0.5); } generateNoise(x, y) { // Get planet type configuration const planetConfig = this.planetTypes[this.currentPlanetType]; // Create multiple layers of noise with different frequencies and amplitudes const baseScale = 0.03; // Reduced base scale for larger features let noise = 0; let amplitude = 1; let frequency = 1; let maxAmplitude = 0; // Use seed to create variation in noise patterns const seedOffsetX = Math.sin(this.seed) * 1000; const seedOffsetY = Math.cos(this.seed) * 1000; x += seedOffsetX; y += seedOffsetY; // Add more octaves for finer detail const octaves = 6; // Increased from 4 // Create continent mask using simple noise const continentScale = 0.02; const continentNoise = this.generateSimpleNoise(x, y, continentScale); // Create ridged noise for mountains const ridgedNoise = (n) => 1 - Math.abs(n * 2 - 1); // Generate octaves of noise for (let i = 0; i < octaves; i++) { // Add variation to each octave based on seed const octaveOffset = this.seed * (i + 1) * 0.1; noise += amplitude * this.generateSimpleNoise( x + octaveOffset, y + octaveOffset, baseScale * frequency ); maxAmplitude += amplitude; amplitude *= 0.5; frequency *= 2.1; // Slightly different frequency multiplier for more variation } // Normalize the base noise noise /= maxAmplitude; // Add more variation to the noise based on planet type const planetVariation = Math.sin(this.seed * 0.1) * 0.2; noise = noise * (1 + planetVariation); // Adjust noise threshold based on seed const oceanThreshold = 0.4 + Math.sin(this.seed * 0.3) * 0.1; // Adjust noise to ensure proper ocean depths with varying thresholds if (noise < oceanThreshold) { // Rescale ocean depths with variation noise = (noise / oceanThreshold) * (0.4 + planetVariation); } else { // Rescale land heights with variation noise = 0.4 + ((noise - oceanThreshold) / (1 - oceanThreshold)) * (0.6 - planetVariation); } // Apply continent and biome-specific modifications switch (this.currentPlanetType) { case 'oceanic': // Create ocean world with less frequent landmasses const oceanBase = (noise - 0.6) * 2; // Lower base for more ocean // Generate continental shelves and islands const continentalNoise = this.generateSimpleNoise(x + 1000, y + 1000, 0.04); const islandChance = this.generateSimpleNoise(x + 2000, y + 2000, 0.03); // Create more varied surface features but with lower frequency let surfaceFeatures = 0; if (islandChance > 0.75) { // 25% chance of surface features (reduced from 40%) const ridgeNoise = ridgedNoise(this.generateSimpleNoise(x + 3000, y + 3000, 0.06)); surfaceFeatures = ridgeNoise * continentalNoise * 0.7; // Reduced intensity } // Add larger continental formations less frequently const continentChance = this.generateSimpleNoise(x + 4000, y + 4000, 0.02); if (continentChance > 0.85) { // 15% chance of major landmasses (reduced from 25%) surfaceFeatures += continentalNoise * 0.5; // Reduced intensity } // Combine base terrain with surface features noise = oceanBase + (surfaceFeatures > 0 ? Math.abs(surfaceFeatures) : 0); // Scale to allow for higher elevations noise = noise * 1.2; // Ensure significant elevation for landmasses if (surfaceFeatures > 0) { noise = Math.max(noise, 0.1); } break; case 'volcanic': // Create volcanic island chains and mountain ranges const volcBase = noise * 0.6; const volcRidges = ridgedNoise(this.generateSimpleNoise(x + 2000, y + 2000, 0.04)); noise = volcBase + (volcRidges * 0.6); // Add volcanic peaks if (noise > 0.7) { noise = noise * 1.3; } break; case 'icy': // Create ice sheets and glacial valleys const iceBase = noise * 0.8; const glaciers = ridgedNoise(this.generateSimpleNoise(x + 3000, y + 3000, 0.03)); noise = iceBase + (glaciers * 0.4); // Smooth out lower elevations noise = noise < 0.4 ? noise * 0.8 : noise; break; case 'desertic': // Create large dune seas and mesas const duneBase = noise * 0.7; const dunes = this.generateSimpleNoise(x + 5000, y + 5000, 0.05) * 0.3; noise = duneBase + Math.abs(dunes); // Add mesa formations if (noise > 0.6) { noise = Math.pow(noise, 1.3); } break; // Remove duplicate cases since they're already handled above case 'icy': // Create jagged terrain noise = (noise * 0.8) + (Math.sin(x * 0.1) * Math.cos(y * 0.1) * 0.2); break; case 'iron': // Create cratered surface const craterNoise = Math.sin(x * 0.2) * Math.cos(y * 0.2) * 0.3; noise = (noise * 0.7) + Math.abs(craterNoise); break; case 'desertic': // Create dune-like patterns const dunePattern = Math.sin((x + y) * 0.05) * 0.2; noise = (noise * 0.8) + dunePattern; break; } // Adjust the noise based on planet type height range const heightRange = planetConfig.heightRange; const adjustedNoise = noise * (heightRange.max - heightRange.min) + heightRange.min; return Math.max(heightRange.min, Math.min(heightRange.max, adjustedNoise)); } drawHexGrid() { // Store current hover state const currentHex = this.selectedHex; // Clear all graphics except hover, buttons, and info window this.children.list.forEach(child => { const isInfoWindowChild = this.infoWindow && this.infoWindow.active && (child === this.infoWindow || (this.infoWindow.list && this.infoWindow.list.includes(child))); if (!child.layerButton && child !== this.hoverGraphics && child !== this.debugText && child !== this.yearText && child !== this.uiContainer && !isInfoWindowChild) { child.destroy(); } }); // Draw all hexagons with lower depth const hexGraphics = this.add.graphics(); hexGraphics.setDepth(0); for (let row = 0; row < this.gridHeight; row++) { for (let col = 0; col < this.gridWidth; col++) { const hex = this.hexGrid[row][col]; this.drawHexagon(hex.x, hex.y, hex.elevation); } } // Ensure hover graphics is on top if (this.hoverGraphics) { this.hoverGraphics.setDepth(1000); } // Restore hover state if (currentHex) { this.updateHexHighlight(currentHex); } } drawHexagon(x, y, elevation) { const graphics = this.add.graphics(); const vertices = this.getHexVertices(x, y); const hex = this.getHexFromPosition(x, y); let color; // Get color based on current layer switch (this.currentLayer) { case 'biome': const biomeColors = this.getBiomeColor(hex.biome, elevation); color = Phaser.Display.Color.GetColor( Math.max(0, Math.min(255, biomeColors.r)), Math.max(0, Math.min(255, biomeColors.g)), Math.max(0, Math.min(255, biomeColors.b)) ); break; case 'Km': color = this.getElevationColor(hex.elevation); break; case 'C°': color = this.getTemperatureColor(hex.temperature); break; case 'B+E': // Get base biome color const baseColors = this.getBiomeColor(hex.biome, elevation); // Convert base color components to Phaser Color object const baseColor = Phaser.Display.Color.GetColor( Math.max(0, Math.min(255, baseColors.r)), Math.max(0, Math.min(255, baseColors.g)), Math.max(0, Math.min(255, baseColors.b)) ); // Check for active events const activeEvent = this.activeEvents.find(event => event.affectedHexes.includes(hex) && event.endTime > this.time.now ); if (activeEvent) { // Get event color based on event type let eventColor; switch (activeEvent.type) { case 'massiveEruption': eventColor = Phaser.Display.Color.ValueToColor(Phaser.Display.Color.GetColor(255, 50, 0)); break; case 'crustalFracture': eventColor = Phaser.Display.Color.ValueToColor(Phaser.Display.Color.GetColor(180, 90, 40)); break; case 'ironMeteorite': eventColor = Phaser.Display.Color.ValueToColor(Phaser.Display.Color.GetColor(255, 120, 30)); break; case 'cryogenicStorm': eventColor = Phaser.Display.Color.ValueToColor(Phaser.Display.Color.GetColor(200, 220, 255)); break; case 'iceCrustFracture': eventColor = Phaser.Display.Color.ValueToColor(Phaser.Display.Color.GetColor(150, 200, 255)); break; case 'ashfall': eventColor = Phaser.Display.Color.ValueToColor(Phaser.Display.Color.GetColor(180, 180, 180)); break; case 'sandstorm': eventColor = Phaser.Display.Color.ValueToColor(Phaser.Display.Color.GetColor(230, 200, 160)); break; case 'meteorite': eventColor = Phaser.Display.Color.ValueToColor(Phaser.Display.Color.GetColor(255, 100, 50)); break; case 'submarineEruption': eventColor = Phaser.Display.Color.ValueToColor(Phaser.Display.Color.GetColor(255, 80, 30)); break; case 'geothermalVent': eventColor = Phaser.Display.Color.ValueToColor(Phaser.Display.Color.GetColor(100, 255, 200)); break; case 'tropicalStorm': eventColor = Phaser.Display.Color.ValueToColor(Phaser.Display.Color.GetColor(70, 130, 255)); break; default: eventColor = Phaser.Display.Color.ValueToColor(Phaser.Display.Color.GetColor(100, 100, 100)); } // Convert base color to Color object const baseColorObj = Phaser.Display.Color.ValueToColor(baseColor); // Blend colors (70% base, 30% event for subtle effect) color = Phaser.Display.Color.GetColor( Math.floor(baseColorObj.r * 0.7 + eventColor.r * 0.3), Math.floor(baseColorObj.g * 0.7 + eventColor.g * 0.3), Math.floor(baseColorObj.b * 0.7 + eventColor.b * 0.3) ); } else { color = baseColor; } break; case 'elevation': color = this.getElevationColor(hex.elevation); break; case 'temperature': color = this.getTemperatureColor(hex.temperature); break; case 'events': color = this.getEventsColor(hex); break; default: color = 0x808080; // Default gray } graphics.lineStyle(1, 0x666666); graphics.fillStyle(color); graphics.beginPath(); graphics.moveTo(vertices[0].x, vertices[0].y); for (let i = 1; i < vertices.length; i++) { graphics.lineTo(vertices[i].x, vertices[i].y); } graphics.closePath(); graphics.strokePath(); graphics.fillPath(); } getHexVertices(x, y) { const vertices = []; for (let i = 0; i < 6; i++) { const angle = (i * Math.PI) / 3; vertices.push({ x: x + this.hexSize * Math.cos(angle), y: y + this.hexSize * Math.sin(angle) }); } return vertices; } calculateBiome(elevation, temperature, humidity, chemicalComposition = null) { const planetConfig = this.planetTypes[this.currentPlanetType]; // Use provided chemical composition or default to null const composition = chemicalComposition; // Check chemical composition thresholds if available if (composition) { // Check water state and composition const waterState = this.getChemicalState('water', temperature); // Water-ice transitions if (composition.water_ice > 60) { if (temperature < -150) { return elevation <= 0 ? 'nitrogen_ice' : 'nitrogen_ice_field'; } else if (temperature < -120) { return elevation <= 0 ? 'methane_ice' : 'methane_ice_field'; } else if (temperature < -10) { return elevation <= 0 ? 'frozen_ocean' : 'frozen_terrain'; } } // Liquid/Gas water transitions if (composition.water > 60) { if (waterState === 'gas') { return 'rocky'; // Convert to rocky when water is gas } else if (waterState === 'liquid') { return elevation <= 0 ? 'deep_ocean' : 'water_ocean'; } } // Methane transitions if (composition.methane > 50) { if (temperature < -160) { return 'methane_ice_field'; } } // Nitrogen transitions if (composition.nitrogen > 50) { if (temperature < -200) { return 'nitrogen_ice_field'; } } } // Handle desertic planet's surface if (this.currentPlanetType === 'desertic') { // Check for polar ice caps (based on temperature) if (temperature < -20) { if (elevation > 0.5) { return 'desert_ice_peak'; } return 'desert_ice_plain'; } // Regular desert biomes if (elevation < 0.3) { return 'sand_sea'; // Extensive sand dunes like Sahara } if (elevation < 0.5) { return 'desert_plain'; // Flat desert terrain } if (elevation > 0.7) { return 'oxide_peaks'; // High mountain ranges } return 'mars_desert'; // Standard desert surface } // Handle volcanic planet's lava seas if (this.currentPlanetType === 'volcanic' && elevation < 0.4) { if (temperature > 1000) { return elevation < 0.2 ? 'deep_lava_sea' : 'lava_sea'; } return elevation < 0.2 ? 'deep_lava_sea' : 'cooling_lava_sea'; } // Handle iron planet's metal seas if (this.currentPlanetType === 'iron') { if (elevation < 0.4) { if (temperature > 800) { return elevation < 0.2 ? 'deep_metal_sea' : 'metal_sea'; } return elevation < 0.2 ? 'deep_metal_sea' : 'metal_sea'; } if (elevation > 0.7) { return 'iron_peaks'; } return 'iron_surface'; } // Temperature-dependent water state changes for other planet types // Handle water bodies based on water state and elevation if (elevation <= 0) { const waterState = this.getChemicalState('water', temperature); if (waterState === 'gas') { return 'rocky'; // Convert to rocky when water is gas } if (temperature < -200) { return 'nitrogen_ice'; } if (temperature < -120) { return 'methane_ice'; } if (temperature < -10) { return elevation < 0.2 ? 'deep_frozen_ocean' : 'frozen_ocean'; } return elevation < 0.2 ? 'deep_ocean' : 'water_ocean'; } // Special handling for oceanic planets if (this.currentPlanetType === 'oceanic') { // Handle water bodies for negative elevation if (elevation <= 0) { const latitudeEffect = Math.abs(y / this.gridHeight - 0.5) * 2; // 0 at equator, 1 at poles if (temperature < 0 && latitudeEffect > 0.8) { // Only freeze near poles (top 20%) return elevation < -0.5 ? 'deep_frozen_ocean' : 'frozen_ocean'; } return elevation < -0.5 ? 'deep_ocean' : 'water_ocean'; } else { // Rocky formations for positive elevation return 'rocky'; } } // Temperature-dependent ice formations if (temperature < -200) { return 'nitrogen_ice_field'; } if (temperature < -120) { return 'methane_ice_field'; } if (temperature < -10) { return 'frozen_terrain'; } // Volcanic planet biomes if (temperature > 80) { if (elevation > 0.8) { return 'volcanic_vent'; // Active volcanic vents } if (elevation < 0.5) { return 'lava_flow'; // Active lava rivers } return 'obsidian_field'; // Cooled volcanic glass fields } // Iron planet biomes if (elevation > 0.7 && temperature > 40) { if (temperature > 60) { return 'metal_lake'; // Extremely hot liquid metal surface } return 'iron_surface'; // Solid iron surface } // Desertic (Mars-like) biomes if (humidity < 0.3 && temperature > 20) { if (elevation > 0.8) { return 'oxide_peaks'; // Iron oxide mountains } return 'mars_desert'; // Regular martian surface } // Rocky terrain for remaining areas if (elevation > 0.6) { return 'rocky'; } return 'rocky'; } createLayerButtons() { const buttonWidth = 60; const buttonHeight = 30; const spacing = 5; const startX = 10; const startY = 10; // Create container for all layer UI elements this.layerButtons = this.add.container(0, 0); this.layerButtons.setDepth(900); // Set high depth to stay on top this.layers.forEach((layer, index) => { const x = startX + (buttonWidth + spacing) * index; const y = startY; // Create button background // Create button background const buttonBg = this.add.graphics(); buttonBg.fillStyle(0x666666); buttonBg.fillRoundedRect(x, y, buttonWidth, buttonHeight, 5); buttonBg.setDepth(900); buttonBg.layerButton = true; // Create button text // Create button text const text = this.add.text(x + buttonWidth / 2, y + buttonHeight / 2, layer, { fontSize: '16px', color: '#ffffff' } ).setOrigin(0.5); text.setDepth(901); text.layerButton = true; // Make button interactive const zone = this.add.zone(x, y, buttonWidth, buttonHeight); zone.setInteractive(); zone.layerButton = true; // Mark as layer button zone.on('pointerover', () => { buttonBg.clear(); buttonBg.fillStyle(0x888888); buttonBg.fillRoundedRect(x, y, buttonWidth, buttonHeight, 5); }); zone.on('pointerout', () => { buttonBg.clear(); buttonBg.fillStyle(0x666666); buttonBg.fillRoundedRect(x, y, buttonWidth, buttonHeight, 5); }); zone.on('pointerdown', () => { this.currentLayer = layer; // Update the grid immediately this.drawHexGrid(); // If there are active events, ensure the update timer is running const hasActiveEvents = this.activeEvents.some(event => event.endTime > this.time.now); if (hasActiveEvents && !this.updateTimer) { this.updateTimer = this.time.addEvent({ delay: 100, callback: () => { this.drawHexGrid(); if (!this.activeEvents.some(event => event.endTime > this.time.now)) { this.updateTimer.destroy(); this.updateTimer = null; } }, loop: true }); } }); }); } getElevationColor(elevation) { // Deep ocean to mountain peaks gradient if (elevation <= 0) { // Deep blue to lighter blue for underwater const blueIntensity = Math.floor((elevation + 1) * 155); // -1 to 0 mapped to 0-155 return Phaser.Display.Color.GetColor( 0, blueIntensity, Math.min(255, 100 + blueIntensity) ); } else { // Green to brown to white for land if (elevation < 0.3) { // Green for low elevation return Phaser.Display.Color.GetColor( 87 + (elevation * 200), 139 + (elevation * 100), 47 ); } else if (elevation < 0.7) { // Brown for medium elevation const factor = (elevation - 0.3) / 0.4; return Phaser.Display.Color.GetColor( 139 + (factor * 61), 69 + (factor * 51), 19 + (factor * 31) ); } else { // White for peaks const factor = (elevation - 0.7) / 0.3; const base = 200; return Phaser.Display.Color.GetColor( base + (factor * (255 - base)), base + (factor * (255 - base)), base + (factor * (255 - base)) ); } } } getTemperatureColor(temperature) { // Enhanced temperature color mapping with more granular transitions if (temperature <= -200) { // Ultra cold (nitrogen freezing) return Phaser.Display.Color.GetColor(100, 140, 255); } else if (temperature <= -150) { // Extremely cold const factor = (temperature + 200) / 50; return Phaser.Display.Color.GetColor( 100 + Math.floor(factor * 50), 140 + Math.floor(factor * 40), 255 ); } else if (temperature <= -100) { // Very cold const factor = (temperature + 150) / 50; return Phaser.Display.Color.GetColor( 150 + Math.floor(factor * 30), 180 + Math.floor(factor * 30), 255 ); } else if (temperature <= -50) { // Cold const factor = (temperature + 100) / 50; return Phaser.Display.Color.GetColor( 180 + Math.floor(factor * 40), 210 + Math.floor(factor * 30), 255 ); } else if (temperature <= 0) { // Freezing const factor = (temperature + 50) / 50; return Phaser.Display.Color.GetColor( 220 + Math.floor(factor * 35), 240 + Math.floor(factor * 15), 255 ); } else if (temperature <= 25) { // Cool const factor = temperature / 25; return Phaser.Display.Color.GetColor( 255, 255, 255 - Math.floor(factor * 100) ); } else if (temperature <= 50) { // Mild const factor = (temperature - 25) / 25; return Phaser.Display.Color.GetColor( 255, 255 - Math.floor(factor * 50), 155 - Math.floor(factor * 55) ); } else if (temperature <= 100) { // Warm const factor = (temperature - 50) / 50; return Phaser.Display.Color.GetColor( 255, 205 - Math.floor(factor * 105), 100 - Math.floor(factor * 100) ); } else if (temperature <= 250) { // Hot const factor = (temperature - 100) / 150; return Phaser.Display.Color.GetColor( 255, 100 - Math.floor(factor * 70), Math.floor(factor * 50) ); } else if (temperature <= 500) { // Very hot const factor = (temperature - 250) / 250; return Phaser.Display.Color.GetColor( 255, 30 - Math.floor(factor * 30), 50 + Math.floor(factor * 50) ); } else if (temperature <= 1000) { // Extremely hot const factor = (temperature - 500) / 500; return Phaser.Display.Color.GetColor( 255 - Math.floor(factor * 55), 0, 100 + Math.floor(factor * 155) ); } else { // Ultra hot (plasma) const factor = Math.min((temperature - 1000) / 1000, 1); return Phaser.Display.Color.GetColor( 200 + Math.floor(factor * 55), 0 + Math.floor(factor * 150), 255 ); } } getEventsColor(hex) { // Check if hex is affected by any active events const activeEvent = this.activeEvents.find(event => event.affectedHexes.includes(hex) && event.endTime > this.time.now ); if (activeEvent) { switch (activeEvent.type) { case 'massiveEruption': return Phaser.Display.Color.GetColor(255, 50, 0); // Bright red for eruption case 'crustalFracture': return Phaser.Display.Color.GetColor(180, 90, 40); // Dark orange-brown for fractures case 'ironMeteorite': return Phaser.Display.Color.GetColor(255, 120, 30); // Bright orange for iron meteorite case 'cryogenicStorm': return Phaser.Display.Color.GetColor(200, 220, 255); // Icy blue-white for storm case 'iceCrustFracture': return Phaser.Display.Color.GetColor(150, 200, 255); // Lighter blue for ice cracks case 'ashfall': return Phaser.Display.Color.GetColor(180, 180, 180); // Gray for ash case 'sandstorm': return Phaser.Display.Color.GetColor(230, 200, 160); // Sandy color case 'meteorite': return Phaser.Display.Color.GetColor(255, 100, 50); // Impact color // New oceanic event colors case 'submarineEruption': return Phaser.Display.Color.GetColor(255, 80, 30); // Orange-red for underwater eruption case 'geothermalVent': return Phaser.Display.Color.GetColor(100, 255, 200); // Cyan-green for thermal activity case 'tropicalStorm': return Phaser.Display.Color.GetColor(70, 130, 255); // Storm blue default: return Phaser.Display.Color.GetColor(40, 40, 40); // Default gray } } // Base color is dark gray if no active events return Phaser.Display.Color.GetColor(40, 40, 40); // Check for special events based on hex properties if (this.currentPlanetType === 'volcanic' && hex.temperature > 800) { // Volcanic activity color = { r: 255, g: 100, b: 0 }; } else if (hex.elevation > 0.8 && hex.temperature < -50) { // Extreme weather color = { r: 200, g: 200, b: 255 }; } else if (hex.humidity > 0.9 && hex.temperature > 30) { // Storms color = { r: 100, g: 100, b: 255 }; } return Phaser.Display.Color.GetColor(color.r, color.g, color.b); } getBiomeColor(biome, elevation) { // Fallback color (grey) for unknown biomes const fallbackColor = { r: 128, g: 128, b: 128 }; const baseColors = { rocky: { r: 139, g: 69, b: 19 }, // Saddle brown // Desert biomes sand_sea: { r: 244, g: 215, b: 164 }, // Light sand color desert_ice_plain: { r: 230, g: 240, b: 255 }, // Icy desert surface desert_ice_peak: { r: 200, g: 220, b: 255 }, // Icy mountain peaks desert_plain: { r: 230, g: 195, b: 150 }, // Slightly darker sand // Iron planet biomes metal_sea: { r: 192, g: 120, b: 80 }, deep_metal_sea: { r: 160, g: 100, b: 60 }, metal_sea: { r: 140, g: 90, b: 70 }, deep_metal_sea: { r: 120, g: 80, b: 60 }, iron_peaks: { r: 180, g: 110, b: 90 }, iron_surface: { r: 150, g: 95, b: 80 }, // Volcanic seas lava_sea: { r: 255, g: 220, b: 0 }, deep_lava_sea: { r: 255, g: 140, b: 0 }, cooling_lava_sea: { r: 255, g: 80, b: 0 }, // Temperature-dependent water states frozen_ocean: { r: 200, g: 220, b: 255 }, deep_frozen_ocean: { r: 150, g: 170, b: 255 }, frozen_surface: { r: 220, g: 240, b: 255 }, frozen_terrain: { r: 230, g: 240, b: 255 }, nitrogen_ice: { r: 180, g: 200, b: 255 }, nitrogen_ice_field: { r: 190, g: 210, b: 255 }, // Volcanic planet biomes lava_flow: { r: 255, g: 50, b: 0 }, // Bright orange-red for active lava obsidian_field: { r: 40, g: 40, b: 45 }, // Dark grey-black for volcanic glass volcanic_vent: { r: 255, g: 140, b: 0 }, // Bright orange for active vents // Icy planet biomes icy_terrain: { r: 210, g: 235, b: 255 }, // Water ice (blue-white) methane_ice: { r: 200, g: 220, b: 190 }, // Methane ice (slight greenish-white) // Iron planet biomes iron_surface: { r: 180, g: 90, b: 70 }, // Solid iron (rusty red-brown) metal_lake: { r: 255, g: 100, b: 0 }, // Liquid metal lake (bright orange) // Mars-like biomes mars_desert: { r: 210, g: 140, b: 80 }, // Regular martian surface oxide_peaks: { r: 170, g: 65, b: 40 }, // Dark red oxide mountains // Ocean biomes water_ocean: { r: 0, g: 120, b: 230 }, // Regular ocean deep_ocean: { r: 0, g: 60, b: 160 } // Deep ocean trenches }; // Use fallback color if biome color is not defined const color = baseColors[biome] || fallbackColor; // Log warning for undefined biomes in development if (!baseColors[biome]) { console.warn(`Unknown biome type: ${biome}`); } // Adjust color based on elevation for terrain variation let elevationFactor = (elevation - 0.4) * 1.5; // Reduce elevation factor impact for water-based biomes if (biome === 'water_ocean' || biome === 'deep_ocean') { elevationFactor *= 0.3; } // Limit color adjustment for oceanic planet const colorAdjustment = Math.min(0.2, elevationFactor * 0.3); return { r: Math.min(255, Math.max(0, color.r * (1 + colorAdjustment))), g: Math.min(255, Math.max(0, color.g * (1 + colorAdjustment))), b: Math.min(255, Math.max(0, color.b * (1 + colorAdjustment))) }; } getHexFromPosition(x, y) { for (let row = 0; row < this.gridHeight; row++) { for (let col = 0; col < this.gridWidth; col++) { const hex = this.hexGrid[row][col]; if (hex.x === x && hex.y === y) { return hex; } } } return null; } getHexDistance(a, b) { // Calculate the Manhattan distance between two hex coordinates using cubic coordinates return Math.max(Math.abs(a.x - b.x), Math.abs(a.y - b.y), Math.abs(a.z - b.z)); } getHexFromScreenPosition(screenX, screenY) { // Find the nearest hex to the screen coordinates let closestHex = null; let closestDistance = Infinity; for (let row = 0; row < this.gridHeight; row++) { for (let col = 0; col < this.gridWidth; col++) { const hex = this.hexGrid[row][col]; const distance = Phaser.Math.Distance.Between(screenX, screenY, hex.x, hex.y); if (distance < this.hexSize && distance < closestDistance) { closestDistance = distance; closestHex = hex; } } } return closestHex; } updateHexHighlight(hex) { if (!this.hoverGraphics) { this.hoverGraphics = this.add.graphics(); this.hoverGraphics.setDepth(1000); } this.hoverGraphics.clear(); // Remove previous debug text if it exists if (this.debugText) { this.debugText.destroy(); this.debugText = null; } if (hex) { // Draw highlight this.hoverGraphics.lineStyle(2, 0xFFFFFF, 0.8); const vertices = this.getHexVertices(hex.x, hex.y); this.hoverGraphics.beginPath(); this.hoverGraphics.moveTo(vertices[0].x, vertices[0].y); for (let i = 1; i < vertices.length; i++) { this.hoverGraphics.lineTo(vertices[i].x, vertices[i].y); } this.hoverGraphics.closePath(); this.hoverGraphics.strokePath(); // Store the currently highlighted hex this.selectedHex = hex; // Show debug information this.showHexDebugInfo(hex); } else { this.selectedHex = null; } } showHexDebugInfo(hex) { // Calculate height display let heightDisplay; if (this.currentPlanetType === 'oceanic') { if (hex.elevation <= 0) { // Ocean depths (negative values) const depthInMeters = Math.abs(hex.elevation * 11000); heightDisplay = `-${Math.round(depthInMeters)}m`; } else { // Surface features (positive values, in km) const heightInMeters = hex.elevation * 8000; heightDisplay = `${(heightInMeters/1000).toFixed(2)}km`; } } else if (hex.biome.includes('ocean') || hex.biome.includes('sea')) { const heightInMeters = hex.elevation * -11000; heightDisplay = `${Math.round(heightInMeters)}m`; } else { const heightInMeters = (hex.elevation - 0.4) * 22000; heightDisplay = heightInMeters >= 1000 ? `${(heightInMeters/1000).toFixed(2)}km` : `${Math.round(heightInMeters)}m`; } // Get chemical composition let compositionText = ''; Object.entries(hex.chemicalComposition).forEach(([chemical, percentage]) => { if (percentage >= 5) { // Only show components with >= 5% const state = this.getChemicalState(chemical, hex.temperature); compositionText += `\n${chemical.replace(/_/g, ' ')}: ${Math.round(percentage)}% (${state})`; } }); // Create debug text // Check for active events on this hex const activeEvent = this.activeEvents.find(event => event.affectedHexes.includes(hex) && event.endTime > this.time.now ); // Create event information text let eventInfo = '\nActive Event: None'; if (activeEvent) { const remainingTime = Math.ceil((activeEvent.endTime - this.time.now) / 1000); eventInfo = [ '\nActive Event:', `Name: ${activeEvent.name}`, `Duration: ${remainingTime} year${remainingTime !== 1 ? 's' : ''} remaining`, 'Effects:', `• Temperature: ${activeEvent.effects.temperature || 0}°C`, `• Elevation: ${activeEvent.effects.elevation || 0}`, activeEvent.effects.erosion ? `• Erosion: ${activeEvent.effects.erosion * 100}%` : '', activeEvent.effects.chemical ? `• Chemical changes: ${Object.entries(activeEvent.effects.chemical) .map(([element, value]) => `${element} +${value}%`).join(', ')}` : '' ].filter(line => line !== '').join('\n'); } const debugInfo = [ `Biome: ${hex.biome.replace(/_/g, ' ').toUpperCase()}`, `Temperature: ${Math.round(hex.temperature)}°C`, `Elevation: ${heightDisplay}`, `Humidity: ${Math.round(hex.humidity * 100)}%`, eventInfo, '\nChemical Composition:', compositionText ].join('\n'); // Position the debug window let x = hex.x + this.hexSize + 10; let y = hex.y; // Adjust position if too close to the right edge if (x + 200 > 800) { x = hex.x - this.hexSize - 210; } // Create semi-transparent background // Increase background height if there's an active event const bgHeight = this.activeEvents.find(event => event.affectedHexes.includes(hex) && event.endTime > this.time.now ) ? 250 : 200; this.hoverGraphics.fillStyle(0x000000, 0.7); this.hoverGraphics.fillRect(x, y, 200, bgHeight); // Add debug text this.debugText = this.add.text(x + 5, y + 5, debugInfo, { fontSize: '14px', color: '#FFFFFF', wordWrap: { width: 190 }, align: 'left' }); this.debugText.setDepth(1001); // Ensure text is above background } calculateChemicalComposition(hex) { const planetConfig = this.planetTypes[this.currentPlanetType]; let composition = {}; // Get base composition from planet type and biome switch (hex.biome) { // Water-based biomes case 'water_ocean': case 'deep_ocean': composition = { water: 95, dissolved_minerals: 3, organic_compounds: 2 }; break; case 'frozen_ocean': case 'deep_frozen_ocean': composition = { water_ice: 92, dissolved_minerals: 5, methane: 3 }; break; case 'nitrogen_ice': case 'nitrogen_ice_field': composition = { nitrogen: 85, methane: 10, water_ice: 5 }; break; // Volcanic biomes case 'lava_sea': case 'deep_lava_sea': composition = { silicates: 70, iron_oxide: 20, sulfur: 10 }; break; case 'volcanic_vent': composition = { silicates: 55, sulfur: 25, iron_oxide: 20 }; break; // Rocky/Desert biomes case 'rocky': composition = { silicates: 75, iron_oxide: 15, water: 10 }; break; case 'mars_desert': composition = { iron_oxide: 60, silicates: 35, water_ice: 5 }; break; // Default to planet type base composition default: switch (this.currentPlanetType) { case 'volcanic': composition = { silicates: 45, iron_oxide: 25, sulfur: 15, carbon_dioxide: 10, water: 5 }; break; case 'oceanic': composition = { water: 60, dissolved_minerals: 20, silicates: 10, organic_compounds: 10 }; break; case 'icy': composition = { water_ice: 60, methane: 20, nitrogen: 15, carbon_dioxide: 5 }; break; case 'desertic': composition = { silicates: 50, iron_oxide: 30, perchlorate: 10, water_ice: 10 }; break; } // Adjust based on elevation const elevationFactor = Math.pow(hex.elevation, 2); Object.keys(composition).forEach(chemical => { if (this.isMineral(chemical)) { composition[chemical] *= (1 + elevationFactor); } else { composition[chemical] *= (1 - elevationFactor * 0.5); } }); // Adjust based on temperature if (hex.temperature < 0) { // Increase solid forms, decrease liquids and gases this.adjustForLowTemperature(composition, hex.temperature); } else if (hex.temperature > 100) { // Increase gases, decrease liquids and solids this.adjustForHighTemperature(composition, hex.temperature); } // Normalize percentages to sum to 100 const total = Object.values(composition).reduce((sum, val) => sum + val, 0); Object.keys(composition).forEach(key => { composition[key] = (composition[key] / total) * 100; }); } // Apply planet type modifiers switch (this.currentPlanetType) { case 'volcanic': // Increase sulfur content if (composition.sulfur) { composition.sulfur *= 1.5; } break; case 'oceanic': // Increase water content if (composition.water) { composition.water *= 1.2; } break; case 'icy': // Increase ice content if (composition.water_ice) { composition.water_ice *= 1.3; } break; case 'desertic': // Increase oxide content if (composition.iron_oxide) { composition.iron_oxide *= 1.25; } break; } return composition; } isMineral(chemical) { const minerals = ['silicates', 'iron_oxide', 'iron', 'nickel', 'sulfur', 'perchlorate']; return minerals.includes(chemical); } adjustForLowTemperature(composition, temperature) { Object.keys(composition).forEach(chemical => { if (chemical.includes('ice') || this.isMineral(chemical)) { composition[chemical] *= (1 + Math.abs(temperature) / 100); } else if (chemical === 'water' || chemical === 'methane') { composition[chemical] *= (1 - Math.abs(temperature) / 200); } }); } adjustForHighTemperature(composition, temperature) { Object.keys(composition).forEach(chemical => { if (chemical === 'water' || chemical === 'methane') { composition[chemical] *= (1 - (temperature - 100) / 200); } else if (!this.isMineral(chemical)) { composition[chemical] *= (1 + (temperature - 100) / 400); } }); } getChemicalState(chemical, temperature) { // Define melting and boiling points for different chemicals const states = { water: { melt: 0, boil: 100 }, water_ice: { melt: 0, boil: 100 }, methane: { melt: -182, boil: -161 }, nitrogen: { melt: -210, boil: -196 }, sulfur: { melt: 115, boil: 445 }, iron: { melt: 1538, boil: 2862 }, nickel: { melt: 1455, boil: 2913 } }; // For minerals and other materials that don't change state in normal conditions if (!states[chemical]) { return 'solid'; } const state = states[chemical]; if (temperature < state.melt) return 'solid'; if (temperature > state.boil) return 'gas'; return 'liquid'; } } const config = { type: Phaser.AUTO, parent: 'renderDiv', scale: { mode: Phaser.Scale.FIT, autoCenter: Phaser.Scale.CENTER_BOTH, }, width: 800, height: 600, scene: [Example] }; window.phaserGame = new Phaser.Game(config);