pokemon-io-core 0.0.83 → 0.0.84

package/dist/core/battleState.d.ts

@@ -1,4 +1,4 @@
-import { BattleRuntime } from "../core/engine.js";
+import { BattleRuntime } from "../engine/rules.js";
 import type { FighterId, TypeId, MoveId, ItemId, AmuletId, StatusId } from "./ids";
 import type { FighterStats } from "./types.js";
 export interface EquippedMove {

package/dist/core/index.d.ts

@@ -1,7 +1,6 @@
 export * from "./actions.js";
 export * from "./amulets.js";
 export * from "./battleState.js";
-export * from "./engine.js";
 export * from "./events.js";
 export * from "./fighters.js";
 export * from "./ids.js";

package/dist/core/index.js

@@ -1,7 +1,6 @@
 export * from "./actions.js";
 export * from "./amulets.js";
 export * from "./battleState.js";
-export * from "./engine.js";
 export * from "./events.js";
 export * from "./fighters.js";
 export * from "./ids.js";

package/dist/engine/actions/forcedSwitch.d.ts

@@ -0,0 +1,5 @@
+import { BattleEvent, BattleState } from "../../core";
+export declare const applyForcedSwitchChoice: (state: BattleState, targetPlayer: "player1" | "player2", newIndex: number) => {
+    state: BattleState;
+    events: BattleEvent[];
+};

package/dist/engine/actions/forcedSwitch.js

@@ -0,0 +1,44 @@
+import { createBaseEvent } from "../events";
+export const applyForcedSwitchChoice = (state, targetPlayer, newIndex) => {
+    const forced = state.forcedSwitch;
+    if (!forced)
+        return { state, events: [] };
+    if (forced.targetPlayer !== targetPlayer)
+        return { state, events: [] };
+    const self = targetPlayer === "player1" ? state.player1 : state.player2;
+    if (newIndex < 0 || newIndex >= self.fighterTeam.length)
+        return { state, events: [] };
+    const fromIndex = self.activeIndex;
+    if (newIndex === fromIndex)
+        return { state, events: [] };
+    const toFighter = self.fighterTeam[newIndex];
+    if (!toFighter || !toFighter.isAlive || toFighter.currentHp <= 0)
+        return { state, events: [] };
+    const fromFighter = self.fighterTeam[fromIndex];
+    const events = [
+        {
+            ...createBaseEvent(state.turnNumber, "fighter_switched", `El entrenador retira a ${fromFighter.fighterId} y manda a ${toFighter.fighterId}`),
+            fromFighterId: fromFighter.fighterId,
+            toFighterId: toFighter.fighterId,
+        },
+        {
+            ...createBaseEvent(state.turnNumber, "turn_end", `Termina el turno ${state.turnNumber}`),
+        },
+    ];
+    const switchedState = targetPlayer === "player1"
+        ? {
+            ...state,
+            forcedSwitch: null,
+            player1: { ...state.player1, activeIndex: newIndex },
+        }
+        : {
+            ...state,
+            forcedSwitch: null,
+            player2: { ...state.player2, activeIndex: newIndex },
+        };
+    const nextState = {
+        ...switchedState,
+        turnNumber: switchedState.turnNumber + 1,
+    };
+    return { state: nextState, events };
+};

package/dist/engine/actions/index.d.ts

@@ -0,0 +1,5 @@
+export * from './forcedSwitch.js';
+export * from './item.js';
+export * from './move.js';
+export * from './priority.js';
+export * from './switch.js';

package/dist/engine/actions/index.js

@@ -0,0 +1,5 @@
+export * from './forcedSwitch.js';
+export * from './item.js';
+export * from './move.js';
+export * from './priority.js';
+export * from './switch.js';

package/dist/engine/actions/item.d.ts

@@ -0,0 +1,6 @@
+import { BattleEvent, PlayerAction } from "../../core";
+import { RuntimeBattleState } from "../rules";
+export declare const resolveItemUse: (state: RuntimeBattleState, playerKey: "player1" | "player2", action: PlayerAction) => {
+    state: RuntimeBattleState;
+    events: BattleEvent[];
+};

package/dist/engine/actions/item.js

@@ -0,0 +1,61 @@
+import { dbg } from "../debug";
+import { applyEffectsOnTarget } from "../effects/applyEffects";
+import { createBaseEvent } from "../events";
+import { getPlayersAndActives } from "../fighters/selectors";
+import { updateFightersInState } from "../fighters/update";
+export const resolveItemUse = (state, playerKey, action) => {
+    if (action.kind !== "use_item") {
+        return { state, events: [] };
+    }
+    const { selfPlayer, oppPlayer, self, opponent } = getPlayersAndActives(state, playerKey);
+    const events = [];
+    const itemSlot = selfPlayer.inventory[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 };
+    }
+    const updatedInventory = selfPlayer.inventory.map((it, idx) => idx === action.itemIndex
+        ? { ...it, usesRemaining: Math.max(0, it.usesRemaining - 1) }
+        : it);
+    let updatedSelf = { ...self };
+    let updatedOpponent = { ...opponent };
+    events.push({
+        ...createBaseEvent(state.turnNumber, "action_declared", `${self.fighterId} usó ${itemDef.name}`),
+        actorId: self.fighterId,
+    });
+    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);
+    let newState = updateFightersInState(state, playerKey, finalSelf, finalOpp);
+    // persistimos el inventario gastado en el jugador que actuó
+    if (playerKey === "player1") {
+        newState = {
+            ...newState,
+            player1: {
+                ...newState.player1,
+                inventory: updatedInventory,
+            },
+        };
+    }
+    else {
+        newState = {
+            ...newState,
+            player2: {
+                ...newState.player2,
+                inventory: updatedInventory,
+            },
+        };
+    }
+    return { state: newState, events };
+};

