pokemon-io-core 0.0.28 → 0.0.30

package/dist/core/engine.js

@@ -123,19 +123,18 @@ const computeCritChance = (rules, critStat) => {
     return Math.max(0, Math.min(1, raw));
 };
 const computeDamage = (input) => {
-    const { state, attacker, defender, move, isCritical } = input;
+    const { state, attacker, defender, moveTypeId, basePower, isCritical } = input;
     const rules = state.runtime.rules;
-    const basePower = move.basePower ?? 0;
     const attackerOff = attacker.effectiveStats.offense;
     const defenderDef = defender.effectiveStats.defense;
-    const typeEffectiveness = getTypeEffectiveness(state, move.typeId, defender.classId);
+    const typeEffectiveness = getTypeEffectiveness(state, moveTypeId, defender.classId);
     if (typeEffectiveness === 0) {
         return {
             damage: 0,
             effectiveness: 0,
         };
     }
-    const stabMultiplier = attacker.classId === move.typeId ? rules.stabMultiplier : 1;
+    const stabMultiplier = attacker.classId === moveTypeId ? rules.stabMultiplier : 1;
     const critMultiplier = isCritical ? rules.critMultiplier : 1;
     const randomFactor = randomInRange(rules.randomMinDamageFactor, rules.randomMaxDamageFactor);
     const rawDamage = basePower *
@@ -190,11 +189,18 @@ const applyDamageToFighter = (state, defender, amount, actorId, isCritical) => {
 // ------------------------------------------------------
 const applyStatusToFighter = (state, target, statusId) => {
     const def = state.runtime.statusesById[statusId];
+    dbg("APPLY_STATUS_FN", {
+        targetId: target.fighterId,
+        statusId,
+        hasDef: !!def,
+        currentStatuses: target.statuses,
+    });
     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({
@@ -227,7 +233,10 @@ const applyStatusToFighter = (state, target, statusId) => {
         events,
     };
 };
-const applyClearStatusToFighter = (state, target, effect) => {
+// ------------------------------------------------------
+// clear_status
+// ------------------------------------------------------
+const clearStatusFromFighter = (state, target, effect) => {
     const { statusIds, kinds, clearAll } = effect;
     const events = [];
     const before = target.statuses;
@@ -299,42 +308,129 @@ const applyHealToFighter = (state, target, amount, sourceId) => {
     return { updated, events };
 };
 // ------------------------------------------------------
+// Target por defecto y resolución de target
+// ------------------------------------------------------
+const defaultTargetForKind = (kind) => {
+    switch (kind) {
+        case "damage":
+        case "apply_status":
+            return "enemy";
+        case "heal":
+        case "clear_status":
+        case "modify_stats":
+        case "modify_hit_chance":
+        case "modify_crit_chance":
+        case "modify_priority":
+        case "modify_effective_speed":
+        case "shield":
+            return "self";
+        default:
+            return "self";
+    }
+};
+const resolveEffectTarget = (eff, actor, target) => {
+    const t = eff.target ?? defaultTargetForKind(eff.kind);
+    const isSelf = t === "self";
+    return {
+        primary: isSelf ? actor : target,
+        isSelf,
+    };
+};
+// ------------------------------------------------------
 // Motor de efectos genérico (move + item)
 // ------------------------------------------------------
-const applyEffectsOnTarget = (state, actor, target, effects) => {
+const applyEffectsOnTarget = (state, actor, target, moveTypeId, isCritical, effects) => {
+    dbg("applyEffectsOnTarget", {
+        actorId: actor.fighterId,
+        targetId: target.fighterId,
+        moveTypeId,
+        isCritical,
+        effects,
+    });
     let currentActor = actor;
     let currentTarget = target;
     const events = [];
+    dbg("APPLY_EFFECTS_START", {
+        actorId: actor.fighterId,
+        targetId: target.fighterId,
+        moveTypeId,
+        isCritical,
+        effectsCount: effects?.length ?? 0,
+    });
     for (const eff of effects) {
+        dbg("EFFECT_LOOP", eff);
         switch (eff.kind) {
             case "heal": {
-                const res = applyHealToFighter(state, currentActor, eff.amount, actor.fighterId);
-                currentActor = res.updated;
+                dbg("EFFECT_HEAL_START", {
+                    amount: eff.amount,
+                    targetDefault: eff.target,
+                });
+                const { primary, isSelf } = resolveEffectTarget(eff, currentActor, currentTarget);
+                const res = applyHealToFighter(state, primary, eff.amount, actor.fighterId);
+                if (isSelf)
+                    currentActor = res.updated;
+                else
+                    currentTarget = res.updated;
                 events.push(...res.events);
                 break;
             }
             case "apply_status": {
-                const res = applyStatusToFighter(state, currentTarget, eff.statusId);
-                currentTarget = res.updated;
+                dbg("EFFECT_APPLY_STATUS_START", {
+                    statusId: eff.statusId,
+                    targetDefault: eff.target,
+                });
+                const { primary, isSelf } = resolveEffectTarget(eff, currentActor, currentTarget);
+                const res = applyStatusToFighter(state, primary, eff.statusId);
+                if (isSelf)
+                    currentActor = res.updated;
+                else
+                    currentTarget = res.updated;
                 events.push(...res.events);
                 break;
             }
             case "clear_status": {
-                const res = applyClearStatusToFighter(state, currentTarget, eff);
-                currentTarget = res.updated;
+                dbg("debemos eliminar status");
+                const { primary, isSelf } = resolveEffectTarget(eff, currentActor, currentTarget);
+                const res = clearStatusFromFighter(state, primary, eff);
+                if (isSelf)
+                    currentActor = res.updated;
+                else
+                    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);
-                    currentTarget = res.updatedDefender;
+                dbg("debemos hacer daño");
+                const { primary, isSelf } = resolveEffectTarget(eff, currentActor, currentTarget);
+                let totalDamage = 0;
+                // Daño de fórmula (stats + tipo + crit…)
+                if (eff.basePower && moveTypeId) {
+                    const { damage } = computeDamage({
+                        state,
+                        attacker: currentActor,
+                        defender: primary,
+                        moveTypeId,
+                        basePower: eff.basePower,
+                        isCritical,
+                    });
+                    totalDamage += damage;
+                }
+                // Daño plano adicional
+                if (eff.flatAmount && eff.flatAmount > 0) {
+                    totalDamage += eff.flatAmount;
+                }
+                if (totalDamage > 0) {
+                    const res = applyDamageToFighter(state, primary, totalDamage, currentActor.fighterId, isCritical);
+                    if (isSelf)
+                        currentActor = res.updatedDefender;
+                    else
+                        currentTarget = res.updatedDefender;
                     events.push(...res.events);
                 }
                 break;
             }
+            // TODO: conectar shield, modify_stats, etc.
             default:
-                // otros efectos (modify_stats, etc.) se pueden añadir aquí
                 break;
         }
     }
@@ -373,6 +469,7 @@ const resolveDamageMove = (state, playerKey, action) => {
     const { self, opponent } = getOpponentAndSelf(state, playerKey);
     const events = [];
     const moveSlot = self.moves[action.moveIndex];
+    dbg("use_move: slot", moveSlot);
     if (!moveSlot) {
         dbg("use_move: empty slot", { playerKey, moveIndex: action.moveIndex });
         return { state, events };
@@ -393,30 +490,6 @@ const resolveDamageMove = (state, playerKey, action) => {
         });
         return { state, events };
     }
-    // Movimiento solo de curación → no calculamos daño base
-    if (move.kind === "heal") {
-        events.push({
-            ...createBaseEvent(state.turnNumber, "action_declared", `${self.fighterId} usa ${move.name}`),
-            actorId: self.fighterId,
-        });
-        const updatedMoves = self.moves.map((m, idx) => idx === action.moveIndex
-            ? { ...m, currentPP: Math.max(0, m.currentPP - 1) }
-            : m);
-        let updatedSelf = { ...self, moves: updatedMoves };
-        let updatedOpponent = { ...opponent };
-        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 };
-    }
-    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,
@@ -448,19 +521,12 @@ const resolveDamageMove = (state, playerKey, action) => {
     }
     const critChance = computeCritChance(state.runtime.rules, updatedSelf.effectiveStats.crit);
     const isCritical = chance(critChance);
-    const { damage, effectiveness } = computeDamage({
-        state,
-        attacker: updatedSelf,
-        defender: updatedOpponent,
-        move,
-        isCritical,
-    });
+    const effectiveness = getTypeEffectiveness(state, move.typeId, updatedOpponent.classId);
     dbg("HIT", {
         fighterId: self.fighterId,
         moveId: move.id,
         moveName: move.name,
         isCritical,
-        damage,
         effectiveness,
         defenderBeforeHp: opponent.currentHp,
     });
@@ -472,21 +538,19 @@ const resolveDamageMove = (state, playerKey, action) => {
         isCritical,
         effectiveness,
     });
-    const damageRes = applyDamageToFighter(state, updatedOpponent, damage, updatedSelf.fighterId, isCritical);
-    dbg("AFTER_DAMAGE", {
-        targetId: opponent.fighterId,
-        newHp: damageRes.updatedDefender.currentHp,
+    dbg("MOVE_EFFECTS", {
+        moveId: move.id,
+        moveName: move.name,
+        effects: move.effects,
     });
-    updatedOpponent = damageRes.updatedDefender;
-    events.push(...damageRes.events);
-    // Efectos secundarios del movimiento (quemado, buffs, daño fijo, etc.)
-    const { actor: finalSelf, target: finalOpp, events: extraEvents, } = applyEffectsOnTarget(state, updatedSelf, updatedOpponent, move.effects);
+    // Todos los efectos (daño, aplicar estado, curas, etc.)
+    const { actor: finalSelf, target: finalOpp, events: extraEvents, } = applyEffectsOnTarget(state, updatedSelf, updatedOpponent, move.typeId, isCritical, move.effects);
     events.push(...extraEvents);
     const newState = updateFightersInState(state, playerKey, finalSelf, finalOpp);
     return { state: newState, events };
 };
 // ------------------------------------------------------
-// use_item (respeta item.target: "self" | "enemy")
+// use_item (ahora el target real está en cada efecto)
 // ------------------------------------------------------
 const resolveItemUse = (state, playerKey, action) => {
     if (action.kind !== "use_item") {
@@ -519,23 +583,9 @@ const resolveItemUse = (state, playerKey, action) => {
         ...createBaseEvent(state.turnNumber, "action_declared", `${self.fighterId} usa objeto ${itemDef.name}`),
         actorId: self.fighterId,
     });
-    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 { actor: finalSelf, target: finalOpp, events: extraEvents, } = applyEffectsOnTarget(state, updatedSelf, updatedOpponent, null, // los items no usan fórmula de tipo por ahora
+    false, itemDef.effects);
+    events.push(...extraEvents);
     const newState = updateFightersInState(state, playerKey, finalSelf, finalOpp);
     return { state: newState, events };
 };
@@ -611,8 +661,12 @@ const applyEndOfTurnStatuses = (state) => {
             def.effectsPerStack.forEach((eff) => {
                 if (eff.kind === "damage") {
                     const stacksMultiplier = st.stacks === 2 ? 2 : 1;
-                    const basePower = typeof eff.amount === "number" ? eff.amount : 10;
-                    damageFromStatus += basePower * stacksMultiplier;
+                    const base = typeof eff.flatAmount === "number"
+                        ? eff.flatAmount
+                        : typeof eff.basePower === "number"
+                            ? eff.basePower
+                            : 10; // fallback
+                    damageFromStatus += base * stacksMultiplier;
                 }
             });
             if (damageFromStatus > 0 && updated.isAlive) {

package/dist/core/moves.d.ts

@@ -1,76 +1,73 @@
 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 EffectTarget = "self" | "enemy";
 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 {
+export type TargetKind = EffectTarget;
+interface BaseEffect {
+    target?: EffectTarget;
+}
+export interface DamageEffect extends BaseEffect {
     kind: "damage";
-    amount: number;
-    powerMultiplier?: number;
-    flatBonus?: number;
+    /**
+     * Daño “de fórmula” (stats + tipo + crit…).
+     * Si no se define, NO se llama a computeDamage.
+     */
+    basePower?: number;
+    /**
+     * Daño plano adicional.
+     * Se suma al daño de fórmula o se usa solo si no hay basePower.
+     */
+    flatAmount?: number;
 }
-export interface HealEffect {
+export interface HealEffect extends BaseEffect {
     kind: "heal";
     amount: number;
 }
-export interface ShieldEffect {
+export interface ShieldEffect extends BaseEffect {
     kind: "shield";
     amount: number;
     durationTurns: number;
 }
-export interface ModifyStatsEffect {
+export interface ModifyStatsEffect extends BaseEffect {
     kind: "modify_stats";
     offenseDelta?: number;
     defenseDelta?: number;
     speedDelta?: number;
     critDelta?: number;
 }
-export interface ApplyStatusEffect {
+export interface ApplyStatusEffect extends BaseEffect {
     kind: "apply_status";
     statusId: StatusId;
 }
-export interface ClearStatusEffect {
+export interface ClearStatusEffect extends BaseEffect {
     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
-     */
+    kinds?: ("hard_cc" | "soft")[];
     clearAll?: boolean;
 }
-export interface ModifyHitChanceEffect {
+export interface ModifyHitChanceEffect extends BaseEffect {
     kind: "modify_hit_chance";
     delta: number;
 }
-export interface ModifyCritChanceEffect {
+export interface ModifyCritChanceEffect extends BaseEffect {
     kind: "modify_crit_chance";
     delta: number;
 }
-export interface ModifyPriorityEffect {
+export interface ModifyPriorityEffect extends BaseEffect {
     kind: "modify_priority";
     delta: number;
 }
-export interface ModifyEffectiveSpeedEffect {
+export interface ModifyEffectiveSpeedEffect extends BaseEffect {
     kind: "modify_effective_speed";
     multiplier: number;
 }
-export type EffectDefinition = DamageEffect | HealEffect | ShieldEffect | ClearStatusEffect | ModifyStatsEffect | ApplyStatusEffect | ModifyHitChanceEffect | ModifyCritChanceEffect | ModifyPriorityEffect | ModifyEffectiveSpeedEffect;
+export type EffectDefinition = DamageEffect | HealEffect | ShieldEffect | ModifyStatsEffect | ApplyStatusEffect | ClearStatusEffect | ModifyHitChanceEffect | ModifyCritChanceEffect | ModifyPriorityEffect | ModifyEffectiveSpeedEffect;
 export interface MoveDefinition {
     id: MoveId;
     name: string;
     typeId: TypeId;
-    kind: MoveKind;
-    basePower?: number;
     accuracy?: number;
     maxPP: number;
     priority?: number;
-    target: TargetKind;
     effects: EffectDefinition[];
 }
+export {};

package/dist/core/moves.js

@@ -1 +1,2 @@
+// core/moves.ts
 export {};

package/dist/skins/pokemon/items.js

@@ -42,7 +42,7 @@ export const POKEMON_ITEMS = [
         category: "damage",
         maxUses: 2,
         effects: [
-            { kind: "damage", amount: 15 },
+            { kind: "damage", flatAmount: 15 },
             { kind: "apply_status", statusId: "burn" },
         ],
         image: "shotgun",
@@ -54,7 +54,7 @@ export const POKEMON_ITEMS = [
         target: "enemy",
         maxUses: 4,
         effects: [
-            { kind: "damage", amount: 8 },
+            { kind: "damage", flatAmount: 8 },
             { kind: "apply_status", statusId: "burn" },
         ],
         image: "pistol",
@@ -66,7 +66,7 @@ export const POKEMON_ITEMS = [
         category: "damage",
         maxUses: 3,
         effects: [
-            { kind: "damage", amount: 10 },
+            { kind: "damage", flatAmount: 10 },
             { kind: "apply_status", statusId: "burn" },
         ],
         image: "riffle",
@@ -78,7 +78,7 @@ export const POKEMON_ITEMS = [
         category: "damage",
         maxUses: 1,
         effects: [
-            { kind: "damage", amount: 30 },
+            { kind: "damage", flatAmount: 30 },
             { kind: "apply_status", statusId: "burn" },
         ],
         image: "sniper",

package/dist/skins/pokemon/moves.js

@@ -4,19 +4,18 @@ export const POKEMON_MOVES = [
         id: "tackle",
         name: "Placaje",
         typeId: POKEMON_TYPE_IDS.fire,
-        kind: "damage",
-        basePower: 40,
         accuracy: 100,
         maxPP: 35,
         priority: 0,
-        target: "enemy",
         effects: [
             {
                 kind: "damage",
-                amount: 20,
+                target: "enemy",
+                basePower: 40,
             },
             {
                 kind: "apply_status",
+                target: "enemy",
                 statusId: "poison",
             },
         ],
@@ -24,35 +23,39 @@ export const POKEMON_MOVES = [
     {
         id: "fire_fang",
         name: "Colmillo Ígneo",
-        typeId: "fire",
-        kind: "damage",
-        basePower: 65,
+        typeId: POKEMON_TYPE_IDS.fire,
         accuracy: 95,
         maxPP: 15,
         priority: 0,
-        target: "enemy",
         effects: [
-            { kind: "damage", amount: 10 },
-            { kind: "apply_status", statusId: "burn" },
+            {
+                kind: "damage",
+                target: "enemy",
+                basePower: 65,
+            },
+            {
+                kind: "apply_status",
+                target: "enemy",
+                statusId: "burn",
+            },
         ],
     },
     {
         id: "ember",
         name: "Ascuas",
         typeId: POKEMON_TYPE_IDS.fire,
-        kind: "damage",
-        basePower: 20,
         accuracy: 100,
         maxPP: 25,
         priority: 0,
-        target: "enemy",
         effects: [
             {
                 kind: "damage",
-                amount: 20,
+                target: "enemy",
+                basePower: 20,
             },
             {
                 kind: "apply_status",
+                target: "enemy",
                 statusId: "burn",
             },
         ],
@@ -61,15 +64,13 @@ export const POKEMON_MOVES = [
         id: "water_gun",
         name: "Pistola Agua",
         typeId: POKEMON_TYPE_IDS.water,
-        kind: "damage",
-        basePower: 40,
         accuracy: 100,
         maxPP: 25,
         priority: 0,
-        target: "enemy",
         effects: [
             {
                 kind: "apply_status",
+                target: "enemy",
                 statusId: "poison",
             },
         ],
@@ -78,16 +79,14 @@ export const POKEMON_MOVES = [
         id: "water_gun2",
         name: "Hidropulso",
         typeId: POKEMON_TYPE_IDS.water,
-        kind: "damage",
-        basePower: 40,
         accuracy: 100,
         maxPP: 25,
         priority: 0,
-        target: "enemy",
         effects: [
             {
                 kind: "damage",
-                amount: 20,
+                target: "enemy",
+                basePower: 40,
             },
         ],
     },
@@ -95,16 +94,14 @@ export const POKEMON_MOVES = [
         id: "water_gun3",
         name: "Llover",
         typeId: POKEMON_TYPE_IDS.water,
-        kind: "damage",
-        basePower: 40,
         accuracy: 100,
         maxPP: 25,
         priority: 0,
-        target: "enemy",
         effects: [
             {
                 kind: "damage",
-                amount: 20,
+                target: "enemy",
+                basePower: 40,
             },
         ],
     },
@@ -112,16 +109,14 @@ export const POKEMON_MOVES = [
         id: "water_gun4",
         name: "Wet",
         typeId: POKEMON_TYPE_IDS.water,
-        kind: "damage",
-        basePower: 40,
         accuracy: 100,
         maxPP: 25,
         priority: 0,
-        target: "enemy",
         effects: [
             {
                 kind: "damage",
-                amount: 20,
+                target: "enemy",
+                basePower: 40,
             },
         ],
     },
@@ -129,16 +124,14 @@ export const POKEMON_MOVES = [
         id: "vine_whip",
         name: "Látigo Cepa",
         typeId: POKEMON_TYPE_IDS.grass,
-        kind: "damage",
-        basePower: 45,
         accuracy: 100,
         maxPP: 25,
         priority: 0,
-        target: "enemy",
         effects: [
             {
                 kind: "damage",
-                amount: 20,
+                target: "enemy",
+                basePower: 45,
             },
         ],
     },
@@ -146,16 +139,14 @@ export const POKEMON_MOVES = [
         id: "vine_whip2",
         name: "Hierbita",
         typeId: POKEMON_TYPE_IDS.grass,
-        kind: "damage",
-        basePower: 45,
         accuracy: 100,
         maxPP: 25,
         priority: 0,
-        target: "enemy",
         effects: [
             {
                 kind: "damage",
-                amount: 20,
+                target: "enemy",
+                basePower: 45,
             },
         ],
     },
@@ -163,16 +154,14 @@ export const POKEMON_MOVES = [
         id: "vine_whip3",
         name: "Buena flor",
         typeId: POKEMON_TYPE_IDS.grass,
-        kind: "damage",
-        basePower: 45,
         accuracy: 100,
         maxPP: 25,
         priority: 0,
-        target: "enemy",
         effects: [
             {
                 kind: "damage",
-                amount: 20,
+                target: "enemy",
+                basePower: 45,
             },
         ],
     },
@@ -180,16 +169,14 @@ export const POKEMON_MOVES = [
         id: "vine_whip4",
         name: "Recurrente",
         typeId: POKEMON_TYPE_IDS.grass,
-        kind: "damage",
-        basePower: 45,
         accuracy: 100,
         maxPP: 25,
         priority: 0,
-        target: "enemy",
         effects: [
             {
                 kind: "damage",
-                amount: 20,
+                target: "enemy",
+                basePower: 45,
             },
         ],
     },
@@ -197,16 +184,14 @@ export const POKEMON_MOVES = [
         id: "thunder_shock",
         name: "Impactrueno",
         typeId: POKEMON_TYPE_IDS.electric,
-        kind: "damage",
-        basePower: 40,
         accuracy: 100,
         maxPP: 30,
         priority: 0,
-        target: "enemy",
         effects: [
             {
                 kind: "damage",
-                amount: 20,
+                target: "enemy",
+                basePower: 40,
             },
         ],
     },
@@ -214,16 +199,14 @@ export const POKEMON_MOVES = [
         id: "thunder_shock2",
         name: "Rayo",
         typeId: POKEMON_TYPE_IDS.electric,
-        kind: "damage",
-        basePower: 40,
         accuracy: 100,
         maxPP: 30,
         priority: 0,
-        target: "enemy",
         effects: [
             {
                 kind: "damage",
-                amount: 20,
+                target: "enemy",
+                basePower: 40,
             },
         ],
     },
@@ -231,16 +214,14 @@ export const POKEMON_MOVES = [
         id: "thunder_shock3",
         name: "Tormenta",
         typeId: POKEMON_TYPE_IDS.electric,
-        kind: "damage",
-        basePower: 40,
         accuracy: 100,
         maxPP: 30,
         priority: 0,
-        target: "enemy",
         effects: [
             {
                 kind: "damage",
-                amount: 20,
+                target: "enemy",
+                basePower: 40,
             },
         ],
     },
@@ -248,16 +229,14 @@ export const POKEMON_MOVES = [
         id: "thunder_shock4",
         name: "Lluvia de rayos",
         typeId: POKEMON_TYPE_IDS.electric,
-        kind: "damage",
-        basePower: 40,
         accuracy: 100,
         maxPP: 30,
         priority: 0,
-        target: "enemy",
         effects: [
             {
                 kind: "damage",
-                amount: 20,
+                target: "enemy",
+                basePower: 40,
             },
         ],
     },
@@ -265,16 +244,14 @@ export const POKEMON_MOVES = [
         id: "think",
         name: "Rayada mental",
         typeId: POKEMON_TYPE_IDS.psychic,
-        kind: "damage",
-        basePower: 40,
         accuracy: 100,
         maxPP: 30,
         priority: 0,
-        target: "enemy",
         effects: [
             {
                 kind: "damage",
-                amount: 20,
+                target: "enemy",
+                basePower: 40,
             },
         ],
     },
@@ -282,16 +259,14 @@ export const POKEMON_MOVES = [
         id: "think2",
         name: "Psicoterapia",
         typeId: POKEMON_TYPE_IDS.psychic,
-        kind: "damage",
-        basePower: 40,
         accuracy: 100,
         maxPP: 30,
         priority: 0,
-        target: "enemy",
         effects: [
             {
                 kind: "damage",
-                amount: 20,
+                target: "enemy",
+                basePower: 40,
             },
         ],
     },

package/dist/skins/pokemon/statuses.js

@@ -6,9 +6,19 @@ export const POKEMON_STATUSES = [
         minDurationTurns: 3,
         maxDurationTurns: 5,
         effectsPerStack: [
-            { kind: "damage", amount: 6 }, // DoT
-            { kind: "modify_stats", offenseDelta: -10 } // pega menos
-        ]
+            {
+                // Daño plano por turno
+                kind: "damage",
+                target: "self",
+                flatAmount: 6,
+            },
+            {
+                // Baja el ataque mientras dure el estado
+                kind: "modify_stats",
+                target: "self",
+                offenseDelta: -10,
+            },
+        ],
     },
     {
         id: "poison",
@@ -17,8 +27,12 @@ export const POKEMON_STATUSES = [
         minDurationTurns: 3,
         maxDurationTurns: 5,
         effectsPerStack: [
-            { kind: "damage", amount: 8 }
-        ]
+            {
+                kind: "damage",
+                target: "self",
+                flatAmount: 8,
+            },
+        ],
     },
     {
         id: "paralysis",
@@ -27,8 +41,12 @@ export const POKEMON_STATUSES = [
         minDurationTurns: 2,
         maxDurationTurns: 4,
         effectsPerStack: [
-            { kind: "modify_effective_speed", multiplier: 0.5 }
-        ]
+            {
+                kind: "modify_effective_speed",
+                target: "self",
+                multiplier: 0.5,
+            },
+        ],
     },
     {
         id: "sleep",
@@ -36,6 +54,9 @@ export const POKEMON_STATUSES = [
         kind: "hard_cc",
         minDurationTurns: 1,
         maxDurationTurns: 3,
-        effectsPerStack: [] // el hard_cc lo interpreta el motor
-    }
+        effectsPerStack: [
+        // El motor interpreta hard_cc y bloquea la acción;
+        // no necesitas más efectos aquí de momento.
+        ],
+    },
 ];

package/package.json

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