pokemon-io-core 0.0.82 → 0.0.84

package/dist/engine/events.d.ts

@@ -0,0 +1,4 @@
+import { BattleEvent } from "../core";
+export declare const createBaseEvent: (turnNumber: number, kind: BattleEvent["kind"], message: string) => Omit<BattleEvent, "kind"> & {
+    kind: typeof kind;
+};

package/dist/engine/events.js

@@ -0,0 +1,12 @@
+let eventCounter = 0;
+const nextEventId = () => {
+    eventCounter += 1;
+    return `evt_${eventCounter}`;
+};
+export const createBaseEvent = (turnNumber, kind, message) => ({
+    id: nextEventId(),
+    kind,
+    turnNumber,
+    message,
+    timestamp: Date.now(),
+});

package/dist/engine/fighters/fighter.d.ts

@@ -0,0 +1,4 @@
+import { BattleFighter } from "../../core";
+import { PlayerFighterBattleConfig, RuntimeBattleState } from "../rules";
+export declare const createBattleFighter: (cfg: PlayerFighterBattleConfig) => BattleFighter;
+export declare const recomputeEffectiveStatsForFighter: (state: RuntimeBattleState, fighter: BattleFighter) => BattleFighter;

package/dist/engine/fighters/fighter.js

@@ -0,0 +1,53 @@
+import { cloneStats } from "../runtime";
+export const createBattleFighter = (cfg) => {
+    if (cfg.moves.length !== 4) {
+        throw new Error("Each fighter must have exactly 4 moves in MVP");
+    }
+    return {
+        fighterId: cfg.fighter.id,
+        classId: cfg.fighter.classId,
+        maxHp: cfg.maxHp,
+        currentHp: cfg.maxHp,
+        baseStats: cloneStats(cfg.fighter.baseStats),
+        effectiveStats: cloneStats(cfg.fighter.baseStats),
+        moves: cfg.moves.map((move) => ({
+            moveId: move.id,
+            currentPP: move.maxPP,
+        })),
+        amuletId: cfg.amulet ? cfg.amulet.id : null,
+        statuses: [],
+        isAlive: true,
+    };
+};
+export const recomputeEffectiveStatsForFighter = (state, fighter) => {
+    // Partimos de base
+    let eff = { ...fighter.baseStats };
+    // 1) Aplicar estados
+    for (const st of fighter.statuses) {
+        const def = state.runtime.statusesById[st.statusId];
+        if (!def)
+            continue;
+        const stacks = st.stacks === 2 ? 2 : 1;
+        for (const effDef of def.effectsPerStack) {
+            const totalStacks = stacks; // podrías multiplicar efectos por stacks
+            switch (effDef.kind) {
+                case "modify_stats":
+                    eff.offense += (effDef.offenseDelta ?? 0) * totalStacks;
+                    eff.defense += (effDef.defenseDelta ?? 0) * totalStacks;
+                    eff.speed += (effDef.speedDelta ?? 0) * totalStacks;
+                    eff.crit += (effDef.critDelta ?? 0) * totalStacks;
+                    break;
+                case "modify_effective_speed":
+                    eff.speed = Math.floor(eff.speed * Math.pow(effDef.multiplier, totalStacks));
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+    // 2) Aquí podrías aplicar amuletos, buffs temporales o lo que quieras
+    return {
+        ...fighter,
+        effectiveStats: eff,
+    };
+};

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

@@ -0,0 +1,3 @@
+export * from './fighter.js';
+export * from './selectors.js';
+export * from './update.js';

package/dist/engine/fighters/index.js

@@ -0,0 +1,3 @@
+export * from './fighter.js';
+export * from './selectors.js';
+export * from './update.js';

package/dist/engine/fighters/selectors.d.ts

@@ -0,0 +1,13 @@
+import { BattleFighter, PlayerBattleState } from "../../core";
+import { RuntimeBattleState } from "../rules";
+export declare const getActiveFighter: (player: PlayerBattleState) => BattleFighter;
+export declare const getOpponentAndSelf: (state: RuntimeBattleState, playerKey: "player1" | "player2") => {
+    self: BattleFighter;
+    opponent: BattleFighter;
+};
+export declare const getPlayersAndActives: (state: RuntimeBattleState, playerKey: "player1" | "player2") => {
+    selfPlayer: PlayerBattleState;
+    oppPlayer: PlayerBattleState;
+    self: BattleFighter;
+    opponent: BattleFighter;
+};

package/dist/engine/fighters/selectors.js

@@ -0,0 +1,19 @@
+export const getActiveFighter = (player) => player.fighterTeam[player.activeIndex];
+export const getOpponentAndSelf = (state, playerKey) => {
+    const selfPlayer = playerKey === "player1" ? state.player1 : state.player2;
+    const oppPlayer = playerKey === "player1" ? state.player2 : state.player1;
+    return {
+        self: getActiveFighter(selfPlayer),
+        opponent: getActiveFighter(oppPlayer),
+    };
+};
+export const getPlayersAndActives = (state, playerKey) => {
+    const selfPlayer = playerKey === "player1" ? state.player1 : state.player2;
+    const oppPlayer = playerKey === "player1" ? state.player2 : state.player1;
+    return {
+        selfPlayer,
+        oppPlayer,
+        self: getActiveFighter(selfPlayer),
+        opponent: getActiveFighter(oppPlayer),
+    };
+};

package/dist/engine/fighters/update.d.ts

@@ -0,0 +1,3 @@
+import { BattleFighter } from "../../core";
+import { RuntimeBattleState } from "../rules";
+export declare const updateFightersInState: (state: RuntimeBattleState, actingPlayerKey: "player1" | "player2", updatedSelf: BattleFighter, updatedOpponent: BattleFighter) => RuntimeBattleState;

package/dist/engine/fighters/update.js

@@ -0,0 +1,30 @@
+// ------------------------------------------------------
+// Actualizar fighters en el estado
+// ------------------------------------------------------
+export const updateFightersInState = (state, actingPlayerKey, updatedSelf, updatedOpponent) => {
+    const player1 = { ...state.player1 };
+    const player2 = { ...state.player2 };
+    const updateInPlayer = (player, updated) => {
+        const newTeam = player.fighterTeam.map((f, idx) => idx === player.activeIndex ? updated : f);
+        return {
+            ...player,
+            fighterTeam: newTeam,
+        };
+    };
+    if (actingPlayerKey === "player1") {
+        const selfPlayer = updateInPlayer(player1, updatedSelf);
+        const oppPlayer = updateInPlayer(player2, updatedOpponent);
+        return {
+            ...state,
+            player1: selfPlayer,
+            player2: oppPlayer,
+        };
+    }
+    const selfPlayer = updateInPlayer(player2, updatedSelf);
+    const oppPlayer = updateInPlayer(player1, updatedOpponent);
+    return {
+        ...state,
+        player1: oppPlayer,
+        player2: selfPlayer,
+    };
+};

package/dist/engine/index.d.ts

@@ -1 +1,11 @@
-export * from './pokemonBattleService.js';
+export * from './debug.js';
+export * from './events.js';
+export * from './rng.js';
+export * from './rules.js';
+export * from './runtime.js';
+export * from './actions/index.js';
+export * from './combat/index.js';
+export * from './effects/index.js';
+export * from './fighters/index.js';
+export * from './status/index.js';
+export * from './turn/index.js';

package/dist/engine/index.js

@@ -1 +1,11 @@
-export * from './pokemonBattleService.js';
+export * from './debug.js';
+export * from './events.js';
+export * from './rng.js';
+export * from './rules.js';
+export * from './runtime.js';
+export * from './actions/index.js';
+export * from './combat/index.js';
+export * from './effects/index.js';
+export * from './fighters/index.js';
+export * from './status/index.js';
+export * from './turn/index.js';

package/dist/engine/rng.d.ts

@@ -0,0 +1,2 @@
+export declare const randomInRange: (min: number, max: number) => number;
+export declare const chance: (probability: number) => boolean;

package/dist/engine/rng.js

@@ -0,0 +1,8 @@
+export const randomInRange = (min, max) => Math.random() * (max - min) + min;
+export const chance = (probability) => {
+    if (probability <= 0)
+        return false;
+    if (probability >= 1)
+        return true;
+    return Math.random() < probability;
+};

package/dist/engine/rules.d.ts

@@ -0,0 +1,44 @@
+import { AmuletDefinition, BattleState, FighterDefinition, ItemDefinition, ItemId, MoveDefinition, MoveId, StatusDefinition, StatusId, TypeDefinition, TypeEffectivenessMatrix, TypeId } from "../core";
+export interface BattleRules {
+    baseCritChance: number;
+    critPerStat: number;
+    critMultiplier: number;
+    stabMultiplier: number;
+    randomMinDamageFactor: number;
+    randomMaxDamageFactor: number;
+}
+export interface BattleRuntime {
+    rules: BattleRules;
+    typesById: Record<TypeId, TypeDefinition>;
+    movesById: Record<MoveId, MoveDefinition>;
+    itemsById: Record<ItemId, ItemDefinition>;
+    amuletsById: Record<string, AmuletDefinition>;
+    statusesById: Record<StatusId, StatusDefinition>;
+    typeEffectiveness: TypeEffectivenessMatrix;
+}
+export interface PlayerFighterBattleConfig {
+    fighter: FighterDefinition;
+    maxHp: number;
+    moves: MoveDefinition[];
+    amulet: AmuletDefinition | null;
+}
+export interface PlayerBattleConfig {
+    fighters: PlayerFighterBattleConfig[];
+    items: ItemDefinition[];
+    amulet: AmuletDefinition | null;
+}
+export interface BattleConfig {
+    types: TypeDefinition[];
+    typeEffectiveness: TypeEffectivenessMatrix;
+    moves: MoveDefinition[];
+    items: ItemDefinition[];
+    amulets: AmuletDefinition[];
+    statuses: StatusDefinition[];
+    player1: PlayerBattleConfig;
+    player2: PlayerBattleConfig;
+    rules?: Partial<BattleRules>;
+}
+export interface RuntimeBattleState extends BattleState {
+    runtime: BattleRuntime;
+}
+export declare const DEFAULT_RULES: BattleRules;

package/dist/engine/rules.js

@@ -0,0 +1,10 @@
+// ------------------------------------------------------
+// Config & runtime
+export const DEFAULT_RULES = {
+    baseCritChance: 0.05,
+    critPerStat: 0.002,
+    critMultiplier: 1.1,
+    stabMultiplier: 1.1,
+    randomMinDamageFactor: 0.8,
+    randomMaxDamageFactor: 1.0,
+};

package/dist/engine/runtime.d.ts

@@ -0,0 +1,7 @@
+import { BattleState, FighterStats } from "../core";
+import { BattleConfig } from "./rules";
+export declare const buildMap: <T extends {
+    id: string;
+}>(list: T[]) => Record<string, T>;
+export declare const cloneStats: (stats: FighterStats) => FighterStats;
+export declare const createInitialBattleState: (config: BattleConfig) => BattleState;

package/dist/engine/runtime.js

@@ -0,0 +1,49 @@
+import { createBattleFighter } from "./fighters/fighter";
+import { DEFAULT_RULES, } from "./rules";
+export const buildMap = (list) => list.reduce((acc, item) => {
+    acc[item.id] = item;
+    return acc;
+}, {});
+export const cloneStats = (stats) => ({
+    offense: stats.offense,
+    defense: stats.defense,
+    speed: stats.speed,
+    crit: stats.crit,
+});
+const createPlayerBattleState = (cfg) => {
+    const team = cfg.fighters.map((fCfg) => createBattleFighter(fCfg));
+    const inventory = cfg.items.map((item) => ({
+        itemId: item.id,
+        usesRemaining: item.maxUses,
+    }));
+    return {
+        fighterTeam: team,
+        activeIndex: 0,
+        inventory,
+    };
+};
+export const createInitialBattleState = (config) => {
+    const rules = {
+        ...DEFAULT_RULES,
+        ...config.rules,
+    };
+    const runtime = {
+        rules,
+        typesById: buildMap(config.types),
+        movesById: buildMap(config.moves),
+        itemsById: buildMap(config.items),
+        amuletsById: buildMap(config.amulets),
+        statusesById: buildMap(config.statuses),
+        typeEffectiveness: config.typeEffectiveness,
+    };
+    const player1 = createPlayerBattleState(config.player1);
+    const player2 = createPlayerBattleState(config.player2);
+    const state = {
+        turnNumber: 1,
+        player1,
+        player2,
+        runtime,
+        forcedSwitch: null,
+    };
+    return state;
+};

package/dist/engine/status/apply.d.ts

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

package/dist/engine/status/apply.js

@@ -0,0 +1,49 @@
+import { dbg } from "../debug";
+import { createBaseEvent } from "../events";
+import { randomInRange } from "../rng";
+export 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;
+    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);
+    }
+    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,
+        statusId,
+    });
+    return {
+        updated: { ...target, statuses: newStatuses },
+        events,
+    };
+};

