pokemon-io-core 0.0.90 → 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,6 +21,8 @@ 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" | "faint";

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/package.json

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