pokemon-io-core 0.0.73 → 0.0.75

package/dist/api/battle.d.ts

@@ -9,6 +9,7 @@ export interface BattlePlayerView {
     nickname: string;
     hp: number;
     statuses: BattlePlayerStatusView[];
+    activeFighterId: string;
 }
 export type BattleStatus = "ongoing" | "finished";
 export interface BattleView {
@@ -23,4 +24,8 @@ export interface BattleView {
         [playerId: string]: number;
     };
     turnNumber: number;
+    pendingActions?: {
+        player1: boolean;
+        player2: boolean;
+    };
 }

package/dist/api/room.d.ts

@@ -1,6 +1,9 @@
-export interface PlayerLoadoutView {
-    fighterId: string | null;
+export interface PlayerLoadoutFighterView {
+    fighterId: string;
     moveIds: string[];
+}
+export interface PlayerLoadoutView {
+    fighters: PlayerLoadoutFighterView[];
     itemIds: string[];
     amuletId: string | null;
 }

package/dist/api/socketTypes.d.ts

@@ -20,8 +20,10 @@ export interface ClientToServerEvents {
     }) => void;
     "room:setLoadout": (payload: {
         roomId: string;
-        fighterId: string;
-        moveIds: string[];
+        fighters: {
+            fighterId: string;
+            moveIds: string[];
+        }[];
         itemIds: string[];
         amuletId?: string | null;
     }) => void;

package/dist/core/battleState.d.ts

@@ -22,7 +22,6 @@ export interface BattleFighter {
     baseStats: FighterStats;
     effectiveStats: FighterStats;
     moves: EquippedMove[];
-    items: EquippedItem[];
     amuletId: AmuletId | null;
     statuses: ActiveStatus[];
     isAlive: boolean;
@@ -30,6 +29,7 @@ export interface BattleFighter {
 export interface PlayerBattleState {
     fighterTeam: BattleFighter[];
     activeIndex: number;
+    inventory: EquippedItem[];
 }
 export interface BattleState {
     turnNumber: number;

package/dist/core/engine.d.ts

@@ -16,10 +16,14 @@ export interface BattleRuntime {
     statusesById: Record<StatusId, StatusDefinition>;
     typeEffectiveness: TypeEffectivenessMatrix;
 }
-export interface PlayerBattleConfig {
+export interface PlayerFighterBattleConfig {
     fighter: FighterDefinition;
     maxHp: number;
     moves: MoveDefinition[];
+    amulet: AmuletDefinition | null;
+}
+export interface PlayerBattleConfig {
+    fighters: PlayerFighterBattleConfig[];
     items: ItemDefinition[];
     amulet: AmuletDefinition | null;
 }

package/dist/core/engine.js

@@ -34,9 +34,6 @@ 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: cfg.fighter.id,
         classId: cfg.fighter.classId,
@@ -48,10 +45,6 @@ const createBattleFighter = (cfg) => {
             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,
@@ -90,10 +83,15 @@ const recomputeEffectiveStatsForFighter = (state, fighter) => {
     };
 };
 const createPlayerBattleState = (cfg) => {
-    const fighter = createBattleFighter(cfg);
+    const team = cfg.fighters.map((fCfg) => createBattleFighter(fCfg));
+    const inventory = cfg.items.map((item) => ({
+        itemId: item.id,
+        usesRemaining: item.maxUses,
+    }));
     return {
-        fighterTeam: [fighter],
+        fighterTeam: team,
         activeIndex: 0,
+        inventory,
     };
 };
 export const createInitialBattleState = (config) => {
@@ -132,6 +130,16 @@ const getOpponentAndSelf = (state, playerKey) => {
         opponent: getActiveFighter(oppPlayer),
     };
 };
+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),
+    };
+};
 const getTypeEffectiveness = (state, attackerTypeId, defenderTypeId) => {
     const matrix = state.runtime.typeEffectiveness;
     const row = matrix[attackerTypeId];
@@ -480,34 +488,6 @@ 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") {
@@ -537,6 +517,53 @@ const getMovePriorityAndSpeed = (state, playerKey, action) => {
         speed: self.effectiveStats.speed,
     };
 };
+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, "action_declared", `${fromFighter.fighterId} cambia a ${target.fighterId}`),
+        actorId: fromFighter.fighterId,
+    });
+    // actualizar activeIndex
+    if (playerKey === "player1") {
+        return {
+            state: {
+                ...state,
+                player1: {
+                    ...state.player1,
+                    activeIndex: toIndex,
+                },
+            },
+            events,
+        };
+    }
+    return {
+        state: {
+            ...state,
+            player2: {
+                ...state.player2,
+                activeIndex: toIndex,
+            },
+        },
+        events,
+    };
+};
 // ------------------------------------------------------
 // use_move
 // ------------------------------------------------------