package/dist/engine/actions/move.d.ts

@@ -0,0 +1,6 @@
+import { BattleEvent, PlayerAction } from "../../core";
+import { RuntimeBattleState } from "../rules";
+export declare const resolveDamageMove: (state: RuntimeBattleState, playerKey: "player1" | "player2", action: PlayerAction) => {
+    state: RuntimeBattleState;
+    events: BattleEvent[];
+};

package/dist/engine/actions/move.js

@@ -0,0 +1,120 @@
+import { computeCritChance } from "../combat/crit";
+import { getTypeEffectiveness } from "../combat/typeEffectiveness";
+import { dbg } from "../debug";
+import { applyEffectsOnTarget } from "../effects/applyEffects";
+import { createBaseEvent } from "../events";
+import { getOpponentAndSelf } from "../fighters/selectors";
+import { updateFightersInState } from "../fighters/update";
+import { chance, randomInRange } from "../rng";
+export const resolveDamageMove = (state, playerKey, action) => {
+    if (action.kind !== "use_move") {
+        return { state, events: [] };
+    }
+    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 };
+    }
+    const move = state.runtime.movesById[moveSlot.moveId];
+    if (!move) {
+        dbg("use_move: move definition not found", {
+            playerKey,
+            moveId: moveSlot.moveId,
+        });
+        return { state, events };
+    }
+    if (moveSlot.currentPP <= 0) {
+        dbg("use_move: no PP", {
+            playerKey,
+            fighterId: self.fighterId,
+            moveId: move.id,
+        });
+        return { state, events };
+    }
+    events.push({
+        ...createBaseEvent(state.turnNumber, "action_declared", `${self.fighterId} usó ${move.name}`),
+        actorId: self.fighterId,
+    });
+    const accuracy = move.accuracy ?? 100;
+    const hitRoll = randomInRange(0, 100);
+    const hit = hitRoll < accuracy;
+    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) {
+        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,
+            moveId: move.id,
+            targetId: opponent.fighterId,
+        });
+        const newState = updateFightersInState(state, playerKey, updatedSelf, updatedOpponent);
+        return { state: newState, events };
+    }
+    const critChance = computeCritChance(state.runtime.rules, updatedSelf.effectiveStats.crit);
+    const isCritical = chance(critChance);
+    const effectiveness = getTypeEffectiveness(state, move.typeId, updatedOpponent.classId);
+    dbg("HIT", {
+        fighterId: self.fighterId,
+        moveId: move.id,
+        moveName: move.name,
+        isCritical,
+        effectiveness,
+        defenderBeforeHp: opponent.currentHp,
+    });
+    events.push({
+        ...createBaseEvent(state.turnNumber, "move_hit", `${self.fighterId} acierta ${move.name}`),
+        actorId: self.fighterId,
+        moveId: move.id,
+        targetId: opponent.fighterId,
+        isCritical,
+        effectiveness,
+    });
+    dbg("MOVE_EFFECTS", {
+        moveId: move.id,
+        moveName: move.name,
+        effects: 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);
+    let newState = updateFightersInState(state, playerKey, finalSelf, finalOpp);
+    // --- FORCED SWITCH (Roar) ---
+    const hasForceSwitch = move.effects.some((e) => e.kind === "force_switch");
+    if (hasForceSwitch) {
+        const targetPlayer = playerKey === "player1" ? "player2" : "player1";
+        const targetSide = targetPlayer === "player1" ? newState.player1 : newState.player2;
+        const activeIdx = targetSide.activeIndex;
+        const hasBenchAlive = targetSide.fighterTeam.some((f, idx) => {
+            if (idx === activeIdx)
+                return false;
+            return f.isAlive && f.currentHp > 0;
+        });
+        if (hasBenchAlive) {
+            newState = {
+                ...newState,
+                forcedSwitch: {
+                    targetPlayer,
+                    reason: "roar",
+                },
+            };
+            events.push({
+                ...createBaseEvent(state.turnNumber, "action_declared", `¡El entrenador rival debe cambiar de luchador!`),
+                actorId: self.fighterId,
+            });
+        }
+    }
+    return { state: newState, events };
+};

