pokemon-io-core 0.0.118 → 0.0.120

package/dist/engine/engine.js

@@ -0,0 +1,1046 @@
+// 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.1,
+    stabMultiplier: 1.1,
+    randomMinDamageFactor: 0.8,
+    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");
+    }
+    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,
+        })),
+        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 team = cfg.fighters.map((fCfg) => createBattleFighter(fCfg));
+    const inventory = cfg.items.map((item) => ({
+        itemId: item.id,
+        usesRemaining: item.maxUses,
+    }));
+    return {
+        fighterTeam: team,
+        activeIndex: 0,
+        inventory,
+    };
+};
+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,
+        forcedSwitch: null,
+    };
+    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 getPlayersAndActives = (state, playerKey) => {
+    const selfPlayer = playerKey === "player1" ? state.player1 : state.player2;
+    const oppPlayer = playerKey === "player1" ? state.player2 : state.player1;
+    return {
+        selfPlayer,
+        oppPlayer,
+        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) => {
+    dbg("🧨 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;
+    dbg("🧨 computeDamage", `
+      basePower(${basePower}) *
+      (attackerOff(${attackerOff}) / Math.max(1, defenderDef(${defenderDef}))) = ${attackerOff / Math.max(1, defenderDef)}*
+      typeEffectiveness(${typeEffectiveness}) *
+      stabMultiplier(${stabMultiplier}) *
+      critMultiplier(${critMultiplier}) *
+      randomFactor(${randomFactor}) = ${rawDamage}
+    `);
+    const finalDamage = Math.max(1, Math.floor(rawDamage));
+    dbg("🧨 computeDamage", `
+      finalDamage(${finalDamage}) = Math.max(1, Math.floor(rawDamage))
+    `);
+    return {
+        damage: finalDamage,
+        effectiveness: typeEffectiveness,
+    };
+};
+export const applyForcedSwitchChoice = (state, targetPlayer, newIndex) => {
+    const forced = state.forcedSwitch;
+    if (!forced)
+        return { state, events: [] };
+    if (forced.targetPlayer !== targetPlayer)
+        return { state, events: [] };
+    const self = targetPlayer === "player1" ? state.player1 : state.player2;
+    if (newIndex < 0 || newIndex >= self.fighterTeam.length)
+        return { state, events: [] };
+    const fromIndex = self.activeIndex;
+    if (newIndex === fromIndex)
+        return { state, events: [] };
+    const toFighter = self.fighterTeam[newIndex];
+    if (!toFighter || !toFighter.isAlive || toFighter.currentHp <= 0)
+        return { state, events: [] };
+    const fromFighter = self.fighterTeam[fromIndex];
+    const events = [
+        {
+            ...createBaseEvent(state.turnNumber, "fighter_switched", `El entrenador retira a ${fromFighter.fighterId} y manda a ${toFighter.fighterId}`),
+            fromFighterId: fromFighter.fighterId,
+            toFighterId: toFighter.fighterId,
+        },
+        {
+            ...createBaseEvent(state.turnNumber, "turn_end", `Termina el turno ${state.turnNumber}`),
+        },
+    ];
+    const switchedState = targetPlayer === "player1"
+        ? {
+            ...state,
+            forcedSwitch: null,
+            player1: { ...state.player1, activeIndex: newIndex },
+        }
+        : {
+            ...state,
+            forcedSwitch: null,
+            player2: { ...state.player2, activeIndex: newIndex },
+        };
+    const nextState = {
+        ...switchedState,
+        turnNumber: switchedState.turnNumber + 1,
+    };
+    return { state: nextState, events };
+};
+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,
+        };
+    }
+    if (action.kind === "switch_fighter") {
+        return {
+            priority: 10, // prioridad especial (ajústalo si quieres)
+            speed: self.effectiveStats.speed,
+        };
+    }
+    // Items y switch: prioridad base 0 por ahora
+    return {
+        priority: 0,
+        speed: self.effectiveStats.speed,
+    };
+};
+const resolveSwitchFighter = (state, playerKey, action) => {
+    if (action.kind !== "switch_fighter")
+        return { state, events: [] };
+    const events = [];
+    const selfPlayer = playerKey === "player1" ? state.player1 : state.player2;
+    const fromIndex = selfPlayer.activeIndex;
+    const toIndex = action.newIndex;
+    // validaciones
+    if (toIndex < 0 || toIndex >= selfPlayer.fighterTeam.length) {
+        return { state, events };
+    }
+    if (toIndex === fromIndex) {
+        return { state, events };
+    }
+    const target = selfPlayer.fighterTeam[toIndex];
+    if (!target || !target.isAlive || target.currentHp <= 0) {
+        return { state, events };
+    }
+    const fromFighter = selfPlayer.fighterTeam[fromIndex];
+    events.push({
+        ...createBaseEvent(state.turnNumber, "fighter_switched", `El entrenador retira a ${fromFighter.fighterId} y manda a ${target.fighterId}`),
+        fromFighterId: fromFighter.fighterId,
+        toFighterId: target.fighterId,
+        toHp: target.currentHp,
+        toStatuses: (target.statuses ?? []).map((st) => ({
+            statusId: st.statusId,
+            stacks: st.stacks,
+            remainingTurns: st.remainingTurns,
+        })),
+    });
+    // actualizar activeIndex
+    if (playerKey === "player1") {
+        return {
+            state: {
+                ...state,
+                player1: {
+                    ...state.player1,
+                    activeIndex: toIndex,
+                },
+            },
+            events,
+        };
+    }
+    return {
+        state: {
+            ...state,
+            player2: {
+                ...state.player2,
+                activeIndex: toIndex,
+            },
+        },
+        events,
+    };
+};
+// ------------------------------------------------------
+// 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} usó ${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);
+    let newState = updateFightersInState(state, playerKey, finalSelf, finalOpp);
+    // --- FORCED SWITCH (Roar) ---
+    const hasForceSwitch = move.effects.some((e) => e.kind === "force_switch");
+    if (hasForceSwitch) {
+        const targetPlayer = playerKey === "player1" ? "player2" : "player1";
+        const targetSide = targetPlayer === "player1" ? newState.player1 : newState.player2;
+        const activeIdx = targetSide.activeIndex;
+        const hasBenchAlive = targetSide.fighterTeam.some((f, idx) => {
+            if (idx === activeIdx)
+                return false;
+            return f.isAlive && f.currentHp > 0;
+        });
+        if (hasBenchAlive) {
+            newState = {
+                ...newState,
+                forcedSwitch: {
+                    targetPlayer,
+                    reason: "roar",
+                },
+            };
+            events.push({
+                ...createBaseEvent(state.turnNumber, "action_declared", `¡El entrenador rival debe cambiar de luchador!`),
+                actorId: self.fighterId,
+            });
+        }
+    }
+    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 { selfPlayer, oppPlayer, self, opponent } = getPlayersAndActives(state, playerKey);
+    const events = [];
+    const itemSlot = selfPlayer.inventory[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 updatedInventory = selfPlayer.inventory.map((it, idx) => idx === action.itemIndex
+        ? { ...it, usesRemaining: Math.max(0, it.usesRemaining - 1) }
+        : it);
+    let updatedSelf = { ...self };
+    let updatedOpponent = { ...opponent };
+    events.push({
+        ...createBaseEvent(state.turnNumber, "action_declared", `${self.fighterId} usó ${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);
+    let newState = updateFightersInState(state, playerKey, finalSelf, finalOpp);
+    // persistimos el inventario gastado en el jugador que actuó
+    if (playerKey === "player1") {
+        newState = {
+            ...newState,
+            player1: {
+                ...newState.player1,
+                inventory: updatedInventory,
+            },
+        };
+    }
+    else {
+        newState = {
+            ...newState,
+            player2: {
+                ...newState.player2,
+                inventory: updatedInventory,
+            },
+        };
+    }
+    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 p1Alive = state.player1.fighterTeam.some((f) => f.isAlive && f.currentHp > 0);
+    const p2Alive = state.player2.fighterTeam.some((f) => f.isAlive && f.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 === "switch_fighter") {
+            const result = resolveSwitchFighter(currentState, playerKey, action);
+            currentState = result.state;
+            events.push(...result.events);
+        }
+        if (action.kind === "use_move") {
+            const result = resolveDamageMove(currentState, playerKey, action);
+            currentState = result.state;
+            events.push(...result.events);
+        }
+        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;
+        }
+        if (currentState.forcedSwitch) {
+            return {
+                newState: currentState,
+                events,
+            };
+        }
+        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,
+    };
+};