pokemon-io-core 0.0.22 → 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/core/items.d.ts

@@ -1,10 +1,11 @@
 import type { ItemId } from "./ids";
-import type { EffectDefinition } from "./moves";
+import type { EffectDefinition, TargetKind } from "./moves";
 export type ItemCategory = "damage" | "heal_shield" | "status_buff";
 export interface ItemDefinition {
     id: ItemId;
     name: string;
     category: ItemCategory;
+    target: TargetKind;
     maxUses: number;
     image: string;
     effects: EffectDefinition[];

package/dist/core/moves.d.ts

@@ -1,7 +1,8 @@
-import type { MoveId, TypeId, StatusId } from "./ids";
+import type { MoveId, StatusId, TypeId } from "./ids";
+import { StatusKind } from "./status";
 export type MoveKind = "damage" | "heal" | "status" | "hybrid";
 export type TargetKind = "self" | "enemy";
-export type EffectKind = "damage" | "heal" | "shield" | "modify_stats" | "apply_status" | "modify_hit_chance" | "modify_crit_chance" | "modify_priority" | "modify_effective_speed";
+export type EffectKind = "damage" | "heal" | "shield" | "modify_stats" | "apply_status" | "clear_status" | "modify_hit_chance" | "modify_crit_chance" | "modify_priority" | "modify_effective_speed";
 export interface DamageEffect {
     kind: "damage";
     amount: number;
@@ -28,6 +29,22 @@ export interface ApplyStatusEffect {
     kind: "apply_status";
     statusId: StatusId;
 }
+export interface ClearStatusEffect {
+    kind: "clear_status";
+    statusIds?: StatusId[];
+    /**
+     * Filtros opcionales por tipo de estado (hard_cc / soft).
+     * Ejemplo: una berry que limpia solo debuffs “soft”.
+     */
+    kinds?: StatusKind[];
+    /**
+     * Si quieres que limpie TODO sin importar id ni tipo:
+     * - statusIds === undefined
+     * - kinds === undefined
+     * - clearAll === true
+     */
+    clearAll?: boolean;
+}
 export interface ModifyHitChanceEffect {
     kind: "modify_hit_chance";
     delta: number;
@@ -44,7 +61,7 @@ export interface ModifyEffectiveSpeedEffect {
     kind: "modify_effective_speed";
     multiplier: number;
 }
-export type EffectDefinition = DamageEffect | HealEffect | ShieldEffect | ModifyStatsEffect | ApplyStatusEffect | ModifyHitChanceEffect | ModifyCritChanceEffect | ModifyPriorityEffect | ModifyEffectiveSpeedEffect;
+export type EffectDefinition = DamageEffect | HealEffect | ShieldEffect | ClearStatusEffect | ModifyStatsEffect | ApplyStatusEffect | ModifyHitChanceEffect | ModifyCritChanceEffect | ModifyPriorityEffect | ModifyEffectiveSpeedEffect;
 export interface MoveDefinition {
     id: MoveId;
     name: string;

package/dist/skins/pokemon/items.js

@@ -1,53 +1,143 @@
 export const POKEMON_ITEMS = [
-    {
-        id: "potion",
-        name: "Poción",
-        category: "heal_shield",
-        maxUses: 2,
-        effects: [{ kind: "heal", amount: 30 }],
-        image: 'antidote',
-    },
     {
         id: "super_potion",
         name: "Super Poción",
         category: "heal_shield",
+        target: "self",
         maxUses: 1,
-        effects: [{ kind: "heal", amount: 60 }],
-        image: 'hiper-potion',
+        effects: [{ kind: "heal", amount: 50 }],
+        image: "hiper-potion",
+    },
+    {
+        id: "potion",
+        name: "Poción",
+        category: "heal_shield",
+        target: "self",
+        maxUses: 2,
+        effects: [{ kind: "heal", amount: 25 }],
+        image: "potion",
     },
     {
         id: "apple",
         name: "Manzana",
         category: "heal_shield",
+        target: "self",
         maxUses: 3,
-        effects: [{ kind: "heal", amount: 60 }],
-        image: 'fancy-apple',
+        effects: [{ kind: "heal", amount: 17 }],
+        image: "fancy-apple",
     },
     {
         id: "mushroom",
         name: "Seta",
         category: "heal_shield",
-        maxUses: 3,
-        effects: [{ kind: "heal", amount: 60 }],
-        image: 'mushroom',
+        target: "self",
+        maxUses: 4,
+        effects: [{ kind: "heal", amount: 14 }],
+        image: "mushroom",
     },
     {
-        id: "yellow-dust",
-        name: "Cristal amarillo",
-        category: "heal_shield",
+        id: "shotgun",
+        name: "Escopeta",
+        target: "enemy",
+        category: "damage",
+        maxUses: 2,
+        effects: [
+            { kind: "damage", amount: 15 },
+            { kind: "apply_status", statusId: "burn" },
+        ],
+        image: "shotgun",
+    },
+    {
+        id: "pistol",
+        name: "Pistola",
+        category: "damage",
+        target: "enemy",
+        maxUses: 4,
+        effects: [
+            { kind: "damage", amount: 8 },
+            { kind: "apply_status", statusId: "burn" },
+        ],
+        image: "pistol",
+    },
+    {
+        id: "riffle",
+        name: "Rifle",
+        target: "enemy",
+        category: "damage",
         maxUses: 3,
-        effects: [{ kind: "heal", amount: 60 }],
-        image: 'fire-stone',
+        effects: [
+            { kind: "damage", amount: 10 },
+            { kind: "apply_status", statusId: "burn" },
+        ],
+        image: "riffle",
     },
     {
-        id: "burn_bomb",
-        name: "Bomba de Fuego",
+        id: "sniper",
+        name: "Sniper",
+        target: "enemy",
         category: "damage",
         maxUses: 1,
         effects: [
-            { kind: "damage", amount: 20 },
+            { kind: "damage", amount: 30 },
             { kind: "apply_status", statusId: "burn" },
         ],
-        image: 'hiper-potion',
+        image: "sniper",
+    },
+    {
+        id: "blue-berry",
+        name: "Baya azul",
+        category: "status_buff",
+        maxUses: 1,
+        target: "self",
+        effects: [
+            {
+                kind: "clear_status",
+                statusIds: ["burn"], // cura QUEMADURA
+            },
+        ],
+        image: "blue-berry",
+    },
+    {
+        id: "pink-berry",
+        name: "Baya rosa",
+        category: "status_buff",
+        maxUses: 1,
+        target: "self",
+        effects: [
+            {
+                kind: "clear_status",
+                statusIds: ["poison"], // cura VENENO
+            },
+        ],
+        image: "pink-berry",
+    },
+    {
+        id: "yellow-berry",
+        name: "Baya amarilla",
+        category: "status_buff",
+        maxUses: 1,
+        target: "self",
+        effects: [
+            {
+                kind: "clear_status",
+                statusIds: ["paralysis"], // cura PARÁLISIS
+            },
+        ],
+        image: "yellow-berry",
+    },
+    {
+        id: "green-berry",
+        name: "Baya verde",
+        category: "status_buff",
+        maxUses: 1,
+        target: "self",
+        effects: [
+            {
+                kind: "clear_status",
+                statusIds: ["burn", "poison"], // por ejemplo: limpia quemadura o veneno
+                kinds: ["soft"], // redundante pero semántico
+            },
+        ],
+        image: "green-berry",
     },
 ];

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/dist/skins/pokemon/statuses.js

@@ -3,19 +3,39 @@ export const POKEMON_STATUSES = [
         id: "burn",
         name: "Quemado",
         kind: "soft",
+        minDurationTurns: 3,
+        maxDurationTurns: 5,
+        effectsPerStack: [
+            { kind: "damage", amount: 6 }, // DoT
+            { kind: "modify_stats", offenseDelta: -10 } // pega menos
+        ]
+    },
+    {
+        id: "poison",
+        name: "Envenenado",
+        kind: "soft",
+        minDurationTurns: 3,
+        maxDurationTurns: 5,
+        effectsPerStack: [
+            { kind: "damage", amount: 8 }
+        ]
+    },
+    {
+        id: "paralysis",
+        name: "Paralizado",
+        kind: "soft",
         minDurationTurns: 2,
         maxDurationTurns: 4,
         effectsPerStack: [
-            // DoT ligero
-            { kind: "damage", amount: 10 }
+            { kind: "modify_effective_speed", multiplier: 0.5 }
         ]
     },
     {
-        id: "stun",
-        name: "Aturdido",
+        id: "sleep",
+        name: "Dormido",
         kind: "hard_cc",
         minDurationTurns: 1,
-        maxDurationTurns: 1,
-        effectsPerStack: []
+        maxDurationTurns: 3,
+        effectsPerStack: [] // el hard_cc lo interpreta el motor
     }
 ];

package/package.json

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