pokemon-io-core 0.0.96 → 0.0.98

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,9 +1,6 @@
 import { BattleView } from "./battle.js";
 import { RoomView } from "./room.js";
 export interface ClientToServerEvents {
-    "player:hello": (payload: {
-        playerKey: string;
-    }) => void;
     "room:create": (payload: {
         nickname: string;
         roomName: string;
@@ -19,7 +16,7 @@ export interface ClientToServerEvents {
     }) => void;
     "room:reconnect": (payload: {
         roomId: string;
-        playerKey: string;
+        oldPlayerId: string;
     }) => void;
     "room:setLoadout": (payload: {
         roomId: string;

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;
@@ -21,11 +26,21 @@ export interface BattleFighter {
     currentHp: number;
     baseStats: FighterStats;
     effectiveStats: FighterStats;
+    statStages: StatStages;
+    volatileStatus: VolatileStatus;
     moves: EquippedMove[];
     amuletId: AmuletId | null;
     statuses: ActiveStatus[];
     isAlive: boolean;
 }
+export interface StatStages {
+    offense: number;
+    defense: number;
+    speed: number;
+    crit: number;
+    accuracy: number;
+    evasion: number;
+}
 export interface PlayerBattleState {
     fighterTeam: BattleFighter[];
     activeIndex: number;

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" | "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" | "stats_changed" | "battle_end";
 export interface BaseBattleEvent {
     id: string;
     turnNumber: number;
@@ -7,6 +7,18 @@ export interface BaseBattleEvent {
     message: string;
     timestamp: number;
 }
+export interface StatsChangedEvent extends BaseBattleEvent {
+    kind: "stats_changed";
+    targetId: FighterId;
+    changes: {
+        offense?: number;
+        defense?: number;
+        speed?: number;
+        crit?: number;
+        accuracy?: number;
+        evasion?: number;
+    };
+}
 export interface ActionDeclaredEvent extends BaseBattleEvent {
     kind: "action_declared";
     actorId: FighterId;
@@ -48,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 {
@@ -58,7 +70,7 @@ export interface FighterSwitchedEvent extends BaseBattleEvent {
     toHp: number;
     toStatuses: {
         statusId: string;
-        stacks: 1 | 2;
+        stacks: number;
         remainingTurns: number;
     }[];
 }
@@ -75,4 +87,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 | BaseBattleEvent;
+export type BattleEvent = ActionDeclaredEvent | MoveMissEvent | MoveHitEvent | ItemUsedEvent | DamageEvent | HealEvent | StatusAppliedEvent | StatusExpiredEvent | FighterFaintedEvent | FighterSwitchedEvent | BattleEndEvent | StatsChangedEvent | BaseBattleEvent;

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

@@ -1,4 +1,5 @@
 import { computeCritChance } from "../combat/crit.js";
+import { getAccuracyMultiplier } from "../combat/stages.js";
 import { getTypeEffectiveness } from "../combat/typeEffectiveness.js";
 import { dbg } from "../debug.js";
 import { applyEffectsOnTarget } from "../effects/applyEffects.js";
@@ -38,21 +39,90 @@ export const resolveDamageMove = (state, playerKey, action) => {
         ...createBaseEvent(state.turnNumber, "action_declared", `${self.fighterId} usó ${move.name}`),
         actorId: self.fighterId,
     });
-    const accuracy = move.accuracy ?? 100;
-    const hitRoll = randomInRange(0, 100);
-    const hit = hitRoll < accuracy;
-    const updatedMoves = self.moves.map((m, idx) => idx === action.moveIndex
-        ? { ...m, currentPP: Math.max(0, m.currentPP - 1) }
-        : m);
-    let updatedSelf = { ...self, moves: updatedMoves };
+    // 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;
     if (!hit) {
         dbg("MISS", {
             fighterId: self.fighterId,
             moveId: move.id,
             moveName: move.name,
             hitRoll,
-            accuracy,
+            accuracy: finalAccuracy,
         });
         events.push({
             ...createBaseEvent(state.turnNumber, "move_miss", `${self.fighterId} falla ${move.name}`),
@@ -63,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);
@@ -87,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/combat/stages.d.ts

@@ -0,0 +1,5 @@
+export declare const STAGE_MULTIPLIERS_STATS: Record<number, number>;
+export declare const STAGE_MULTIPLIERS_ACCURACY: Record<number, number>;
+export declare const getCritChanceFromStage: (stage: number) => number;
+export declare const getStatMultiplier: (stage: number) => number;
+export declare const getAccuracyMultiplier: (stage: number) => number;

package/dist/engine/combat/stages.js

@@ -0,0 +1,53 @@
+export const STAGE_MULTIPLIERS_STATS = {
+    "-6": 2 / 8,
+    "-5": 2 / 7,
+    "-4": 2 / 6,
+    "-3": 2 / 5,
+    "-2": 2 / 4,
+    "-1": 2 / 3,
+    0: 2 / 2,
+    1: 3 / 2,
+    2: 4 / 2,
+    3: 5 / 2,
+    4: 6 / 2,
+    5: 7 / 2,
+    6: 8 / 2,
+};
+// Accuracy/Evasion multipliers (3/3 base)
+export const STAGE_MULTIPLIERS_ACCURACY = {
+    "-6": 3 / 9,
+    "-5": 3 / 8,
+    "-4": 3 / 7,
+    "-3": 3 / 6,
+    "-2": 3 / 5,
+    "-1": 3 / 4,
+    0: 3 / 3,
+    1: 4 / 3,
+    2: 5 / 3,
+    3: 6 / 3,
+    4: 7 / 3,
+    5: 8 / 3,
+    6: 9 / 3,
+};
+// Critical Hit Ratio (Table)
+// Stage 0: ~4.17% (1/24)
+// Stage 1: 12.5% (1/8)
+// Stage 2: 50% (1/2)
+// Stage 3+: 100% (1/1)
+export const getCritChanceFromStage = (stage) => {
+    if (stage <= 0)
+        return 1 / 24;
+    if (stage === 1)
+        return 1 / 8;
+    if (stage === 2)
+        return 1 / 2;
+    return 1;
+};
+export const getStatMultiplier = (stage) => {
+    const clamped = Math.max(-6, Math.min(6, stage));
+    return STAGE_MULTIPLIERS_STATS[clamped] ?? 1;
+};
+export const getAccuracyMultiplier = (stage) => {
+    const clamped = Math.max(-6, Math.min(6, stage));
+    return STAGE_MULTIPLIERS_ACCURACY[clamped] ?? 1;
+};

package/dist/engine/effects/applyEffects.js

@@ -4,6 +4,8 @@ import { dbg } from "../debug.js";
 import { applyStatusToFighter } from "../status/apply.js";
 import { clearStatusFromFighter } from "../status/clear.js";
 import { resolveEffectTarget } from "./target.js";
+import { createBaseEvent } from "../events.js";
+import { recomputeEffectiveStatsForFighter } from "../fighters/fighter.js";
 export const applyEffectsOnTarget = (state, actor, target, moveTypeId, isCritical, effects) => {
     dbg("applyEffectsOnTarget", {
         actorId: actor.fighterId,
@@ -23,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": {
@@ -94,7 +99,74 @@ export const applyEffectsOnTarget = (state, actor, target, moveTypeId, isCritica
                 }
                 break;
             }
-            // TODO: conectar shield, modify_stats, etc.
+            case "modify_stats": {
+                const { primary, isSelf } = resolveEffectTarget(eff, currentActor, currentTarget);
+                const newStages = { ...primary.statStages };
+                const changes = {};
+                if (eff.offenseDelta) {
+                    newStages.offense = Math.max(-6, Math.min(6, newStages.offense + eff.offenseDelta));
+                    changes.offense = eff.offenseDelta;
+                }
+                if (eff.defenseDelta) {
+                    newStages.defense = Math.max(-6, Math.min(6, newStages.defense + eff.defenseDelta));
+                    changes.defense = eff.defenseDelta;
+                }
+                if (eff.speedDelta) {
+                    newStages.speed = Math.max(-6, Math.min(6, newStages.speed + eff.speedDelta));
+                    changes.speed = eff.speedDelta;
+                }
+                if (eff.critDelta) {
+                    newStages.crit = Math.max(0, Math.min(6, newStages.crit + eff.critDelta));
+                    changes.crit = eff.critDelta;
+                }
+                let updated = { ...primary, statStages: newStages };
+                updated = recomputeEffectiveStatsForFighter(state, updated);
+                events.push({
+                    ...createBaseEvent(state.turnNumber, "stats_changed", `Estadísticas cambiadas`),
+                    targetId: primary.fighterId,
+                    changes
+                });
+                if (isSelf)
+                    currentActor = updated;
+                else
+                    currentTarget = updated;
+                break;
+            }
+            case "modify_crit_chance": {
+                const { primary, isSelf } = resolveEffectTarget(eff, currentActor, currentTarget);
+                const newStages = { ...primary.statStages };
+                newStages.crit = Math.max(0, Math.min(6, newStages.crit + eff.delta));
+                let updated = { ...primary, statStages: newStages };
+                updated = recomputeEffectiveStatsForFighter(state, updated);
+                events.push({
+                    ...createBaseEvent(state.turnNumber, "stats_changed", `Ratio de crítico cambiado`),
+                    targetId: primary.fighterId,
+                    changes: { crit: eff.delta }
+                });
+                if (isSelf)
+                    currentActor = updated;
+                else
+                    currentTarget = updated;
+                break;
+            }
+            case "modify_hit_chance": {
+                // Interpreted as Accuracy Stage
+                const { primary, isSelf } = resolveEffectTarget(eff, currentActor, currentTarget);
+                const newStages = { ...primary.statStages };
+                newStages.accuracy = Math.max(-6, Math.min(6, newStages.accuracy + eff.delta));
+                let updated = { ...primary, statStages: newStages };
+                updated = recomputeEffectiveStatsForFighter(state, updated);
+                events.push({
+                    ...createBaseEvent(state.turnNumber, "stats_changed", `Precisión cambiada`),
+                    targetId: primary.fighterId,
+                    changes: { accuracy: eff.delta }
+                });
+                if (isSelf)
+                    currentActor = updated;
+                else
+                    currentTarget = updated;
+                break;
+            }
             default:
                 break;
         }

package/dist/engine/fighters/fighter.js

@@ -1,4 +1,5 @@
 import { cloneStats } from "../runtime.js";
+import { getCritChanceFromStage, getStatMultiplier, } from "../combat/stages.js";
 export const createBattleFighter = (cfg) => {
     if (cfg.moves.length !== 4) {
         throw new Error("Each fighter must have exactly 4 moves in MVP");
@@ -10,19 +11,35 @@ export const createBattleFighter = (cfg) => {
         currentHp: cfg.maxHp,
         baseStats: cloneStats(cfg.fighter.baseStats),
         effectiveStats: cloneStats(cfg.fighter.baseStats),
+        statStages: {
+            offense: 0,
+            defense: 0,
+            speed: 0,
+            crit: 0,
+            accuracy: 0,
+            evasion: 0,
+        },
         moves: cfg.moves.map((move) => ({
             moveId: move.id,
             currentPP: move.maxPP,
         })),
         amuletId: cfg.amulet ? cfg.amulet.id : null,
         statuses: [],
+        volatileStatus: null,
         isAlive: true,
     };
 };
 export const recomputeEffectiveStatsForFighter = (state, fighter) => {
     // Partimos de base
     let eff = { ...fighter.baseStats };
-    // 1) Aplicar estados
+    // 1) Aplicar Etapas (Stages)
+    eff.offense = Math.floor(eff.offense * getStatMultiplier(fighter.statStages.offense));
+    eff.defense = Math.floor(eff.defense * getStatMultiplier(fighter.statStages.defense));
+    eff.speed = Math.floor(eff.speed * getStatMultiplier(fighter.statStages.speed));
+    // Crit se reemplaza por el valor de la etapa (o se suma si baseStats tuviera un % base)
+    // Asumimos que baseStats.crit es 0 o un bono base pequeño.
+    eff.crit = getCritChanceFromStage(fighter.statStages.crit) + eff.crit;
+    // 2) Aplicar estados (Bonificadores temporales/external)
     for (const st of fighter.statuses) {
         const def = state.runtime.statusesById[st.statusId];
         if (!def)
@@ -32,10 +49,11 @@ export const recomputeEffectiveStatsForFighter = (state, fighter) => {
             const totalStacks = stacks; // podrías multiplicar efectos por stacks
             switch (effDef.kind) {
                 case "modify_stats":
+                    // Estos serían bonos flat POST-etapas
                     eff.offense += (effDef.offenseDelta ?? 0) * totalStacks;
                     eff.defense += (effDef.defenseDelta ?? 0) * totalStacks;
                     eff.speed += (effDef.speedDelta ?? 0) * totalStacks;
-                    eff.crit += (effDef.critDelta ?? 0) * totalStacks;
+                    // eff.crit += (effDef.critDelta ?? 0) * totalStacks; // Crit ya va por stages
                     break;
                 case "modify_effective_speed":
                     eff.speed = Math.floor(eff.speed * Math.pow(effDef.multiplier, totalStacks));
@@ -45,7 +63,16 @@ export const recomputeEffectiveStatsForFighter = (state, fighter) => {
             }
         }
     }
-    // 2) Aquí podrías aplicar amuletos, buffs temporales o lo que quieras
+    // 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/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"
@@ -45,8 +45,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,9 +144,31 @@ export const resolveTurn = (state, actions) => {
         const { self } = getOpponentAndSelf(currentState, playerKey);
         if (!self.isAlive || self.currentHp <= 0)
             continue;
+        // ✅ Paralysis check (25% chance to skip)
+        if (self.statuses.some((s) => s.statusId === "paralysis") &&
+            Math.random() < 0.25) {
+            events.push({
+                ...createBaseEvent(currentState.turnNumber, "action_skipped_hard_cc", `${self.fighterId} está paralizado y no puede moverse`),
+                actorId: self.fighterId,
+            });
+            continue;
+        }
         if (hasHardCc(currentState, self)) {
+            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)";
+            }
             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} no puede actuar por control total${interruptionSuffix}`),
                 actorId: self.fighterId,
             });
             continue;