pokemon-io-core 0.0.97 → 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/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/events.d.ts

@@ -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;
     }[];
 }

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/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;

package/dist/skins/pokemon/items.js

@@ -140,4 +140,66 @@ export const POKEMON_ITEMS = [
         ],
         image: "green-berry",
     },
+    {
+        id: "attack_potion",
+        name: "Poción Ofensiva",
+        category: "status_buff",
+        maxUses: 2,
+        target: "self",
+        effects: [
+            { kind: "heal", amount: 30 },
+            { kind: "modify_stats", target: "self", offenseDelta: 1 },
+        ],
+        image: "potion_red", // Placeholder
+    },
+    {
+        id: "defense_potion",
+        name: "Poción Defensiva",
+        category: "status_buff",
+        maxUses: 2,
+        target: "self",
+        effects: [
+            { kind: "heal", amount: 30 },
+            { kind: "modify_stats", target: "self", defenseDelta: 1 },
+        ],
+        image: "potion_blue", // Placeholder
+    },
+    {
+        id: "speed_elixir",
+        name: "Elixir de Velocidad",
+        category: "status_buff",
+        maxUses: 2,
+        target: "self",
+        effects: [
+            { kind: "heal", amount: 30 },
+            { kind: "modify_stats", target: "self", speedDelta: 1 },
+        ],
+        image: "potion_yellow", // Placeholder
+    },
+    {
+        id: "crit_injection",
+        name: "Inyección Crítica",
+        category: "status_buff",
+        maxUses: 2,
+        target: "self",
+        effects: [
+            { kind: "heal", amount: 30 },
+            { kind: "modify_crit_chance", target: "self", delta: 1 },
+        ],
+        image: "potion_purple", // Placeholder
+    },
+    {
+        id: "chesto_berry",
+        name: "Baya Atania",
+        category: "status_buff",
+        maxUses: 1,
+        target: "self",
+        effects: [
+            {
+                kind: "clear_status",
+                statusIds: ["sleep"],
+            },
+        ],
+        image: "chesto-berry", // Placeholder
+    },
 ];