pokemon-io-core 0.0.1

package/dist/api/battle.d.ts

@@ -0,0 +1,14 @@
+export interface BattlePlayerView {
+    playerId: string;
+    nickname: string;
+    hp: number;
+}
+export type BattleStatusView = "ongoing" | "finished";
+export interface BattleView {
+    roomId: string;
+    status: BattleStatusView;
+    currentTurnPlayerId: string | null;
+    winnerId: string | null;
+    endsAt: string;
+    players: BattlePlayerView[];
+}

package/dist/api/battle.js

@@ -0,0 +1,2 @@
+// @pokemon-io/combat-core/src/api/battle.ts
+export {};

package/dist/api/room.d.ts

@@ -0,0 +1,21 @@
+export interface PlayerLoadoutView {
+    fighterId: string | null;
+    moveIds: string[];
+    itemIds: string[];
+    amuletId: string | null;
+}
+export interface PlayerView {
+    id: string;
+    nickname: string;
+    isOwner: boolean;
+    isSelf: boolean;
+    isReady: boolean;
+    loadout: PlayerLoadoutView | null;
+}
+export type RoomStatusView = "waiting" | "in_battle" | "finished";
+export interface RoomView {
+    id: string;
+    ownerId: string;
+    status: RoomStatusView;
+    players: PlayerView[];
+}

package/dist/api/room.js

@@ -0,0 +1,2 @@
+// @pokemon-io/combat-core/src/api/room.ts
+export {};

package/dist/core/actions.d.ts

@@ -0,0 +1,21 @@
+export type ActionKind = "use_move" | "use_item" | "switch_fighter" | "no_action";
+export interface UseMoveAction {
+    kind: "use_move";
+    moveIndex: number;
+}
+export interface UseItemAction {
+    kind: "use_item";
+    itemIndex: number;
+}
+export interface SwitchFighterAction {
+    kind: "switch_fighter";
+    targetIndex: number;
+}
+export interface NoAction {
+    kind: "no_action";
+}
+export type PlayerAction = UseMoveAction | UseItemAction | SwitchFighterAction | NoAction;
+export interface BattleActions {
+    player1: PlayerAction;
+    player2: PlayerAction;
+}

package/dist/core/actions.js

@@ -0,0 +1 @@
+export {};

package/dist/core/amulets.d.ts

@@ -0,0 +1,18 @@
+import type { AmuletId, TypeId, StatusId } from "./ids";
+import type { EffectDefinition } from "./moves";
+export type PassiveTriggerKind = "always" | "on_hit" | "on_damage_taken" | "on_below_hp_threshold";
+export interface PassiveTriggerCondition {
+    kind: PassiveTriggerKind;
+    hpThresholdPercent?: number;
+}
+export interface PassiveEffectDefinition {
+    trigger: PassiveTriggerCondition;
+    effects: EffectDefinition[];
+    appliedStatusId?: StatusId;
+}
+export interface AmuletDefinition {
+    id: AmuletId;
+    name: string;
+    classId: TypeId | null;
+    passiveEffects: PassiveEffectDefinition[];
+}

package/dist/core/amulets.js

@@ -0,0 +1 @@
+export {};

package/dist/core/battleState.d.ts

@@ -0,0 +1,37 @@
+import type { FighterId, TypeId, MoveId, ItemId, AmuletId, StatusId } from "./ids";
+import type { FighterStats } from "./types";
+export interface EquippedMove {
+    moveId: MoveId;
+    currentPP: number;
+}
+export interface EquippedItem {
+    itemId: ItemId;
+    usesRemaining: number;
+}
+export interface ActiveStatus {
+    statusId: StatusId;
+    stacks: 1 | 2;
+    remainingTurns: number;
+}
+export interface BattleFighter {
+    fighterId: FighterId;
+    classId: TypeId;
+    maxHp: number;
+    currentHp: number;
+    baseStats: FighterStats;
+    effectiveStats: FighterStats;
+    moves: EquippedMove[];
+    items: EquippedItem[];
+    amuletId: AmuletId | null;
+    statuses: ActiveStatus[];
+    isAlive: boolean;
+}
+export interface PlayerBattleState {
+    fighterTeam: BattleFighter[];
+    activeIndex: number;
+}
+export interface BattleState {
+    turnNumber: number;
+    player1: PlayerBattleState;
+    player2: PlayerBattleState;
+}

package/dist/core/battleState.js

@@ -0,0 +1 @@
+export {};

package/dist/core/engine.d.ts

