pokemon-io-core 0.0.89 → 0.0.91

package/dist/api/battle.d.ts

@@ -4,6 +4,16 @@ export interface BattlePlayerStatusView {
     stacks: 1 | 2;
     remainingTurns: number;
 }
+export interface BattleMovePpView {
+    moveId: string;
+    currentPP: number;
+    maxPP: number;
+}
+export interface BattleItemUsesView {
+    itemId: string;
+    usesRemaining: number;
+    maxUses: number;
+}
 export interface BattlePlayerView {
     playerId: string;
     nickname: string;
@@ -11,9 +21,11 @@ export interface BattlePlayerView {
     statuses: BattlePlayerStatusView[];
     activeFighterId: string | null;
     activeIndex: number;
+    activeMoves?: BattleMovePpView[];
+    inventory?: BattleItemUsesView[];
 }
 export type BattleStatus = "ongoing" | "awaiting_forced_switch" | "finished";
-export type ForcedSwitchReason = "roar";
+export type ForcedSwitchReason = "roar" | "faint";
 export interface ForcedSwitchView {
     targetPlayerId: string;
     sourcePlayerId: string;

package/dist/core/battleState.d.ts

@@ -37,6 +37,9 @@ export type ForcedSwitchState = null | {
         kind: "move";
         moveId: string;
         actorFighterId: string;
+    } | {
+        kind: "faint";
+        actorFighterId: string;
     };
 };
 export interface BattleState {

package/dist/core/battleState.js

@@ -1 +1,2 @@
+// pokemon-io-core/src/core/battleState.ts
 export {};

package/dist/engine/actions/forcedSwitch.js

@@ -17,28 +17,20 @@ export const applyForcedSwitchChoice = (state, targetPlayer, newIndex) => {
     const fromFighter = self.fighterTeam[fromIndex];
     const events = [
         {
-            ...createBaseEvent(state.turnNumber, "fighter_switched", `El entrenador retira a ${fromFighter.fighterId} y manda a ${toFighter.fighterId}`),
+            ...createBaseEvent(state.turnNumber, "fighter_switched", `El entrenador cambia a ${toFighter.fighterId}`),
             fromFighterId: fromFighter.fighterId,
             toFighterId: toFighter.fighterId,
-        },
-        {
-            ...createBaseEvent(state.turnNumber, "turn_end", `Termina el turno ${state.turnNumber}`),
+            // ✅ CLAVE para tu replay:
+            toHp: toFighter.currentHp,
+            toStatuses: (toFighter.statuses ?? []).map((st) => ({
+                statusId: st.statusId,
+                stacks: st.stacks,
+                remainingTurns: st.remainingTurns,
+            })),
         },
     ];
-    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,
-    };
+    const nextState = targetPlayer === "player1"
+        ? { ...state, forcedSwitch: null, player1: { ...state.player1, activeIndex: newIndex } }
+        : { ...state, forcedSwitch: null, player2: { ...state.player2, activeIndex: newIndex } };
     return { state: nextState, events };
 };

package/dist/engine/status/endOfTurn.js

@@ -1,22 +1,26 @@
 import { applyDamageToFighter } from "../combat/damage.js";
-import { dbg } from "../debug.js";
 import { createBaseEvent } from "../events.js";
 import { getActiveFighter } from "../fighters/selectors.js";
+const isFainted = (f) => !f.isAlive || f.currentHp <= 0;
 export const applyEndOfTurnStatuses = (state) => {
     const events = [];
     const applyForPlayer = (player) => {
         const active = getActiveFighter(player);
+        // ✅ Si ya está KO, no hay ticks ni expiraciones
+        if (!active || isFainted(active)) {
+            return player;
+        }
         let updated = { ...active };
         const updatedStatuses = [];
         for (const st of active.statuses) {
+            // ✅ Si ha muerto durante ticks previos, paramos y limpiamos
+            if (isFainted(updated)) {
+                updated = { ...updated, statuses: [] };
+                break;
+            }
             const def = state.runtime.statusesById[st.statusId];
-            if (!def) {
-                dbg("STATUS_MISSING_DEF", {
-                    fighterId: active.fighterId,
-                    statusId: st.statusId,
-                });
+            if (!def)
                 continue;
-            }
             let damageFromStatus = 0;
             def.effectsPerStack.forEach((eff) => {
                 if (eff.kind === "damage") {
@@ -25,33 +29,25 @@ export const applyEndOfTurnStatuses = (state) => {
                         ? eff.flatAmount
                         : typeof eff.basePower === "number"
                             ? eff.basePower
-                            : 10; // fallback
+                            : 10;
                     damageFromStatus += base * stacksMultiplier;
                 }
             });
-            if (damageFromStatus > 0 && updated.isAlive) {
-                dbg("STATUS_DOT", {
-                    fighterId: updated.fighterId,
-                    statusId: st.statusId,
-                    damageFromStatus,
-                    stacks: st.stacks,
-                });
+            if (damageFromStatus > 0) {
                 const damageRes = applyDamageToFighter(state, updated, damageFromStatus, updated.fighterId, false);
                 updated = damageRes.updatedDefender;
                 events.push(...damageRes.events);
+                // ✅ Si muere por este tick: no expiraciones, no más ticks
+                if (isFainted(updated)) {
+                    updated = { ...updated, statuses: [] };
+                    break;
+                }
             }
+            // solo decrementamos si sigue vivo
             const remaining = st.remainingTurns - 1;
-            if (remaining > 0) {
-                updatedStatuses.push({
-                    ...st,
-                    remainingTurns: remaining,
-                });
-            }
+            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,
@@ -59,22 +55,13 @@ export const applyEndOfTurnStatuses = (state) => {
                 });
             }
         }
-        updated = {
-            ...updated,
-            statuses: updatedStatuses,
-        };
+        if (!isFainted(updated)) {
+            updated = { ...updated, statuses: updatedStatuses };
+        }
         const newTeam = player.fighterTeam.map((f, idx) => idx === player.activeIndex ? updated : f);
-        return {
-            ...player,
-            fighterTeam: newTeam,
-        };
+        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 };
+    return { state: { ...state, player1: p1, player2: p2 }, events };
 };

package/dist/engine/turn/resolveTurn.js

@@ -1,5 +1,4 @@
-// ------------------------------------------------------
-// Bucle principal de turno
+// turn/resolveTurn.ts (o donde lo tengas)
 import { resolveItemUse } from "../actions/item.js";
 import { resolveDamageMove } from "../actions/move.js";
 import { getMovePriorityAndSpeed } from "../actions/priority.js";
@@ -12,6 +11,42 @@ import { getOpponentAndSelf } from "../fighters/selectors.js";
 import { applyEndOfTurnStatuses } from "../status/endOfTurn.js";
 import { hasHardCc } from "../status/hardCc.js";
 // ------------------------------------------------------
+// Helpers KO -> forced switch (estilo Pokémon real)
+// ------------------------------------------------------
+const isActiveFainted = (player) => {
+    const active = player.fighterTeam[player.activeIndex];
+    if (!active)
+        return true;
+    return !active.isAlive || active.currentHp <= 0;
+};
+const hasAliveBench = (player) => player.fighterTeam.some((f, idx) => idx !== player.activeIndex && f.isAlive && f.currentHp > 0);
+/**
+ * Si hay un activo KO con banca viva, pedimos forced switch.
+ * Regla:
+ * - primero forzamos al oponente del que acaba de actuar (lo normal)
+ * - si no, forzamos al propio (recoil/status raro)
+ */
+const computeForcedSwitchFromFaint = (state, lastActingPlayerKey, actorFighterId) => {
+    if (state.forcedSwitch)
+        return null;
+    const oppKey = lastActingPlayerKey === "player1" ? "player2" : "player1";
+    const oppPlayer = oppKey === "player1" ? state.player1 : state.player2;
+    if (isActiveFainted(oppPlayer) && hasAliveBench(oppPlayer)) {
+        return {
+            targetPlayer: oppKey,
+            reason: { kind: "faint", actorFighterId },
+        };
+    }
+    const selfPlayer = lastActingPlayerKey === "player1" ? state.player1 : state.player2;
+    if (isActiveFainted(selfPlayer) && hasAliveBench(selfPlayer)) {
+        return {
+            targetPlayer: lastActingPlayerKey,
+            reason: { kind: "faint", actorFighterId },
+        };
+    }
+    return null;
+};
+// ------------------------------------------------------
 export const resolveTurn = (state, actions) => {
     const runtimeState = state;
     let currentState = runtimeState;
@@ -19,6 +54,7 @@ export const resolveTurn = (state, actions) => {
         const team = player.fighterTeam.map((f) => recomputeEffectiveStatsForFighter(runtimeState, f));
         return { ...player, fighterTeam: team };
     };
+    // Recalcular stats efectivos antes del turno
     currentState = {
         ...currentState,
         player1: recalcForPlayer(currentState.player1),
@@ -45,13 +81,10 @@ export const resolveTurn = (state, actions) => {
         },
     ];
     entries.sort((a, b) => {
-        if (b.priority !== a.priority) {
+        if (b.priority !== a.priority)
             return b.priority - a.priority;
-        }
-        if (b.speed !== a.speed) {
+        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) => ({
@@ -64,6 +97,30 @@ export const resolveTurn = (state, actions) => {
         const { playerKey, action } = entry;
         if (action.kind === "no_action")
             continue;
+        // ✅ CLAVE: permitir SWITCH incluso si el activo está KO (evita soft-locks)
+        if (action.kind === "switch_fighter") {
+            const result = resolveSwitchFighter(currentState, playerKey, action);
+            currentState = result.state;
+            events.push(...result.events);
+            // Si el engine ya trae forcedSwitch (por roar u otro), paramos aquí
+            if (currentState.forcedSwitch) {
+                return { newState: currentState, events };
+            }
+            const winnerAfterSwitch = checkWinner(currentState);
+            if (winnerAfterSwitch !== "none") {
+                events.push({
+                    ...createBaseEvent(currentState.turnNumber, "battle_end", `La batalla termina: ${winnerAfterSwitch}`),
+                    winner: winnerAfterSwitch,
+                });
+                const finalState = {
+                    ...currentState,
+                    turnNumber: currentState.turnNumber + 1,
+                };
+                return { newState: finalState, events };
+            }
+            continue;
+        }
+        // A partir de aquí: moves/items solo si el activo está vivo
         const { self } = getOpponentAndSelf(currentState, playerKey);
         if (!self.isAlive || self.currentHp <= 0)
             continue;
@@ -74,30 +131,31 @@ export const resolveTurn = (state, actions) => {
             });
             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") {
+        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;
         }
+        // ✅ forcedSwitch existente (roar, etc.)
         if (currentState.forcedSwitch) {
-            return {
-                newState: currentState,
-                events,
+            return { newState: currentState, events };
+        }
+        // ✅ NUEVO: forced switch automático por KO (sin consumir turno)
+        const faintForced = computeForcedSwitchFromFaint(currentState, playerKey, self.fighterId);
+        if (faintForced) {
+            currentState = {
+                ...currentState,
+                forcedSwitch: faintForced,
             };
+            return { newState: currentState, events };
         }
         const winnerAfterAction = checkWinner(currentState);
         if (winnerAfterAction !== "none") {
@@ -109,15 +167,38 @@ export const resolveTurn = (state, actions) => {
                 ...currentState,
                 turnNumber: currentState.turnNumber + 1,
             };
-            return {
-                newState: finalState,
-                events,
-            };
+            return { newState: finalState, events };
         }
     }
+    // Fin de turno: estados (DoT, etc.)
     const statusResult = applyEndOfTurnStatuses(currentState);
     currentState = statusResult.state;
     events.push(...statusResult.events);
+    // ✅ NUEVO: KO por estados al final del turno también fuerza cambio
+    if (!currentState.forcedSwitch) {
+        const p1Needs = isActiveFainted(currentState.player1) && hasAliveBench(currentState.player1);
+        const p2Needs = isActiveFainted(currentState.player2) && hasAliveBench(currentState.player2);
+        if (p1Needs) {
+            currentState = {
+                ...currentState,
+                forcedSwitch: {
+                    targetPlayer: "player1",
+                    reason: { kind: "faint", actorFighterId: "status" },
+                },
+            };
+            return { newState: currentState, events };
+        }
+        if (p2Needs) {
+            currentState = {
+                ...currentState,
+                forcedSwitch: {
+                    targetPlayer: "player2",
+                    reason: { kind: "faint", actorFighterId: "status" },
+                },
+            };
+            return { newState: currentState, events };
+        }
+    }
     const winnerAtEnd = checkWinner(currentState);
     if (winnerAtEnd !== "none") {
         events.push({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pokemon-io-core",
-  "version": "0.0.89",
+  "version": "0.0.91",
   "description": "",
   "main": "index.js",
   "type": "module",