pokemon-io-core 0.0.23 → 0.0.24

package/dist/api/battle.d.ts

@@ -1,14 +1,22 @@
+import { StatusId } from "../core";
+export interface BattlePlayerStatusView {
+    statusId: StatusId;
+    stacks: 1 | 2;
+    remainingTurns: number;
+}
 export interface BattlePlayerView {
     playerId: string;
     nickname: string;
     hp: number;
+    statuses: BattlePlayerStatusView[];
 }
-export type BattleStatusView = "ongoing" | "finished";
+export type BattleStatus = "ongoing" | "finished";
 export interface BattleView {
     roomId: string;
-    status: BattleStatusView;
-    currentTurnPlayerId: string | null;
+    status: BattleStatus;
     winnerId: string | null;
+    currentTurnPlayerId: string | null;
+    startedAt: string;
     endsAt: string;
     players: BattlePlayerView[];
 }

package/dist/core/engine.js

@@ -1,4 +1,14 @@
 // 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,
@@ -7,18 +17,19 @@ const DEFAULT_RULES = {
     randomMinDamageFactor: 0.85,
     randomMaxDamageFactor: 1.0,
 };
-const buildMap = (list) => {
-    return list.reduce((acc, item) => {
-        acc[item.id] = item;
-        return acc;
-    }, {});
-};
+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");
@@ -77,10 +88,10 @@ export const createInitialBattleState = (config) => {
     };
     return state;
 };
-// HELPERS
-const getActiveFighter = (player) => {
-    return player.fighterTeam[player.activeIndex];
-};
+// ------------------------------------------------------
+// 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;
@@ -96,9 +107,7 @@ const getTypeEffectiveness = (state, attackerTypeId, defenderTypeId) => {
         return 1;
     return row[defenderTypeId] ?? 1;
 };
-const randomInRange = (min, max) => {
-    return Math.random() * (max - min) + min;
-};
+const randomInRange = (min, max) => Math.random() * (max - min) + min;
 const chance = (probability) => {
     if (probability <= 0)
         return false;
@@ -106,8 +115,9 @@ const chance = (probability) => {
         return true;
     return Math.random() < probability;
 };
-// FIN HELPERS
-// CALCULO DE CRITICOS Y DAÑO
+// ------------------------------------------------------
+// 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));
@@ -175,14 +185,16 @@ const applyDamageToFighter = (state, defender, amount, actorId, isCritical) => {
     }
     return { updatedDefender, events };
 };