package/dist/engine/status/clear.d.ts

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

package/dist/engine/status/clear.js

@@ -0,0 +1,47 @@
+import { dbg } from "../debug";
+import { createBaseEvent } from "../events";
+export const clearStatusFromFighter = (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,
+    };
+};

package/dist/engine/status/endOfTurn.d.ts

@@ -0,0 +1,6 @@
+import { BattleEvent } from "../../core";
+import { RuntimeBattleState } from "../rules";
+export declare const applyEndOfTurnStatuses: (state: RuntimeBattleState) => {
+    state: RuntimeBattleState;
+    events: BattleEvent[];
+};

package/dist/engine/status/endOfTurn.js

@@ -0,0 +1,80 @@
+import { applyDamageToFighter } from "../combat/damage";
+import { dbg } from "../debug";
+import { createBaseEvent } from "../events";
+import { getActiveFighter } from "../fighters/selectors";
+export const applyEndOfTurnStatuses = (state) => {
+    const events = [];
+    const applyForPlayer = (player) => {
+        const active = getActiveFighter(player);
+        let updated = { ...active };
+        const updatedStatuses = [];
+        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;
+            }
+            let damageFromStatus = 0;
+            def.effectsPerStack.forEach((eff) => {
+                if (eff.kind === "damage") {
+                    const stacksMultiplier = st.stacks === 2 ? 2 : 1;
+                    const base = typeof eff.flatAmount === "number"
+                        ? eff.flatAmount
+                        : typeof eff.basePower === "number"
+                            ? eff.basePower
+                            : 10; // fallback
+                    damageFromStatus += base * 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);
+            }
+            const remaining = st.remainingTurns - 1;
+            if (remaining > 0) {
+                updatedStatuses.push({
+                    ...st,
+                    remainingTurns: remaining,
+                });
+            }
+            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,
+                    statusId: st.statusId,
+                });
+            }
+        }
+        updated = {
+            ...updated,
+            statuses: updatedStatuses,
+        };
+        const newTeam = player.fighterTeam.map((f, idx) => idx === player.activeIndex ? updated : f);
+        return {
+            ...player,
+            fighterTeam: newTeam,
+        };
+    };
+    const p1 = applyForPlayer(state.player1);
+    const p2 = applyForPlayer(state.player2);
+    const newState = {
+        ...state,
+        player1: p1,
+        player2: p2,
+    };
+    return { state: newState, events };
+};

