pokemon-io-core 0.0.71 → 0.0.72

package/dist/api/room.d.ts

@@ -1,10 +1,8 @@
 export interface PlayerLoadoutView {
-    fighterIds: string[];
-    movesByFighterId: Record<string, string[]>;
-    itemIds: string[];
-    amuletId: string | null;
     fighterId: string | null;
     moveIds: string[];
+    itemIds: string[];
+    amuletId: string | null;
 }
 export interface PlayerView {
     id: string;

package/dist/api/socketTypes.d.ts

@@ -42,6 +42,10 @@ export interface ClientToServerEvents {
         roomId: string;
         itemIndex: number;
     }) => void;
+    "battle:switchFighter": (payload: {
+        roomId: string;
+        newIndex: number;
+    }) => void;
     "battle:rematchSameLoadout": (payload: {
         roomId: string;
     }) => void;

package/dist/api/socketTypes.js

@@ -1 +1,2 @@
+// @pokemon-io/combat-core/src/api/socketTypests
 export {};

package/dist/core/engine.d.ts

@@ -16,39 +16,7 @@ export interface BattleRuntime {
     statusesById: Record<StatusId, StatusDefinition>;
     typeEffectiveness: TypeEffectivenessMatrix;
 }
-/**
- * Slot de equipo: UN luchador con sus stats base y movimientos.
- * OJO: aquí NO van los items; los items son por jugador.
- */
-export interface PlayerFighterConfig {
-    fighter: FighterDefinition;
-    maxHp: number;
-    moves: MoveDefinition[];
-    amulet: AmuletDefinition | null;
-}
-/**
- * Configuración de un jugador para el combate.
- *
- * - Forma nueva (multi-team): usar `team`.
- * - Forma legacy (1 vs 1): usar fighter/maxHp/moves/items/amulet como hasta ahora.
- *   Si `team` no viene o está vacío, el engine construye un equipo de 1 con esos datos.
- */
-export interface FighterSlotConfig {
-    fighter: FighterDefinition;
-    maxHp: number;
-    moves: MoveDefinition[];
-    amulet: AmuletDefinition | null;
-}
 export interface PlayerBattleConfig {
-    /**
-     * Nueva forma: equipo completo. Si existe y tiene elementos,
-     * el engine usará esto como fuente de verdad.
-     */
-    team?: FighterSlotConfig[];
-    /**
-     * Forma legacy (1 vs 1). Se mantiene para compatibilidad
-     * con skins y backends actuales.
-     */
     fighter: FighterDefinition;
     maxHp: number;
     moves: MoveDefinition[];

package/dist/core/engine.js

@@ -30,26 +30,29 @@ const cloneStats = (stats) => ({
 // ------------------------------------------------------
 // Creación de estado inicial
 // ------------------------------------------------------
-const createBattleFighter = (slot, playerItems) => {
+const createBattleFighter = (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: slot.fighter.id,
-        classId: slot.fighter.classId,
-        maxHp: slot.maxHp,
-        currentHp: slot.maxHp,
-        baseStats: slot.fighter.baseStats,
-        effectiveStats: slot.fighter.baseStats,
-        moves: slot.moves.map((m) => ({
-            moveId: m.id,
-            currentPP: m.maxPP,
+        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,
         })),
-        // ⚠️ De momento mantenemos el comportamiento actual:
-        // cada luchador tiene su copia de items.
-        // Más adelante, si quieres, los movemos a nivel jugador.
-        items: playerItems.map((it) => ({
-            itemId: it.id,
-            usesRemaining: it.maxUses ?? 1,
+        items: cfg.items.map((item) => ({
+            itemId: item.id,
+            usesRemaining: item.maxUses,
         })),
-        amuletId: slot.amulet?.id ?? null,
+        amuletId: cfg.amulet ? cfg.amulet.id : null,
         statuses: [],
         isAlive: true,
     };
@@ -86,36 +89,10 @@ const recomputeEffectiveStatsForFighter = (state, fighter) => {
         effectiveStats: eff,
     };
 };
-const normalizeTeamFromConfig = (cfg) => {
-    // Si ya viene en forma de equipo, úsalo tal cual
-    if (cfg.team && cfg.team.length > 0) {
-        return cfg.team;
-    }
-    // Forma legacy: un solo fighter → lo envolvemos en un array
-    return [
-        {
-            fighter: cfg.fighter,
-            maxHp: cfg.maxHp,
-            moves: cfg.moves,
-            amulet: cfg.amulet,
-        },
-    ];
-};
 const createPlayerBattleState = (cfg) => {
-    // Si viene team, lo usamos; si no, construimos equipo de 1 (modo legacy)
-    const teamSlots = cfg.team && cfg.team.length > 0
-        ? cfg.team
-        : [
-            {
-                fighter: cfg.fighter,
-                maxHp: cfg.maxHp,
-                moves: cfg.moves,
-                amulet: cfg.amulet,
-            },
-        ];
-    const fighterTeam = teamSlots.map((slot) => createBattleFighter(slot, cfg.items));
+    const fighter = createBattleFighter(cfg);
     return {
-        fighterTeam,
+        fighterTeam: [fighter],
         activeIndex: 0,
     };
 };
@@ -503,6 +480,34 @@ const applyEffectsOnTarget = (state, actor, target, moveTypeId, isCritical, effe
     }
     return { actor: currentActor, target: currentTarget, events };
 };
+const resolveSwitchFighter = (state, playerKey, action) => {
+    if (action.kind !== "switch_fighter") {
+        return { state, events: [] };
+    }
+    const events = [];
+    const player = playerKey === "player1" ? state.player1 : state.player2;
+    const from = getActiveFighter(player);
+    const to = player.fighterTeam[action.newIndex];
+    if (!to)
+        return { state, events };
+    if (!to.isAlive || to.currentHp <= 0)
+        return { state, events };
+    if (action.newIndex === player.activeIndex)
+        return { state, events };
+    const updatedPlayer = {
+        ...player,
+        activeIndex: action.newIndex,
+    };
+    const newState = playerKey === "player1"
+        ? { ...state, player1: updatedPlayer }
+        : { ...state, player2: updatedPlayer };
+    events.push({
+        ...createBaseEvent(state.turnNumber, "fighter_switched", `${from.fighterId} cambia a ${to.fighterId}`),
+        fromFighterId: from.fighterId,
+        toFighterId: to.fighterId,
+    });
+    return { state: newState, events };
+};
 const getMovePriorityAndSpeed = (state, playerKey, action) => {
     const { self } = getOpponentAndSelf(state, playerKey);
     if (action.kind === "no_action") {
@@ -520,6 +525,12 @@ const getMovePriorityAndSpeed = (state, playerKey, action) => {
             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,
@@ -785,35 +796,6 @@ const applyEndOfTurnStatuses = (state) => {
     };
     return { state: newState, events };
 };
-const applySwitchAction = (state, playerKey, newIndex, events) => {
-    const playerState = state[playerKey];
-    const team = playerState.fighterTeam;
-    // Validaciones básicas
-    if (newIndex < 0 || newIndex >= team.length)
-        return state;
-    if (!team[newIndex]?.isAlive)
-        return state;
-    if (newIndex === playerState.activeIndex)
-        return state;
-    const oldIndex = playerState.activeIndex;
-    const oldFighter = team[oldIndex];
-    const newFighter = team[newIndex];
-    const newPlayerState = {
-        ...playerState,
-        activeIndex: newIndex,
-    };
-    const newState = {
-        ...state,
-        [playerKey]: newPlayerState,
-    };
-    events.push({
-        ...createBaseEvent(state.turnNumber, "fighter_switched", `${oldFighter.fighterId} se retira. ¡Adelante ${newFighter.fighterId}!`),
-        player: playerKey,
-        oldFighterId: oldFighter.fighterId,
-        newFighterId: newFighter.fighterId,
-    });
-    return newState;
-};
 // ------------------------------------------------------
 // Bucle principal de turno
 // ------------------------------------------------------
@@ -849,7 +831,6 @@ export const resolveTurn = (state, actions) => {
             ...getMovePriorityAndSpeed(runtimeState, "player2", actions.player2),
         },
     ];
-    // Orden clásico por prioridad + velocidad
     entries.sort((a, b) => {
         if (b.priority !== a.priority) {
             return b.priority - a.priority;
@@ -866,29 +847,7 @@ export const resolveTurn = (state, actions) => {
         priority: e.priority,
         speed: e.speed,
     })));
-    // 🔁 1) FASE DE CAMBIOS (switch_fighter) – prioridad absoluta
-    const switchEntries = entries.filter((e) => e.action.kind === "switch_fighter");
-    for (const entry of switchEntries) {
-        const { playerKey, action } = entry;
-        if (action.kind !== "switch_fighter")
-            continue;
-        const { self } = getOpponentAndSelf(currentState, playerKey);
-        // Si el activo ya está muerto, no tiene sentido cambiar (o el combate ya está decidido).
-        if (!self.isAlive || self.currentHp <= 0)
-            continue;
-        if (hasHardCc(currentState, self)) {
-            // No puede cambiar tampoco si está bajo hard CC
-            events.push({
-                ...createBaseEvent(currentState.turnNumber, "action_skipped_hard_cc", `${self.fighterId} no puede actuar por control total`),
-                actorId: self.fighterId,
-            });
-            continue;
-        }
-        currentState = applySwitchAction(currentState, playerKey, action.newIndex, events);
-    }
-    // 🔁 2) FASE DE ACCIONES (movimientos / objetos)
-    const actionEntries = entries.filter((e) => e.action.kind !== "switch_fighter");
-    for (const entry of actionEntries) {
+    for (const entry of entries) {
         const { playerKey, action } = entry;
         if (action.kind === "no_action")
             continue;
@@ -907,13 +866,18 @@ export const resolveTurn = (state, actions) => {
             currentState = result.state;
             events.push(...result.events);
         }
-        else if (action.kind === "use_item") {
+        if (action.kind === "use_item") {
             const result = resolveItemUse(currentState, playerKey, action);
             currentState = result.state;
             events.push(...result.events);
         }
+        if (action.kind === "switch_fighter") {
+            const result = resolveSwitchFighter(currentState, playerKey, action);
+            currentState = result.state;
+            events.push(...result.events);
+        }
         else {
-            // Cualquier otro tipo de acción futura se ignora de momento
+            // switch_fighter u otros no implementados aún
             continue;
         }
         const winnerAfterAction = checkWinner(currentState);
@@ -932,7 +896,6 @@ export const resolveTurn = (state, actions) => {
             };
         }
     }
-    // 🔁 3) Estados de final de turno
     const statusResult = applyEndOfTurnStatuses(currentState);
     currentState = statusResult.state;
     events.push(...statusResult.events);

package/dist/core/events.d.ts

@@ -1,5 +1,5 @@
 import type { FighterId, MoveId, ItemId, StatusId } from "./ids.js";
-export type BattleEventKind = "turn_start" | "action_declared" | "action_skipped_hard_cc" | "move_miss" | "move_hit" | "item_used" | "status_cleared" | "damage" | "heal" | "shield_applied" | "status_applied" | "status_refreshed" | "status_expired" | "fighter_fainted" | "fighter_switched" | "turn_end" | "battle_end";
+export type BattleEventKind = "turn_start" | "action_declared" | "action_skipped_hard_cc" | "move_miss" | "move_hit" | "item_used" | "status_cleared" | "damage" | "heal" | "fighter_switched" | "shield_applied" | "status_applied" | "status_refreshed" | "status_expired" | "fighter_fainted" | "turn_end" | "battle_end";
 export interface BaseBattleEvent {
     id: string;
     turnNumber: number;
@@ -51,6 +51,11 @@ export interface StatusAppliedEvent extends BaseBattleEvent {
     stacks: 1 | 2;
     durationTurns: number;
 }
+export interface FighterSwitchedEvent extends BaseBattleEvent {
+    kind: "fighter_switched";
+    fromFighterId: FighterId;
+    toFighterId: FighterId;
+}
 export interface StatusExpiredEvent extends BaseBattleEvent {
     kind: "status_expired";
     targetId: FighterId;
@@ -60,12 +65,6 @@ export interface FighterFaintedEvent extends BaseBattleEvent {
     kind: "fighter_fainted";
     fighterId: FighterId;
 }
-export interface FighterSwitchedEvent extends BaseBattleEvent {
-    kind: "fighter_switched";
-    player: "player1" | "player2";
-    oldFighterId: FighterId;
-    newFighterId: FighterId;
-}
 export interface BattleEndEvent extends BaseBattleEvent {
     kind: "battle_end";
     winner: "player1" | "player2" | "draw";

package/dist/skins/CombatSkin.d.ts

@@ -2,24 +2,9 @@ import type { TypeDefinition, TypeEffectivenessMatrix, MoveDefinition, ItemDefin
 import type { PlayerBattleConfig } from "../core/engine.js";
 export interface FighterLoadout {
     fighterId: string | null;
-    moveIds: string[];
     itemIds: string[];
     amuletId: string | null;
-    /**
-     * Lista de luchadores del equipo (máx. 6).
-     * Si solo hay uno, puede contener un único id.
-     */
-    fighterIds?: string[];
-    /**
-     * Movimientos por luchador. Si falta para alguno, se usan
-     * `moveIds` como fallback.
-     */
-    movesByFighterId?: Record<string, string[]>;
-    /**
-     * (Opcional) Futuro: cuál es el activo actual.
-     * Si no se define, se asume fighterIds[0].
-     */
-    activeFighterId?: string | null;
+    moveIds: string[];
 }
 export interface CombatSkin {
     readonly id: string;

package/dist/skins/cliches/clicheSkin.js

@@ -1,8 +1,8 @@
-// pokemon-io-core/src/skins/tribes/clicheSkin.ts
+// pokemon-io-core/src/skins/pokemon/pokemonSkin.ts
 import { POKEMON_ITEMS } from "../pokemon/index.js";
 import { TRIBE_FIGHTERS, TRIBE_MOVES, TRIBE_STATUSES, TRIBE_TYPES, TRIBE_TYPE_MATRIX, } from "./index.js";
 // --- helpers ---
-const findTribeFighterById = (id) => {
+const findPokemonById = (id) => {
     const lower = id.toLowerCase();
     return TRIBE_FIGHTERS.find((f) => f.id.toLowerCase() === lower) ?? null;
 };
@@ -72,27 +72,15 @@ export class TribeSkin {
             throw new Error("fighterId is required in FighterLoadout");
         }
         console.log("buildPlayerConfig", loadout.fighterId);
-        const fighter = findTribeFighterById(loadout.fighterId);
+        const fighter = findPokemonById(loadout.fighterId);
         if (!fighter) {
             throw new Error(`Unknown fighterId for Pokemon skin: ${loadout.fighterId}`);
         }
         const moves = buildMovesFromLoadout(fighter, loadout);
         const items = buildItemsFromLoadout(loadout);
-        const maxHp = fighter.baseStats.defense + fighter.baseStats.offense;
         return {
-            // ✅ NUEVO: modelo multi-equipo
-            team: [
-                {
-                    fighter,
-                    maxHp,
-                    moves,
-                    amulet: null,
-                },
-            ],
-            // ✅ LEGACY: seguimos rellenando los campos antiguos
-            // por si algún sitio sigue leyéndolos.
             fighter,
-            maxHp,
+            maxHp: fighter.baseStats.defense + fighter.baseStats.offense,
             moves,
             items,
             amulet: null,

package/dist/skins/pokemon/pokemonSkin.js

@@ -77,21 +77,9 @@ export class PokemonSkin {
         }
         const moves = buildMovesFromLoadout(fighter, loadout);
         const items = buildItemsFromLoadout(loadout);
-        const maxHp = fighter.baseStats.defense + fighter.baseStats.offense;
         return {
-            // ✅ NUEVO: modelo multi-equipo
-            team: [
-                {
-                    fighter,
-                    maxHp,
-                    moves,
-                    amulet: null,
-                },
-            ],
-            // ✅ LEGACY: seguimos rellenando los campos antiguos
-            // por si algún sitio sigue leyéndolos.
             fighter,
-            maxHp,
+            maxHp: fighter.baseStats.defense + fighter.baseStats.offense,
             moves,
             items,
             amulet: null,

package/package.json

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