pokemon-io-core 0.0.97 → 0.0.99

package/dist/api/battle.d.ts

@@ -1,7 +1,7 @@
-import { BattleEvent, StatusId } from "../core/index.js";
+import { BattleEvent, StatusId, VolatileStatus } from "../core/index.js";
 export interface BattlePlayerStatusView {
     statusId: StatusId;
-    stacks: 1 | 2;
+    stacks: number;
     remainingTurns: number;
 }
 export interface BattlePlayerMoveView {
@@ -25,6 +25,7 @@ export interface BattlePlayerView {
     nickname: string;
     hp: number;
     statuses: BattlePlayerStatusView[];
+    volatileStatus: VolatileStatus;
     activeFighterId: string | null;
     activeIndex: number;
     activeMoves: BattlePlayerMoveView[];

package/dist/api/socketTypes.d.ts

@@ -1,5 +1,6 @@
 import { BattleView } from "./battle.js";
 import { RoomView } from "./room.js";
+import { EmoteId } from "../core/emotes.js";
 export interface ClientToServerEvents {
     "room:create": (payload: {
         nickname: string;
@@ -59,6 +60,10 @@ export interface ClientToServerEvents {
     "battle:rematchChangeLoadout": (payload: {
         roomId: string;
     }) => void;
+    "battle:sendEmote": (payload: {
+        roomId: string;
+        emoteId: EmoteId;
+    }) => void;
     ping: () => void;
 }
 export interface ServerToClientEvents {
@@ -73,5 +78,10 @@ export interface ServerToClientEvents {
         message: string;
     }) => void;
     "battle:state": (payload: BattleView) => void;
+    "battle:emote": (payload: {
+        playerId: string;
+        emoteId: EmoteId;
+        timestamp: number;
+    }) => void;
     pong: (msg: string) => void;
 }

package/dist/core/battleState.d.ts

@@ -11,9 +11,14 @@ export interface EquippedItem {
 }
 export interface ActiveStatus {
     statusId: StatusId;
-    stacks: 1 | 2;
+    stacks: number;
     remainingTurns: number;
 }
+export type VolatileStatus = {
+    kind: "charging";
+    moveId: string;
+    invulnerability?: string;
+} | null;
 export interface BattleFighter {
     fighterId: FighterId;
     classId: TypeId;
@@ -22,6 +27,7 @@ export interface BattleFighter {
     baseStats: FighterStats;
     effectiveStats: FighterStats;
     statStages: StatStages;
+    volatileStatus: VolatileStatus;
     moves: EquippedMove[];
     amuletId: AmuletId | null;
     statuses: ActiveStatus[];

package/dist/core/emotes.d.ts

@@ -0,0 +1,13 @@
+export type EmoteCategory = "emotional" | "strategic" | "social";
+export type EmoteId = string;
+export interface EmoteDefinition {
+    id: EmoteId;
+    category: EmoteCategory;
+    emoji: string;
+    label: string;
+    description?: string;
+}
+export declare const EMOTES: EmoteDefinition[];
+export declare const getEmoteById: (id: EmoteId) => EmoteDefinition | undefined;
+export declare const getEmotesByCategory: (category: EmoteCategory) => EmoteDefinition[];
+export declare const isValidEmoteId: (id: string) => id is EmoteId;

package/dist/core/emotes.js

@@ -0,0 +1,127 @@
+// src/core/emotes.ts
+export const EMOTES = [
+    // Emotional (6)
+    {
+        id: "laugh",
+        category: "emotional",
+        emoji: "😂",
+        label: "Risa",
+        description: "¡Jaja!",
+    },
+    {
+        id: "scared",
+        category: "emotional",
+        emoji: "😱",
+        label: "Susto",
+        description: "¡Oh no!",
+    },
+    {
+        id: "cool",
+        category: "emotional",
+        emoji: "😎",
+        label: "Cool",
+        description: "Genial",
+    },
+    {
+        id: "angry",
+        category: "emotional",
+        emoji: "😡",
+        label: "Enfadado",
+        description: "¡Grr!",
+    },
+    {
+        id: "sad",
+        category: "emotional",
+        emoji: "😢",
+        label: "Triste",
+        description: "Auch...",
+    },
+    {
+        id: "thinking",
+        category: "emotional",
+        emoji: "🤔",
+        label: "Pensando",
+        description: "Hmm...",
+    },
+    // Strategic (6)
+    {
+        id: "attack",
+        category: "strategic",
+        emoji: "💥",
+        label: "Voy a atacar",
+        description: "¡Prepárate!",
+    },
+    {
+        id: "heal",
+        category: "strategic",
+        emoji: "💊",
+        label: "Voy a curarme",
+        description: "Necesito curarme",
+    },
+    {
+        id: "switch",
+        category: "strategic",
+        emoji: "🔄",
+        label: "Voy a cambiar",
+        description: "¡Cambio!",
+    },
+    {
+        id: "special",
+        category: "strategic",
+        emoji: "⚡",
+        label: "Movimiento especial",
+        description: "¡Algo grande viene!",
+    },
+    {
+        id: "defend",
+        category: "strategic",
+        emoji: "🛡️",
+        label: "Voy a defenderme",
+        description: "Me protejo",
+    },
+    {
+        id: "plan",
+        category: "strategic",
+        emoji: "🎯",
+        label: "Tengo un plan",
+        description: "Sé lo que hago",
+    },
+    // Social (4)
+    {
+        id: "well_played",
+        category: "social",
+        emoji: "👍",
+        label: "Bien jugado",
+        description: "¡Buen movimiento!",
+    },
+    {
+        id: "thanks",
+        category: "social",
+        emoji: "🙏",
+        label: "Gracias",
+        description: "Gracias por la partida",
+    },
+    {
+        id: "hello",
+        category: "social",
+        emoji: "👋",
+        label: "Hola",
+        description: "¡Hola!",
+    },
+    {
+        id: "good_luck",
+        category: "social",
+        emoji: "🤝",
+        label: "Buena suerte",
+        description: "¡Suerte!",
+    },
+];
+export const getEmoteById = (id) => {
+    return EMOTES.find((emote) => emote.id === id);
+};
+export const getEmotesByCategory = (category) => {
+    return EMOTES.filter((emote) => emote.category === category);
+};
+export const isValidEmoteId = (id) => {
+    return EMOTES.some((emote) => emote.id === id);
+};

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" | "fighter_switched" | "shield_applied" | "status_applied" | "status_refreshed" | "status_expired" | "fighter_fainted" | "turn_end" | "stats_changed" | "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" | "status_tick" | "fighter_fainted" | "turn_end" | "stats_changed" | "battle_end";
 export interface BaseBattleEvent {
     id: string;
     turnNumber: number;
@@ -60,7 +60,7 @@ export interface StatusAppliedEvent extends BaseBattleEvent {
     kind: "status_applied";
     targetId: FighterId;
     statusId: StatusId;
-    stacks: 1 | 2;
+    stacks: number;
     durationTurns: number;
 }
 export interface FighterSwitchedEvent extends BaseBattleEvent {
@@ -70,7 +70,7 @@ export interface FighterSwitchedEvent extends BaseBattleEvent {
     toHp: number;
     toStatuses: {
         statusId: string;
-        stacks: 1 | 2;
+        stacks: number;
         remainingTurns: number;
     }[];
 }
@@ -79,6 +79,12 @@ export interface StatusExpiredEvent extends BaseBattleEvent {
     targetId: FighterId;
     statusId: StatusId;
 }
+export interface StatusTickEvent extends BaseBattleEvent {
+    kind: "status_tick";
+    targetId: FighterId;
+    statusId: StatusId;
+    stacks: number;
+}
 export interface FighterFaintedEvent extends BaseBattleEvent {
     kind: "fighter_fainted";
     fighterId: FighterId;
@@ -87,4 +93,4 @@ export interface BattleEndEvent extends BaseBattleEvent {
     kind: "battle_end";
     winner: "player1" | "player2" | "draw";
 }
-export type BattleEvent = ActionDeclaredEvent | MoveMissEvent | MoveHitEvent | ItemUsedEvent | DamageEvent | HealEvent | StatusAppliedEvent | StatusExpiredEvent | FighterFaintedEvent | FighterSwitchedEvent | BattleEndEvent | StatsChangedEvent | BaseBattleEvent;
+export type BattleEvent = ActionDeclaredEvent | MoveMissEvent | MoveHitEvent | ItemUsedEvent | DamageEvent | HealEvent | StatusAppliedEvent | StatusExpiredEvent | StatusTickEvent | FighterFaintedEvent | FighterSwitchedEvent | BattleEndEvent | StatsChangedEvent | BaseBattleEvent;

package/dist/core/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./actions.js";
 export * from "./amulets.js";
 export * from "./battleState.js";
+export * from "./emotes.js";
 export * from "./events.js";
 export * from "./fighters.js";
 export * from "./ids.js";

package/dist/core/index.js

@@ -1,6 +1,7 @@
 export * from "./actions.js";
 export * from "./amulets.js";
 export * from "./battleState.js";
+export * from "./emotes.js";
 export * from "./events.js";
 export * from "./fighters.js";
 export * from "./ids.js";

package/dist/core/moves.d.ts

@@ -4,6 +4,7 @@ export type EffectKind = "damage" | "heal" | "shield" | "modify_stats" | "apply_
 export type TargetKind = EffectTarget;
 interface BaseEffect {
     target?: EffectTarget;
+    chance?: number;
 }
 export interface DamageEffect extends BaseEffect {
     kind: "damage";
@@ -76,6 +77,10 @@ export interface MoveDefinition {
     accuracy?: number;
     maxPP: number;
     priority?: number;
+    charge?: {
+        invulnerability?: string;
+    };
+    bypassInvulnerability?: string[];
     effects: EffectDefinition[];
 }
 export {};

package/dist/engine/actions/move.js

@@ -39,18 +39,83 @@ export const resolveDamageMove = (state, playerKey, action) => {
         ...createBaseEvent(state.turnNumber, "action_declared", `${self.fighterId} usó ${move.name}`),
         actorId: self.fighterId,
     });
-    // Cálculo de puntería con Stages
-    const accStage = self.statStages.accuracy - opponent.statStages.evasion;
+    // Prepare mutable copies for updates through the function
+    let updatedSelf = { ...self };
+    let updatedOpponent = { ...opponent };
+    // -------------------------------------------------------------
+    // 1. Invulnerability Check (Target is Charging/Flying/Digging)
+    // -------------------------------------------------------------
+    if (updatedOpponent.volatileStatus?.kind === "charging" &&
+        updatedOpponent.volatileStatus.invulnerability) {
+        const isBypassed = move.bypassInvulnerability?.includes(updatedOpponent.volatileStatus.invulnerability);
+        if (!isBypassed) {
+            dbg("MISS_INVULNERABLE", {
+                attacker: self.fighterId,
+                defender: opponent.fighterId,
+                invulnerability: updatedOpponent.volatileStatus.invulnerability,
+            });
+            events.push({
+                ...createBaseEvent(state.turnNumber, "move_miss", `${self.fighterId} no alcanza a ${opponent.fighterId}`),
+                actorId: self.fighterId,
+                moveId: move.id,
+                targetId: opponent.fighterId,
+            });
+            // Still consume PP? Normally yes, you missed.
+            const updatedMoves = updatedSelf.moves.map((m, idx) => idx === action.moveIndex
+                ? { ...m, currentPP: Math.max(0, m.currentPP - 1) }
+                : m);
+            updatedSelf.moves = updatedMoves;
+            const newState = updateFightersInState(state, playerKey, updatedSelf, updatedOpponent);
+            return { state: newState, events };
+        }
+    }
+    // -------------------------------------------------------------
+    // 2. Charging Logic (Self)
+    // -------------------------------------------------------------
+    const isCharging = updatedSelf.volatileStatus?.kind === "charging";
+    // A) Start Charging (Turn 1)
+    if (!isCharging && move.charge) {
+        dbg("START_CHARGING", { moveId: move.id });
+        // Set status
+        updatedSelf.volatileStatus = {
+            kind: "charging",
+            moveId: move.id,
+            invulnerability: move.charge.invulnerability,
+        };
+        // Updates message
+        events[events.length - 1].message = `${self.fighterId} prepara ${move.name}...`;
+        // Deduct PP on charge turn
+        const updatedMoves = updatedSelf.moves.map((m, idx) => idx === action.moveIndex
+            ? { ...m, currentPP: Math.max(0, m.currentPP - 1) }
+            : m);
+        updatedSelf.moves = updatedMoves;
+        const newState = updateFightersInState(state, playerKey, updatedSelf, updatedOpponent);
+        return { state: newState, events };
+    }
+    // B) Execute Charge (Turn 2)
+    if (isCharging) {
+        // Clear status
+        updatedSelf.volatileStatus = null;
+        // Do NOT deduct PP (paid in turn 1)
+        // We do nothing to moves here.
+    }
+    else {
+        // Normal Move (not charging move, and not currently charging)
+        // Deduct PP
+        const updatedMoves = updatedSelf.moves.map((m, idx) => idx === action.moveIndex
+            ? { ...m, currentPP: Math.max(0, m.currentPP - 1) }
+            : m);
+        updatedSelf.moves = updatedMoves;
+    }
+    // -------------------------------------------------------------
+    // 3. Accuracy Calculation
+    // -------------------------------------------------------------
+    const accStage = updatedSelf.statStages.accuracy - updatedOpponent.statStages.evasion;
     const accMult = getAccuracyMultiplier(accStage);
     const baseAcc = move.accuracy ?? 100;
     const finalAccuracy = baseAcc * accMult;
     const hitRoll = randomInRange(0, 100);
     const hit = hitRoll < finalAccuracy;
-    const updatedMoves = self.moves.map((m, idx) => idx === action.moveIndex
-        ? { ...m, currentPP: Math.max(0, m.currentPP - 1) }
-        : m);
-    let updatedSelf = { ...self, moves: updatedMoves };
-    let updatedOpponent = { ...opponent };
     if (!hit) {
         dbg("MISS", {
             fighterId: self.fighterId,
@@ -68,6 +133,9 @@ export const resolveDamageMove = (state, playerKey, action) => {
         const newState = updateFightersInState(state, playerKey, updatedSelf, updatedOpponent);
         return { state: newState, events };
     }
+    // -------------------------------------------------------------
+    // 4. Hit / Crit / Damage / Effects
+    // -------------------------------------------------------------
     const critChance = computeCritChance(state.runtime.rules, updatedSelf.effectiveStats.crit);
     const isCritical = chance(critChance);
     const effectiveness = getTypeEffectiveness(state, move.typeId, updatedOpponent.classId);
@@ -92,7 +160,7 @@ export const resolveDamageMove = (state, playerKey, action) => {
         moveName: move.name,
         effects: move.effects,
     });
-    // Todos los efectos (daño, aplicar estado, curas, etc.)
+    // Apply Effects
     const { actor: finalSelf, target: finalOpp, events: extraEvents, } = applyEffectsOnTarget(state, updatedSelf, updatedOpponent, move.typeId, isCritical, move.effects);
     events.push(...extraEvents);
     let newState = updateFightersInState(state, playerKey, finalSelf, finalOpp);

package/dist/engine/combat/damage.js

@@ -44,11 +44,22 @@ export const computeDamage = (input) => {
 export const applyDamageToFighter = (state, defender, amount, actorId, isCritical) => {
     const events = [];
     const newHp = Math.max(0, defender.currentHp - amount);
-    const updatedDefender = {
+    let updatedDefender = {
         ...defender,
         currentHp: newHp,
         isAlive: newHp > 0,
     };
+    // ✅ Sleep Wake check (30%)
+    if (updatedDefender.isAlive &&
+        updatedDefender.statuses.some((s) => s.statusId === "sleep") &&
+        Math.random() < 0.3) {
+        updatedDefender.statuses = updatedDefender.statuses.filter((s) => s.statusId !== "sleep");
+        events.push({
+            ...createBaseEvent(state.turnNumber, "status_cleared", `${defender.fighterId} se despierta por el golpe`),
+            targetId: defender.fighterId,
+            statusId: "sleep",
+        });
+    }
     events.push({
         ...createBaseEvent(state.turnNumber, "damage", `${actorId} inflige ${amount} de daño a ${defender.fighterId}`),
         actorId,

package/dist/engine/effects/applyEffects.js

@@ -25,6 +25,9 @@ export const applyEffectsOnTarget = (state, actor, target, moveTypeId, isCritica
         effectsCount: effects?.length ?? 0,
     });
     for (const eff of effects) {
+        if (eff.chance !== undefined && Math.random() > eff.chance) {
+            continue;
+        }
         dbg("EFFECT_LOOP", eff);
         switch (eff.kind) {
             case "heal": {

package/dist/engine/fighters/fighter.js

@@ -25,6 +25,7 @@ export const createBattleFighter = (cfg) => {
         })),
         amuletId: cfg.amulet ? cfg.amulet.id : null,
         statuses: [],
+        volatileStatus: null,
         isAlive: true,
     };
 };
@@ -63,6 +64,15 @@ export const recomputeEffectiveStatsForFighter = (state, fighter) => {
         }
     }
     // 3) Aquí podrías aplicar amuletos, buffs temporales o lo que quieras
+    // 3) Hardcoded Status Multipliers (Balance Overhaul)
+    const hasBurn = fighter.statuses.some((s) => s.statusId === "burn");
+    const hasParalysis = fighter.statuses.some((s) => s.statusId === "paralysis");
+    if (hasBurn) {
+        eff.offense = Math.floor(eff.offense * 0.5);
+    }
+    if (hasParalysis) {
+        eff.speed = Math.floor(eff.speed * 0.5);
+    }
     return {
         ...fighter,
         effectiveStats: eff,

package/dist/engine/status/apply.js

@@ -37,10 +37,13 @@ export const applyStatusToFighter = (state, target, statusId) => {
         duration,
         prevStacks: existing?.stacks ?? 0,
     });
+    const finalStacks = !existing ? 1 : existing.stacks === 1 ? 2 : existing.stacks;
     events.push({
         ...createBaseEvent(state.turnNumber, "status_applied", `Se aplica ${statusId} a ${target.fighterId}`),
         targetId: target.fighterId,
         statusId,
+        stacks: finalStacks,
+        durationTurns: duration,
     });
     return {
         updated: { ...target, statuses: newStatuses },

package/dist/engine/status/endOfTurn.js

@@ -24,7 +24,7 @@ export const applyEndOfTurnStatuses = (state) => {
             let damageFromStatus = 0;
             def.effectsPerStack.forEach((eff) => {
                 if (eff.kind === "damage") {
-                    const stacksMultiplier = st.stacks === 2 ? 2 : 1;
+                    const stacksMultiplier = st.stacks;
                     const base = typeof eff.flatAmount === "number"
                         ? eff.flatAmount
                         : typeof eff.basePower === "number"
@@ -34,6 +34,13 @@ export const applyEndOfTurnStatuses = (state) => {
                 }
             });
             if (damageFromStatus > 0) {
+                // Emit status tick event for narration
+                events.push({
+                    ...createBaseEvent(state.turnNumber, "status_tick", `${updated.fighterId} sufre por ${st.statusId}`),
+                    targetId: updated.fighterId,
+                    statusId: st.statusId,
+                    stacks: st.stacks,
+                });
                 const damageRes = applyDamageToFighter(state, updated, damageFromStatus, updated.fighterId, false);
                 updated = damageRes.updatedDefender;
                 events.push(...damageRes.events);
@@ -45,8 +52,18 @@ export const applyEndOfTurnStatuses = (state) => {
             }
             // solo decrementamos si sigue vivo
             const remaining = st.remainingTurns - 1;
-            if (remaining > 0)
-                updatedStatuses.push({ ...st, remainingTurns: remaining });
+            if (remaining > 0) {
+                let nextStacks = st.stacks;
+                // ✅ Toxic Scaling
+                if (st.statusId === "poison") {
+                    nextStacks += 1;
+                }
+                updatedStatuses.push({
+                    ...st,
+                    remainingTurns: remaining,
+                    stacks: nextStacks,
+                });
+            }
             else {
                 events.push({
                     ...createBaseEvent(state.turnNumber, "status_expired", `El estado ${st.statusId} expira en ${updated.fighterId}`),

package/dist/engine/turn/resolveTurn.js

@@ -61,9 +61,29 @@ export const resolveTurn = (state, actions) => {
         player2: recalcForPlayer(currentState.player2),
     };
     const events = [];
+    // -----------------------------------------------------------------------
+    // 1. Force Actions for Charging Fighters (Fly, Dig, etc.)
+    // -----------------------------------------------------------------------
+    const overrideAction = (player, originalAction) => {
+        const active = player.fighterTeam[player.activeIndex];
+        if (active && active.isAlive && active.volatileStatus?.kind === "charging") {
+            const moveId = active.volatileStatus.moveId;
+            const moveIndex = active.moves.findIndex((m) => m.moveId === moveId);
+            if (moveIndex >= 0) {
+                return { kind: "use_move", moveIndex };
+            }
+        }
+        return originalAction;
+    };
+    const finalActions = {
+        player1: overrideAction(runtimeState.player1, actions.player1),
+        player2: overrideAction(runtimeState.player2, actions.player2),
+    };
     dbg(`TURN ${runtimeState.turnNumber} start`, {
-        p1Action: actions.player1.kind,
-        p2Action: actions.player2.kind,
+        p1Action: finalActions.player1.kind,
+        p2Action: finalActions.player2.kind,
+        originalP1: actions.player1.kind,
+        originalP2: actions.player2.kind,
     });
     events.push({
         ...createBaseEvent(runtimeState.turnNumber, "turn_start", `Comienza el turno ${runtimeState.turnNumber}`),
@@ -71,13 +91,13 @@ export const resolveTurn = (state, actions) => {
     const entries = [
         {
             playerKey: "player1",
-            action: actions.player1,
-            ...getMovePriorityAndSpeed(runtimeState, "player1", actions.player1),
+            action: finalActions.player1,
+            ...getMovePriorityAndSpeed(runtimeState, "player1", finalActions.player1),
         },
         {
             playerKey: "player2",
-            action: actions.player2,
-            ...getMovePriorityAndSpeed(runtimeState, "player2", actions.player2),
+            action: finalActions.player2,
+            ...getMovePriorityAndSpeed(runtimeState, "player2", finalActions.player2),
         },
     ];
     entries.sort((a, b) => {
@@ -124,20 +144,61 @@ export const resolveTurn = (state, actions) => {
         const { self } = getOpponentAndSelf(currentState, playerKey);
         if (!self.isAlive || self.currentHp <= 0)
             continue;
-        if (hasHardCc(currentState, self)) {
+        // ✅ Paralysis check (25% chance to skip ALL actions, including items)
+        if (self.statuses.some((s) => s.statusId === "paralysis") &&
+            Math.random() < 0.25) {
             events.push({
-                ...createBaseEvent(currentState.turnNumber, "action_skipped_hard_cc", `${self.fighterId} no puede actuar por control total`),
+                ...createBaseEvent(currentState.turnNumber, "action_skipped_hard_cc", `${self.fighterId} está paralizado y no puede moverse`),
                 actorId: self.fighterId,
+                statusId: "paralysis",
             });
             continue;
         }
-        if (action.kind === "use_move") {
-            const result = resolveDamageMove(currentState, playerKey, action);
+        // ✅ Items can be used regardless of hard CC (trainer action, not Pokémon action)
+        if (action.kind === "use_item") {
+            const result = resolveItemUse(currentState, playerKey, action);
             currentState = result.state;
             events.push(...result.events);
         }
-        else if (action.kind === "use_item") {
-            const result = resolveItemUse(currentState, playerKey, action);
+        else if (action.kind === "use_move") {
+            // ✅ Moves are blocked by hard CC (sleep, freeze, flinch)
+            if (hasHardCc(currentState, self)) {
+                // Find the hard CC status
+                const ccStatus = self.statuses.find((s) => {
+                    const def = currentState.runtime.statusesById[s.statusId];
+                    return def?.kind === "hard_cc";
+                });
+                let interruptionSuffix = "";
+                // Si estaba cargando y es interrumpido, pierde la carga (Fly/Dig fallan)
+                if (self.volatileStatus?.kind === "charging") {
+                    const newFighter = { ...self, volatileStatus: null };
+                    currentState = {
+                        ...currentState,
+                        [playerKey]: {
+                            ...currentState[playerKey],
+                            fighterTeam: currentState[playerKey].fighterTeam.map((f) => f.fighterId === self.fighterId ? newFighter : f),
+                        },
+                    };
+                    interruptionSuffix = " (Concentración perdida)";
+                }
+                // Status-specific messages
+                const statusMessages = {
+                    sleep: `${self.fighterId} está dormido y no puede moverse`,
+                    freeze: `${self.fighterId} está congelado y no puede actuar`,
+                    flinch: `${self.fighterId} se acobarda y no puede atacar`,
+                };
+                const statusId = ccStatus?.statusId || "unknown";
+                const message = statusMessages[statusId] ||
+                    `${self.fighterId} no puede actuar por control total`;
+                events.push({
+                    ...createBaseEvent(currentState.turnNumber, "action_skipped_hard_cc", `${message}${interruptionSuffix}`),
+                    actorId: self.fighterId,
+                    statusId: statusId,
+                });
+                continue;
+            }
+            // Execute the move
+            const result = resolveDamageMove(currentState, playerKey, action);
             currentState = result.state;
             events.push(...result.events);
         }