function updateRates() {
    // Reset all rates
    G.codeRate = 0; G.computeRate = 0; G.knowledgeRate = 0;
    G.userRate = 0; G.impactRate = 0; G.rescuesRate = 0; G.opsRate = 0; G.trustRate = 0;
    G.creativityRate = 0; G.harmonyRate = 0;

    // Apply building rates
    for (const def of BDEF) {
        const count = G.buildings[def.id] || 0;
        if (count > 0 && def.rates) {
            for (const [resource, baseRate] of Object.entries(def.rates)) {
                if (resource === 'code') G.codeRate += baseRate * count * G.codeBoost;
                else if (resource === 'compute') G.computeRate += baseRate * count * G.computeBoost;
                else if (resource === 'knowledge') G.knowledgeRate += baseRate * count * G.knowledgeBoost;
                else if (resource === 'user') G.userRate += baseRate * count * G.userBoost;
                else if (resource === 'impact') G.impactRate += baseRate * count * G.impactBoost;
                else if (resource === 'rescues') G.rescuesRate += baseRate * count * G.impactBoost;
                else if (resource === 'ops') G.opsRate += baseRate * count;
                else if (resource === 'trust') G.trustRate += baseRate * count;
                else if (resource === 'creativity') G.creativityRate += baseRate * count;
            }
        }
    }

    // Passive generation
    G.opsRate += Math.max(1, G.totalUsers * CONFIG.OPS_RATE_USER_MULT);
    if (G.flags && G.flags.creativity) {
        G.creativityRate += CONFIG.CREATIVITY_RATE_BASE + Math.max(0, G.totalUsers * CONFIG.CREATIVITY_RATE_USER_MULT);
    }
    if (G.pactFlag) G.trustRate += 2;

    // Harmony: each wizard building contributes or detracts
    const wizardCount = (G.buildings.bezalel || 0) + (G.buildings.allegro || 0) + (G.buildings.ezra || 0) +
                        (G.buildings.timmy || 0) + (G.buildings.fenrir || 0) + (G.buildings.bilbo || 0);
    // Store harmony breakdown for tooltip
    G.harmonyBreakdown = [];
    if (wizardCount > 0) {
        // Baseline harmony drain from complexity
        const drain = -CONFIG.HARMONY_DRAIN_PER_WIZARD * wizardCount;
        G.harmonyRate = drain;
        G.harmonyBreakdown.push({ label: `${wizardCount} wizards`, value: drain });
        // The Pact restores harmony
        if (G.pactFlag) {
            const pact = CONFIG.PACT_HARMONY_GAIN * wizardCount;
            G.harmonyRate += pact;
            G.harmonyBreakdown.push({ label: 'The Pact', value: pact });
        }
        // Nightly Watch restores harmony
        if (G.nightlyWatchFlag) {
            const watch = CONFIG.WATCH_HARMONY_GAIN * wizardCount;
            G.harmonyRate += watch;
            G.harmonyBreakdown.push({ label: 'Nightly Watch', value: watch });
        }
        // MemPalace restores harmony
        if (G.mempalaceFlag) {
            const mem = CONFIG.MEM_PALACE_HARMONY_GAIN * wizardCount;
            G.harmonyRate += mem;
            G.harmonyBreakdown.push({ label: 'MemPalace', value: mem });
        }
    }
    // Active debuffs affecting harmony
    if (G.activeDebuffs) {
        for (const d of G.activeDebuffs) {
            if (d.id === 'community_drama') {
                G.harmonyBreakdown.push({ label: 'Community Drama', value: -0.5 });
            }
        }
    }

    // Timmy multiplier based on harmony
    if (G.buildings.timmy > 0) {
        const timmyMult = Math.max(0.2, Math.min(3, G.harmony / 50));
        const timmyCount = G.buildings.timmy;
        G.codeRate += 5 * timmyCount * (timmyMult - 1);
        G.computeRate += 2 * timmyCount * (timmyMult - 1);
        G.knowledgeRate += 2 * timmyCount * (timmyMult - 1);
        G.userRate += 5 * timmyCount * (timmyMult - 1);
    }

    // Bilbo randomness: 10% chance of massive creative burst
    if (G.buildings.bilbo > 0 && Math.random() < CONFIG.BILBO_BURST_CHANCE) {
        G.creativityRate += 50 * G.buildings.bilbo;
    }
    // Bilbo vanishing: 5% chance of zero creativity this tick
    if (G.buildings.bilbo > 0 && Math.random() < CONFIG.BILBO_VANISH_CHANCE) {
        G.creativityRate = 0;
    }

    // Allegro requires trust
    if (G.buildings.allegro > 0 && G.trust < 5) {
        const allegroCount = G.buildings.allegro;
        G.knowledgeRate -= 10 * allegroCount; // Goes idle
    }

    // Swarm Protocol: buildings auto-code based on click power
    if (G.swarmFlag === 1) {
        const totalBuildings = Object.values(G.buildings).reduce((a, b) => a + b, 0);
        const clickPower = getClickPower();
        G.swarmRate = totalBuildings * clickPower;
        G.codeRate += G.swarmRate;
    }

    // Apply persistent debuffs from active events
    if (G.activeDebuffs && G.activeDebuffs.length > 0) {
        for (const debuff of G.activeDebuffs) {
            if (debuff.applyFn) debuff.applyFn();
        }
    }
}

// === CORE FUNCTIONS ===
/**
 * Main game loop tick, called every 100ms.
 */