package/dist/engine/actions/priority.d.ts

@@ -0,0 +1,6 @@
+import { PlayerAction } from "../../core";
+import { RuntimeBattleState } from "../rules";
+export declare const getMovePriorityAndSpeed: (state: RuntimeBattleState, playerKey: "player1" | "player2", action: PlayerAction) => {
+    priority: number;
+    speed: number;
+};

package/dist/engine/actions/priority.js

@@ -0,0 +1,30 @@
+import { getOpponentAndSelf } from "../fighters/selectors";
+export const getMovePriorityAndSpeed = (state, playerKey, action) => {
+    const { self } = getOpponentAndSelf(state, playerKey);
+    if (action.kind === "no_action") {
+        return { priority: 0, speed: 0 };
+    }
+    if (action.kind === "use_move") {
+        const moveEntry = self.moves[action.moveIndex];
+        if (!moveEntry) {
+            return { priority: 0, speed: self.effectiveStats.speed };
+        }
+        const moveDef = state.runtime.movesById[moveEntry.moveId];
+        const priority = moveDef?.priority ?? 0;
+        return {
+            priority,
+            speed: self.effectiveStats.speed,
+        };
+    }
+    if (action.kind === "switch_fighter") {
+        return {
+            priority: 10, // prioridad especial (ajústalo si quieres)
+            speed: self.effectiveStats.speed,
+        };
+    }
+    // Items y switch: prioridad base 0 por ahora
+    return {
+        priority: 0,
+        speed: self.effectiveStats.speed,
+    };
+};

package/dist/engine/actions/switch.d.ts

@@ -0,0 +1,6 @@
+import { BattleEvent, PlayerAction } from "../../core";
+import { RuntimeBattleState } from "../rules";
+export declare const resolveSwitchFighter: (state: RuntimeBattleState, playerKey: "player1" | "player2", action: PlayerAction) => {
+    state: RuntimeBattleState;
+    events: BattleEvent[];
+};

package/dist/engine/actions/switch.js

@@ -0,0 +1,55 @@
+import { createBaseEvent } from "../events";
+export const resolveSwitchFighter = (state, playerKey, action) => {
+    if (action.kind !== "switch_fighter")
+        return { state, events: [] };
+    const events = [];
+    const selfPlayer = playerKey === "player1" ? state.player1 : state.player2;
+    const fromIndex = selfPlayer.activeIndex;
+    const toIndex = action.newIndex;
+    // validaciones
+    if (toIndex < 0 || toIndex >= selfPlayer.fighterTeam.length) {
+        return { state, events };
+    }
+    if (toIndex === fromIndex) {
+        return { state, events };
+    }
+    const target = selfPlayer.fighterTeam[toIndex];
+    if (!target || !target.isAlive || target.currentHp <= 0) {
+        return { state, events };
+    }
+    const fromFighter = selfPlayer.fighterTeam[fromIndex];
+    events.push({
+        ...createBaseEvent(state.turnNumber, "fighter_switched", `El entrenador retira a ${fromFighter.fighterId} y manda a ${target.fighterId}`),
+        fromFighterId: fromFighter.fighterId,
+        toFighterId: target.fighterId,
+        toHp: target.currentHp,
+        toStatuses: (target.statuses ?? []).map((st) => ({
+            statusId: st.statusId,
+            stacks: st.stacks,
+            remainingTurns: st.remainingTurns,
+        })),
+    });
+    // actualizar activeIndex
+    if (playerKey === "player1") {
+        return {
+            state: {
+                ...state,
+                player1: {
+                    ...state.player1,
+                    activeIndex: toIndex,
+                },
+            },
+            events,
+        };
+    }
+    return {
+        state: {
+            ...state,
+            player2: {
+                ...state.player2,
+                activeIndex: toIndex,
+            },
+        },
+        events,
+    };
+};

