pokemon-io-core 0.0.89 → 0.0.90

package/dist/api/battle.d.ts

@@ -13,7 +13,7 @@ export interface BattlePlayerView {
     activeIndex: number;
 }
 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/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.90",
   "description": "",
   "main": "index.js",
   "type": "module",