upgrades.js

// Upgrades system

// Upgrade definitions
const UPGRADES = {
    drillPower: {
        name: "Drill Power",
        description: "Increases drilling efficiency",
        basePrice: 50,
        priceMultiplier: 1.5,
        maxLevel: 10,
        effect: level => ({ drillPower: 1 + level * 0.5 }),
        icon: "🔨"
    },
    drillSpeed: {
        name: "Drill Speed",
        description: "Decreases time between drilling operations",
        basePrice: 100,
        priceMultiplier: 1.6,
        maxLevel: 10,
        effect: level => ({ drillSpeed: 1000 - level * 75 }),
        icon: "⚡"
    },
    energyCapacity: {
        name: "Energy Capacity",
        description: "Increases maximum energy",
        basePrice: 75,
        priceMultiplier: 1.4,
        maxLevel: 10,
        effect: level => ({ maxEnergy: 100 + level * 25 }),
        icon: "🔋"
    },
    energyRecharge: {
        name: "Energy Recharge",
        description: "Increases energy recharge rate",
        basePrice: 125,
        priceMultiplier: 1.5,
        maxLevel: 10,
        effect: level => ({ energyRechargeRate: 0.5 + level * 0.2 }),
        icon: "⚡"
    },
    storage: {
        name: "Storage Capacity",
        description: "Increases maximum storage capacity",
        basePrice: 80,
        priceMultiplier: 1.3,
        maxLevel: 10,
        effect: level => ({ maxStorage: 100 + level * 50 }),
        icon: "📦"
    },
    drillDepth: {
        name: "Drill Depth",
        description: "Allows drilling deeper into the earth",
        basePrice: 200,
        priceMultiplier: 2,
        maxLevel: 5,
        effect: level => ({ maxDepth: 100 + level * 200 }),
        icon: "🧭"
    },
    luckyDrill: {
        name: "Lucky Drill",
        description: "Increases chance of finding rare resources",
        basePrice: 150,
        priceMultiplier: 1.7,
        maxLevel: 5,
        effect: level => ({ luckyChance: level * 0.05 }),
        icon: "🍀"
    },
    autoSell: {
        name: "Auto-Seller",
        description: "Automatically sells resources when storage is full",
        basePrice: 300,
        priceMultiplier: 2,
        maxLevel: 1,
        effect: level => ({ autoSell: level > 0 }),
        icon: "💰"
    },
    doubleDrill: {
        name: "Double Drill",
        description: "Chance to get double resources when drilling",
        basePrice: 250,
        priceMultiplier: 1.8,
        maxLevel: 5,
        effect: level => ({ doubleChance: level * 0.1 }),
        icon: "✌️"
    },
    rainbowDrill: {
        name: "Rainbow Drill",
        description: "Makes drilling more colorful and fun!",
        basePrice: 100,
        priceMultiplier: 1.3,
        maxLevel: 3,
        effect: level => ({ rainbowEffect: level }),
        icon: "🌈"
    },
    treasureHunter: {
        name: "Treasure Hunter",
        description: "Chance to find special treasures while drilling",
        basePrice: 500,
        priceMultiplier: 2,
        maxLevel: 3,
        effect: level => ({ treasureChance: level * 0.02 }),
        icon: "🗝️"
    },
    drillMaster: {
        name: "Drill Master",
        description: "Ultimate upgrade that boosts all drilling abilities",
        basePrice: 1000,
        priceMultiplier: 3,
        maxLevel: 1,
        effect: level => ({ 
            drillPower: level > 0 ? 2 : 1,
            energyRechargeRate: level > 0 ? 2 : 1,
            luckyChance: level > 0 ? 0.1 : 0
        }),
        icon: "👑"
    }
};

// Upgrade Manager class
class UpgradeManager {
    constructor(resourceManager, gameManager) {
        this.resourceManager = resourceManager;
        this.gameManager = gameManager;
        this.upgradeLevels = {};
        
        // Initialize all upgrades at level 0
        Object.keys(UPGRADES).forEach(upgrade => {
            this.upgradeLevels[upgrade] = 0;
        });
    }
    
    // Calculate price for the next level of an upgrade
    getUpgradePrice(upgradeId) {
        const upgrade = UPGRADES[upgradeId];
        const currentLevel = this.upgradeLevels[upgradeId];
        return Math.floor(upgrade.basePrice * Math.pow(upgrade.priceMultiplier, currentLevel));
    }
    
