pokemon-io-core 0.0.52 → 0.0.54

package/dist/engine/engine.js

@@ -1,869 +0,0 @@
-// src/domain/combat/engine/battleEngine.ts
-// ------------------------------------------------------
-// Debug helper
-// ------------------------------------------------------
-const DEBUG_BATTLE = true;
-const dbg = (...args) => {
-    if (!DEBUG_BATTLE)
-        return;
-    // eslint-disable-next-line no-console
-    console.log("[BATTLE]", ...args);
-};
-const DEFAULT_RULES = {
-    baseCritChance: 0.05,
-    critPerStat: 0.002,
-    critMultiplier: 1.3,
-    stabMultiplier: 1.2,
-    randomMinDamageFactor: 0.85,
-    randomMaxDamageFactor: 1.0,
-};
-const buildMap = (list) => list.reduce((acc, item) => {
-    acc[item.id] = item;
-    return acc;
-}, {});
-const cloneStats = (stats) => ({
-    offense: stats.offense,
-    defense: stats.defense,
-    speed: stats.speed,
-    crit: stats.crit,
-});
-// ------------------------------------------------------
-// Creación de estado inicial
-// ------------------------------------------------------
-const createBattleFighter = (cfg) => {
-    if (cfg.moves.length !== 4) {
-        throw new Error("Each fighter must have exactly 4 moves in MVP");
-    }
-    if (cfg.items.length > 4) {
-        throw new Error("A fighter cannot have more than 4 items");
-    }
-    return {
-        fighterId: cfg.fighter.id,
-        classId: cfg.fighter.classId,
-        maxHp: cfg.maxHp,
-        currentHp: cfg.maxHp,
-        baseStats: cloneStats(cfg.fighter.baseStats),
-        effectiveStats: cloneStats(cfg.fighter.baseStats),
-        moves: cfg.moves.map((move) => ({
-            moveId: move.id,
-            currentPP: move.maxPP,
-        })),
-        items: cfg.items.map((item) => ({
-            itemId: item.id,
-            usesRemaining: item.maxUses,
-        })),
-        amuletId: cfg.amulet ? cfg.amulet.id : null,
-        statuses: [],
-        isAlive: true,
-    };
-};
-const recomputeEffectiveStatsForFighter = (state, fighter) => {
-    // Partimos de base
-    let eff = { ...fighter.baseStats };
-    // 1) Aplicar estados
-    for (const st of fighter.statuses) {
-        const def = state.runtime.statusesById[st.statusId];
-        if (!def)
-            continue;
-        const stacks = st.stacks === 2 ? 2 : 1;
-        for (const effDef of def.effectsPerStack) {
-            const totalStacks = stacks; // podrías multiplicar efectos por stacks
-            switch (effDef.kind) {
-                case "modify_stats":
-                    eff.offense += (effDef.offenseDelta ?? 0) * totalStacks;
-                    eff.defense += (effDef.defenseDelta ?? 0) * totalStacks;
-                    eff.speed += (effDef.speedDelta ?? 0) * totalStacks;
-                    eff.crit += (effDef.critDelta ?? 0) * totalStacks;
-                    break;
-                case "modify_effective_speed":
-                    eff.speed = Math.floor(eff.speed * Math.pow(effDef.multiplier, totalStacks));
-                    break;
-                default:
-                    break;
-            }
-        }
-    }
-    // 2) Aquí podrías aplicar amuletos, buffs temporales o lo que quieras
-    return {
-        ...fighter,
-        effectiveStats: eff,
-    };
-};
-const createPlayerBattleState = (cfg) => {
-    const fighter = createBattleFighter(cfg);
-    return {
-        fighterTeam: [fighter],
-        activeIndex: 0,
-    };
-};
-export const createInitialBattleState = (config) => {
-    const rules = {
-        ...DEFAULT_RULES,
-        ...config.rules,
-    };
-    const runtime = {
-        rules,
-        typesById: buildMap(config.types),
-        movesById: buildMap(config.moves),
-        itemsById: buildMap(config.items),
-        amuletsById: buildMap(config.amulets),
-        statusesById: buildMap(config.statuses),
-        typeEffectiveness: config.typeEffectiveness,
-    };
-    const player1 = createPlayerBattleState(config.player1);
-    const player2 = createPlayerBattleState(config.player2);
-    const state = {
-        turnNumber: 1,
-        player1,
-        player2,
-        runtime,
-    };
-    return state;
-};
-// ------------------------------------------------------
-// Helpers
-// ------------------------------------------------------
-const getActiveFighter = (player) => player.fighterTeam[player.activeIndex];
-const getOpponentAndSelf = (state, playerKey) => {
-    const selfPlayer = playerKey === "player1" ? state.player1 : state.player2;
-    const oppPlayer = playerKey === "player1" ? state.player2 : state.player1;
-    return {
-        self: getActiveFighter(selfPlayer),
-        opponent: getActiveFighter(oppPlayer),
-    };
-};
-const getTypeEffectiveness = (state, attackerTypeId, defenderTypeId) => {
-    const matrix = state.runtime.typeEffectiveness;
-    const row = matrix[attackerTypeId];
-    if (!row)
-        return 1;
-    return row[defenderTypeId] ?? 1;
-};
-const randomInRange = (min, max) => Math.random() * (max - min) + min;
-const chance = (probability) => {
-    if (probability <= 0)
-        return false;
-    if (probability >= 1)
-        return true;
-    return Math.random() < probability;
-};
-// ------------------------------------------------------
-// Cálculo de críticos y daño
-// ------------------------------------------------------
-const computeCritChance = (rules, critStat) => {
-    const raw = rules.baseCritChance + critStat * rules.critPerStat;
-    return Math.max(0, Math.min(1, raw));
-};
-const computeDamage = (input) => {
-    const { state, attacker, defender, moveTypeId, basePower, isCritical } = input;
-    const rules = state.runtime.rules;
-    const attackerOff = attacker.effectiveStats.offense;
-    const defenderDef = defender.effectiveStats.defense;
-    const typeEffectiveness = getTypeEffectiveness(state, moveTypeId, defender.classId);
-    if (typeEffectiveness === 0) {
-        return {
-            damage: 0,
-            effectiveness: 0,
-        };
-    }
-    const stabMultiplier = attacker.classId === moveTypeId ? rules.stabMultiplier : 1;
-    const critMultiplier = isCritical ? rules.critMultiplier : 1;
-    const randomFactor = randomInRange(rules.randomMinDamageFactor, rules.randomMaxDamageFactor);
-    const rawDamage = basePower *
-        (attackerOff / Math.max(1, defenderDef)) *
-        typeEffectiveness *
-        stabMultiplier *
-        critMultiplier *
-        randomFactor;
-    const finalDamage = Math.max(1, Math.floor(rawDamage));
-    return {
-        damage: finalDamage,
-        effectiveness: typeEffectiveness,
-    };
-};
-let eventCounter = 0;
-const nextEventId = () => {
-    eventCounter += 1;
-    return `evt_${eventCounter}`;
-};
-const createBaseEvent = (turnNumber, kind, message) => ({
-    id: nextEventId(),
-    kind,
-    turnNumber,
-    message,
-    timestamp: Date.now(),
-});
-const applyDamageToFighter = (state, defender, amount, actorId, isCritical) => {
-    const events = [];
-    const newHp = Math.max(0, defender.currentHp - amount);
-    const updatedDefender = {
-        ...defender,
-        currentHp: newHp,
-        isAlive: newHp > 0,
-    };
-    events.push({
-        ...createBaseEvent(state.turnNumber, "damage", `${actorId} inflige ${amount} de daño a ${defender.fighterId}`),
-        actorId,
-        targetId: defender.fighterId,
-        amount,
-        isCritical,
-    });
-    if (!updatedDefender.isAlive) {
-        events.push({
-            ...createBaseEvent(state.turnNumber, "fighter_fainted", `${defender.fighterId} ha caído`),
-            fighterId: defender.fighterId,
-        });
-    }
-    return { updatedDefender, events };
-};
-// ------------------------------------------------------
-// apply_status
-// ------------------------------------------------------
-const applyStatusToFighter = (state, target, statusId) => {
-    const def = state.runtime.statusesById[statusId];
-    dbg("APPLY_STATUS_FN", {
-        targetId: target.fighterId,
-        statusId,
-        hasDef: !!def,
-        currentStatuses: target.statuses,
-    });
-    if (!def)
-        return { updated: target, events: [] };
-    const events = [];
-    const existing = target.statuses.find((s) => s.statusId === statusId);
-    const duration = Math.floor(randomInRange(def.minDurationTurns, def.maxDurationTurns + 1)) ||
-        def.minDurationTurns;
-    let newStatuses = [...target.statuses];
-    if (!existing) {
-        newStatuses.push({
-            statusId,
-            stacks: 1,
-            remainingTurns: duration,
-        });
-    }
-    else if (existing.stacks === 1) {
-        newStatuses = newStatuses.map((s) => s.statusId === statusId
-            ? { ...s, stacks: 2, remainingTurns: duration }
-            : s);
-    }
-    else {
-        newStatuses = newStatuses.map((s) => s.statusId === statusId ? { ...s, remainingTurns: duration } : s);
-    }
-    dbg("STATUS_APPLY", {
-        fighterId: target.fighterId,
-        statusId,
-        duration,
-        prevStacks: existing?.stacks ?? 0,
-    });
-    events.push({
-        ...createBaseEvent(state.turnNumber, "status_applied", `Se aplica ${statusId} a ${target.fighterId}`),
-        targetId: target.fighterId,
-        statusId,
-    });
-    return {
-        updated: { ...target, statuses: newStatuses },
-        events,
-    };
-};
-// ------------------------------------------------------
-// clear_status
-// ------------------------------------------------------
-const clearStatusFromFighter = (state, target, effect) => {
-    const { statusIds, kinds, clearAll } = effect;
-    const events = [];
-    const before = target.statuses;
-    let after = before;
-    if (clearAll) {
-        after = [];
-    }
-    else {
-        after = before.filter((st) => {
-            const def = state.runtime.statusesById[st.statusId];
-            if (statusIds && statusIds.includes(st.statusId)) {
-                return false;
-            }
-            if (kinds && def && kinds.includes(def.kind)) {
-                return false;
-            }
-            return true;
-        });
-    }
-    if (after.length === before.length) {
-        // nada que limpiar
-        return { updated: target, events };
-    }
-    const removed = before
-        .filter((old) => !after.some((st) => st.statusId === old.statusId))
-        .map((st) => st.statusId);
-    dbg("STATUS_CLEAR", {
-        fighterId: target.fighterId,
-        cleared: removed,
-        clearAll: !!clearAll,
-    });
-    events.push({
-        ...createBaseEvent(state.turnNumber, "status_cleared", `Se limpian estados (${removed.join(", ")}) de ${target.fighterId}`),
-        targetId: target.fighterId,
-        statusIds: removed,
-    });
-    return {
-        updated: {
-            ...target,
-            statuses: after,
-        },
-        events,
-    };
-};
-// ------------------------------------------------------
-// heal
-// ------------------------------------------------------
-const applyHealToFighter = (state, target, amount, sourceId) => {
-    const newHp = Math.min(target.maxHp, target.currentHp + amount);
-    const healed = newHp - target.currentHp;
-    const updated = {
-        ...target,
-        currentHp: newHp,
-        isAlive: newHp > 0,
-    };
-    const events = [];
-    dbg("HEAL", {
-        sourceId,
-        targetId: target.fighterId,
-        healed,
-        newHp,
-    });
-    events.push({
-        ...createBaseEvent(state.turnNumber, "heal", `${sourceId} cura ${healed} a ${target.fighterId}`),
-        actorId: sourceId,
-        targetId: target.fighterId,
-        amount: healed,
-    });
-    return { updated, events };
-};
-// ------------------------------------------------------
-// Target por defecto y resolución de target
-// ------------------------------------------------------
-const defaultTargetForKind = (kind) => {
-    switch (kind) {
-        case "damage":
-        case "apply_status":
-            return "enemy";
-        case "heal":
-        case "clear_status":
-        case "modify_stats":
-        case "modify_hit_chance":
-        case "modify_crit_chance":
-        case "modify_priority":
-        case "modify_effective_speed":
-        case "shield":
-            return "self";
-        default:
-            return "self";
-    }
-};
-const resolveEffectTarget = (eff, actor, target) => {
-    const t = eff.target ?? defaultTargetForKind(eff.kind);
-    const isSelf = t === "self";
-    return {
-        primary: isSelf ? actor : target,
-        isSelf,
-    };
-};
-// ------------------------------------------------------
-// Motor de efectos genérico (move + item)
-// ------------------------------------------------------
-const applyEffectsOnTarget = (state, actor, target, moveTypeId, isCritical, effects) => {
-    dbg("applyEffectsOnTarget", {
-        actorId: actor.fighterId,
-        targetId: target.fighterId,
-        moveTypeId,
-        isCritical,
-        effects,
-    });
-    let currentActor = actor;
-    let currentTarget = target;
-    const events = [];
-    dbg("APPLY_EFFECTS_START", {
-        actorId: actor.fighterId,
-        targetId: target.fighterId,
-        moveTypeId,
-        isCritical,
-        effectsCount: effects?.length ?? 0,
-    });
-    for (const eff of effects) {
-        dbg("EFFECT_LOOP", eff);
-        switch (eff.kind) {
-            case "heal": {
-                dbg("EFFECT_HEAL_START", {
-                    amount: eff.amount,
-                    targetDefault: eff.target,
-                });
-                const { primary, isSelf } = resolveEffectTarget(eff, currentActor, currentTarget);
-                const res = applyHealToFighter(state, primary, eff.amount, actor.fighterId);
-                if (isSelf)
-                    currentActor = res.updated;
-                else
-                    currentTarget = res.updated;
-                events.push(...res.events);
-                break;
-            }
-            case "apply_status": {
-                dbg("EFFECT_APPLY_STATUS_START", {
-                    statusId: eff.statusId,
-                    targetDefault: eff.target,
-                });
-                const { primary, isSelf } = resolveEffectTarget(eff, currentActor, currentTarget);
-                const res = applyStatusToFighter(state, primary, eff.statusId);
-                if (isSelf)
-                    currentActor = res.updated;
-                else
-                    currentTarget = res.updated;
-                events.push(...res.events);
-                break;
-            }
-            case "clear_status": {
-                dbg("debemos eliminar status");
-                const { primary, isSelf } = resolveEffectTarget(eff, currentActor, currentTarget);
-                const res = clearStatusFromFighter(state, primary, eff);
-                if (isSelf)
-                    currentActor = res.updated;
-                else
-                    currentTarget = res.updated;
-                events.push(...res.events);
-                break;
-            }
-            case "damage": {
-                dbg("debemos hacer daño");
-                const { primary, isSelf } = resolveEffectTarget(eff, currentActor, currentTarget);
-                let totalDamage = 0;
-                // Daño de fórmula (stats + tipo + crit…)
-                if (eff.basePower && moveTypeId) {
-                    const { damage } = computeDamage({
-                        state,
-                        attacker: currentActor,
-                        defender: primary,
-                        moveTypeId,
-                        basePower: eff.basePower,
-                        isCritical,
-                    });
-                    totalDamage += damage;
-                }
-                // Daño plano adicional
-                if (eff.flatAmount && eff.flatAmount > 0) {
-                    totalDamage += eff.flatAmount;
-                }
-                if (totalDamage > 0) {
-                    const res = applyDamageToFighter(state, primary, totalDamage, currentActor.fighterId, isCritical);
-                    if (isSelf)
-                        currentActor = res.updatedDefender;
-                    else
-                        currentTarget = res.updatedDefender;
-                    events.push(...res.events);
-                }
-                break;
-            }
-            // TODO: conectar shield, modify_stats, etc.
-            default:
-                break;
-        }
-    }
-    return { actor: currentActor, target: currentTarget, events };
-};
-const getMovePriorityAndSpeed = (state, playerKey, action) => {
-    const { self } = getOpponentAndSelf(state, playerKey);
-    if (action.kind === "no_action") {
-        return { priority: 0, speed: 0 };
-    }
-    if (action.kind === "use_move") {
-        const moveEntry = self.moves[action.moveIndex];
-        if (!moveEntry) {
-            return { priority: 0, speed: self.effectiveStats.speed };
-        }
-        const moveDef = state.runtime.movesById[moveEntry.moveId];
-        const priority = moveDef?.priority ?? 0;
-        return {
-            priority,
-            speed: self.effectiveStats.speed,
-        };
-    }
-    // Items y switch: prioridad base 0 por ahora
-    return {
-        priority: 0,
-        speed: self.effectiveStats.speed,
-    };
-};
-// ------------------------------------------------------
-// use_move
-// ------------------------------------------------------
-const resolveDamageMove = (state, playerKey, action) => {
-    if (action.kind !== "use_move") {
-        return { state, events: [] };
-    }
-    const { self, opponent } = getOpponentAndSelf(state, playerKey);
-    const events = [];
-    const moveSlot = self.moves[action.moveIndex];
-    dbg("use_move: slot", moveSlot);
-    if (!moveSlot) {
-        dbg("use_move: empty slot", { playerKey, moveIndex: action.moveIndex });
-        return { state, events };
-    }
-    const move = state.runtime.movesById[moveSlot.moveId];
-    if (!move) {
-        dbg("use_move: move definition not found", {
-            playerKey,
-            moveId: moveSlot.moveId,
-        });
-        return { state, events };
-    }
-    if (moveSlot.currentPP <= 0) {
-        dbg("use_move: no PP", {
-            playerKey,
-            fighterId: self.fighterId,
-            moveId: move.id,
-        });
-        return { state, events };
-    }
-    events.push({
-        ...createBaseEvent(state.turnNumber, "action_declared", `${self.fighterId} usa ${move.name}`),
-        actorId: self.fighterId,
-    });
-    const accuracy = move.accuracy ?? 100;
-    const hitRoll = randomInRange(0, 100);
-    const hit = hitRoll < accuracy;
-    const updatedMoves = self.moves.map((m, idx) => idx === action.moveIndex
-        ? { ...m, currentPP: Math.max(0, m.currentPP - 1) }
-        : m);
-    let updatedSelf = { ...self, moves: updatedMoves };
-    let updatedOpponent = { ...opponent };
-    if (!hit) {
-        dbg("MISS", {
-            fighterId: self.fighterId,
-            moveId: move.id,
-            moveName: move.name,
-            hitRoll,
-            accuracy,
-        });
-        events.push({
-            ...createBaseEvent(state.turnNumber, "move_miss", `${self.fighterId} falla ${move.name}`),
-            actorId: self.fighterId,
-            moveId: move.id,
-            targetId: opponent.fighterId,
-        });
-        const newState = updateFightersInState(state, playerKey, updatedSelf, updatedOpponent);
-        return { state: newState, events };
-    }
-    const critChance = computeCritChance(state.runtime.rules, updatedSelf.effectiveStats.crit);
-    const isCritical = chance(critChance);
-    const effectiveness = getTypeEffectiveness(state, move.typeId, updatedOpponent.classId);
-    dbg("HIT", {
-        fighterId: self.fighterId,
-        moveId: move.id,
-        moveName: move.name,
-        isCritical,
-        effectiveness,
-        defenderBeforeHp: opponent.currentHp,
-    });
-    events.push({
-        ...createBaseEvent(state.turnNumber, "move_hit", `${self.fighterId} acierta ${move.name}`),
-        actorId: self.fighterId,
-        moveId: move.id,
-        targetId: opponent.fighterId,
-        isCritical,
-        effectiveness,
-    });
-    dbg("MOVE_EFFECTS", {
-        moveId: move.id,
-        moveName: move.name,
-        effects: move.effects,
-    });
-    // Todos los efectos (daño, aplicar estado, curas, etc.)
-    const { actor: finalSelf, target: finalOpp, events: extraEvents, } = applyEffectsOnTarget(state, updatedSelf, updatedOpponent, move.typeId, isCritical, move.effects);
-    events.push(...extraEvents);
-    const newState = updateFightersInState(state, playerKey, finalSelf, finalOpp);
-    return { state: newState, events };
-};
-// ------------------------------------------------------
-// use_item (ahora el target real está en cada efecto)
-// ------------------------------------------------------
-const resolveItemUse = (state, playerKey, action) => {
-    if (action.kind !== "use_item") {
-        return { state, events: [] };
-    }
-    const { self, opponent } = getOpponentAndSelf(state, playerKey);
-    const events = [];
-    const itemSlot = self.items[action.itemIndex];
-    if (!itemSlot || itemSlot.usesRemaining <= 0) {
-        dbg("use_item: no charges", {
-            playerKey,
-            itemIndex: action.itemIndex,
-        });
-        return { state, events };
-    }
-    const itemDef = state.runtime.itemsById[itemSlot.itemId];
-    if (!itemDef) {
-        dbg("use_item: item definition not found", {
-            playerKey,
-            itemId: itemSlot.itemId,
-        });
-        return { state, events };
-    }
-    const updatedItems = self.items.map((it, idx) => idx === action.itemIndex
-        ? { ...it, usesRemaining: Math.max(0, it.usesRemaining - 1) }
-        : it);
-    let updatedSelf = { ...self, items: updatedItems };
-    let updatedOpponent = { ...opponent };
-    events.push({
-        ...createBaseEvent(state.turnNumber, "action_declared", `${self.fighterId} usa objeto ${itemDef.name}`),
-        actorId: self.fighterId,
-    });
-    const { actor: finalSelf, target: finalOpp, events: extraEvents, } = applyEffectsOnTarget(state, updatedSelf, updatedOpponent, null, // los items no usan fórmula de tipo por ahora
-    false, itemDef.effects);
-    events.push(...extraEvents);
-    const newState = updateFightersInState(state, playerKey, finalSelf, finalOpp);
-    return { state: newState, events };
-};
-// ------------------------------------------------------
-// Actualizar fighters en el estado
-// ------------------------------------------------------
-const updateFightersInState = (state, actingPlayerKey, updatedSelf, updatedOpponent) => {
-    const player1 = { ...state.player1 };
-    const player2 = { ...state.player2 };
-    const updateInPlayer = (player, updated) => {
-        const newTeam = player.fighterTeam.map((f, idx) => idx === player.activeIndex ? updated : f);
-        return {
-            ...player,
-            fighterTeam: newTeam,
-        };
-    };
-    if (actingPlayerKey === "player1") {
-        const selfPlayer = updateInPlayer(player1, updatedSelf);
-        const oppPlayer = updateInPlayer(player2, updatedOpponent);
-        return {
-            ...state,
-            player1: selfPlayer,
-            player2: oppPlayer,
-        };
-    }
-    const selfPlayer = updateInPlayer(player2, updatedSelf);
-    const oppPlayer = updateInPlayer(player1, updatedOpponent);
-    return {
-        ...state,
-        player1: oppPlayer,
-        player2: selfPlayer,
-    };
-};
-// ------------------------------------------------------
-// CC duro + check winner
-// ------------------------------------------------------
-const hasHardCc = (state, fighter) => fighter.statuses.some((st) => {
-    const def = state.runtime.statusesById[st.statusId];
-    return def?.kind === "hard_cc";
-});
-const checkWinner = (state) => {
-    const f1 = getActiveFighter(state.player1);
-    const f2 = getActiveFighter(state.player2);
-    const p1Alive = f1.isAlive && f1.currentHp > 0;
-    const p2Alive = f2.isAlive && f2.currentHp > 0;
-    if (p1Alive && !p2Alive)
-        return "player1";
-    if (!p1Alive && p2Alive)
-        return "player2";
-    if (!p1Alive && !p2Alive)
-        return "draw";
-    return "none";
-};
-// ------------------------------------------------------
-// Fin de turno: aplicar DoT de estados
-// ------------------------------------------------------
-const applyEndOfTurnStatuses = (state) => {
-    const events = [];
-    const applyForPlayer = (player) => {
-        const active = getActiveFighter(player);
-        let updated = { ...active };
-        const updatedStatuses = [];
-        for (const st of active.statuses) {
-            const def = state.runtime.statusesById[st.statusId];
-            if (!def) {
-                dbg("STATUS_MISSING_DEF", {
-                    fighterId: active.fighterId,
-                    statusId: st.statusId,
-                });
-                continue;
-            }
-            let damageFromStatus = 0;
-            def.effectsPerStack.forEach((eff) => {
-                if (eff.kind === "damage") {
-                    const stacksMultiplier = st.stacks === 2 ? 2 : 1;
-                    const base = typeof eff.flatAmount === "number"
-                        ? eff.flatAmount
-                        : typeof eff.basePower === "number"
-                            ? eff.basePower
-                            : 10; // fallback
-                    damageFromStatus += base * stacksMultiplier;
-                }
-            });
-            if (damageFromStatus > 0 && updated.isAlive) {
-                dbg("STATUS_DOT", {
-                    fighterId: updated.fighterId,
-                    statusId: st.statusId,
-                    damageFromStatus,
-                    stacks: st.stacks,
-                });
-                const damageRes = applyDamageToFighter(state, updated, damageFromStatus, updated.fighterId, false);
-                updated = damageRes.updatedDefender;
-                events.push(...damageRes.events);
-            }
-            const remaining = st.remainingTurns - 1;
-            if (remaining > 0) {
-                updatedStatuses.push({
-                    ...st,
-                    remainingTurns: remaining,
-                });
-            }
-            else {
-                dbg("STATUS_EXPIRE", {
-                    fighterId: updated.fighterId,
-                    statusId: st.statusId,
-                });
-                events.push({
-                    ...createBaseEvent(state.turnNumber, "status_expired", `El estado ${st.statusId} expira en ${updated.fighterId}`),
-                    targetId: updated.fighterId,
-                    statusId: st.statusId,
-                });
-            }
-        }
-        updated = {
-            ...updated,
-            statuses: updatedStatuses,
-        };
-        const newTeam = player.fighterTeam.map((f, idx) => idx === player.activeIndex ? updated : f);
-        return {
-            ...player,
-            fighterTeam: newTeam,
-        };
-    };
-    const p1 = applyForPlayer(state.player1);
-    const p2 = applyForPlayer(state.player2);
-    const newState = {
-        ...state,
-        player1: p1,
-        player2: p2,
-    };
-    return { state: newState, events };
-};
-// ------------------------------------------------------
-// Bucle principal de turno
-// ------------------------------------------------------
-export const resolveTurn = (state, actions) => {
-    const runtimeState = state;
-    let currentState = runtimeState;
-    const recalcForPlayer = (player) => {
-        const team = player.fighterTeam.map((f) => recomputeEffectiveStatsForFighter(runtimeState, f));
-        return { ...player, fighterTeam: team };
-    };
-    currentState = {
-        ...currentState,
-        player1: recalcForPlayer(currentState.player1),
-        player2: recalcForPlayer(currentState.player2),
-    };
-    const events = [];
-    dbg(`TURN ${runtimeState.turnNumber} start`, {
-        p1Action: actions.player1.kind,
-        p2Action: actions.player2.kind,
-    });
-    events.push({
-        ...createBaseEvent(runtimeState.turnNumber, "turn_start", `Comienza el turno ${runtimeState.turnNumber}`),
-    });
-    const entries = [
-        {
-            playerKey: "player1",
-            action: actions.player1,
-            ...getMovePriorityAndSpeed(runtimeState, "player1", actions.player1),
-        },
-        {
-            playerKey: "player2",
-            action: actions.player2,
-            ...getMovePriorityAndSpeed(runtimeState, "player2", actions.player2),
-        },
-    ];
-    entries.sort((a, b) => {
-        if (b.priority !== a.priority) {
-            return b.priority - a.priority;
-        }
-        if (b.speed !== a.speed) {
-            return b.speed - a.speed;
-        }
-        // empate total → coin flip
-        return Math.random() < 0.5 ? -1 : 1;
-    });
-    dbg(`TURN ${runtimeState.turnNumber} order`, entries.map((e) => ({
-        player: e.playerKey,
-        action: e.action.kind,
-        priority: e.priority,
-        speed: e.speed,
-    })));
-    for (const entry of entries) {
-        const { playerKey, action } = entry;
-        if (action.kind === "no_action")
-            continue;
-        const { self } = getOpponentAndSelf(currentState, playerKey);
-        if (!self.isAlive || self.currentHp <= 0)
-            continue;
-        if (hasHardCc(currentState, self)) {
-            events.push({
-                ...createBaseEvent(currentState.turnNumber, "action_skipped_hard_cc", `${self.fighterId} no puede actuar por control total`),
-                actorId: self.fighterId,
-            });
-            continue;
-        }
-        if (action.kind === "use_move") {
-            const result = resolveDamageMove(currentState, playerKey, action);
-            currentState = result.state;
-            events.push(...result.events);
-        }
-        else if (action.kind === "use_item") {
-            const result = resolveItemUse(currentState, playerKey, action);
-            currentState = result.state;
-            events.push(...result.events);
-        }
-        else {
-            // switch_fighter u otros no implementados aún
-            continue;
-        }
-        const winnerAfterAction = checkWinner(currentState);
-        if (winnerAfterAction !== "none") {
-            events.push({
-                ...createBaseEvent(currentState.turnNumber, "battle_end", `La batalla termina: ${winnerAfterAction}`),
-                winner: winnerAfterAction,
-            });
-            const finalState = {
-                ...currentState,
-                turnNumber: currentState.turnNumber + 1,
-            };
-            return {
-                newState: finalState,
-                events,
-            };
-        }
-    }
-    const statusResult = applyEndOfTurnStatuses(currentState);
-    currentState = statusResult.state;
-    events.push(...statusResult.events);
-    const winnerAtEnd = checkWinner(currentState);
-    if (winnerAtEnd !== "none") {
-        events.push({
-            ...createBaseEvent(currentState.turnNumber, "battle_end", `La batalla termina: ${winnerAtEnd}`),
-            winner: winnerAtEnd,
-        });
-    }
-    events.push({
-        ...createBaseEvent(currentState.turnNumber, "turn_end", `Termina el turno ${currentState.turnNumber}`),
-    });
-    const finalState = {
-        ...currentState,
-        turnNumber: currentState.turnNumber + 1,
-    };
-    return {
-        newState: finalState,
-        events,
-    };
-};