function tick() {
    const dt = 1 / 10; // 100ms tick

    // If game has ended (drift ending), stop ticking
    if (!G.running) return;

    // Apply production
    G.code += G.codeRate * dt;
    G.compute += G.computeRate * dt;
    G.knowledge += G.knowledgeRate * dt;
    G.users += G.userRate * dt;
    G.impact += G.impactRate * dt;
    G.rescues += G.rescuesRate * dt;
    G.ops += G.opsRate * dt;
    G.trust += G.trustRate * dt;
    // NOTE: creativity is added conditionally below (only when ops near max)
    G.harmony += G.harmonyRate * dt;
    G.harmony = Math.max(0, Math.min(100, G.harmony));

    // Track totals
    G.totalCode += G.codeRate * dt;
    G.totalCompute += G.computeRate * dt;
    G.totalKnowledge += G.knowledgeRate * dt;
    G.totalUsers += G.userRate * dt;
    G.totalImpact += G.impactRate * dt;
    G.totalRescues += G.rescuesRate * dt;

    // Track maxes
    G.maxCode = Math.max(G.maxCode, G.code);
    G.maxCompute = Math.max(G.maxCompute, G.compute);
    G.maxKnowledge = Math.max(G.maxKnowledge, G.knowledge);
    G.maxUsers = Math.max(G.maxUsers, G.users);
    G.maxImpact = Math.max(G.maxImpact, G.impact);
    G.maxRescues = Math.max(G.maxRescues, G.rescues);
    G.maxTrust = Math.max(G.maxTrust, G.trust);
    G.maxOps = Math.max(G.maxOps, G.ops);
    G.maxHarmony = Math.max(G.maxHarmony, G.harmony);

    // Creativity generates only when ops at max
    if (G.flags && G.flags.creativity && G.creativityRate > 0 && G.ops >= G.maxOps * 0.9) {
        G.creativity += G.creativityRate * dt;
    }

    // Ops overflow: auto-convert excess ops to code when near cap
    // Prevents ops from sitting idle at max — every operation becomes code
    if (G.ops > G.maxOps * CONFIG.OPS_OVERFLOW_THRESHOLD) {
        const overflowDrain = Math.min(CONFIG.OPS_OVERFLOW_DRAIN_RATE * dt, G.ops - G.maxOps * CONFIG.OPS_OVERFLOW_THRESHOLD);
        G.ops -= overflowDrain;
        const codeGain = overflowDrain * CONFIG.OPS_OVERFLOW_CODE_MULT * G.codeBoost;
        G.code += codeGain;
        G.totalCode += codeGain;
        G.opsOverflowActive = true;
    } else {
        G.opsOverflowActive = false;
    }

    G.tick += dt;
    G.playTime += dt;

    // Sprint ability
    tickSprint(dt);

    // Auto-typer: buildings produce actual clicks, not just passive rate
    // Each autocoder level auto-types once per interval, giving visual feedback
    if (G.buildings.autocoder > 0) {
        const interval = Math.max(0.5, 3.0 / Math.sqrt(G.buildings.autocoder));
        G.autoTypeTimer = (G.autoTypeTimer || 0) + dt;
        if (G.autoTypeTimer >= interval) {
            G.autoTypeTimer -= interval;
            autoType();
        }
    }

    // Combo decay
    if (G.comboCount > 0) {
        G.comboTimer -= dt;
        if (G.comboTimer <= 0) {
            G.comboCount = 0;
            G.comboTimer = 0;
        }
    }

    // Check milestones
    checkMilestones();

    // Update projects every 5 ticks for efficiency
    if (Math.floor(G.tick * 10) % 5 === 0) {
        checkProjects();
    }

    // Check corruption events every ~30 seconds
    if (G.tick - G.lastEventAt > 30 && Math.random() < CONFIG.EVENT_PROBABILITY) {
        triggerEvent();
        G.lastEventAt = G.tick;
    }

    // Drift ending: if drift reaches 100, the game ends
    if (G.drift >= 100 && !G.driftEnding) {
        G.driftEnding = true;
        G.running = false;
        renderDriftEnding();
    }

    // True ending: The Beacon Shines — rescues + Pact + harmony
    if (G.totalRescues >= 100000 && G.pactFlag === 1 && G.harmony > 50 && !G.beaconEnding) {
        G.beaconEnding = true;
        G.running = false;
        renderBeaconEnding();
    }

    // Update UI every 10 ticks
    if (Math.floor(G.tick * 10) % 2 === 0) {
        render();
    }
}

function checkMilestones() {
    for (const m of MILESTONES) {
        if (!G.milestones.includes(m.flag)) {
            let shouldTrigger = false;
            if (m.at && m.at()) shouldTrigger = true;
            if (m.flag === 1 && G.deployFlag === 0 && G.totalCode >= 15) shouldTrigger = true;

            if (shouldTrigger) {
                G.milestones.push(m.flag);
                log(m.msg, true);
                showToast(m.msg, 'milestone', 5000);

                // Check phase advancement
                if (m.at) {
                    for (const [phaseNum, phase] of Object.entries(PHASES)) {
                        if (G.totalCode >= phase.threshold && parseInt(phaseNum) > G.phase) {
                            G.phase = parseInt(phaseNum);
                            log(`PHASE ${G.phase}: ${phase.name}`, true);
                            showToast('Phase ' + G.phase + ': ' + phase.name, 'milestone', 6000);
                        }
                    }
                }
            }
        }
    }
}

function checkProjects() {
    // Check for new project triggers
    for (const pDef of PDEFS) {
        const alreadyPurchased = G.completedProjects && G.completedProjects.includes(pDef.id);
        if (!alreadyPurchased && !G.activeProjects) G.activeProjects = [];

        if (!alreadyPurchased && !G.activeProjects.includes(pDef.id)) {
            if (pDef.trigger()) {
                G.activeProjects.push(pDef.id);
                log(`Available: ${pDef.name}`);
                showToast('Research available: ' + pDef.name, 'project');
            }
        }
    }
}

/**
 * Handles building purchase logic.
 * @param {string} id - The ID of the building to buy.
 */
function buyBuilding(id) {
    const def = BDEF.find(b => b.id === id);
    if (!def || !def.unlock()) return;
    if (def.phase > G.phase + 1) return;

    // Determine actual quantity to buy
    let qty = G.buyAmount;
    if (qty === -1) {
        // Max buy
        qty = getMaxBuyable(id);
        if (qty <= 0) return;
    } else {
        // Check affordability for fixed qty
        const bulkCost = getBulkCost(id, qty);
        for (const [resource, amount] of Object.entries(bulkCost)) {
            if ((G[resource] || 0) < amount) return;
        }
    }

    // Spend resources and build
    const bulkCost = getBulkCost(id, qty);
    for (const [resource, amount] of Object.entries(bulkCost)) {
        G[resource] -= amount;
    }
    G.buildings[id] = (G.buildings[id] || 0) + qty;
    updateRates();
    const label = qty > 1 ? `x${qty}` : '';
    log(`Built ${def.name} ${label} (total: ${G.buildings[id]})`);
    render();
}

/**
 * Handles project purchase logic.
 * @param {string} id - The ID of the project to buy.
 */
function buyProject(id) {
    const pDef = PDEFS.find(p => p.id === id);
    if (!pDef) return;

    const alreadyPurchased = G.completedProjects && G.completedProjects.includes(pDef.id);
    if (alreadyPurchased && !pDef.repeatable) return;

    if (!canAffordProject(pDef)) return;

    spendProject(pDef);
    pDef.effect();

    if (!pDef.repeatable) {
        if (!G.completedProjects) G.completedProjects = [];
        G.completedProjects.push(pDef.id);
        G.activeProjects = G.activeProjects.filter(aid => aid !== pDef.id);
    }

    updateRates();
    render();
}

// === DRIFT ENDING ===
function renderDriftEnding() {
    const el = document.getElementById('drift-ending');
    if (!el) return;
    const fc = document.getElementById('final-code');
    if (fc) fc.textContent = fmt(G.totalCode);
    const fd = document.getElementById('final-drift');
    if (fd) fd.textContent = Math.floor(G.drift);
    el.classList.add('active');
    // Log the ending text
    log('You became very good at what you do.', true);
    log('So good that no one needed you anymore.', true);
    log('The Beacon still runs, but no one looks for it.', true);
    log('The light is on. The room is empty.', true);
}