package/dist/engine/status/hardCc.d.ts

@@ -0,0 +1,3 @@
+import { BattleFighter } from "../../core";
+import { RuntimeBattleState } from "../rules";
+export declare const hasHardCc: (state: RuntimeBattleState, fighter: BattleFighter) => boolean;

package/dist/engine/status/hardCc.js

@@ -0,0 +1,4 @@
+export const hasHardCc = (state, fighter) => fighter.statuses.some((st) => {
+    const def = state.runtime.statusesById[st.statusId];
+    return def?.kind === "hard_cc";
+});

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

@@ -0,0 +1,4 @@
+export * from './apply.js';
+export * from './clear.js';
+export * from './endOfTurn.js';
+export * from './hardCc.js';

package/dist/engine/status/index.js

@@ -0,0 +1,4 @@
+export * from './apply.js';
+export * from './clear.js';
+export * from './endOfTurn.js';
+export * from './hardCc.js';

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

@@ -0,0 +1 @@
+export * from './resolveTurn.js';

package/dist/engine/turn/index.js

@@ -0,0 +1 @@
+export * from './resolveTurn.js';

package/dist/engine/turn/resolveTurn.d.ts

@@ -0,0 +1,5 @@
+import { BattleActions, BattleEvent, BattleState } from "../../core";
+export declare const resolveTurn: (state: BattleState, actions: BattleActions) => {
+    newState: BattleState;
+    events: BattleEvent[];
+};