pokemon-io-core 0.0.69 → 0.0.71

package/dist/api/room.d.ts

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

package/dist/core/actions.d.ts

@@ -9,7 +9,8 @@ export interface UseItemAction {
 }
 export interface SwitchFighterAction {
     kind: "switch_fighter";
-    targetIndex: number;
+    newIndex: number;
+    forced?: boolean;
 }
 export interface NoAction {
     kind: "no_action";

package/dist/core/engine.d.ts

@@ -16,7 +16,39 @@ 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,29 +30,26 @@ const cloneStats = (stats) => ({
 // ------------------------------------------------------
 // Creación de estado inicial
 // ------------------------------------------------------
-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");
-    }
+const createBattleFighter = (slot, playerItems) => {
     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,
+        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,
         })),
-        items: cfg.items.map((item) => ({
-            itemId: item.id,
-            usesRemaining: item.maxUses,
+        // ⚠️ 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,
         })),
-        amuletId: cfg.amulet ? cfg.amulet.id : null,
+        amuletId: slot.amulet?.id ?? null,
         statuses: [],
         isAlive: true,
     };
@@ -89,10 +86,36 @@ 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) => {
-    const fighter = createBattleFighter(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));
     return {
-        fighterTeam: [fighter],
+        fighterTeam,
         activeIndex: 0,
     };
 };
@@ -762,6 +785,35 @@ 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
 // ------------------------------------------------------
@@ -797,6 +849,7 @@ 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;
@@ -813,7 +866,29 @@ export const resolveTurn = (state, actions) => {
         priority: e.priority,
         speed: e.speed,
     })));
-    for (const entry of entries) {
+    // 🔁 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) {
         const { playerKey, action } = entry;
         if (action.kind === "no_action")
             continue;
@@ -838,7 +913,7 @@ export const resolveTurn = (state, actions) => {
             events.push(...result.events);
         }
         else {
-            // switch_fighter u otros no implementados aún
+            // Cualquier otro tipo de acción futura se ignora de momento
             continue;
         }
         const winnerAfterAction = checkWinner(currentState);
@@ -857,6 +932,7 @@ 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" | "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" | "shield_applied" | "status_applied" | "status_refreshed" | "status_expired" | "fighter_fainted" | "fighter_switched" | "turn_end" | "battle_end";
 export interface BaseBattleEvent {
     id: string;
     turnNumber: number;
@@ -60,8 +60,14 @@ 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";
 }
-export type BattleEvent = ActionDeclaredEvent | MoveMissEvent | MoveHitEvent | ItemUsedEvent | DamageEvent | HealEvent | StatusAppliedEvent | StatusExpiredEvent | FighterFaintedEvent | BattleEndEvent | BaseBattleEvent;
+export type BattleEvent = ActionDeclaredEvent | MoveMissEvent | MoveHitEvent | ItemUsedEvent | DamageEvent | HealEvent | StatusAppliedEvent | StatusExpiredEvent | FighterFaintedEvent | FighterSwitchedEvent | BattleEndEvent | BaseBattleEvent;

package/dist/index.d.ts

@@ -3,4 +3,3 @@ export * from "./api/battle.js";
 export * from "./api/room.js";
 export * from "./api/socketTypes.js";
 export * from "./skins/CombatSkin.js";
-export * from "./engine/pokemonBattleService.js";

package/dist/index.js

@@ -3,4 +3,3 @@ export * from "./api/battle.js";
 export * from "./api/room.js";
 export * from "./api/socketTypes.js";
 export * from "./skins/CombatSkin.js";
-export * from "./engine/pokemonBattleService.js";

package/dist/skins/CombatSkin.d.ts

@@ -2,9 +2,24 @@ 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;
-    moveIds: string[];
+    /**
+     * 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;
 }
 export interface CombatSkin {
     readonly id: string;

package/dist/skins/cliches/clicheSkin.js

@@ -1,8 +1,8 @@
-// pokemon-io-core/src/skins/pokemon/pokemonSkin.ts
+// pokemon-io-core/src/skins/tribes/clicheSkin.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 findPokemonById = (id) => {
+const findTribeFighterById = (id) => {
     const lower = id.toLowerCase();
     return TRIBE_FIGHTERS.find((f) => f.id.toLowerCase() === lower) ?? null;
 };
@@ -72,15 +72,27 @@ export class TribeSkin {
             throw new Error("fighterId is required in FighterLoadout");
         }
         console.log("buildPlayerConfig", loadout.fighterId);
-        const fighter = findPokemonById(loadout.fighterId);
+        const fighter = findTribeFighterById(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: fighter.baseStats.defense + fighter.baseStats.offense,
+            maxHp,
             moves,
             items,
             amulet: null,

package/dist/skins/pokemon/pokemonSkin.js

@@ -77,9 +77,21 @@ 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: fighter.baseStats.defense + fighter.baseStats.offense,
+            maxHp,
             moves,
             items,
             amulet: null,

package/package.json

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