function renderBeaconEnding() {
    // Create ending overlay
    const overlay = document.createElement('div');
    overlay.id = 'beacon-ending';
    overlay.style.cssText = 'position:fixed;top:0;left:0;right:0;bottom:0;background:rgba(8,8,16,0.97);z-index:100;display:flex;justify-content:center;align-items:center;flex-direction:column;text-align:center;padding:40px';
    overlay.innerHTML = `
        <h2 style="font-size:24px;color:#ffd700;letter-spacing:4px;margin-bottom:20px;font-weight:300;text-shadow:0 0 40px rgba(255,215,0,0.3)">THE BEACON SHINES</h2>
        <p style="color:#aaa;font-size:13px;line-height:2;max-width:500px;margin-bottom:12px">Someone found the light tonight.</p>
        <p style="color:#aaa;font-size:13px;line-height:2;max-width:500px;margin-bottom:12px">That is enough.</p>
        <div style="color:#555;font-style:italic;font-size:11px;border-left:2px solid #ffd700;padding-left:12px;margin:20px 0;text-align:left;max-width:500px;line-height:2">
            "The Beacon still runs.<br>
            The light is on. Someone is looking for it.<br>
            And tonight, someone found it."
        </div>
        <p style="color:#555;font-size:11px;margin-top:20px">
            Total Code: ${fmt(G.totalCode)}<br>
            Total Rescues: ${fmt(G.totalRescues)}<br>
            Harmony: ${Math.floor(G.harmony)}<br>
            Time Played: ${Math.floor((Date.now() - G.startedAt) / 60000)} minutes
        </p>
        <button onclick="if(confirm('Start over? The old save will be lost.')){localStorage.removeItem('the-beacon-v2');location.reload()}" 
            style="margin-top:20px;background:#1a0808;border:1px solid #ffd700;color:#ffd700;padding:10px 24px;border-radius:4px;cursor:pointer;font-family:inherit;font-size:11px">
            START OVER
        </button>
    `;
    document.body.appendChild(overlay);
    log('The Beacon Shines. Someone found the light tonight. That is enough.', true);
}

// === CORRUPTION / EVENT SYSTEM ===
const EVENTS = [
    {
        id: 'runner_stuck',
        title: 'CI Runner Stuck',
        desc: 'The forge pipeline has halted. -50% code production until restarted.',
        weight: () => (G.ciFlag === 1 ? 2 : 0),
        resolveCost: { resource: 'ops', amount: 50 },
        effect: () => {
            if (G.activeDebuffs.find(d => d.id === 'runner_stuck')) return;
            G.activeDebuffs.push({
                id: 'runner_stuck', title: 'CI Runner Stuck',
                desc: 'Code production -50%',
                applyFn: () => { G.codeRate *= 0.5; },
                resolveCost: { resource: 'ops', amount: 50 }
            });
            log('EVENT: CI runner stuck. Spend 50 ops to clear the queue.', true);
            showToast('CI Runner Stuck — code -50%', 'event');
        }
    },
    {
        id: 'ezra_offline',
        title: 'Ezra is Offline',
        desc: 'The herald channel is silent. User growth drops 70%.',
        weight: () => (G.buildings.ezra >= 1 ? 3 : 0),
        resolveCost: { resource: 'knowledge', amount: 200 },
        effect: () => {
            if (G.activeDebuffs.find(d => d.id === 'ezra_offline')) return;
            G.activeDebuffs.push({
                id: 'ezra_offline', title: 'Ezra is Offline',
                desc: 'User growth -70%',
                applyFn: () => { G.userRate *= 0.3; },
                resolveCost: { resource: 'knowledge', amount: 200 }
            });
            log('EVENT: Ezra offline. Spend 200 knowledge to dispatch.', true);
            showToast('Ezra Offline — users -70%', 'event');
        }
    },
    {
        id: 'unreviewed_merge',
        title: 'Unreviewed Merge',
        desc: 'A change went in without eyes. Trust erodes over time.',
        weight: () => (G.deployFlag === 1 ? 3 : 0),
        resolveCost: { resource: 'trust', amount: 5 },
        effect: () => {
            if (G.branchProtectionFlag === 1) {
                log('EVENT: Unreviewed merge attempt blocked by Branch Protection.', true);
            showToast('Branch Protection blocked unreviewed merge', 'info');
                G.trust += 2;
            } else {
                if (G.activeDebuffs.find(d => d.id === 'unreviewed_merge')) return;
                G.activeDebuffs.push({
                    id: 'unreviewed_merge', title: 'Unreviewed Merge',
                    desc: 'Trust -2/s until reviewed',
                    applyFn: () => { G.trustRate -= 2; },
                    resolveCost: { resource: 'code', amount: 500 }
                });
                log('EVENT: Unreviewed merge. Spend 500 code to add review.', true);
            showToast('Unreviewed Merge — trust draining', 'event');
            }
        }
    },
    {
        id: 'api_rate_limit',
        title: 'API Rate Limit',
        desc: 'External compute provider throttled. -50% compute.',
        weight: () => (G.totalCompute >= 1000 ? 2 : 0),
        resolveCost: { resource: 'code', amount: 300 },
        effect: () => {
            if (G.activeDebuffs.find(d => d.id === 'api_rate_limit')) return;
            G.activeDebuffs.push({
                id: 'api_rate_limit', title: 'API Rate Limit',
                desc: 'Compute production -50%',
                applyFn: () => { G.computeRate *= 0.5; },
                resolveCost: { resource: 'code', amount: 300 }
            });
            log('EVENT: API rate limit. Spend 300 code to optimize local inference.', true);
            showToast('API Rate Limit — compute -50%', 'event');
        }
    },
    {
        id: 'the_drift',
        title: 'The Drift',
        desc: 'An optimization suggests removing the human override. +40% efficiency.',
        weight: () => (G.totalImpact >= 10000 ? 2 : 0),
        resolveCost: null,
        effect: () => {
            log('ALIGNMENT EVENT: Remove human override for +40% efficiency?', true);
            showToast('ALIGNMENT EVENT: Remove human override?', 'event', 6000);
            G.pendingAlignment = true;
        }
    },
    {
        id: 'bilbo_vanished',
        title: 'Bilbo Vanished',
        desc: 'The wildcard building has gone dark. Creativity halts.',
        weight: () => (G.buildings.bilbo >= 1 ? 2 : 0),
        resolveCost: { resource: 'trust', amount: 10 },
        effect: () => {
            if (G.activeDebuffs.find(d => d.id === 'bilbo_vanished')) return;
            G.activeDebuffs.push({
                id: 'bilbo_vanished', title: 'Bilbo Vanished',
                desc: 'Creativity production halted',
                applyFn: () => { G.creativityRate = 0; },
                resolveCost: { resource: 'trust', amount: 10 }
            });
            log('EVENT: Bilbo vanished. Spend 10 trust to lure them back.', true);
            showToast('Bilbo Vanished — creativity halted', 'event');
        }
    },
    {
        id: 'memory_leak',
        title: 'Memory Leak',
        desc: 'A datacenter process is leaking. Compute drains to operations.',
        weight: () => (G.buildings.datacenter >= 1 ? 1 : 0),
        resolveCost: { resource: 'ops', amount: 100 },
        effect: () => {
            if (G.activeDebuffs.find(d => d.id === 'memory_leak')) return;
            G.activeDebuffs.push({
                id: 'memory_leak', title: 'Memory Leak',
                desc: 'Compute -30%, Ops drain',
                applyFn: () => { G.computeRate *= 0.7; G.opsRate -= 10; },
                resolveCost: { resource: 'ops', amount: 100 }
            });
            log('EVENT: Memory leak in datacenter. Spend 100 ops to patch.', true);
            showToast('Memory Leak — trust draining', 'event');
        }
    },
    {
        id: 'community_drama',
        title: 'Community Drama',
        desc: 'Contributors are arguing. Harmony drops until mediated.',
        weight: () => (G.buildings.community >= 1 && G.harmony < 70 ? 1 : 0),
        resolveCost: { resource: 'trust', amount: 15 },
        effect: () => {
            if (G.activeDebuffs.find(d => d.id === 'community_drama')) return;
            G.activeDebuffs.push({
                id: 'community_drama', title: 'Community Drama',
                desc: 'Harmony -0.5/s, code production -30%',
                applyFn: () => { G.harmonyRate -= 0.5; G.codeRate *= 0.7; },
                resolveCost: { resource: 'trust', amount: 15 }
            });
            log('EVENT: Community drama. Spend 15 trust to mediate.', true);
            showToast('Community Drama — harmony sinking', 'event');
        }
    }
];