package/dist/engine/combat/crit.d.ts

@@ -0,0 +1,2 @@
+import { BattleRules } from "../rules";
+export declare const computeCritChance: (rules: BattleRules, critStat: number) => number;

package/dist/engine/combat/crit.js

@@ -0,0 +1,4 @@
+export const computeCritChance = (rules, critStat) => {
+    const raw = rules.baseCritChance + critStat * rules.critPerStat;
+    return Math.max(0, Math.min(1, raw));
+};

package/dist/engine/combat/damage.d.ts

@@ -0,0 +1,20 @@
+import { BattleEvent, BattleFighter, FighterId, TypeId } from "../../core";
+import { RuntimeBattleState } from "../rules";
+interface DamageComputationInput {
+    state: RuntimeBattleState;
+    attacker: BattleFighter;
+    defender: BattleFighter;
+    moveTypeId: TypeId;
+    basePower: number;
+    isCritical: boolean;
+}
+export declare const computeDamage: (input: DamageComputationInput) => {
+    damage: number;
+    effectiveness: number;
+};
+interface DamageApplyResult {
+    updatedDefender: BattleFighter;
+    events: BattleEvent[];
+}
+export declare const applyDamageToFighter: (state: RuntimeBattleState, defender: BattleFighter, amount: number, actorId: FighterId, isCritical: boolean) => DamageApplyResult;
+export {};

package/dist/engine/combat/damage.js

@@ -0,0 +1,66 @@
+import { dbg } from "../debug";
+import { createBaseEvent } from "../events";
+import { randomInRange } from "../rng";
+import { getTypeEffectiveness } from "./typeEffectiveness";
+export const computeDamage = (input) => {
+    dbg("🧨 computeDamage", { input });
+    const { state, attacker, defender, moveTypeId, basePower, isCritical } = input;
+    const rules = state.runtime.rules;
+    const attackerOff = attacker.effectiveStats.offense;
+    const defenderDef = defender.effectiveStats.defense;
+    const typeEffectiveness = getTypeEffectiveness(state, moveTypeId, defender.classId);
+    if (typeEffectiveness === 0) {
+        return {
+            damage: 0,
+            effectiveness: 0,
+        };
+    }
+    const stabMultiplier = attacker.classId === moveTypeId ? rules.stabMultiplier : 1;
+    const critMultiplier = isCritical ? rules.critMultiplier : 1;
+    const randomFactor = randomInRange(rules.randomMinDamageFactor, rules.randomMaxDamageFactor);
+    const rawDamage = basePower *
+        (attackerOff / Math.max(1, defenderDef)) *
+        typeEffectiveness *
+        stabMultiplier *
+        critMultiplier *
+        randomFactor;
+    dbg("🧨 computeDamage", `
+      basePower(${basePower}) *
+      (attackerOff(${attackerOff}) / Math.max(1, defenderDef(${defenderDef}))) = ${attackerOff / Math.max(1, defenderDef)}*
+      typeEffectiveness(${typeEffectiveness}) *
+      stabMultiplier(${stabMultiplier}) *
+      critMultiplier(${critMultiplier}) *
+      randomFactor(${randomFactor}) = ${rawDamage}
+    `);
+    const finalDamage = Math.max(1, Math.floor(rawDamage));
+    dbg("🧨 computeDamage", `
+      finalDamage(${finalDamage}) = Math.max(1, Math.floor(rawDamage))
+    `);
+    return {
+        damage: finalDamage,
+        effectiveness: typeEffectiveness,
+    };
+};
+export const applyDamageToFighter = (state, defender, amount, actorId, isCritical) => {
+    const events = [];
+    const newHp = Math.max(0, defender.currentHp - amount);
+    const updatedDefender = {
+        ...defender,
+        currentHp: newHp,
+        isAlive: newHp > 0,
+    };
+    events.push({
+        ...createBaseEvent(state.turnNumber, "damage", `${actorId} inflige ${amount} de daño a ${defender.fighterId}`),
+        actorId,
+        targetId: defender.fighterId,
+        amount,
+        isCritical,
+    });
+    if (!updatedDefender.isAlive) {
+        events.push({
+            ...createBaseEvent(state.turnNumber, "fighter_fainted", `${defender.fighterId} ha caído`),
+            fighterId: defender.fighterId,
+        });
+    }
+    return { updatedDefender, events };
+};