@@ -0,0 +1,45 @@
+import { type BattleState, type FighterDefinition, type MoveDefinition, type ItemDefinition, type AmuletDefinition, type StatusDefinition, type TypeDefinition, type TypeEffectivenessMatrix, type BattleActions, type BattleEvent, type MoveId, type ItemId, type StatusId, type TypeId } from ".";
+interface BattleRules {
+    baseCritChance: number;
+    critPerStat: number;
+    critMultiplier: number;
+    stabMultiplier: number;
+    randomMinDamageFactor: number;
+    randomMaxDamageFactor: number;
+}
+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 PlayerBattleConfig {
+    fighter: FighterDefinition;
+    maxHp: number;
+    moves: MoveDefinition[];
+    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 createInitialBattleState: (config: BattleConfig) => RuntimeBattleState;
+export declare const resolveTurn: (state: BattleState, actions: BattleActions) => {
+    newState: BattleState;
+    events: BattleEvent[];
+};
+export {};

package/dist/core/engine.js

@@ -0,0 +1,481 @@
+// src/domain/combat/engine/battleEngine.ts
+import { logger } from "../utils/logger";
+const DEFAULT_RULES = {
+    baseCritChance: 0.05,
+    critPerStat: 0.002,
+    critMultiplier: 1.5,
+    stabMultiplier: 1.5,
+    randomMinDamageFactor: 0.85,
+    randomMaxDamageFactor: 1.0,
+};
+const buildMap = (list) => {
+    return list.reduce((acc, item) => {
+        acc[item.id] = item;
+        return acc;
+    }, {});
+};
+const cloneStats = (stats) => ({
+    offense: stats.offense,
+    defense: stats.defense,
+    speed: stats.speed,
+    crit: stats.crit,
+});
+const createBattleFighter = (cfg) => {
+    logger.info(`Creating fighter ${JSON.stringify(cfg)}`);
+    if (cfg.moves.length !== 4) {
+        throw new Error("Each fighter must have exactly 4 moves in MVP");
+    }
+    if (cfg.items.length > 4) {
+        throw new Error("A fighter cannot have more than 4 items");
+    }
+    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,
+        })),
+        items: cfg.items.map((item) => ({
+            itemId: item.id,
+            usesRemaining: item.maxUses,
+        })),
+        amuletId: cfg.amulet ? cfg.amulet.id : null,
+        statuses: [],
+        isAlive: true,
+    };
+};
+const createPlayerBattleState = (cfg) => {
+    const fighter = createBattleFighter(cfg);
+    return {
+        fighterTeam: [fighter],
+        activeIndex: 0,
+    };
+};
+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,
+    };
+    return state;
+};
+// HELPERS
+const getActiveFighter = (player) => {
+    return player.fighterTeam[player.activeIndex];
+};
+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),
+    };
+};
+const getTypeEffectiveness = (state, attackerTypeId, defenderTypeId) => {
+    const matrix = state.runtime.typeEffectiveness;
+    const row = matrix[attackerTypeId];
+    if (!row)
+        return 1;
+    return row[defenderTypeId] ?? 1;
+};
+const randomInRange = (min, max) => {
+    return Math.random() * (max - min) + min;
+};
+const chance = (probability) => {
+    if (probability <= 0)
+        return false;
+    if (probability >= 1)
+        return true;
+    return Math.random() < probability;
+};
+// FIN HELPERS
+// CALCULO DE CRITICOS Y DAÑO
+const computeCritChance = (rules, critStat) => {
+    const raw = rules.baseCritChance + critStat * rules.critPerStat;
+    return Math.max(0, Math.min(1, raw));
+};
+const computeDamage = (input) => {
+    const { state, attacker, defender, move, 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);
+    if (typeEffectiveness === 0) {
+        return {
+            damage: 0,
+            effectiveness: 0,
+        };
+    }
+    const stabMultiplier = attacker.classId === move.typeId ? 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;
+    const finalDamage = Math.max(1, Math.floor(rawDamage));
+    return {
+        damage: finalDamage,
+        effectiveness: typeEffectiveness,
+    };
+};
+let eventCounter = 0;
+const nextEventId = () => {
+    eventCounter += 1;
+    return `evt_${eventCounter}`;
+};
+const createBaseEvent = (turnNumber, kind, message) => ({
+    id: nextEventId(),
+    kind,
+    turnNumber,
+    message,
+    timestamp: Date.now(),
+});
+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 };
+};
+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,
+        };
+    }
+    // Items y switch: prioridad base 0 por ahora
+    return {
+        priority: 0,
+        speed: self.effectiveStats.speed,
+    };
+};
+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)
+    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 };
+    }
+    // Acción declarada (para narrador avanzado)
+    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 };
+    if (!hit) {
+        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, opponent);
+        return { state: newState, events };
+    }
+    // Crítico
+    const critChance = computeCritChance(state.runtime.rules, updatedSelf.effectiveStats.crit);
+    const isCritical = chance(critChance);
+    const { damage, effectiveness } = computeDamage({
+        state,
+        attacker: updatedSelf,
+        defender: opponent,
+        move,
+        isCritical,
+    });
+    events.push({
+        ...createBaseEvent(state.turnNumber, "move_hit", `${self.fighterId} acierta ${move.name}`),
+        actorId: self.fighterId,
+        moveId: move.id,
+        targetId: opponent.fighterId,
+        isCritical,
+        effectiveness,
+    });
+    const damageResult = applyDamageToFighter(state, opponent, damage, updatedSelf.fighterId, isCritical);
+    events.push(...damageResult.events);
+    const newState = updateFightersInState(state, playerKey, updatedSelf, damageResult.updatedDefender);
+    return { state: newState, events };
+};
+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,
+    };
+};
+// FIN RESOLUCION DE ACCION DE use_move
+// ORDEN DE ACCIONES HARD CC Y FIN DE TURNO
+const hasHardCc = (state, fighter) => {
+    return fighter.statuses.some((st) => {
+        const def = state.runtime.statusesById[st.statusId];
+        return def?.kind === "hard_cc";
+    });
+};
+const checkWinner = (state) => {
+    const f1 = getActiveFighter(state.player1);
+    const f2 = getActiveFighter(state.player2);
+    const p1Alive = f1.isAlive && f1.currentHp > 0;
+    const p2Alive = f2.isAlive && f2.currentHp > 0;
+    if (p1Alive && !p2Alive)
+        return "player1";
+    if (!p1Alive && p2Alive)
+        return "player2";
+    if (!p1Alive && !p2Alive)
+        return "draw";
+    return "none";
+};
+// Estados al final del turno: MVP = aplicar DoT básico
+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) {
+                continue;
+            }
+            // MVP: interpretamos cualquier efecto kind: "damage" como DoT
+            let damageFromStatus = 0;
+            def.effectsPerStack.forEach((eff) => {
+                if (eff.kind === "damage") {
+                    const stacksMultiplier = st.stacks === 2 ? 2 : 1;
+                    const basePower = 10; // DoT base “genérico” (podrás parametrizar)
+                    damageFromStatus += basePower * stacksMultiplier;
+                }
+            });
+            if (damageFromStatus > 0 && updated.isAlive) {
+                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 {
+                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 };
+};
+// FIN ORDEN DE ACCIONES HARD CC Y FIN DE TURNO
+export const resolveTurn = (state, actions) => {
+    const runtimeState = state;
+    const events = [];
+    // Evento de inicio de turno
+    events.push({
+        ...createBaseEvent(runtimeState.turnNumber, "turn_start", `Comienza el turno ${runtimeState.turnNumber}`),
+    });
+    // Construir orden con prioridad+speed
+    const entries = [
+        {
+            playerKey: "player1",
+            action: actions.player1,
+            ...getMovePriorityAndSpeed(runtimeState, "player1", actions.player1),
+        },
+        {
+            playerKey: "player2",
+            action: actions.player2,
+            ...getMovePriorityAndSpeed(runtimeState, "player2", actions.player2),
+        },
+    ];
+    entries.sort((a, b) => {
+        if (b.priority !== a.priority) {
+            return b.priority - a.priority;
+        }
+        if (b.speed !== a.speed) {
+            return b.speed - a.speed;
+        }
+        // empate total → coin flip
+        return Math.random() < 0.5 ? -1 : 1;
+    });
+    let currentState = runtimeState;
+    for (const entry of entries) {
+        const { playerKey, action } = entry;
+        if (action.kind === "no_action") {
+            continue;
+        }
+        const { self } = getOpponentAndSelf(currentState, playerKey);
+        // Si ya está muerto, no hace nada
+        if (!self.isAlive || self.currentHp <= 0) {
+            continue;
+        }
+        // Hard CC → se salta acción
+        if (hasHardCc(currentState, self)) {
+            events.push({
+                ...createBaseEvent(currentState.turnNumber, "action_skipped_hard_cc", `${self.fighterId} no puede actuar por control total`),
+                actorId: self.fighterId,
+            });
+            continue;
+        }
+        if (action.kind === "use_move") {
+            const result = resolveDamageMove(currentState, playerKey, action);
+            currentState = result.state;
+            events.push(...result.events);
+        }
+        else {
+            // MVP: ignoramos use_item y switch_fighter de momento
+            continue;
+        }
+        // Comprobar victoria inmediata tras cada acción
+        const winnerAfterAction = checkWinner(currentState);
+        if (winnerAfterAction !== "none") {
+            events.push({
+                ...createBaseEvent(currentState.turnNumber, "battle_end", `La batalla termina: ${winnerAfterAction}`),
+                winner: winnerAfterAction,
+            });
+            const finalState = {
+                ...currentState,
+                turnNumber: currentState.turnNumber + 1,
+            };
+            return {
+                newState: finalState,
+                events,
+            };
+        }
+    }
+    // Fin de turno: aplicar estados
+    const statusResult = applyEndOfTurnStatuses(currentState);
+    currentState = statusResult.state;
+    events.push(...statusResult.events);
+    const winnerAtEnd = checkWinner(currentState);
+    if (winnerAtEnd !== "none") {
+        events.push({
+            ...createBaseEvent(currentState.turnNumber, "battle_end", `La batalla termina: ${winnerAtEnd}`),
+            winner: winnerAtEnd,
+        });
+    }
+    events.push({
+        ...createBaseEvent(currentState.turnNumber, "turn_end", `Termina el turno ${currentState.turnNumber}`),
+    });
+    const finalState = {
+        ...currentState,
+        turnNumber: currentState.turnNumber + 1,
+    };
+    return {
+        newState: finalState,
+        events,
+    };
+};