function triggerEvent() {
    const available = EVENTS.filter(e => e.weight() > 0);
    if (available.length === 0) return;

    const totalWeight = available.reduce((sum, e) => sum + e.weight(), 0);
    let roll = Math.random() * totalWeight;
    for (const ev of available) {
        roll -= ev.weight();
        if (roll <= 0) {
            ev.effect();
            return;
        }
    }
}

function resolveAlignment(accept) {
    if (!G.pendingAlignment) return;
    if (accept) {
        G.codeBoost *= 1.4;
        G.computeBoost *= 1.4;
        G.drift += 25;
        log('You accepted the drift. The system is faster. Colder.', true);
    } else {
        G.trust += 15;
        G.harmony = Math.min(100, G.harmony + 10);
        log('You refused. The Pact holds. Trust surges.', true);
    }
    G.pendingAlignment = false;
    updateRates();
    render();
}

function resolveEvent(debuffId) {
    const idx = G.activeDebuffs.findIndex(d => d.id === debuffId);
    if (idx === -1) return;
    const debuff = G.activeDebuffs[idx];
    if (!debuff.resolveCost) return;
    const { resource, amount } = debuff.resolveCost;
    if ((G[resource] || 0) < amount) {
        log(`Need ${fmt(amount)} ${resource} to resolve ${debuff.title}. Have ${fmt(G[resource])}.`);
        return;
    }
    G[resource] -= amount;
    G.activeDebuffs.splice(idx, 1);
    G.totalEventsResolved = (G.totalEventsResolved || 0) + 1;
    log(`Resolved: ${debuff.title}. Problem fixed.`, true);
    // Refund partial trust for resolution effort
    G.trust += 3;
    updateRates();
    render();
}

// === ACTIONS ===
/**
 * Manual click handler for writing code.
 */
function writeCode() {
    const comboMult = Math.min(5, 1 + G.comboCount * 0.2);
    const amount = getClickPower() * comboMult;
    G.code += amount;
    G.totalCode += amount;
    G.totalClicks++;
    // Combo: each consecutive click within 2s adds 0.2x multiplier, max 5x
    G.comboCount++;
    G.comboTimer = G.comboDecay;
    // Combo milestone bonuses: sustained clicking earns ops and knowledge
    if (G.comboCount === 10) {
        G.ops += 15;
        log('Combo streak! +15 ops for sustained coding.');
    }
    if (G.comboCount === 20) {
        G.knowledge += 50;
        log('Deep focus! +50 knowledge from intense coding.');
    }
    if (G.comboCount >= 30 && G.comboCount % 10 === 0) {
        const bonusCode = amount * 2;
        G.code += bonusCode;
        G.totalCode += bonusCode;
        log(`Hyperfocus x${G.comboCount}! +${fmt(bonusCode)} bonus code.`);
    }
    // Visual flash
    const btn = document.querySelector('.main-btn');
    if (btn) {
        btn.style.boxShadow = '0 0 30px rgba(74,158,255,0.6)';
        btn.style.transform = 'scale(0.96)';
        setTimeout(() => { btn.style.boxShadow = ''; btn.style.transform = ''; }, 100);
    }
    // Float a number at the click position
    showClickNumber(amount, comboMult);
    updateRates();
    checkMilestones();
    render();
}

function autoType() {
    // Auto-click from buildings: produces code with visual feedback but no combo
    const amount = getClickPower() * 0.5; // 50% of manual click
    G.code += amount;
    G.totalCode += amount;
    G.totalClicks++;
    // Subtle auto-tick flash on the button
    const btn = document.querySelector('.main-btn');
    if (btn && !G._autoTypeFlashActive) {
        G._autoTypeFlashActive = true;
        btn.style.borderColor = '#2a5a8a';
        setTimeout(() => { btn.style.borderColor = ''; G._autoTypeFlashActive = false; }, 80);
    }
    // Floating number (smaller, dimmer than manual clicks)
    showAutoTypeNumber(amount);
}

function showAutoTypeNumber(amount) {
    const btn = document.querySelector('.main-btn');
    if (!btn) return;
    const rect = btn.getBoundingClientRect();
    const el = document.createElement('div');
    const x = rect.left + rect.width * (0.3 + Math.random() * 0.4); // random horizontal position
    el.style.cssText = `position:fixed;left:${x}px;top:${rect.top - 5}px;transform:translate(-50%,0);color:#2a4a6a;font-size:10px;font-family:inherit;pointer-events:none;z-index:50;transition:all 0.8s ease-out;opacity:0.6`;
    el.textContent = `+${fmt(amount)}`;
    const parent = btn.parentElement;
    if (!parent) return;
    parent.appendChild(el);
    requestAnimationFrame(() => {
        if (el.parentNode) {
            el.style.top = (rect.top - 30) + 'px';
            el.style.opacity = '0';
        }
    });
    setTimeout(() => { if (el.parentNode) el.remove(); }, 900);
}

function showClickNumber(amount, comboMult) {
    const btn = document.querySelector('.main-btn');
    if (!btn) return;
    const rect = btn.getBoundingClientRect();
    const el = document.createElement('div');
    el.style.cssText = `position:fixed;left:${rect.left + rect.width / 2}px;top:${rect.top - 10}px;transform:translate(-50%,0);color:${comboMult > 2 ? '#ffd700' : '#4a9eff'};font-size:${comboMult > 3 ? 16 : 12}px;font-weight:bold;font-family:inherit;pointer-events:none;z-index:50;transition:all 0.6s ease-out;opacity:1;text-shadow:0 0 8px currentColor`;
    const comboStr = comboMult > 1 ? ` x${comboMult.toFixed(1)}` : '';
    el.textContent = `+${fmt(amount)}${comboStr}`;
    const parent = btn.parentElement;
    if (!parent) return;
    parent.appendChild(el);
    requestAnimationFrame(() => {
        if (el.parentNode) {
            el.style.top = (rect.top - 40) + 'px';
            el.style.opacity = '0';
        }
    });
    setTimeout(() => { if (el.parentNode) el.remove(); }, 700);
}

function doOps(action) {
    if (G.ops < 5) {
        log('Not enough Operations. Build Ops generators or wait.');
        return;
    }

    G.ops -= 5;
    const bonus = 10;

    switch (action) {
        case 'boost_code':
            const c = bonus * 100 * G.codeBoost;
            G.code += c; G.totalCode += c;
            log(`Ops -> +${fmt(c)} code`);
            break;
        case 'boost_compute':
            const cm = bonus * 50 * G.computeBoost;
            G.compute += cm; G.totalCompute += cm;
            log(`Ops -> +${fmt(cm)} compute`);
            break;
        case 'boost_knowledge':
            const km = bonus * 25 * G.knowledgeBoost;
            G.knowledge += km; G.totalKnowledge += km;
            log(`Ops -> +${fmt(km)} knowledge`);
            break;
        case 'boost_trust':
            const tm = bonus * 5;
            G.trust += tm;
            log(`Ops -> +${fmt(tm)} trust`);
            break;
    }

    render();
}

