pokemon-io-core 0.0.10 → 0.0.12

package/dist/core/engine.js

@@ -175,6 +175,89 @@ const applyDamageToFighter = (state, defender, amount, actorId, isCritical) => {
     }
     return { updatedDefender, events };
 };
+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;
+    let newStatuses = [...target.statuses];
+    if (!existing) {
+        newStatuses.push({
+            statusId,
+            stacks: 1,
+            remainingTurns: duration,
+        });
+    }
+    else if (existing.stacks === 1) {
+        newStatuses = newStatuses.map((s) => s.statusId === statusId
+            ? { ...s, stacks: 2, remainingTurns: duration }
+            : s);
+    }
+    else {
+        newStatuses = newStatuses.map((s) => s.statusId === statusId ? { ...s, remainingTurns: duration } : s);
+    }
+    events.push({
+        ...createBaseEvent(state.turnNumber, "status_applied", `Se aplica ${statusId} a ${target.fighterId}`),
+        targetId: target.fighterId,
+        statusId,
+    });
+    return {
+        updated: { ...target, statuses: newStatuses },
+        events,
+    };
+};
+const applyHealToFighter = (state, target, amount, sourceId) => {
+    const newHp = Math.min(target.maxHp, target.currentHp + amount);
+    const healed = newHp - target.currentHp;
+    const updated = {
+        ...target,
+        currentHp: newHp,
+        isAlive: newHp > 0,
+    };
+    const events = [];
+    events.push({
+        ...createBaseEvent(state.turnNumber, "heal", `${sourceId} cura ${healed} a ${target.fighterId}`),
+        actorId: sourceId,
+        targetId: target.fighterId,
+        amount: healed,
+    });
+    return { updated, events };
+};
+const applyEffectsOnTarget = (state, actor, target, effects) => {
+    let currentActor = actor;
+    let currentTarget = target;
+    const events = [];
+    for (const eff of effects) {
+        switch (eff.kind) {
+            case "heal": {
+                const res = applyHealToFighter(state, currentActor, eff.amount, actor.fighterId);
+                currentActor = res.updated;
+                events.push(...res.events);
+                break;
+            }
+            case "apply_status": {
+                const res = applyStatusToFighter(state, currentTarget, eff.statusId);
+                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;
+                    events.push(...res.events);
+                }
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    return { actor: currentActor, target: currentTarget, events };
+};
 const getMovePriorityAndSpeed = (state, playerKey, action) => {
     const { self } = getOpponentAndSelf(state, playerKey);
     if (action.kind === "no_action") {
@@ -200,43 +283,51 @@ const getMovePriorityAndSpeed = (state, playerKey, action) => {
 };
 const resolveDamageMove = (state, playerKey, action) => {
     if (action.kind !== "use_move") {
-        // por ahora ignoramos otros tipos aquí
         return { state, events: [] };
     }
     const { self, opponent } = getOpponentAndSelf(state, playerKey);
     const events = [];
     const moveSlot = self.moves[action.moveIndex];
     if (!moveSlot) {
-        // movimiento vacío → no hace nada
         return { state, events };
     }
     const move = state.runtime.movesById[moveSlot.moveId];
     if (!move) {
         return { state, events };
     }
-    // Sin PP → no hace nada (podrías emitir evento de "sin PP" si quieres)
+    // Sin PP → no hace nada
     if (moveSlot.currentPP <= 0) {
         return { state, events };
     }
-    // Movimientos de estado/curación aún no implementados en detalle
-    if (move.kind === "status" || move.kind === "heal") {
-        // stub: no hacemos nada por ahora
-        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 };
     }
-    // Acción declarada (para narrador avanzado)
+    // Movimiento de daño/hybrid
     events.push({
         ...createBaseEvent(state.turnNumber, "action_declared", `${self.fighterId} usa ${move.name}`),
         actorId: self.fighterId,
     });
-    // Comprobar accuracy
     const accuracy = move.accuracy ?? 100;
     const hitRoll = randomInRange(0, 100);
     const hit = hitRoll < accuracy;
-    // Reducir PP
     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 };
     if (!hit) {
         events.push({
             ...createBaseEvent(state.turnNumber, "move_miss", `${self.fighterId} falla ${move.name}`),
@@ -244,16 +335,16 @@ const resolveDamageMove = (state, playerKey, action) => {
             moveId: move.id,
             targetId: opponent.fighterId,
         });
-        const newState = updateFightersInState(state, playerKey, updatedSelf, opponent);
+        const newState = updateFightersInState(state, playerKey, updatedSelf, updatedOpponent);
         return { state: newState, events };
     }
-    // Crítico
+    // Crítico y daño base
     const critChance = computeCritChance(state.runtime.rules, updatedSelf.effectiveStats.crit);
     const isCritical = chance(critChance);
     const { damage, effectiveness } = computeDamage({
         state,
         attacker: updatedSelf,
-        defender: opponent,
+        defender: updatedOpponent,
         move,
         isCritical,
     });
@@ -265,9 +356,42 @@ const resolveDamageMove = (state, playerKey, action) => {
         isCritical,
         effectiveness,
     });
-    const damageResult = applyDamageToFighter(state, opponent, damage, updatedSelf.fighterId, isCritical);
-    events.push(...damageResult.events);
-    const newState = updateFightersInState(state, playerKey, updatedSelf, damageResult.updatedDefender);
+    const damageRes = applyDamageToFighter(state, updatedOpponent, damage, updatedSelf.fighterId, isCritical);
+    updatedOpponent = damageRes.updatedDefender;
+    events.push(...damageRes.events);
+    // Efectos secundarios del movimiento (quemado, buffs, daño extra 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 };
+};
+const resolveItemUse = (state, playerKey, action) => {
+    if (action.kind !== "use_item") {
+        return { state, events: [] };
+    }
+    const { self, opponent } = getOpponentAndSelf(state, playerKey);
+    const events = [];
+    const itemSlot = self.items[action.itemIndex];
+    if (!itemSlot || itemSlot.usesRemaining <= 0) {
+        return { state, events };
+    }
+    const itemDef = state.runtime.itemsById[itemSlot.itemId];
+    if (!itemDef) {
+        return { state, events };
+    }
+    // Reducir usos
+    const updatedItems = self.items.map((it, idx) => idx === action.itemIndex
+        ? { ...it, usesRemaining: Math.max(0, it.usesRemaining - 1) }
+        : it);
+    let updatedSelf = { ...self, items: updatedItems };
+    let updatedOpponent = { ...opponent };
+    events.push({
+        ...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);
+    const newState = updateFightersInState(state, playerKey, finalSelf, finalOpp);
     return { state: newState, events };
 };
 const updateFightersInState = (state, actingPlayerKey, updatedSelf, updatedOpponent) => {
@@ -433,8 +557,13 @@ export const resolveTurn = (state, actions) => {
             currentState = result.state;
             events.push(...result.events);
         }
+        else if (action.kind === "use_item") {
+            const result = resolveItemUse(currentState, playerKey, action);
+            currentState = result.state;
+            events.push(...result.events);
+        }
         else {
-            // MVP: ignoramos use_item y switch_fighter de momento
+            // switch_fighter y otros aún no implementados
             continue;
         }
         // Comprobar victoria inmediata tras cada acción

package/dist/core/moves.d.ts

@@ -4,6 +4,7 @@ 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 interface DamageEffect {
     kind: "damage";
+    amount: number;
     powerMultiplier?: number;
     flatBonus?: number;
 }

package/dist/skins/pokemon/index.d.ts

@@ -2,3 +2,5 @@ export * from "./types.js";
 export * from "./moves.js";
 export * from "./fighters.js";
 export * from "./pokemonSkin.js";
+export * from "./items.js";
+export * from "./statuses.js";

package/dist/skins/pokemon/index.js

@@ -2,3 +2,5 @@ export * from "./types.js";
 export * from "./moves.js";
 export * from "./fighters.js";
 export * from "./pokemonSkin.js";
+export * from "./items.js";
+export * from "./statuses.js";

package/dist/skins/pokemon/items.d.ts

@@ -0,0 +1,2 @@
+import { ItemDefinition } from "../../core";
+export declare const POKEMON_ITEMS: ItemDefinition[];

package/dist/skins/pokemon/items.js

@@ -0,0 +1,26 @@
+export const POKEMON_ITEMS = [
+    {
+        id: "potion",
+        name: "Poción",
+        category: "heal_shield",
+        maxUses: 2,
+        effects: [{ kind: "heal", amount: 30 }]
+    },
+    {
+        id: "super_potion",
+        name: "Super Poción",
+        category: "heal_shield",
+        maxUses: 1,
+        effects: [{ kind: "heal", amount: 60 }]
+    },
+    {
+        id: "burn_bomb",
+        name: "Bomba de Fuego",
+        category: "damage",
+        maxUses: 1,
+        effects: [
+            { kind: "damage", amount: 20 },
+            { kind: "apply_status", statusId: "burn" }
+        ]
+    }
+];

package/dist/skins/pokemon/moves.js

@@ -12,9 +12,10 @@ export const POKEMON_MOVES = [
         target: "enemy",
         effects: [
             {
-                kind: "damage"
-            }
-        ]
+                kind: "damage",
+                amount: 20,
+            },
+        ],
     },
     {
         id: "ember",
@@ -28,9 +29,10 @@ export const POKEMON_MOVES = [
         target: "enemy",
         effects: [
             {
-                kind: "damage"
-            }
-        ]
+                kind: "apply_status",
+                statusId: "burn",
+            },
+        ],
     },
     {
         id: "water_gun",
@@ -44,9 +46,10 @@ export const POKEMON_MOVES = [
         target: "enemy",
         effects: [
             {
-                kind: "damage"
-            }
-        ]
+                kind: "damage",
+                amount: 20,
+            },
+        ],
     },
     {
         id: "vine_whip",
@@ -60,9 +63,10 @@ export const POKEMON_MOVES = [
         target: "enemy",
         effects: [
             {
-                kind: "damage"
-            }
-        ]
+                kind: "damage",
+                amount: 20,
+            },
+        ],
     },
     {
         id: "thunder_shock",
@@ -76,8 +80,24 @@ export const POKEMON_MOVES = [
         target: "enemy",
         effects: [
             {
-                kind: "damage"
-            }
-        ]
-    }
+                kind: "damage",
+                amount: 20,
+            },
+        ],
+    },
+    {
+        id: "fire_fang",
+        name: "Colmillo Ígneo",
+        typeId: "fire",
+        kind: "damage",
+        basePower: 65,
+        accuracy: 95,
+        maxPP: 15,
+        priority: 0,
+        target: "enemy",
+        effects: [
+            { kind: "damage", amount: 10 },
+            { kind: "apply_status", statusId: "burn" },
+        ],
+    },
 ];