@@ -634,9 +661,9 @@ const resolveItemUse = (state, playerKey, action) => {
     if (action.kind !== "use_item") {
         return { state, events: [] };
     }
-    const { self, opponent } = getOpponentAndSelf(state, playerKey);
+    const { selfPlayer, oppPlayer, self, opponent } = getPlayersAndActives(state, playerKey);
     const events = [];
-    const itemSlot = self.items[action.itemIndex];
+    const itemSlot = selfPlayer.inventory[action.itemIndex];
     if (!itemSlot || itemSlot.usesRemaining <= 0) {
         dbg("use_item: no charges", {
             playerKey,
@@ -652,10 +679,10 @@ const resolveItemUse = (state, playerKey, action) => {
         });
         return { state, events };
     }
-    const updatedItems = self.items.map((it, idx) => idx === action.itemIndex
+    const updatedInventory = selfPlayer.inventory.map((it, idx) => idx === action.itemIndex
         ? { ...it, usesRemaining: Math.max(0, it.usesRemaining - 1) }
         : it);
-    let updatedSelf = { ...self, items: updatedItems };
+    let updatedSelf = { ...self };
     let updatedOpponent = { ...opponent };
     events.push({
         ...createBaseEvent(state.turnNumber, "action_declared", `${self.fighterId} usó ${itemDef.name}`),
@@ -664,7 +691,26 @@ const resolveItemUse = (state, playerKey, action) => {
     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);
-    const newState = updateFightersInState(state, playerKey, finalSelf, finalOpp);
+    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 };
 };
 // ------------------------------------------------------
@@ -705,10 +751,8 @@ const hasHardCc = (state, fighter) => fighter.statuses.some((st) => {
     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;
+    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)
@@ -861,6 +905,11 @@ export const resolveTurn = (state, actions) => {
             });
             continue;
         }
+        if (action.kind === "switch_fighter") {
+            const result = resolveSwitchFighter(currentState, playerKey, action);
+            currentState = result.state;
+            events.push(...result.events);
+        }
         if (action.kind === "use_move") {
             const result = resolveDamageMove(currentState, playerKey, action);
             currentState = result.state;
@@ -871,11 +920,6 @@ export const resolveTurn = (state, actions) => {
             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 {
             // switch_fighter u otros no implementados aún
             continue;

package/dist/skins/CombatSkin.d.ts

@@ -1,10 +1,13 @@
 import type { TypeDefinition, TypeEffectivenessMatrix, MoveDefinition, ItemDefinition, AmuletDefinition, StatusDefinition } from "../core/index.js";
 import type { PlayerBattleConfig } from "../core/engine.js";
-export interface FighterLoadout {
+export interface TeamFighterLoadout {
     fighterId: string | null;
+    moveIds: string[];
+}
+export interface PlayerTeamLoadout {
+    fighters: TeamFighterLoadout[];
     itemIds: string[];
     amuletId: string | null;
-    moveIds: string[];
 }
 export interface CombatSkin {
     readonly id: string;
@@ -14,5 +17,5 @@ export interface CombatSkin {
     getItems(): ItemDefinition[];
     getAmulets(): AmuletDefinition[];
     getStatuses(): StatusDefinition[];
-    buildPlayerConfig(loadout: FighterLoadout): PlayerBattleConfig;
+    buildPlayerConfig(loadout: PlayerTeamLoadout): PlayerBattleConfig;
 }

package/dist/skins/cliches/clicheSkin.d.ts

@@ -1,5 +1,5 @@
 import { ItemDefinition, MoveDefinition, PlayerBattleConfig } from "../../core/index.js";
-import type { CombatSkin, FighterLoadout } from "../CombatSkin.js";
+import type { CombatSkin, PlayerTeamLoadout } from "../CombatSkin.js";
 export declare class TribeSkin implements CombatSkin {
     readonly id = "tribe";
     getTypes(): import("../../index.js").TypeDefinition[];
@@ -8,6 +8,6 @@ export declare class TribeSkin implements CombatSkin {
     getItems(): ItemDefinition[];
     getAmulets(): never[];
     getStatuses(): import("../../index.js").StatusDefinition[];
-    buildPlayerConfig(loadout: FighterLoadout): PlayerBattleConfig;
+    buildPlayerConfig(loadout: PlayerTeamLoadout): PlayerBattleConfig;
 }
 export declare const createTribeSkin: () => CombatSkin;

package/dist/skins/cliches/clicheSkin.js

@@ -13,8 +13,7 @@ const findItemById = (id) => {
     return POKEMON_ITEMS.find((i) => i.id === id) ?? null;
 };
 const FILLER_MOVE_ID = "tackle";
-const buildMovesFromLoadout = (fighter, loadout) => {
-    const selectedMoveIds = loadout.moveIds ?? [];
+const buildMovesFromLoadout = (fighter, selectedMoveIds) => {
     const selectedMoves = selectedMoveIds
         .map((id) => findMoveById(id))
         .filter((m) => m !== null);
@@ -68,22 +67,30 @@ export class TribeSkin {
         return TRIBE_STATUSES; // más adelante
     }
     buildPlayerConfig(loadout) {
-        if (!loadout.fighterId) {
-            throw new Error("fighterId is required in FighterLoadout");
+        if (!loadout.fighters || loadout.fighters.length === 0) {
+            throw new Error("fighters[] is required in PlayerTeamLoadout");
         }
-        console.log("buildPlayerConfig", 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 fighters = loadout.fighters.map((slot, idx) => {
+            if (!slot.fighterId) {
+                throw new Error(`fighterId is required in slot ${idx}`);
+            }
+            const fighter = findPokemonById(slot.fighterId);
+            if (!fighter) {
+                throw new Error(`Unknown fighterId for Pokemon skin: ${slot.fighterId}`);
+            }
+            const moves = buildMovesFromLoadout(fighter, slot.moveIds ?? []);
+            return {
+                fighter,
+                maxHp: fighter.baseStats.defense + fighter.baseStats.offense,
+                moves,
+                amulet: null
+            };
+        });
         const items = buildItemsFromLoadout(loadout);
         return {
-            fighter,
-            maxHp: fighter.baseStats.defense + fighter.baseStats.offense,
-            moves,
+            fighters,
             items,
-            amulet: null,
+            amulet: null
         };
     }
 }

package/dist/skins/pokemon/pokemonSkin.d.ts

@@ -1,5 +1,5 @@
 import { ItemDefinition, MoveDefinition, PlayerBattleConfig } from "../../core/index.js";
-import type { CombatSkin, FighterLoadout } from "../CombatSkin.js";
+import type { CombatSkin, PlayerTeamLoadout } from "../CombatSkin.js";
 export declare class PokemonSkin implements CombatSkin {
     readonly id = "pokemon";
     getTypes(): import("../../index.js").TypeDefinition[];
@@ -8,6 +8,6 @@ export declare class PokemonSkin implements CombatSkin {
     getItems(): ItemDefinition[];
     getAmulets(): never[];
     getStatuses(): import("../../index.js").StatusDefinition[];
-    buildPlayerConfig(loadout: FighterLoadout): PlayerBattleConfig;
+    buildPlayerConfig(loadout: PlayerTeamLoadout): PlayerBattleConfig;
 }
 export declare const createPokemonSkin: () => CombatSkin;

package/dist/skins/pokemon/pokemonSkin.js

@@ -12,8 +12,7 @@ const findItemById = (id) => {
     return POKEMON_ITEMS.find((i) => i.id === id) ?? null;
 };
 const FILLER_MOVE_ID = "tackle";
-const buildMovesFromLoadout = (fighter, loadout) => {
-    const selectedMoveIds = loadout.moveIds ?? [];
+const buildMovesFromLoadout = (fighter, selectedMoveIds) => {
     const selectedMoves = selectedMoveIds
         .map((id) => findMoveById(id))
         .filter((m) => m !== null);
@@ -67,22 +66,30 @@ export class PokemonSkin {
         return POKEMON_STATUSES; // más adelante
     }
     buildPlayerConfig(loadout) {
-        if (!loadout.fighterId) {
-            throw new Error("fighterId is required in FighterLoadout");
+        if (!loadout.fighters || loadout.fighters.length === 0) {
+            throw new Error("fighters[] is required in PlayerTeamLoadout");
         }
-        console.log("buildPlayerConfig", 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 fighters = loadout.fighters.map((slot, idx) => {
+            if (!slot.fighterId) {
+                throw new Error(`fighterId is required in slot ${idx}`);
+            }
+            const fighter = findPokemonById(slot.fighterId);
+            if (!fighter) {
+                throw new Error(`Unknown fighterId for Pokemon skin: ${slot.fighterId}`);
+            }
+            const moves = buildMovesFromLoadout(fighter, slot.moveIds ?? []);
+            return {
+                fighter,
+                maxHp: fighter.baseStats.defense + fighter.baseStats.offense,
+                moves,
+                amulet: null
+            };
+        });
         const items = buildItemsFromLoadout(loadout);
         return {
-            fighter,
-            maxHp: fighter.baseStats.defense + fighter.baseStats.offense,
-            moves,
+            fighters,
             items,
-            amulet: null,
+            amulet: null
         };
     }
 }

package/package.json

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