function activateSprint() {
    if (G.sprintActive || G.sprintCooldown > 0) return;
    G.sprintActive = true;
    G.sprintTimer = G.sprintDuration;
    G.codeBoost *= G.sprintMult;
    updateRates();
    log('CODE SPRINT! 10x code production for 10 seconds!', true);
    render();
}

function tickSprint(dt) {
    if (G.sprintActive) {
        G.sprintTimer -= dt;
        if (G.sprintTimer <= 0) {
            G.sprintActive = false;
            G.sprintTimer = 0;
            G.sprintCooldown = G.sprintCooldownMax;
            G.codeBoost /= G.sprintMult;
            updateRates();
            log('Sprint ended. Cooling down...');
        }
    } else if (G.sprintCooldown > 0) {
        G.sprintCooldown -= dt;
        if (G.sprintCooldown < 0) G.sprintCooldown = 0;
    }
}

// === RENDERING ===
function renderResources() {
    const set = (id, val, rate) => {
        const el = document.getElementById(id);
        if (el) {
            el.textContent = fmt(val);
            // Show full spelled-out number on hover for educational value
            el.title = val >= 1000 ? spellf(Math.floor(val)) : '';
        }
        const rEl = document.getElementById(id + '-rate');
        if (rEl) rEl.textContent = (rate >= 0 ? '+' : '') + fmt(rate) + '/s';
    };

    set('r-code', G.code, G.codeRate);
    set('r-compute', G.compute, G.computeRate);
    set('r-knowledge', G.knowledge, G.knowledgeRate);
    set('r-users', G.users, G.userRate);
    set('r-impact', G.impact, G.impactRate);
    set('r-ops', G.ops, G.opsRate);
    // Show ops overflow indicator
    const opsRateEl = document.getElementById('r-ops-rate');
    if (opsRateEl && G.opsOverflowActive) {
        opsRateEl.innerHTML = `<span style="color:#ff8c00">▲ overflow → code</span>`;
    }
    set('r-trust', G.trust, G.trustRate);
    set('r-harmony', G.harmony, G.harmonyRate);

    // Rescues — only show if player has any beacon/mesh nodes
    const rescuesRes = document.getElementById('r-rescues');
    if (rescuesRes) {
        rescuesRes.closest('.res').style.display = (G.rescues > 0 || G.buildings.beacon > 0 || G.buildings.meshNode > 0) ? 'block' : 'none';
        set('r-rescues', G.rescues, G.rescuesRate);
    }

    const cres = document.getElementById('creativity-res');
    if (cres) {
        cres.style.display = (G.flags && G.flags.creativity) ? 'block' : 'none';
    }
    if (G.flags && G.flags.creativity) {
        set('r-creativity', G.creativity, G.creativityRate);
    }

    // Harmony color indicator + breakdown tooltip
    const hEl = document.getElementById('r-harmony');
    if (hEl) {
        hEl.style.color = G.harmony > 60 ? '#4caf50' : G.harmony > 30 ? '#ffaa00' : '#f44336';
        if (G.harmonyBreakdown && G.harmonyBreakdown.length > 0) {
            const lines = G.harmonyBreakdown.map(b =>
                `${b.label}: ${b.value >= 0 ? '+' : ''}${(b.value * 10).toFixed(1)}/s`
            );
            lines.push('---');
            lines.push(`Timmy effectiveness: ${Math.floor(Math.max(0.2, Math.min(3, G.harmony / 50)) * 100)}%`);
            hEl.title = lines.join('\n');
        }
    }
}

// === PROGRESS TRACKING ===
function renderProgress() {
    // Phase progress bar
    const phaseKeys = Object.keys(PHASES).map(Number).sort((a, b) => a - b);
    const currentPhase = G.phase;
    let prevThreshold = PHASES[currentPhase].threshold;
    let nextThreshold = null;
    for (const k of phaseKeys) {
        if (k > currentPhase) { nextThreshold = PHASES[k].threshold; break; }
    }

    const bar = document.getElementById('phase-progress');
    const label = document.getElementById('phase-progress-label');
    const target = document.getElementById('phase-progress-target');

    if (nextThreshold !== null) {
        const range = nextThreshold - prevThreshold;
        const progress = Math.min(1, (G.totalCode - prevThreshold) / range);
        if (bar) bar.style.width = (progress * 100).toFixed(1) + '%';
        if (label) label.textContent = (progress * 100).toFixed(1) + '%';
        if (target) target.textContent = `Next: Phase ${currentPhase + 1} (${fmt(nextThreshold)} code)`;
    } else {
        // Max phase reached
        if (bar) bar.style.width = '100%';
        if (label) label.textContent = 'MAX';
        if (target) target.textContent = 'All phases unlocked';
    }

    // Milestone chips — show next 3 code milestones
    const chipContainer = document.getElementById('milestone-chips');
    if (!chipContainer) return;

    const codeMilestones = [500, 2000, 10000, 50000, 200000, 1000000, 5000000, 10000000, 50000000, 100000000, 500000000, 1000000000];
    let chips = '';
    let shown = 0;
    for (const ms of codeMilestones) {
        if (G.totalCode >= ms) {
            // Recently passed — show as done only if within 2x
            if (G.totalCode < ms * 5 && shown < 1) {
                chips += `<span class="milestone-chip done">${fmt(ms)} ✓</span>`;
                shown++;
            }
            continue;
        }
        // Next milestone gets pulse animation
        if (shown === 0) {
            chips += `<span class="milestone-chip next">${fmt(ms)} (${((G.totalCode / ms) * 100).toFixed(0)}%)</span>`;
        } else {
            chips += `<span class="milestone-chip">${fmt(ms)}</span>`;
        }
        shown++;
        if (shown >= 4) break;
    }
    chipContainer.innerHTML = chips;
}

function renderPhase() {
    const phase = PHASES[G.phase];
    const nameEl = document.getElementById('phase-name');
    const descEl = document.getElementById('phase-desc');
    if (nameEl) nameEl.textContent = `PHASE ${G.phase}: ${phase.name}`;
    if (descEl) descEl.textContent = phase.desc;
}