package/dist/skins/pokemon/pokemonSkin.d.ts

@@ -1,14 +1,13 @@
+import { ItemDefinition, MoveDefinition, PlayerBattleConfig } from "../../core";
 import type { CombatSkin, FighterLoadout } from "../CombatSkin";
-import type { MoveDefinition, ItemDefinition, AmuletDefinition, StatusDefinition } from "../../core";
-import type { PlayerBattleConfig } from "../../core/engine";
 export declare class PokemonSkin implements CombatSkin {
     readonly id = "pokemon";
     getTypes(): import("../..").TypeDefinition[];
     getTypeEffectiveness(): import("../..").TypeEffectivenessMatrix;
     getMoves(): MoveDefinition[];
     getItems(): ItemDefinition[];
-    getAmulets(): AmuletDefinition[];
-    getStatuses(): StatusDefinition[];
+    getAmulets(): never[];
+    getStatuses(): never[];
     buildPlayerConfig(loadout: FighterLoadout): PlayerBattleConfig;
 }
 export declare const createPokemonSkin: () => CombatSkin;

package/dist/skins/pokemon/pokemonSkin.js

@@ -1,7 +1,7 @@
-// src/skins/pokemon/pokemonSkin.ts
-import { POKEMON_TYPES, POKEMON_TYPE_MATRIX, POKEMON_MOVES, POKEMON_FIGHTERS } from "./index";
+// pokemon-io-core/src/skins/pokemon/pokemonSkin.ts
+import { POKEMON_TYPES, POKEMON_TYPE_MATRIX, POKEMON_MOVES, POKEMON_FIGHTERS, POKEMON_ITEMS } from "./index";
 const MAX_HP_DEFAULT = 100;