+// ------------------------------------------------------
+// apply_status
+// ------------------------------------------------------
 const applyStatusToFighter = (state, target, statusId) => {
     const def = state.runtime.statusesById[statusId];
     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;
+    const duration = Math.floor(randomInRange(def.minDurationTurns, def.maxDurationTurns + 1)) || def.minDurationTurns;
     let newStatuses = [...target.statuses];
     if (!existing) {
         newStatuses.push({
@@ -199,6 +211,12 @@ const applyStatusToFighter = (state, target, statusId) => {
     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,
@@ -209,6 +227,54 @@ const applyStatusToFighter = (state, target, statusId) => {
         events,
     };
 };
+const applyClearStatusToFighter = (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;
@@ -218,6 +284,12 @@ const applyHealToFighter = (state, target, amount, sourceId) => {
         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,
@@ -226,6 +298,9 @@ const applyHealToFighter = (state, target, amount, sourceId) => {
     });
     return { updated, events };
 };
+// ------------------------------------------------------
+// Motor de efectos genérico (move + item)
+// ------------------------------------------------------
 const applyEffectsOnTarget = (state, actor, target, effects) => {
     let currentActor = actor;
     let currentTarget = target;
@@ -244,6 +319,12 @@ const applyEffectsOnTarget = (state, actor, target, effects) => {
                 events.push(...res.events);
                 break;
             }
+            case "clear_status": {
+                const res = applyClearStatusToFighter(state, currentTarget, eff);
+                currentTarget = res.updated;
+                events.push(...res.events);
+                break;
+            }
             case "damage": {
                 if (typeof eff.amount === "number") {
                     const res = applyDamageToFighter(state, currentTarget, eff.amount, actor.fighterId, false);
@@ -253,6 +334,7 @@ const applyEffectsOnTarget = (state, actor, target, effects) => {
                 break;
             }
             default:
+                // otros efectos (modify_stats, etc.) se pueden añadir aquí
                 break;
         }
     }
@@ -281,6 +363,9 @@ const getMovePriorityAndSpeed = (state, playerKey, action) => {
         speed: self.effectiveStats.speed,
     };
 };
+// ------------------------------------------------------
+// use_move
+// ------------------------------------------------------
 const resolveDamageMove = (state, playerKey, action) => {
     if (action.kind !== "use_move") {
         return { state, events: [] };
@@ -289,14 +374,23 @@ const resolveDamageMove = (state, playerKey, action) => {
     const events = [];
     const moveSlot = self.moves[action.moveIndex];
     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 };
     }
-    // Sin PP → no hace nada
     if (moveSlot.currentPP <= 0) {
+        dbg("use_move: no PP", {
+            playerKey,
+            fighterId: self.fighterId,
+            moveId: move.id,
+        });
         return { state, events };
     }
     // Movimiento solo de curación → no calculamos daño base
@@ -315,7 +409,14 @@ const resolveDamageMove = (state, playerKey, action) => {
         const newState = updateFightersInState(state, playerKey, finalSelf, finalOpp);
         return { state: newState, events };
     }
-    // Movimiento de daño/hybrid
+    dbg("ACTION", {
+        playerKey,
+        fighterId: self.fighterId,
+        moveId: move.id,
+        moveName: move.name,
+        targetId: opponent.fighterId,
+        currentPP: moveSlot.currentPP,
+    });
     events.push({
         ...createBaseEvent(state.turnNumber, "action_declared", `${self.fighterId} usa ${move.name}`),
         actorId: self.fighterId,
@@ -329,6 +430,13 @@ const resolveDamageMove = (state, playerKey, action) => {
     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,
@@ -338,7 +446,6 @@ const resolveDamageMove = (state, playerKey, action) => {
         const newState = updateFightersInState(state, playerKey, updatedSelf, updatedOpponent);
         return { state: newState, events };
     }
-    // Crítico y daño base
     const critChance = computeCritChance(state.runtime.rules, updatedSelf.effectiveStats.crit);
     const isCritical = chance(critChance);
     const { damage, effectiveness } = computeDamage({
@@ -348,6 +455,15 @@ const resolveDamageMove = (state, playerKey, action) => {
         move,
         isCritical,
     });
+    dbg("HIT", {
+        fighterId: self.fighterId,
+        moveId: move.id,
+        moveName: move.name,
+        isCritical,
+        damage,
+        effectiveness,
+        defenderBeforeHp: opponent.currentHp,
+    });
     events.push({
         ...createBaseEvent(state.turnNumber, "move_hit", `${self.fighterId} acierta ${move.name}`),
         actorId: self.fighterId,
@@ -357,14 +473,21 @@ const resolveDamageMove = (state, playerKey, action) => {
         effectiveness,
     });
     const damageRes = applyDamageToFighter(state, updatedOpponent, damage, updatedSelf.fighterId, isCritical);
+    dbg("AFTER_DAMAGE", {
+        targetId: opponent.fighterId,
+        newHp: damageRes.updatedDefender.currentHp,
+    });
     updatedOpponent = damageRes.updatedDefender;
     events.push(...damageRes.events);
-    // Efectos secundarios del movimiento (quemado, buffs, daño extra fijo, etc.)
+    // Efectos secundarios del movimiento (quemado, buffs, daño fijo, etc.)
     const { actor: finalSelf, target: finalOpp, events: extraEvents, } = applyEffectsOnTarget(state, updatedSelf, updatedOpponent, move.effects);
     events.push(...extraEvents);
     const newState = updateFightersInState(state, playerKey, finalSelf, finalOpp);
     return { state: newState, events };
 };
+// ------------------------------------------------------
+// use_item (respeta item.target: "self" | "enemy")
+// ------------------------------------------------------
 const resolveItemUse = (state, playerKey, action) => {
     if (action.kind !== "use_item") {
         return { state, events: [] };
@@ -373,13 +496,20 @@ const resolveItemUse = (state, playerKey, action) => {
     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 };
     }
-    // Reducir usos
     const updatedItems = self.items.map((it, idx) => idx === action.itemIndex
         ? { ...it, usesRemaining: Math.max(0, it.usesRemaining - 1) }
         : it);
@@ -389,11 +519,29 @@ const resolveItemUse = (state, playerKey, action) => {
         ...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, itemDef.effects);
-    events.push(...extraEvents);
+    let finalSelf = updatedSelf;
+    let finalOpp = updatedOpponent;
+    // interpretamos itemDef.target:
+    // - "self"  → efectos aplican sobre el propio usuario
+    // - "enemy" → efectos sobre el rival
+    if (itemDef.target === "self") {
+        const res = applyEffectsOnTarget(state, updatedSelf, updatedSelf, itemDef.effects);
+        finalSelf = res.actor; // o res.target, son el mismo
+        // el oponente no cambia
+        events.push(...res.events);
+    }
+    else {
+        const res = applyEffectsOnTarget(state, updatedSelf, updatedOpponent, itemDef.effects);
+        finalSelf = res.actor;
+        finalOpp = res.target;
+        events.push(...res.events);
+    }
     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 };
@@ -421,14 +569,13 @@ const updateFightersInState = (state, actingPlayerKey, updatedSelf, updatedOppon
         player2: selfPlayer,
     };
 };
-// FIN RESOLUCION DE ACCION DE use_move
-// ORDEN DE ACCIONES HARD CC Y FIN DE TURNO
-const hasHardCc = (state, fighter) => {
-    return fighter.statuses.some((st) => {
-        const def = state.runtime.statusesById[st.statusId];
-        return def?.kind === "hard_cc";
-    });
-};
+// ------------------------------------------------------
+// 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);
@@ -442,7 +589,9 @@ const checkWinner = (state) => {
         return "draw";
     return "none";
 };
-// Estados al final del turno: MVP = aplicar DoT básico
+// ------------------------------------------------------
+// Fin de turno: aplicar DoT de estados
+// ------------------------------------------------------
 const applyEndOfTurnStatuses = (state) => {
     const events = [];
     const applyForPlayer = (player) => {
@@ -452,18 +601,27 @@ const applyEndOfTurnStatuses = (state) => {
         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;
             }
-            // MVP: interpretamos cualquier efecto kind: "damage" como DoT
             let damageFromStatus = 0;
             def.effectsPerStack.forEach((eff) => {
                 if (eff.kind === "damage") {
                     const stacksMultiplier = st.stacks === 2 ? 2 : 1;
-                    const basePower = 10; // DoT base “genérico” (podrás parametrizar)
+                    const basePower = typeof eff.amount === "number" ? eff.amount : 10;
                     damageFromStatus += basePower * 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);
@@ -476,6 +634,10 @@ const applyEndOfTurnStatuses = (state) => {
                 });
             }
             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,
@@ -502,15 +664,19 @@ const applyEndOfTurnStatuses = (state) => {
     };
     return { state: newState, events };
 };
-// FIN ORDEN DE ACCIONES HARD CC Y FIN DE TURNO
+// ------------------------------------------------------
+// Bucle principal de turno
+// ------------------------------------------------------
 export const resolveTurn = (state, actions) => {
     const runtimeState = state;
     const events = [];
-    // Evento de inicio de turno
+    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}`),
     });
-    // Construir orden con prioridad+speed
     const entries = [
         {
             playerKey: "player1",
@@ -533,18 +699,20 @@ export const resolveTurn = (state, actions) => {
         // 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,
+    })));
     let currentState = runtimeState;
     for (const entry of entries) {
         const { playerKey, action } = entry;
-        if (action.kind === "no_action") {
+        if (action.kind === "no_action")
             continue;
-        }
         const { self } = getOpponentAndSelf(currentState, playerKey);
-        // Si ya está muerto, no hace nada
-        if (!self.isAlive || self.currentHp <= 0) {
+        if (!self.isAlive || self.currentHp <= 0)
             continue;
-        }
-        // Hard CC → se salta acción
         if (hasHardCc(currentState, self)) {
             events.push({
                 ...createBaseEvent(currentState.turnNumber, "action_skipped_hard_cc", `${self.fighterId} no puede actuar por control total`),
@@ -563,10 +731,9 @@ export const resolveTurn = (state, actions) => {
             events.push(...result.events);
         }
         else {
-            // switch_fighter y otros aún no implementados
+            // switch_fighter u otros no implementados aún
             continue;
         }
-        // Comprobar victoria inmediata tras cada acción
         const winnerAfterAction = checkWinner(currentState);
         if (winnerAfterAction !== "none") {
             events.push({
@@ -583,7 +750,6 @@ export const resolveTurn = (state, actions) => {
             };
         }
     }
-    // Fin de turno: aplicar estados
     const statusResult = applyEndOfTurnStatuses(currentState);
     currentState = statusResult.state;
     events.push(...statusResult.events);

package/dist/core/events.d.ts

@@ -1,5 +1,5 @@
 import type { FighterId, MoveId, ItemId, StatusId } from "./ids";
-export type BattleEventKind = "turn_start" | "action_declared" | "action_skipped_hard_cc" | "move_miss" | "move_hit" | "item_used" | "damage" | "heal" | "shield_applied" | "status_applied" | "status_refreshed" | "status_expired" | "fighter_fainted" | "turn_end" | "battle_end";
+export type BattleEventKind = "turn_start" | "action_declared" | "action_skipped_hard_cc" | "move_miss" | "move_hit" | "item_used" | "status_cleared" | "damage" | "heal" | "shield_applied" | "status_applied" | "status_refreshed" | "status_expired" | "fighter_fainted" | "turn_end" | "battle_end";
 export interface BaseBattleEvent {
     id: string;
     turnNumber: number;

package/dist/skins/pokemon/moves.js

@@ -37,12 +37,16 @@ export const POKEMON_MOVES = [
         name: "Ascuas",
         typeId: POKEMON_TYPE_IDS.fire,
         kind: "damage",
-        basePower: 40,
+        basePower: 20,
         accuracy: 100,
         maxPP: 25,
         priority: 0,
         target: "enemy",
         effects: [
+            {
+                kind: "damage",
+                amount: 20,
+            },
             {
                 kind: "apply_status",
                 statusId: "burn",

package/package.json

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