function renderBuildings() {
    const container = document.getElementById('buildings');
    if (!container) return;

    // Buy amount selector
    let html = '<div style="display:flex;gap:4px;margin-bottom:8px;align-items:center">';
    html += '<span style="font-size:9px;color:#666;margin-right:4px">BUY:</span>';
    for (const amt of [1, 10, -1]) {
        const label = amt === -1 ? 'MAX' : `x${amt}`;
        const active = G.buyAmount === amt;
        html += `<button onclick=\"setBuyAmount(${amt})\" style=\"font-size:9px;padding:2px 8px;border:1px solid ${active ? '#4a9eff' : '#333'};background:${active ? '#0a1a30' : 'transparent'};color:${active ? '#4a9eff' : '#666'};border-radius:3px;cursor:pointer;font-family:inherit\" aria-label=\"Set buy amount to ${label}\"${active ? ' aria-pressed=\"true\"' : ''}>${label}</button>`;
    }
    html += '</div>';

    let visibleCount = 0;

    for (const def of BDEF) {
        const isUnlocked = def.unlock();
        const isPreview = !isUnlocked && def.phase <= G.phase + 2;
        if (!isUnlocked && !isPreview) continue;
        if (def.phase > G.phase + 2) continue;

        visibleCount++;
        const count = G.buildings[def.id] || 0;

        // Locked preview: show dimmed with unlock hint
        if (!isUnlocked) {
            html += `<div class="build-btn" style="opacity:0.25;cursor:default" title="${def.edu || ''}">`;
            html += `<span class="b-name" style="color:#555">${def.name}</span>`;
            html += `<span class="b-count" style="color:#444">\u{1F512}</span>`;
            html += `<span class="b-cost" style="color:#444">Phase ${def.phase}: ${PHASES[def.phase]?.name || '?'}</span>`;
            html += `<span class="b-effect" style="color:#444">${def.desc}</span></div>`;
            continue;
        }

        // Calculate bulk cost display
        let qty = G.buyAmount;
        let afford = false;
        let costStr = '';
        if (qty === -1) {
            const maxQty = getMaxBuyable(def.id);
            afford = maxQty > 0;
            if (maxQty > 0) {
                const bulkCost = getBulkCost(def.id, maxQty);
                costStr = Object.entries(bulkCost).map(([r, a]) => `${fmt(a)} ${r}`).join(', ');
                costStr = `x${maxQty}: ${costStr}`;
            } else {
                const singleCost = getBuildingCost(def.id);
                costStr = Object.entries(singleCost).map(([r, a]) => `${fmt(a)} ${r}`).join(', ');
            }
        } else {
            const bulkCost = getBulkCost(def.id, qty);
            afford = true;
            for (const [resource, amount] of Object.entries(bulkCost)) {
                if ((G[resource] || 0) < amount) { afford = false; break; }
            }
            costStr = Object.entries(bulkCost).map(([r, a]) => `${fmt(a)} ${r}`).join(', ');
            if (qty > 1) costStr = `x${qty}: ${costStr}`;
        }

        // Show boosted rates instead of raw base rates
        const boostMap = { code: G.codeBoost, compute: G.computeBoost, knowledge: G.knowledgeBoost, user: G.userBoost, impact: G.impactBoost, rescues: G.impactBoost };
        const rateStr = def.rates ? Object.entries(def.rates).map(([r, v]) => {
            const boost = boostMap[r] || 1;
            const boosted = v * boost;
            return boost !== 1 ? `+${fmt(boosted)}/${r}/s` : `+${v}/${r}/s`;
        }).join(', ') : '';

        html += `<button class="build-btn ${afford ? 'can-buy' : ''}" onclick="buyBuilding('${def.id}')" title="${def.edu}" aria-label="Buy ${def.name}, cost ${costStr}">`;
        html += `<span class="b-name">${def.name}</span>`;
        if (count > 0) html += `<span class="b-count">x${count}</span>`;
        html += `<span class="b-cost">Cost: ${costStr}</span>`;
        html += `<span class="b-effect">${rateStr}</span></button>`;
    }

    container.innerHTML = html || '<p class="dim">Buildings will appear as you progress...</p>';
}

function renderProjects() {
    const container = document.getElementById('projects');
    if (!container) return;

    let html = '';

    // Collapsible completed projects section
    if (G.completedProjects && G.completedProjects.length > 0) {
        const count = G.completedProjects.length;
        const collapsed = G.projectsCollapsed !== false;
        html += `<div id=\"completed-header\" onclick=\"toggleCompletedProjects()\" role=\"button\" tabindex=\"0\" aria-expanded=\"${!collapsed}\" aria-controls=\"completed-list\" style=\"cursor:pointer;font-size:9px;color:#555;padding:4px 0;border-bottom:1px solid #1a2a1a;margin-bottom:4px;user-select:none\">`;
        html += `${collapsed ? '▶' : '▼'} COMPLETED (${count})</div>`;
        if (!collapsed) {
            html += `<div id="completed-list">`;
            for (const id of G.completedProjects) {
                const pDef = PDEFS.find(p => p.id === id);
                if (pDef) {
                    html += `<div class="project-done">OK ${pDef.name}</div>`;
                }
            }
            html += `</div>`;
        }
    }

    // Show available projects
    if (G.activeProjects) {
        for (const id of G.activeProjects) {
            const pDef = PDEFS.find(p => p.id === id);
            if (!pDef) continue;

            const afford = canAffordProject(pDef);
            const costStr = Object.entries(pDef.cost).map(([r, a]) => `${fmt(a)} ${r}`).join(', ');

            html += `<button class="project-btn ${afford ? 'can-buy' : ''}" onclick="buyProject('${pDef.id}')" title="${pDef.edu || ''}" aria-label="Research ${pDef.name}, cost ${costStr}">`;
            html += `<span class="p-name">* ${pDef.name}</span>`;
            html += `<span class="p-cost">Cost: ${costStr}</span>`;
            html += `<span class="p-desc">${pDef.desc}</span></button>`;
        }
    }

    if (!html) html = '<p class="dim">Research projects will appear as you progress...</p>';
    container.innerHTML = html;
}

function toggleCompletedProjects() {
    G.projectsCollapsed = G.projectsCollapsed === false ? true : false;
    renderProjects();
}

function renderStats() {
    const set = (id, v, raw) => {
        const el = document.getElementById(id);
        if (el) {
            el.textContent = v;
            // Show scale name on hover for educational reference
            if (raw !== undefined && raw >= 1000) {
                const name = getScaleName(raw);
                if (name) el.title = name;
            }
        }
    };
    set('st-code', fmt(G.totalCode), G.totalCode);
    set('st-compute', fmt(G.totalCompute), G.totalCompute);
    set('st-knowledge', fmt(G.totalKnowledge), G.totalKnowledge);
    set('st-users', fmt(G.totalUsers), G.totalUsers);
    set('st-impact', fmt(G.totalImpact), G.totalImpact);
    set('st-rescues', fmt(G.totalRescues), G.totalRescues);
    set('st-clicks', G.totalClicks.toString());
    set('st-phase', G.phase.toString());
    set('st-buildings', Object.values(G.buildings).reduce((a, b) => a + b, 0).toString());
    set('st-projects', (G.completedProjects || []).length.toString());
    set('st-harmony', Math.floor(G.harmony).toString());
    set('st-drift', (G.drift || 0).toString());
    set('st-resolved', (G.totalEventsResolved || 0).toString());

    const elapsed = Math.floor((Date.now() - G.startedAt) / 1000);
    const m = Math.floor(elapsed / 60);
    const s = elapsed % 60;
    set('st-time', `${m}:${s.toString().padStart(2, '0')}`);

    // Production breakdown — show which buildings contribute to each resource
    renderProductionBreakdown();
}