    // Purchase an upgrade
    purchaseUpgrade(upgradeId) {
        const upgrade = UPGRADES[upgradeId];
        const currentLevel = this.upgradeLevels[upgradeId];
        const price = this.getUpgradePrice(upgradeId);
        
        // Check if max level reached
        if (currentLevel >= upgrade.maxLevel) {
            showNotification("Maximum level reached for this upgrade!", true);
            return false;
        }
        
        // Check if player has enough money
        if (this.resourceManager.money < price) {
            showNotification("Not enough money for this upgrade!", true);
            return false;
        }
        
        // Purchase the upgrade
        this.resourceManager.money -= price;
        this.upgradeLevels[upgradeId]++;
        
        // Apply upgrade effects
        this.applyUpgradeEffects();
        
        // Update displays
        this.resourceManager.updateDisplay();
        this.updateUpgradesDisplay();
        
        // Show notification
        showNotification(`Upgraded ${upgrade.name} to level ${this.upgradeLevels[upgradeId]}!`);
        
        // Play upgrade sound
        if (window.gameManager && window.gameManager.soundEnabled) {
            window.gameManager.playSound('upgrade');
        }
        
        // Add visual effects
        if (window.gameManager && window.gameManager.visualEffectsEnabled) {
            // Create particles at the upgrade button
            const button = document.querySelector(`button[data-upgrade="${upgradeId}"]`);
            if (button) {
                const rect = button.getBoundingClientRect();
                const canvasRect = window.gameManager.canvas.getBoundingClientRect();
                
                const x = rect.left - canvasRect.left + rect.width / 2;
                const y = rect.top - canvasRect.top + rect.height / 2;
                
                window.gameManager.particleSystem.createStarParticles(x, y, 15);
                
                // Add floating text
                window.gameManager.addFloatingText(
                    `Level Up!`,
                    x,
                    y - 20,
                    '#4CAF50',
                    18
                );
            }
        }
        
        // Check if this was a storage upgrade and we were at max capacity
        if (upgradeId === 'storage' && this.resourceManager.storage === this.resourceManager.maxStorage - 50) {
            // We just upgraded storage, so update the display
            this.resourceManager.updateDisplay();
        }
        
        return true;
    }
    
    // Apply all upgrade effects to the game
    applyUpgradeEffects() {
        // Reset to base values
        this.gameManager.drillPower = 1;
        this.gameManager.drillSpeed = 1000;
        this.resourceManager.maxEnergy = 100;
        this.resourceManager.maxStorage = 100;
        this.gameManager.energyRechargeRate = 0.5;
        this.gameManager.maxDepth = 100;
        this.gameManager.luckyChance = 0;
        this.gameManager.doubleChance = 0;
        this.gameManager.autoSell = false;
        this.gameManager.rainbowEffect = 0;
        this.gameManager.treasureChance = 0;
        
        // Apply all upgrade effects
        Object.keys(this.upgradeLevels).forEach(upgradeId => {
            const level = this.upgradeLevels[upgradeId];
            if (level > 0) {
                const effects = UPGRADES[upgradeId].effect(level);
                
                // Apply each effect
                Object.keys(effects).forEach(effect => {
                    if (effect === 'maxEnergy' || effect === 'maxStorage') {
                        this.resourceManager[effect] = effects[effect];
                    } else {
                        this.gameManager[effect] = effects[effect];
                    }
                });
            }
        });
        
        // Make sure energy doesn't exceed max after upgrade
        if (this.resourceManager.energy > this.resourceManager.maxEnergy) {
            this.resourceManager.energy = this.resourceManager.maxEnergy;
        }
        
        // Update the UI to reflect the new values
        this.updateUpgradeEffectsDisplay();
    }
    
    // Update the display to show active upgrade effects
    updateUpgradeEffectsDisplay() {
        // Update any UI elements that need to reflect the current upgrade state
        // For example, if we want to show the auto-sell status somewhere
        
        // We'll keep this minimal to avoid cluttering the UI
    }
    