-// Helpers locales
+// --- helpers ---
 const findPokemonById = (id) => {
     const lower = id.toLowerCase();
     return (POKEMON_FIGHTERS.find((f) => f.id.toLowerCase() === lower || f.name.toLowerCase() === lower) ?? null);
@@ -9,19 +9,19 @@ const findPokemonById = (id) => {
 const findMoveById = (id) => {
     return POKEMON_MOVES.find((m) => m.id === id) ?? null;
 };
+const findItemById = (id) => {
+    return POKEMON_ITEMS.find((i) => i.id === id) ?? null;
+};
 const FILLER_MOVE_ID = "tackle";
 const buildMovesFromLoadout = (fighter, loadout) => {
-    // 1) si el jugador ha elegido moveIds, intentamos respetarlos
     const selectedMoveIds = loadout.moveIds ?? [];
     const selectedMoves = selectedMoveIds
         .map((id) => findMoveById(id))
         .filter((m) => m !== null);
-    // 2) si ya hay 4 válidos → nos quedamos con los primeros 4
     if (selectedMoves.length >= 4) {
         return selectedMoves.slice(0, 4);
     }
     const result = [...selectedMoves];
-    // 3) completamos con recommendedMoves del fighter
     const recommendedIds = fighter.recommendedMoves ?? [];
     for (const recId of recommendedIds) {
         if (result.length >= 4)
@@ -31,22 +31,27 @@ const buildMovesFromLoadout = (fighter, loadout) => {
             result.push(move);
         }
     }
-    // 4) si sigue faltando, rellenamos con "tackle"
     const filler = findMoveById(FILLER_MOVE_ID);
     while (result.length < 4 && filler) {
         result.push(filler);
     }
-    // Garantizamos que haya al menos 1 movimiento
     if (result.length === 0 && filler) {
         result.push(filler);
     }
-    // Cortamos por si acaso
     return result.slice(0, 4);
 };
-// De momento no tenemos objetos / amuletos / estados modelados para Pokémon
-const POKEMON_ITEMS = [];
-const POKEMON_AMULETS = [];
-const POKEMON_STATUSES = [];
+const buildItemsFromLoadout = (loadout) => {
+    const selectedItemIds = loadout.itemIds ?? [];
+    const selectedItems = selectedItemIds
+        .map((id) => findItemById(id))
+        .filter((i) => i !== null);
+    // Si tu motor sigue exigiendo 4 items, puedes rellenar aquí:
+    // while (selectedItems.length < 4 && POKEMON_ITEMS[selectedItems.length]) {
+    //   selectedItems.push(POKEMON_ITEMS[selectedItems.length]);
+    // }
+    return selectedItems;
+};
+// --- skin ---
 export class PokemonSkin {
     id = "pokemon";
     getTypes() {
@@ -62,10 +67,10 @@ export class PokemonSkin {
         return POKEMON_ITEMS;
     }
     getAmulets() {
-        return POKEMON_AMULETS;
+        return []; // más adelante
     }
     getStatuses() {
-        return POKEMON_STATUSES;
+        return []; // más adelante
     }
     buildPlayerConfig(loadout) {
         if (!loadout.fighterId) {
@@ -76,17 +81,16 @@ export class PokemonSkin {
             throw new Error(`Unknown fighterId for Pokemon skin: ${loadout.fighterId}`);
         }
         const moves = buildMovesFromLoadout(fighter, loadout);
-        // Importante: aquí aún no aplicamos items/amuletos, pero dejamos el contrato listo
+        const items = buildItemsFromLoadout(loadout);
         return {
             fighter,
             maxHp: MAX_HP_DEFAULT,
             moves,
-            items: [], // Más adelante: mapear loadout.itemIds -> ItemDefinition[]
-            amulet: null // Más adelante: loadout.amuletId -> AmuletDefinition
+            items,
+            amulet: null
         };
     }
 }
-// Helper para crear la skin (así importas siempre una factoría)
 export const createPokemonSkin = () => {
     return new PokemonSkin();
 };

package/dist/skins/pokemon/statuses.d.ts

@@ -0,0 +1,2 @@
+import { StatusDefinition } from "../../core";
+export declare const POKEMON_STATUSES: StatusDefinition[];

package/dist/skins/pokemon/statuses.js

@@ -0,0 +1,21 @@
+export const POKEMON_STATUSES = [
+    {
+        id: "burn",
+        name: "Quemado",
+        kind: "soft",
+        minDurationTurns: 2,
+        maxDurationTurns: 4,
+        effectsPerStack: [
+            // DoT ligero
+            { kind: "damage", amount: 10 }
+        ]
+    },
+    {
+        id: "stun",
+        name: "Aturdido",
+        kind: "hard_cc",
+        minDurationTurns: 1,
+        maxDurationTurns: 1,
+        effectsPerStack: []
+    }
+];

package/package.json

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