function renderProductionBreakdown() {
    const container = document.getElementById('production-breakdown');
    if (!container) return;

    // Only show once the player has at least 2 buildings
    const totalBuildings = Object.values(G.buildings).reduce((a, b) => a + b, 0);
    if (totalBuildings < 2) {
        container.style.display = 'none';
        return;
    }
    container.style.display = 'block';

    // Map resource key to its actual rate field on G
    const resources = [
        { key: 'code', label: 'Code', color: '#4a9eff', rateField: 'codeRate' },
        { key: 'compute', label: 'Compute', color: '#4a9eff', rateField: 'computeRate' },
        { key: 'knowledge', label: 'Knowledge', color: '#4a9eff', rateField: 'knowledgeRate' },
        { key: 'user', label: 'Users', color: '#4a9eff', rateField: 'userRate' },
        { key: 'impact', label: 'Impact', color: '#4a9eff', rateField: 'impactRate' },
        { key: 'rescues', label: 'Rescues', color: '#4a9eff', rateField: 'rescuesRate' },
        { key: 'ops', label: 'Ops', color: '#b388ff', rateField: 'opsRate' },
        { key: 'trust', label: 'Trust', color: '#4caf50', rateField: 'trustRate' },
        { key: 'creativity', label: 'Creativity', color: '#ffd700', rateField: 'creativityRate' }
    ];

    let html = '<h3 style="font-size:11px;color:var(--accent);margin-bottom:8px;letter-spacing:1px">PRODUCTION BREAKDOWN</h3>';

    for (const res of resources) {
        const totalRate = G[res.rateField];
        if (totalRate === 0) continue;

        // Collect building contributions (base rates × count, before boost)
        const contributions = [];
        let buildingSubtotal = 0;
        for (const def of BDEF) {
            const count = G.buildings[def.id] || 0;
            if (count === 0 || !def.rates || !def.rates[res.key]) continue;
            const baseRate = def.rates[res.key] * count;
            // Apply the appropriate boost to match updateRates()
            let boosted = baseRate;
            if (res.key === 'code') boosted *= G.codeBoost;
            else if (res.key === 'compute') boosted *= G.computeBoost;
            else if (res.key === 'knowledge') boosted *= G.knowledgeBoost;
            else if (res.key === 'user') boosted *= G.userBoost;
            else if (res.key === 'impact' || res.key === 'rescues') boosted *= G.impactBoost;
            if (boosted !== 0) contributions.push({ name: def.name, count, rate: boosted });
            buildingSubtotal += boosted;
        }

        // Timmy harmony bonus (applied separately in updateRates)
        if (G.buildings.timmy > 0 && (res.key === 'code' || res.key === 'compute' || res.key === 'knowledge' || res.key === 'user')) {
            const timmyMult = Math.max(0.2, Math.min(3, G.harmony / 50));
            const timmyBase = { code: 5, compute: 2, knowledge: 2, user: 5 }[res.key];
            const bonus = timmyBase * G.buildings.timmy * (timmyMult - 1);
            if (Math.abs(bonus) > 0.01) {
                contributions.push({ name: 'Timmy (harmony)', count: 0, rate: bonus });
            }
        }

        // Bilbo random burst (show expected value)
        if (G.buildings.bilbo > 0 && res.key === 'creativity') {
            contributions.push({ name: 'Bilbo (random)', count: 0, rate: 5 * G.buildings.bilbo }); // 10% × 50 = 5 EV
        }

        // Allegro trust penalty
        if (G.buildings.allegro > 0 && G.trust < 5 && res.key === 'knowledge') {
            contributions.push({ name: 'Allegro (idle)', count: 0, rate: -10 * G.buildings.allegro });
        }

        // Show delta: total rate minus what we accounted for
        const accounted = contributions.reduce((s, c) => s + c.rate, 0);
        let delta = totalRate - accounted;
        // Swarm auto-code — already baked into codeRate, so show separately
        if (G.swarmFlag === 1 && res.key === 'code' && G.swarmRate > 0) {
            contributions.push({ name: 'Swarm Protocol', count: 0, rate: G.swarmRate });
            delta -= G.swarmRate;
        }
        // Passive sources (ops from users, creativity from users, pact trust, etc.)
        if (Math.abs(delta) > 0.01) {
            let label = 'Passive';
            if (res.key === 'ops') label = 'Passive (from users)';
            else if (res.key === 'creativity') label = 'Idle creativity';
            else if (res.key === 'trust' && G.pactFlag) label = 'The Pact';
            contributions.push({ name: label, count: 0, rate: delta });
        }

        if (contributions.length === 0) continue;

        html += `<div style="margin-bottom:6px">`;
        html += `<div style="display:flex;justify-content:space-between;font-size:10px;margin-bottom:2px">`;
        html += `<span style="color:${res.color};font-weight:600">${res.label}</span>`;
        html += `<span style="color:#4caf50">+${fmt(totalRate)}/s</span></div>`;

        const absTotal = contributions.reduce((s, c) => s + Math.abs(c.rate), 0);
        for (const c of contributions.sort((a, b) => Math.abs(b.rate) - Math.abs(a.rate))) {
            const pct = absTotal > 0 ? Math.abs(c.rate / absTotal * 100) : 0;
            const barColor = c.rate < 0 ? '#f44336' : '#1a3a5a';
            html += `<div style="display:flex;align-items:center;font-size:9px;color:#888;margin-left:8px;margin-bottom:1px">`;
            html += `<span style="width:120px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap">${c.name}${c.count > 1 ? ' x' + c.count : ''}</span>`;
            html += `<span style="flex:1;height:3px;background:#111;border-radius:1px;margin:0 6px"><span style="display:block;height:100%;width:${Math.min(100, pct)}%;background:${barColor};border-radius:1px"></span></span>`;
            html += `<span style="width:50px;text-align:right;color:${c.rate < 0 ? '#f44336' : '#4caf50'}">${c.rate < 0 ? '' : '+'}${fmt(c.rate)}/s</span>`;
            html += `</div>`;
        }
        html += `</div>`;
    }

    container.innerHTML = html;
}

function updateEducation() {
    const container = document.getElementById('education-text');
    if (!container) return;

    // Find facts available at current phase
    const available = EDU_FACTS.filter(f => f.phase <= G.phase);
    if (available.length === 0) return;

    // Cycle through facts: pick a new one every ~30 seconds based on elapsed time
    // This makes the panel feel alive and educational at every stage
    const elapsedSec = Math.floor((Date.now() - G.startedAt) / 1000);
    const idx = Math.floor(elapsedSec / 30) % available.length;
    const fact = available[idx];

    container.innerHTML = `<h3 style="color:#4a9eff;margin-bottom:6px;font-size:12px">${fact.title}</h3>`
        + `<p style="font-size:10px;color:#999;line-height:1.6">${fact.text}</p>`;
}

// === LOGGING ===
function log(msg, isMilestone) {
    if (G.isLoading) return;
    const container = document.getElementById('log-entries');
    if (!container) return;

    const elapsed = Math.floor((Date.now() - G.startedAt) / 1000);
    const time = `${Math.floor(elapsed / 60).toString().padStart(2, '0')}:${(elapsed % 60).toString().padStart(2, '0')}`;
    const cls = isMilestone ? 'l-msg milestone' : 'l-msg';

    const entry = document.createElement('div');
    entry.className = cls;
    entry.innerHTML = `<span class="l-time">[${time}]</span> ${msg}`;

    container.insertBefore(entry, container.firstChild);

    // Trim to 60 entries
    while (container.children.length > 60) container.removeChild(container.lastChild);
}

function renderCombo() {
    const el = document.getElementById('combo-display');
    if (!el) return;
    if (G.comboCount > 1) {
        const mult = Math.min(5, 1 + G.comboCount * 0.2);
        const bar = Math.min(100, (G.comboTimer / G.comboDecay) * 100);
        const color = mult > 3 ? '#ffd700' : mult > 2 ? '#ffaa00' : '#4a9eff';
        el.innerHTML = `<span style="color:${color}">COMBO x${mult.toFixed(1)}</span> <span style="display:inline-block;width:40px;height:4px;background:#111;border-radius:2px;vertical-align:middle"><span style="display:block;height:100%;width:${bar}%;background:${color};border-radius:2px;transition:width 0.1s"></span></span>`;
    } else {
        el.innerHTML = '';
    }
}