package/dist/engine/combat/heal.d.ts

@@ -0,0 +1,6 @@
+import { BattleEvent, BattleFighter, FighterId } from "../../core";
+import { RuntimeBattleState } from "../rules";
+export declare const applyHealToFighter: (state: RuntimeBattleState, target: BattleFighter, amount: number, sourceId: FighterId) => {
+    updated: BattleFighter;
+    events: BattleEvent[];
+};

package/dist/engine/combat/heal.js

@@ -0,0 +1,25 @@
+import { dbg } from "../debug";
+import { createBaseEvent } from "../events";
+export 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 = [];
+    dbg("HEAL", {
+        sourceId,
+        targetId: target.fighterId,
+        healed,
+        newHp,
+    });
+    events.push({
+        ...createBaseEvent(state.turnNumber, "heal", `${sourceId} cura ${healed} a ${target.fighterId}`),
+        actorId: sourceId,
+        targetId: target.fighterId,
+        amount: healed,
+    });
+    return { updated, events };
+};

package/dist/engine/combat/index.d.ts

@@ -0,0 +1,5 @@
+export * from './crit.js';
+export * from './damage.js';
+export * from './heal.js';
+export * from './typeEffectiveness.js';
+export * from './winner.js';

package/dist/engine/combat/index.js

@@ -0,0 +1,5 @@
+export * from './crit.js';
+export * from './damage.js';
+export * from './heal.js';
+export * from './typeEffectiveness.js';
+export * from './winner.js';

package/dist/engine/combat/typeEffectiveness.d.ts

@@ -0,0 +1,3 @@
+import { TypeId } from "../../core";
+import { RuntimeBattleState } from "../rules";
+export declare const getTypeEffectiveness: (state: RuntimeBattleState, attackerTypeId: TypeId, defenderTypeId: TypeId) => number;

package/dist/engine/combat/typeEffectiveness.js

@@ -0,0 +1,7 @@
+export const getTypeEffectiveness = (state, attackerTypeId, defenderTypeId) => {
+    const matrix = state.runtime.typeEffectiveness;
+    const row = matrix[attackerTypeId];
+    if (!row)
+        return 1;
+    return row[defenderTypeId] ?? 1;
+};

package/dist/engine/combat/winner.d.ts

@@ -0,0 +1,2 @@
+import { RuntimeBattleState } from "../rules";
+export declare const checkWinner: (state: RuntimeBattleState) => "none" | "player1" | "player2" | "draw";

package/dist/engine/combat/winner.js

@@ -0,0 +1,11 @@
+export const checkWinner = (state) => {
+    const p1Alive = state.player1.fighterTeam.some((f) => f.isAlive && f.currentHp > 0);
+    const p2Alive = state.player2.fighterTeam.some((f) => f.isAlive && f.currentHp > 0);
+    if (p1Alive && !p2Alive)
+        return "player1";
+    if (!p1Alive && p2Alive)
+        return "player2";
+    if (!p1Alive && !p2Alive)
+        return "draw";
+    return "none";
+};

package/dist/engine/debug.d.ts

@@ -0,0 +1 @@
+export declare const dbg: (...args: unknown[]) => void;

package/dist/engine/debug.js

@@ -0,0 +1,6 @@
+const DEBUG_BATTLE = true;
+export const dbg = (...args) => {
+    if (!DEBUG_BATTLE)
+        return;
+    console.log("[BATTLE]", ...args);
+};

package/dist/engine/effects/applyEffects.d.ts

@@ -0,0 +1,7 @@
+import { BattleEvent, BattleFighter, EffectDefinition, TypeId } from "../../core";
+import { RuntimeBattleState } from "../rules";
+export declare const applyEffectsOnTarget: (state: RuntimeBattleState, actor: BattleFighter, target: BattleFighter, moveTypeId: TypeId | null, isCritical: boolean, effects: EffectDefinition[]) => {
+    actor: BattleFighter;
+    target: BattleFighter;
+    events: BattleEvent[];
+};