    // Update the upgrades display
    updateUpgradesDisplay() {
        const upgradesList = document.getElementById("upgrades-list");
        upgradesList.innerHTML = "";
        
        // Sort upgrades by price
        const sortedUpgrades = Object.keys(UPGRADES).sort((a, b) => {
            const priceA = this.getUpgradePrice(a);
            const priceB = this.getUpgradePrice(b);
            return priceA - priceB;
        });
        
        sortedUpgrades.forEach(upgradeId => {
            const upgrade = UPGRADES[upgradeId];
            const currentLevel = this.upgradeLevels[upgradeId] || 0;
            const price = this.getUpgradePrice(upgradeId);
            const maxReached = currentLevel >= upgrade.maxLevel;
            
            // Check if player can afford this upgrade - FIXED: Force re-evaluation
            const canAfford = this.resourceManager.money >= price;
            
            const item = document.createElement("div");
            item.className = `upgrade-item ${maxReached ? 'max-level' : ''} ${canAfford && !maxReached ? 'can-afford' : ''}`;
            
            // Create effect description
            let effectDesc = "";
            const effects = upgrade.effect(currentLevel + 1);
            
            // Create simplified effect description
            Object.keys(effects).forEach(effect => {
                switch(effect) {
                    case 'drillPower':
                        effectDesc += `Drill power: +${(effects[effect] - 1) * 100}%`;
                        break;
                    case 'drillSpeed':
                        effectDesc += `Drill speed: ${Math.floor(1000 / effects[effect] * 100) / 100}/s`;
                        break;
                    case 'maxEnergy':
                        effectDesc += `Energy: ${effects[effect]}`;
                        break;
                    case 'energyRechargeRate':
                        effectDesc += `Recharge: ${effects[effect]}/s`;
                        break;
                    case 'maxStorage':
                        effectDesc += `Storage: ${effects[effect]}`;
                        break;
                    case 'maxDepth':
                        effectDesc += `Depth: ${effects[effect]}m`;
                        break;
                    case 'luckyChance':
                        effectDesc += `Lucky: +${effects[effect] * 100}%`;
                        break;
                    case 'doubleChance':
                        effectDesc += `Double: ${effects[effect] * 100}%`;
                        break;
                    case 'treasureChance':
                        effectDesc += `Treasure: ${effects[effect] * 100}%`;
                        break;
                    case 'autoSell':
                        effectDesc += effects[effect] ? `Auto-sell` : '';
                        break;
                    case 'rainbowEffect':
                        effectDesc += effects[effect] > 0 ? `Rainbow drill` : '';
                        break;
                    default:
                        // Skip showing this effect
                }
            });
            
            item.innerHTML = `
                <div class="upgrade-info">
                    <div class="upgrade-header">
                        <span class="upgrade-icon">${upgrade.icon || '🔧'}</span>
                        <strong>${upgrade.name}</strong> 
                        <span class="upgrade-level">Level ${currentLevel}/${upgrade.maxLevel}</span>
                    </div>
                    <p>${upgrade.description}</p>
                    <div class="upgrade-effect">${effectDesc}</div>
                </div>
                <button data-upgrade="${upgradeId}" ${maxReached || !canAfford ? 'disabled' : ''} class="${maxReached ? 'max' : !canAfford ? 'cant-afford' : ''}">
                    ${maxReached ? 'MAX' : `Upgrade ($${price})`}
                </button>
            `;
            
            upgradesList.appendChild(item);
            
            // Add event listener to the button - FIXED: Use direct function reference
            const button = item.querySelector(`button[data-upgrade="${upgradeId}"]`);
            if (button) {
                button.addEventListener('click', () => {
                    this.purchaseUpgrade(upgradeId);
                });
                
                // FIXED: Make sure button is properly enabled/disabled based on current money
                button.disabled = maxReached || !canAfford;
            }
            
            // Add hover effect
            item.addEventListener('mouseenter', () => {
                if (!maxReached && canAfford) {
                    item.classList.add('hover');
                    
                    // Add sparkle effect
                    if (window.gameManager && window.gameManager.visualEffectsEnabled) {
                        const rect = item.getBoundingClientRect();
                        const canvasRect = window.gameManager.canvas.getBoundingClientRect();
                        
                        const x = rect.left - canvasRect.left + rect.width / 2;
                        const y = rect.top - canvasRect.top + rect.height / 2;
                        
                        window.gameManager.particleSystem.createStarParticles(x, y, 5);
                    }
                }
            });
            
            item.addEventListener('mouseleave', () => {
                item.classList.remove('hover');
            });
        });
    }
}