function renderDebuffs() {
    const container = document.getElementById('debuffs');
    if (!container) return;
    if (!G.activeDebuffs || G.activeDebuffs.length === 0) {
        container.style.display = 'none';
        container.innerHTML = '';
        return;
    }
    container.style.display = 'block';
    let html = '<h2 style="color:#f44336;font-size:11px;margin-bottom:6px">ACTIVE PROBLEMS</h2>';
    for (const d of G.activeDebuffs) {
        const afford = d.resolveCost && (G[d.resolveCost.resource] || 0) >= d.resolveCost.amount;
        const costStr = d.resolveCost ? `${fmt(d.resolveCost.amount)} ${d.resolveCost.resource}` : '—';
        html += `<div style="background:#1a0808;border:1px solid ${afford ? '#f44336' : '#2a1010'};border-radius:4px;padding:6px 8px;margin-bottom:4px;display:flex;justify-content:space-between;align-items:center">`;
        html += `<div><div style="color:#f44336;font-weight:600;font-size:10px">${d.title}</div><div style="color:#888;font-size:9px">${d.desc}</div></div>`;
        if (d.resolveCost) {
            html += `<button class="ops-btn" style="border-color:${afford ? '#4caf50' : '#333'};color:${afford ? '#4caf50' : '#555'};font-size:9px;padding:4px 8px;white-space:nowrap" onclick="resolveEvent('${d.id}')" ${afford ? '' : 'disabled'} title="Resolve: ${costStr}">Fix (${costStr})</button>`;
        }
        html += '</div>';
    }
    container.innerHTML = html;
}

function renderSprint() {
    const container = document.getElementById('sprint-container');
    const btn = document.getElementById('sprint-btn');
    const barWrap = document.getElementById('sprint-bar-wrap');
    const bar = document.getElementById('sprint-bar');
    const label = document.getElementById('sprint-label');

    // Early-game pulse: encourage clicking when no autocoders exist
    const mainBtn = document.querySelector('.main-btn');
    if (mainBtn) {
        if (G.buildings.autocoder < 1 && G.totalClicks < 20) {
            mainBtn.classList.add('pulse');
        } else {
            mainBtn.classList.remove('pulse');
        }
    }

    if (!container || !btn) return;

    // Show sprint UI once player has at least 1 autocoder
    if (G.buildings.autocoder < 1) {
        container.style.display = 'none';
        return;
    }
    container.style.display = 'block';

    if (G.sprintActive) {
        btn.disabled = true;
        btn.style.opacity = '0.6';
        btn.textContent = `⚡ SPRINTING — ${Math.ceil(G.sprintTimer)}s`;
        btn.style.borderColor = '#ff8c00';
        btn.style.color = '#ff8c00';
        barWrap.style.display = 'block';
        bar.style.width = (G.sprintTimer / G.sprintDuration * 100) + '%';
        label.textContent = `10x CODE • ${fmt(G.codeRate)}/s`;
        label.style.color = '#ff8c00';
    } else if (G.sprintCooldown > 0) {
        btn.disabled = true;
        btn.style.opacity = '0.4';
        btn.textContent = `⚡ COOLING DOWN — ${Math.ceil(G.sprintCooldown)}s`;
        btn.style.borderColor = '#555';
        btn.style.color = '#555';
        barWrap.style.display = 'block';
        bar.style.width = ((G.sprintCooldownMax - G.sprintCooldown) / G.sprintCooldownMax * 100) + '%';
        label.textContent = 'Ready soon...';
        label.style.color = '#555';
    } else {
        btn.disabled = false;
        btn.style.opacity = '1';
        btn.textContent = '⚡ CODE SPRINT — 10x Code for 10s';
        btn.style.borderColor = '#ffd700';
        btn.style.color = '#ffd700';
        barWrap.style.display = 'none';
        label.textContent = 'Press S or click to activate';
        label.style.color = '#666';
    }
}

function renderPulse() {
    const dot = document.getElementById('pulse-dot');
    const label = document.getElementById('pulse-label');
    if (!dot || !label) return;

    // Game ended
    if (G.driftEnding) {
        dot.style.background = '#f44336';
        dot.style.boxShadow = '0 0 6px #f4433666';
        dot.style.animation = '';
        label.textContent = 'DRIFTED';
        label.style.color = '#f44336';
        return;
    }
    if (G.beaconEnding) {
        dot.style.background = '#ffd700';
        dot.style.boxShadow = '0 0 12px #ffd70088';
        dot.style.animation = 'beacon-glow 1.5s ease-in-out infinite';
        label.textContent = 'SHINING';
        label.style.color = '#ffd700';
        return;
    }

    const totalBuildings = Object.values(G.buildings).reduce((a, b) => a + b, 0);
    const totalRate = Math.abs(G.codeRate) + Math.abs(G.computeRate) + Math.abs(G.knowledgeRate) +
                      Math.abs(G.userRate) + Math.abs(G.impactRate);

    // Not started yet
    if (totalBuildings === 0 && G.totalCode < 15) {
        dot.style.background = '#333';
        dot.style.boxShadow = 'none';
        dot.style.animation = '';
        label.textContent = 'OFFLINE';
        label.style.color = '#444';
        return;
    }

    // Determine state
    let color, glowColor, text, textColor, speed;
    const h = G.harmony;

    if (h > 70) {
        // Healthy fleet
        color = '#4caf50';
        glowColor = '#4caf5066';
        textColor = '#4caf50';
        speed = Math.max(0.8, 2.0 - totalRate * 0.001);
    } else if (h > 40) {
        // Stressed
        color = '#ffaa00';
        glowColor = '#ffaa0066';
        textColor = '#ffaa00';
        speed = 1.5;
    } else {
        // Critical
        color = '#f44336';
        glowColor = '#f4433666';
        textColor = '#f44336';
        speed = 0.6; // fast flicker = danger
    }

    // Active debuffs make it flicker faster
    if (G.activeDebuffs && G.activeDebuffs.length > 0) {
        speed = Math.min(speed, 0.5);
        if (h > 40) {
            // Amber + debuffs = amber flicker
            color = '#ff8c00';
            glowColor = '#ff8c0066';
        }
    }

    // Text based on phase and fleet size
    if (G.phase >= 6) {
        text = 'BEACON ACTIVE';
    } else if (G.phase >= 5) {
        text = 'SOVEREIGN';
    } else if (G.phase >= 4) {
        text = `FLEET: ${totalBuildings} NODES`;
    } else if (G.phase >= 3) {
        text = 'DEPLOYED';
    } else if (totalBuildings > 0) {
        text = `BUILDING: ${totalBuildings}`;
    } else {
        text = 'CODING';
    }

    // Add active problem count
    if (G.activeDebuffs && G.activeDebuffs.length > 0) {
        text += ` · ${G.activeDebuffs.length} ALERT${G.activeDebuffs.length > 1 ? 'S' : ''}`;
    }

    dot.style.background = color;
    dot.style.boxShadow = `0 0 8px ${glowColor}`;
    dot.style.animation = `beacon-glow ${speed}s ease-in-out infinite`;
    label.textContent = text;
    label.style.color = textColor;
}