clibuddy 1.0.0

package/dist/adventure/combat.js

@@ -0,0 +1,732 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveCombatStats = deriveCombatStats;
+exports.deriveEnemyStats = deriveEnemyStats;
+exports.startCombat = startCombat;
+exports.playerAttack = playerAttack;
+exports.playerDefend = playerDefend;
+exports.playerFlee = playerFlee;
+exports.playerUseSkill = playerUseSkill;
+exports.enemyTurn = enemyTurn;
+exports.processConditions = processConditions;
+exports.applyShield = applyShield;
+exports.hasCondition = hasCondition;
+exports.addCondition = addCondition;
+exports.getConditionStatMod = getConditionStatMod;
+exports.tickCombat = tickCombat;
+const species_1 = require("../buddy/species");
+const items_1 = require("../inventory/items");
+const types_1 = require("./types");
+const lines_1 = require("../dialogue/lines");
+// ─── Species Dodge Chances ───────────────────────────────────
+const SPECIES_DODGE = {
+    cat: 0.20,
+    fox: 0.15,
+    rabbit: 0.10,
+    owl: 0.08,
+    frog: 0.05,
+    phoenix: 0.05,
+    dragon: 0.03,
+};
+function pickCombatLine(pool, speciesId) {
+    const lines = pool[speciesId];
+    if (!lines || lines.length === 0)
+        return "";
+    return lines[Math.floor(Math.random() * lines.length)];
+}
+const COMBOS = [
+    { skill1: "focus", skill2: "pounce", name: "Focused Pounce", damageMultiplier: 2.5 },
+    { skill1: "focus", skill2: "fire_breath", name: "Focused Breath", damageMultiplier: 2.8, extraEffect: "burn" },
+    { skill1: "shadow_step", skill2: "pounce", name: "Shadow Ambush", damageMultiplier: 3.0 },
+    { skill1: "scale_shield", skill2: "fire_breath", name: "Dragon Fury", damageMultiplier: 2.5, extraEffect: "burn" },
+    { skill1: "keen_eye", skill2: "piercing_gaze", name: "Owl Strike", damageMultiplier: 3.0 },
+    { skill1: "quick_hop", skill2: "earthquake", name: "Nature's Wrath", damageMultiplier: 2.0, extraEffect: "stun" },
+    { skill1: "focus", skill2: "flame_burst", name: "Focused Flame", damageMultiplier: 2.4, extraEffect: "burn" },
+];
+function checkCombo(lastSkill, currentSkill) {
+    if (!lastSkill)
+        return null;
+    return COMBOS.find((c) => c.skill1 === lastSkill && c.skill2 === currentSkill) ?? null;
+}
+// ─── Combat Stat Derivation ─────────────────────────────────
+/** Collect all equipped gear items */
+function getEquippedGear(state) {
+    return [
+        state.adventureStats.equippedWeapon ? (0, items_1.getItem)(state.adventureStats.equippedWeapon) ?? null : null,
+        state.adventureStats.equippedArmor ? (0, items_1.getItem)(state.adventureStats.equippedArmor) ?? null : null,
+        state.adventureStats.equippedAccessory ? (0, items_1.getItem)(state.adventureStats.equippedAccessory) ?? null : null,
+    ];
+}
+/** Sum a numeric gear property across all equipped items */
+function sumGearProp(gear, prop) {
+    let total = 0;
+    for (const item of gear) {
+        if (item && typeof item[prop] === "number")
+            total += item[prop];
+    }
+    return total;
+}
+function deriveCombatStats(state) {
+    const species = (0, species_1.getSpecies)(state.speciesId);
+    const mod = species?.statModifier ?? 1.0;
+    const gear = getEquippedGear(state);
+    const bonusATK = sumGearProp(gear, "combatATK");
+    const bonusDEF = sumGearProp(gear, "combatDEF");
+    const bonusHP = sumGearProp(gear, "combatHP");
+    const bonusSPD = sumGearProp(gear, "combatSPD");
+    const bonusDodge = sumGearProp(gear, "dodgeBonus");
+    const maxHp = Math.floor((20 + state.level * 5) * mod) + bonusHP;
+    return {
+        maxHp,
+        hp: maxHp,
+        atk: Math.floor((3 + state.level * 2) * mod) + bonusATK,
+        def: Math.floor((2 + state.level * 1) * mod) + bonusDEF,
+        spd: Math.floor((5 + state.level * 1) * mod) + bonusSPD,
+        dodgeChance: (SPECIES_DODGE[state.speciesId] ?? 0.05) + bonusDodge,
+    };
+}
+function deriveEnemyStats(enemy) {
+    return {
+        maxHp: enemy.baseHp,
+        hp: enemy.baseHp,
+        atk: enemy.baseAtk,
+        def: enemy.baseDef,
+        spd: enemy.baseSpd,
+        dodgeChance: enemy.baseDodge ?? 0.05,
+    };
+}
+// ─── Combat Initialization ──────────────────────────────────
+function startCombat(state, enemy, morale = 50) {
+    const gear = getEquippedGear(state);
+    const energyBonus = sumGearProp(gear, "energyBonus");
+    const combatEnergy = 3 + Math.floor(state.level / 5) + energyBonus;
+    // Gear passive conditions at combat start
+    const startConditions = [];
+    for (const item of gear) {
+        if (!item)
+            continue;
+        if (item.id === "phoenix_robe")
+            startConditions.push({ type: "regen", healPerTurn: 3, turnsLeft: 99 });
+        if (item.id === "guardian_shield")
+            startConditions.push({ type: "shield", amount: 15 });
+    }
+    return {
+        phase: "player_turn",
+        playerStats: deriveCombatStats(state),
+        enemyStats: deriveEnemyStats(enemy),
+        enemy,
+        combatEnergy,
+        maxCombatEnergy: combatEnergy,
+        playerEffects: [],
+        enemyEffects: [],
+        playerConditions: startConditions,
+        enemyConditions: [],
+        isDefending: false,
+        turnCount: 0,
+        log: [enemy.encounterLine, pickCombatLine(lines_1.COMBAT_START_LINES, state.speciesId)],
+        ticksInPhase: 0,
+        damageTakenThisBattle: 0,
+        usedRevive: false,
+        morale,
+        playerElement: types_1.SPECIES_ELEMENTS[state.speciesId] ?? "neutral",
+        enemyElement: enemy.element,
+        equippedGearIds: gear.filter((g) => g !== null).map((g) => g.id),
+        comboTriggeredThisBattle: 0,
+    };
+}
+// ─── Damage Calculation ─────────────────────────────────────
+function calculateDamage(atkStat, defStat) {
+    const variance = 0.8 + Math.random() * 0.4;
+    return Math.max(1, Math.floor(atkStat * variance - defStat / 2));
+}
+function isCritical(effects, morale = 50) {
+    const critBonus = effects
+        .filter((e) => e.stat === "crit")
+        .reduce((sum, e) => sum + e.amount, 0);
+    const moraleBonus = morale > 70 ? 0.10 : 0; // high morale = +10% crit
+    return Math.random() < (0.10 + critBonus + moraleBonus);
+}
+function getEffectiveAtk(base, effects) {
+    let mod = 1;
+    for (const e of effects) {
+        if (e.stat === "atk")
+            mod += e.amount;
+    }
+    return Math.floor(base * mod);
+}
+function getEffectiveDef(base, effects) {
+    let mod = 1;
+    for (const e of effects) {
+        if (e.stat === "def")
+            mod += e.amount;
+    }
+    return Math.floor(base * mod);
+}
+function getEffectiveDodge(base, effects) {
+    let bonus = 0;
+    for (const e of effects) {
+        if (e.stat === "dodge")
+            bonus += e.amount;
+    }
+    return Math.min(0.8, base + bonus);
+}
+function tickEffects(effects) {
+    return effects
+        .map((e) => ({ ...e, turnsLeft: e.turnsLeft - 1 }))
+        .filter((e) => e.turnsLeft > 0);
+}
+// ─── Player Actions ─────────────────────────────────────────
+function playerAttack(combat) {
+    let atk = getEffectiveAtk(combat.playerStats.atk, combat.playerEffects);
+    if (combat.morale < 20)
+        atk = Math.floor(atk * 0.9);
+    const def = getEffectiveDef(combat.enemyStats.def, combat.enemyEffects);
+    const crit = isCritical(combat.playerEffects, combat.morale);
+    let damage = calculateDamage(atk, def);
+    // Element type matchup
+    const { multiplier: elemMult, label: elemLabel } = (0, types_1.getElementMultiplier)(combat.playerElement, combat.enemyElement);
+    damage = Math.max(1, Math.floor(damage * elemMult));
+    if (crit)
+        damage = Math.floor(damage * 1.5);
+    const enemyDodge = getEffectiveDodge(combat.enemyStats.dodgeChance, combat.enemyEffects);
+    if (Math.random() < enemyDodge) {
+        return {
+            ...combat,
+            phase: "player_animate",
+            log: [...combat.log, `${combat.enemy.name} dodges!`],
+            ticksInPhase: 0,
+        };
+    }
+    const newEnemyHp = Math.max(0, combat.enemyStats.hp - damage);
+    const logLines = [...combat.log];
+    if (elemLabel)
+        logLines.push(elemLabel);
+    logLines.push(crit ? `CRITICAL HIT! Dealt ${damage} damage!` : `Dealt ${damage} damage!`);
+    const log = logLines;
+    // Check weapon on-hit passive effects
+    let enemyConds = combat.enemyConditions;
+    for (const gearId of combat.equippedGearIds) {
+        const item = (0, items_1.getItem)(gearId);
+        if (!item?.onHitEffect || !item.onHitChance)
+            continue;
+        if (Math.random() < item.onHitChance) {
+            const condType = item.onHitEffect;
+            const power = item.onHitPower ?? 1;
+            if (condType === "burn") {
+                enemyConds = addCondition(enemyConds, { type: "burn", damagePerTurn: power, turnsLeft: 2 }, combat.enemyElement);
+                log.push(`${item.name} inflicts burn!`);
+            }
+            else if (condType === "freeze") {
+                enemyConds = addCondition(enemyConds, { type: "freeze", turnsLeft: power }, combat.enemyElement);
+                log.push(`${item.name} freezes the enemy!`);
+            }
+            else if (condType === "charm") {
+                enemyConds = addCondition(enemyConds, { type: "charm", turnsLeft: power }, combat.enemyElement);
+                log.push(`${item.name} charms the enemy!`);
+            }
+        }
+    }
+    return {
+        ...combat,
+        phase: "player_animate",
+        enemyStats: { ...combat.enemyStats, hp: newEnemyHp },
+        enemyConditions: enemyConds,
+        log,
+        ticksInPhase: 0,
+    };
+}
+function playerDefend(combat) {
+    return {
+        ...combat,
+        phase: "player_animate",
+        isDefending: true,
+        log: [...combat.log, "Bracing for impact!"],
+        ticksInPhase: 0,
+    };
+}
+function playerFlee(combat) {
+    const fleeChance = 0.4 + (combat.playerStats.spd - combat.enemyStats.spd) * 0.05;
+    if (Math.random() < Math.max(0.2, Math.min(0.9, fleeChance))) {
+        return { ...combat, phase: "fled", log: [...combat.log, "Got away safely!"], ticksInPhase: 0 };
+    }
+    return {
+        ...combat,
+        phase: "player_animate",
+        log: [...combat.log, "Couldn't escape!"],
+        ticksInPhase: 0,
+    };
+}
+function playerUseSkill(combat, skill) {
+    if (combat.combatEnergy < skill.energyCost) {
+        return { ...combat, log: [...combat.log, "Not enough energy!"] };
+    }
+    // Check for combo
+    const combo = checkCombo(combat.lastSkillUsed, skill.id);
+    let result = { ...combat, combatEnergy: combat.combatEnergy - skill.energyCost, lastSkillUsed: skill.id };
+    const effect = skill.effect;
+    switch (effect.type) {
+        case "damage": {
+            const atk = getEffectiveAtk(result.playerStats.atk, result.playerEffects);
+            const multiplier = combo ? combo.damageMultiplier : effect.multiplier;
+            let damage = Math.floor(atk * multiplier);
+            if (!effect.ignoreDefense) {
+                const def = getEffectiveDef(result.enemyStats.def, result.enemyEffects);
+                damage = Math.max(1, damage - Math.floor(def / 2));
+            }
+            // Element matchup: use skill element if present, otherwise species element
+            const skillElem = skill.element ?? combat.playerElement;
+            const { multiplier: eMult, label: eLabel } = (0, types_1.getElementMultiplier)(skillElem, combat.enemyElement);
+            damage = Math.max(1, Math.floor(damage * eMult));
+            const newHp = Math.max(0, result.enemyStats.hp - damage);
+            let enemyConds = result.enemyConditions;
+            let skillLog;
+            if (combo) {
+                skillLog = [`COMBO! ${combo.name}!`, `Dealt ${damage} damage!`];
+                result = { ...result, comboTriggeredThisBattle: result.comboTriggeredThisBattle + 1 };
+                if (combo.extraEffect === "burn")
+                    enemyConds = addCondition(enemyConds, { type: "burn", damagePerTurn: 4, turnsLeft: 3 }, result.enemyElement);
+                if (combo.extraEffect === "stun")
+                    enemyConds = addCondition(enemyConds, { type: "stun", turnsLeft: 2 }, result.enemyElement);
+            }
+            else {
+                skillLog = eLabel ? [`${skill.name}! ${eLabel}`, `Dealt ${damage} damage!`] : [`${skill.name}! Dealt ${damage} damage!`];
+            }
+            // Apply bonus conditions based on specific skills
+            if (skill.id === "earthquake")
+                enemyConds = addCondition(enemyConds, { type: "stun", turnsLeft: 1 }, result.enemyElement);
+            if (skill.id === "shadow_strike")
+                enemyConds = addCondition(enemyConds, { type: "charm", turnsLeft: 1 }, result.enemyElement);
+            if (skill.id === "tidal_wave")
+                enemyConds = addCondition(enemyConds, { type: "freeze", turnsLeft: 1 }, result.enemyElement);
+            if (skill.id === "inferno")
+                enemyConds = addCondition(enemyConds, { type: "burn", damagePerTurn: 5, turnsLeft: 3 }, result.enemyElement);
+            if (skill.id === "supernova")
+                enemyConds = addCondition(enemyConds, { type: "burn", damagePerTurn: 5, turnsLeft: 3 }, result.enemyElement);
+            if (skill.id === "outfox")
+                enemyConds = addCondition(enemyConds, { type: "charm", turnsLeft: 1 }, result.enemyElement);
+            if (skill.id === "piercing_gaze")
+                enemyConds = addCondition(enemyConds, { type: "debuff", stat: "def", amount: 0.5, turnsLeft: 2 }, result.enemyElement);
+            result = {
+                ...result,
+                phase: "player_animate",
+                enemyStats: { ...result.enemyStats, hp: newHp },
+                enemyConditions: enemyConds,
+                log: [...result.log, ...skillLog],
+                ticksInPhase: 0,
+            };
+            break;
+        }
+        case "buff": {
+            // Special skills that apply conditions instead of simple buffs
+            let playerConds = result.playerConditions;
+            if (skill.id === "aqua_shield") {
+                playerConds = [...playerConds, { type: "shield", amount: 20 }];
+                result = { ...result, phase: "player_animate", playerConditions: playerConds, log: [...result.log, `${skill.name}! Shield active (20 HP)!`], ticksInPhase: 0 };
+            }
+            else if (skill.id === "natures_blessing") {
+                playerConds = [...playerConds, { type: "regen", healPerTurn: 5, turnsLeft: 3 }];
+                result = { ...result, phase: "player_animate", playerConditions: playerConds, log: [...result.log, `${skill.name}! Regenerating!`], ticksInPhase: 0 };
+            }
+            else if (skill.id === "shadow_step") {
+                // Dodge buff + guaranteed crit on next attack
+                playerConds = [...playerConds, { type: "buff", stat: "crit", amount: 1.0, turnsLeft: 1 }];
+                result = {
+                    ...result, phase: "player_animate",
+                    playerEffects: [...result.playerEffects, { stat: effect.stat, amount: effect.amount, turnsLeft: effect.turns }],
+                    playerConditions: playerConds,
+                    log: [...result.log, `${skill.name}! Next attack will crit!`], ticksInPhase: 0,
+                };
+            }
+            else {
+                result = {
+                    ...result, phase: "player_animate",
+                    playerEffects: [...result.playerEffects, { stat: effect.stat, amount: effect.amount, turnsLeft: effect.turns }],
+                    log: [...result.log, `${skill.name}!`], ticksInPhase: 0,
+                };
+            }
+            break;
+        }
+        case "debuff":
+            result = {
+                ...result,
+                phase: "player_animate",
+                enemyEffects: [...result.enemyEffects, { stat: effect.stat, amount: -effect.amount, turnsLeft: effect.turns }],
+                log: [...result.log, `${skill.name}! Enemy weakened!`],
+                ticksInPhase: 0,
+            };
+            break;
+        case "poison":
+            result = {
+                ...result,
+                phase: "player_animate",
+                enemyEffects: [...result.enemyEffects, { stat: "poison", amount: effect.damagePerTurn, turnsLeft: effect.turns }],
+                log: [...result.log, `${skill.name}! Enemy poisoned!`],
+                ticksInPhase: 0,
+            };
+            break;
+        case "stun":
+        case "skip_enemy_turn": {
+            let newEnemyConds = result.enemyConditions;
+            // Special: illuminate applies blind instead of stun
+            if (skill.id === "illuminate") {
+                newEnemyConds = addCondition(newEnemyConds, { type: "blind", turnsLeft: 2 }, result.enemyElement);
+                result = { ...result, phase: "player_animate", enemyConditions: newEnemyConds, log: [...result.log, `${skill.name}! Enemy blinded!`], ticksInPhase: 0 };
+            }
+            else {
+                newEnemyConds = addCondition(newEnemyConds, { type: "stun", turnsLeft: effect.type === "stun" ? effect.turns : 1 }, result.enemyElement);
+                result = { ...result, phase: "player_animate", enemyConditions: newEnemyConds, log: [...result.log, `${skill.name}! Enemy stunned!`], ticksInPhase: 0 };
+            }
+            break;
+        }
+        case "revive":
+            // Mark revive as used — actual effect triggers on KO
+            result = {
+                ...result,
+                phase: "player_animate",
+                usedRevive: true,
+                log: [...result.log, `${skill.name} activated!`],
+                ticksInPhase: 0,
+            };
+            break;
+    }
+    return result;
+}
+// ─── Enemy Turn ─────────────────────────────────────────────
+function enemyTurn(combat) {
+    const enemy = combat.enemy;
+    const hpPct = combat.enemyStats.hp / combat.enemyStats.maxHp;
+    let enemyHp = combat.enemyStats.hp;
+    const extraLog = [];
+    // ─── Boss Phase Logic ──────────────────────────────
+    // Phase 3: Enraged (HP < 25%) — boosted ATK, special every other turn
+    const isEnraged = enemy.isBoss && enemy.enrageAtkBonus && hpPct < 0.25;
+    if (isEnraged && combat.turnCount % 2 === 0 && enemy.specialMove) {
+        const special = enemy.specialMove;
+        if (special.damageMultiplier < 0) {
+            const heal = Math.floor(combat.enemyStats.maxHp * Math.abs(special.damageMultiplier));
+            const newHp = Math.min(combat.enemyStats.maxHp, enemyHp + heal);
+            return { ...combat, phase: "enemy_animate", enemyStats: { ...combat.enemyStats, hp: newHp }, enemyEffects: tickEffects(combat.enemyEffects), log: [...combat.log, "ENRAGED!", special.line, `Healed ${heal} HP!`], ticksInPhase: 0 };
+        }
+        const enragedAtk = Math.floor(enemy.baseAtk * (1 + enemy.enrageAtkBonus));
+        const dmg = Math.floor(enragedAtk * special.damageMultiplier);
+        return applyDamageToPlayer(combat, dmg, ["ENRAGED!", special.line], enemyHp);
+    }
+    // Phase 2: (HP < 50%) — use phase2Move if available
+    if (enemy.isBoss && enemy.phase2Move && hpPct < 0.5 && hpPct >= 0.25) {
+        if (Math.random() < enemy.phase2Move.chance) {
+            const p2 = enemy.phase2Move;
+            if (p2.damageMultiplier < 0) {
+                const heal = Math.floor(combat.enemyStats.maxHp * Math.abs(p2.damageMultiplier));
+                const newHp = Math.min(combat.enemyStats.maxHp, enemyHp + heal);
+                return { ...combat, phase: "enemy_animate", enemyStats: { ...combat.enemyStats, hp: newHp }, enemyEffects: tickEffects(combat.enemyEffects), log: [...combat.log, p2.line, `Healed ${heal} HP!`], ticksInPhase: 0 };
+            }
+            const dmg = Math.floor(enemy.baseAtk * p2.damageMultiplier);
+            return applyDamageToPlayer(combat, dmg, [p2.line], enemyHp);
+        }
+    }
+    // Phase 1 / non-boss: specialMove at < 30%
+    if (enemy.specialMove && hpPct < 0.3) {
+        if (Math.random() < enemy.specialMove.chance) {
+            const special = enemy.specialMove;
+            if (special.damageMultiplier < 0) {
+                const heal = Math.floor(combat.enemyStats.maxHp * Math.abs(special.damageMultiplier));
+                const newHp = Math.min(combat.enemyStats.maxHp, enemyHp + heal);
+                return { ...combat, phase: "enemy_animate", enemyStats: { ...combat.enemyStats, hp: newHp }, enemyEffects: tickEffects(combat.enemyEffects), log: [...combat.log, special.line, `Healed ${heal} HP!`], ticksInPhase: 0 };
+            }
+            const dmg = Math.floor(enemy.baseAtk * special.damageMultiplier);
+            return applyDamageToPlayer(combat, dmg, [special.line], enemyHp);
+        }
+    }
+    // ─── AI Behavior ───────────────────────────────────
+    // Blind check — 40% miss
+    if (hasCondition(combat.enemyConditions, "blind") && Math.random() < 0.4) {
+        return { ...combat, phase: "enemy_animate", enemyEffects: tickEffects(combat.enemyEffects), isDefending: false, log: [...combat.log, `${enemy.name} attacks but misses! (blinded)`], ticksInPhase: 0 };
+    }
+    // Defensive: alternate attack/defend, defend when HP < 50%
+    if (enemy.aiBehavior === "defensive" && (hpPct < 0.5 || combat.turnCount % 2 === 1)) {
+        return { ...combat, phase: "enemy_animate", enemyEffects: tickEffects(combat.enemyEffects), isDefending: false, log: [...combat.log, enemy.defendLine ?? `${enemy.name} braces for impact!`], ticksInPhase: 0 };
+        // Defending enemies take less damage next turn — we'd need enemy isDefending state
+        // For now, defensive AI just skips attack occasionally (effectively a weaker turn)
+    }
+    // Evasive: high dodge, flee at < 20% HP
+    if (enemy.aiBehavior === "evasive" && hpPct < 0.2) {
+        // Enemy flees — player doesn't get full XP
+        return { ...combat, phase: "fled", log: [...combat.log, `${enemy.name} flees into the shadows!`], ticksInPhase: 0 };
+    }
+    // Tactical: debuff player first turn, then attack
+    if (enemy.aiBehavior === "tactical" && combat.turnCount <= 1) {
+        const debuffConds = addCondition(combat.playerConditions, { type: "debuff", stat: "def", amount: 0.2, turnsLeft: 3 }, combat.playerElement);
+        return { ...combat, phase: "enemy_animate", playerConditions: debuffConds, enemyEffects: tickEffects(combat.enemyEffects), isDefending: false, log: [...combat.log, `${enemy.name} studies your weaknesses! (-20% DEF)`], ticksInPhase: 0 };
+    }
+    // Berserker: ATK increases as HP drops
+    let atkMod = 1.0;
+    if (enemy.aiBehavior === "berserker" && hpPct < 0.25) {
+        atkMod = 1.5;
+        extraLog.push(`${enemy.name} is berserk!`);
+    }
+    else if (enemy.aiBehavior === "berserker" && hpPct < 0.5) {
+        atkMod = 1.25;
+    }
+    // Enraged boss ATK bonus (use max of berserker and enrage, don't stack)
+    if (isEnraged && enemy.enrageAtkBonus) {
+        atkMod = Math.max(atkMod, 1 + enemy.enrageAtkBonus);
+    }
+    // ─── Normal Attack ─────────────────────────────────
+    const atk = Math.floor(getEffectiveAtk(enemy.baseAtk, combat.enemyEffects) * atkMod);
+    const def = getEffectiveDef(combat.playerStats.def, combat.playerEffects);
+    let damage = calculateDamage(atk, def);
+    const { multiplier: enemyElemMult } = (0, types_1.getElementMultiplier)(combat.enemyElement, combat.playerElement);
+    damage = Math.max(1, Math.floor(damage * enemyElemMult));
+    if (combat.isDefending)
+        damage = Math.floor(damage * 0.5);
+    // Player dodge check
+    let dodge = getEffectiveDodge(combat.playerStats.dodgeChance, combat.playerEffects);
+    if (combat.morale < 40)
+        dodge = Math.max(0, dodge - 0.15);
+    // Evasive enemies are hard to counter-dodge against
+    if (Math.random() < dodge) {
+        return {
+            ...combat, phase: "enemy_animate",
+            enemyStats: { ...combat.enemyStats, hp: enemyHp },
+            enemyEffects: tickEffects(combat.enemyEffects),
+            isDefending: false,
+            log: [...combat.log, ...extraLog, enemy.attackLine, "Dodged!"],
+            ticksInPhase: 0,
+        };
+    }
+    return applyDamageToPlayer(combat, damage, [...extraLog, combat.enemy.attackLine], enemyHp);
+}
+function applyDamageToPlayer(combat, damage, extraLog, enemyHp) {
+    // Apply shield first
+    const shieldResult = applyShield(damage, combat.playerConditions);
+    damage = shieldResult.damage;
+    let playerConditions = shieldResult.conditions;
+    if (shieldResult.damage < damage)
+        extraLog.push("Shield absorbs some damage!");
+    // Freeze shatters on taking damage
+    playerConditions = playerConditions.filter((c) => c.type !== "freeze");
+    let playerHp = Math.max(0, combat.playerStats.hp - damage);
+    const damageTaken = combat.damageTakenThisBattle + damage;
+    // Low HP panic line
+    if (playerHp > 0 && playerHp < combat.playerStats.maxHp * 0.25 && combat.playerStats.hp >= combat.playerStats.maxHp * 0.25) {
+        const panicLine = lines_1.COMBAT_LOW_HP_LINES[Math.floor(Math.random() * lines_1.COMBAT_LOW_HP_LINES.length)];
+        extraLog.push(panicLine);
+    }
+    // Check revive
+    if (playerHp <= 0 && combat.usedRevive) {
+        playerHp = Math.floor(combat.playerStats.maxHp * 0.3);
+        return {
+            ...combat,
+            phase: "enemy_animate",
+            playerStats: { ...combat.playerStats, hp: playerHp },
+            enemyStats: { ...combat.enemyStats, hp: enemyHp },
+            enemyEffects: tickEffects(combat.enemyEffects),
+            playerEffects: tickEffects(combat.playerEffects),
+            isDefending: false,
+            usedRevive: false,
+            damageTakenThisBattle: damageTaken,
+            log: [...combat.log, ...extraLog, `Took ${damage} damage!`, "Revived!"],
+            ticksInPhase: 0,
+        };
+    }
+    if (playerHp <= 0) {
+        return {
+            ...combat,
+            phase: "defeat",
+            playerStats: { ...combat.playerStats, hp: 0 },
+            damageTakenThisBattle: damageTaken,
+            log: [...combat.log, ...extraLog, `Took ${damage} damage!`, "Knocked out!"],
+            ticksInPhase: 0,
+        };
+    }
+    return {
+        ...combat,
+        phase: "enemy_animate",
+        playerStats: { ...combat.playerStats, hp: playerHp },
+        enemyStats: { ...combat.enemyStats, hp: enemyHp },
+        enemyEffects: tickEffects(combat.enemyEffects),
+        playerEffects: tickEffects(combat.playerEffects),
+        isDefending: false,
+        damageTakenThisBattle: damageTaken,
+        log: [...combat.log, ...extraLog, `Took ${damage} damage!`],
+        ticksInPhase: 0,
+    };
+}
+// ─── Condition Processing ────────────────────────────────────
+/** Apply start-of-turn conditions to a combatant. Returns updated HP, conditions, and log messages. */
+function processConditions(hp, maxHp, conditions, log, targetName) {
+    let skipTurn = false;
+    const newLog = [...log];
+    let newConditions = [];
+    for (const cond of conditions) {
+        switch (cond.type) {
+            case "burn":
+                hp = Math.max(0, hp - cond.damagePerTurn);
+                newLog.push(`${targetName} takes ${cond.damagePerTurn} burn damage!`);
+                if (cond.turnsLeft > 1)
+                    newConditions.push({ ...cond, turnsLeft: cond.turnsLeft - 1 });
+                // turnsLeft <= 1: burn expires, not pushed back
+                break;
+            case "poison":
+                hp = Math.max(0, hp - cond.damagePerTurn);
+                newLog.push(`${targetName} takes ${cond.damagePerTurn} poison damage!`);
+                if (cond.turnsLeft > 1)
+                    newConditions.push({ ...cond, turnsLeft: cond.turnsLeft - 1 });
+                break;
+            case "freeze":
+                skipTurn = true;
+                newLog.push(`${targetName} is frozen solid!`);
+                // Freeze breaks after 1 turn or when damaged
+                if (cond.turnsLeft > 1)
+                    newConditions.push({ ...cond, turnsLeft: cond.turnsLeft - 1 });
+                break;
+            case "stun":
+                skipTurn = true;
+                newLog.push(`${targetName} is stunned!`);
+                if (cond.turnsLeft > 1)
+                    newConditions.push({ ...cond, turnsLeft: cond.turnsLeft - 1 });
+                break;
+            case "charm":
+                skipTurn = true; // handled specially — enemy attacks itself
+                newLog.push(`${targetName} is charmed and confused!`);
+                if (cond.turnsLeft > 1)
+                    newConditions.push({ ...cond, turnsLeft: cond.turnsLeft - 1 });
+                break;
+            case "blind":
+                // Blind doesn't skip turn, just reduces accuracy — handled in attack logic
+                if (cond.turnsLeft > 1)
+                    newConditions.push({ ...cond, turnsLeft: cond.turnsLeft - 1 });
+                break;
+            case "regen":
+                const heal = Math.min(cond.healPerTurn, maxHp - hp);
+                if (heal > 0) {
+                    hp = hp + heal;
+                    newLog.push(`${targetName} regenerates ${heal} HP!`);
+                }
+                if (cond.turnsLeft > 1)
+                    newConditions.push({ ...cond, turnsLeft: cond.turnsLeft - 1 });
+                break;
+            case "shield":
+                // Shield persists until broken by damage — not tick-based
+                newConditions.push(cond);
+                break;
+            case "buff":
+            case "debuff":
+                if (cond.turnsLeft > 1)
+                    newConditions.push({ ...cond, turnsLeft: cond.turnsLeft - 1 });
+                break;
+        }
+    }
+    return { hp, conditions: newConditions, log: newLog, skipTurn };
+}
+/** Apply shield absorption — returns remaining damage and updated conditions */
+function applyShield(damage, conditions) {
+    const newConds = [];
+    let remaining = damage;
+    for (const cond of conditions) {
+        if (cond.type === "shield" && remaining > 0) {
+            if (cond.amount > remaining) {
+                newConds.push({ ...cond, amount: cond.amount - remaining });
+                remaining = 0;
+            }
+            else {
+                remaining -= cond.amount;
+                // shield broken, don't keep it
+            }
+        }
+        else {
+            newConds.push(cond);
+        }
+    }
+    return { damage: remaining, conditions: newConds };
+}
+/** Check if target has a specific condition */
+function hasCondition(conditions, type) {
+    return conditions.some((c) => c.type === type);
+}
+/** Add a condition, respecting immunities */
+function addCondition(conditions, cond, targetElement) {
+    if ((0, types_1.isImmune)(cond.type, targetElement))
+        return conditions;
+    return [...conditions, cond];
+}
+/** Get effective stat modifier from conditions (buff/debuff) */
+function getConditionStatMod(conditions, stat) {
+    let mod = 0;
+    for (const c of conditions) {
+        if ((c.type === "buff" || c.type === "debuff") && c.stat === stat) {
+            mod += c.type === "buff" ? c.amount : -c.amount;
+        }
+    }
+    return mod;
+}
+// ─── Turn Advancement ───────────────────────────────────────
+/** Called each tick to advance animation phases */
+function tickCombat(combat) {
+    const ticks = combat.ticksInPhase + 1;
+    if (combat.phase === "player_animate" && ticks >= 2) {
+        if (combat.enemyStats.hp <= 0) {
+            return { ...combat, phase: "victory", ticksInPhase: 0, log: [...combat.log, `${combat.enemy.name} is defeated!`] };
+        }
+        // Process enemy conditions before enemy turn
+        const enemyProc = processConditions(combat.enemyStats.hp, combat.enemyStats.maxHp, combat.enemyConditions, combat.log, combat.enemy.name);
+        const updatedCombat = {
+            ...combat,
+            enemyStats: { ...combat.enemyStats, hp: enemyProc.hp },
+            enemyConditions: enemyProc.conditions,
+            log: enemyProc.log,
+        };
+        if (enemyProc.hp <= 0) {
+            return { ...updatedCombat, phase: "victory", ticksInPhase: 0, log: [...enemyProc.log, `${combat.enemy.name} is defeated!`] };
+        }
+        if (enemyProc.skipTurn) {
+            // Charm: enemy attacks itself
+            if (hasCondition(combat.enemyConditions, "charm")) {
+                const selfDmg = Math.max(1, Math.floor(combat.enemyStats.atk * 0.5));
+                return {
+                    ...updatedCombat,
+                    enemyStats: { ...updatedCombat.enemyStats, hp: Math.max(0, updatedCombat.enemyStats.hp - selfDmg) },
+                    phase: "enemy_animate",
+                    log: [...updatedCombat.log, `${combat.enemy.name} attacks itself for ${selfDmg} damage!`],
+                    ticksInPhase: 0,
+                };
+            }
+            return { ...updatedCombat, phase: "enemy_animate", ticksInPhase: 0 };
+        }
+        return { ...updatedCombat, phase: "enemy_turn", ticksInPhase: 0 };
+    }
+    if (combat.phase === "enemy_turn") {
+        return enemyTurn(combat);
+    }
+    if (combat.phase === "enemy_animate" && ticks >= 2) {
+        // Process player conditions before player turn
+        const playerProc = processConditions(combat.playerStats.hp, combat.playerStats.maxHp, combat.playerConditions, combat.log, "You");
+        const turnCount = combat.turnCount + 1;
+        // Energy regen: +1 every 3 turns
+        const energyRegen = turnCount % 3 === 0 ? 1 : 0;
+        const newEnergy = Math.min(combat.maxCombatEnergy, combat.combatEnergy + energyRegen);
+        let regenLog = playerProc.log;
+        if (energyRegen > 0)
+            regenLog = [...regenLog, "+1 energy recovered!"];
+        if (playerProc.hp <= 0) {
+            return {
+                ...combat, phase: "defeat", ticksInPhase: 0,
+                playerStats: { ...combat.playerStats, hp: 0 },
+                playerConditions: playerProc.conditions,
+                log: [...regenLog, "Knocked out!"],
+            };
+        }
+        return {
+            ...combat,
+            phase: "player_turn",
+            ticksInPhase: 0,
+            turnCount,
+            combatEnergy: newEnergy,
+            playerStats: { ...combat.playerStats, hp: playerProc.hp },
+            playerConditions: playerProc.conditions,
+            log: regenLog,
+        };
+    }
+    return { ...combat, ticksInPhase: ticks };
+}
+//# sourceMappingURL=combat.js.map