pokemon-io-core 0.0.100 → 0.0.102

package/dist/api/battle.d.ts

@@ -65,5 +65,17 @@ export interface BattleView {
         player1: boolean;
         player2: boolean;
     };
+    pendingRandomEvent?: {
+        eventName: string;
+        eventDescription: string;
+        imageUrl?: string;
+        effects: Array<{
+            effectType: string;
+            target: string;
+            percentValue?: number;
+            statType?: string;
+            statChange?: number;
+        }>;
+    } | null;
     forcedSwitch: ForcedSwitchView | null;
 }

package/dist/api/socketTypes.d.ts

@@ -64,6 +64,9 @@ export interface ClientToServerEvents {
         roomId: string;
         emoteId: EmoteId;
     }) => void;
+    "battle:acknowledgeRandomEvent": (payload: {
+        roomId: string;
+    }) => void;
     ping: () => void;
 }
 export interface ServerToClientEvents {
@@ -83,5 +86,11 @@ export interface ServerToClientEvents {
         emoteId: EmoteId;
         timestamp: number;
     }) => void;
+    "battle:randomEventTriggered": (payload: {
+        eventId: string;
+        eventName: string;
+        eventDescription: string;
+        imageUrl?: string;
+    }) => void;
     pong: (msg: string) => void;
 }

package/dist/core/battleRuntime.d.ts

@@ -0,0 +1,46 @@
+import { AmuletDefinition } from "./amulets.js";
+import { FighterDefinition } from "./fighters.js";
+import { ItemDefinition } from "./items.js";
+import { MoveDefinition } from "./moves.js";
+import { StatusDefinition } from "./status.js";
+import { TypeDefinition, TypeEffectivenessMatrix } from "./types.js";
+import { ItemId, MoveId, StatusId, TypeId } from "./ids.js";
+export interface BattleRules {
+    baseCritChance: number;
+    critPerStat: number;
+    critMultiplier: number;
+    stabMultiplier: number;
+    randomMinDamageFactor: number;
+    randomMaxDamageFactor: number;
+}
+export interface BattleRuntime {
+    rules: BattleRules;
+    typesById: Record<TypeId, TypeDefinition>;
+    movesById: Record<MoveId, MoveDefinition>;
+    itemsById: Record<ItemId, ItemDefinition>;
+    amuletsById: Record<string, AmuletDefinition>;
+    statusesById: Record<StatusId, StatusDefinition>;
+    typeEffectiveness: TypeEffectivenessMatrix;
+}
+export interface PlayerFighterBattleConfig {
+    fighter: FighterDefinition;
+    maxHp: number;
+    moves: MoveDefinition[];
+    amulet: AmuletDefinition | null;
+}
+export interface PlayerBattleConfig {
+    fighters: PlayerFighterBattleConfig[];
+    items: ItemDefinition[];
+    amulet: AmuletDefinition | null;
+}
+export interface BattleConfig {
+    types: TypeDefinition[];
+    typeEffectiveness: TypeEffectivenessMatrix;
+    moves: MoveDefinition[];
+    items: ItemDefinition[];
+    amulets: AmuletDefinition[];
+    statuses: StatusDefinition[];
+    player1: PlayerBattleConfig;
+    player2: PlayerBattleConfig;
+    rules?: Partial<BattleRules>;
+}

package/dist/core/battleRuntime.js

@@ -0,0 +1 @@
+export {};

package/dist/core/battleState.d.ts

@@ -1,4 +1,4 @@
-import { BattleRuntime } from "../engine/rules.js";
+import { BattleRuntime } from "./battleRuntime.js";
 import type { FighterId, TypeId, MoveId, ItemId, AmuletId, StatusId } from "./ids";
 import type { FighterStats } from "./types.js";
 export interface EquippedMove {
@@ -62,5 +62,5 @@ export interface BattleState {
     player1: PlayerBattleState;
     player2: PlayerBattleState;
     runtime: BattleRuntime;
-    forcedSwitch: ForcedSwitchState;
+    forcedSwitch?: ForcedSwitchState;
 }

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" | "status_tick" | "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" | "random_event_triggered" | "random_event_effect" | "battle_end";
 export interface BaseBattleEvent {
     id: string;
     turnNumber: number;
@@ -18,6 +18,7 @@ export interface StatsChangedEvent extends BaseBattleEvent {
         accuracy?: number;
         evasion?: number;
     };
+    source?: "move" | "status" | "item" | "random_event";
 }
 export interface ActionDeclaredEvent extends BaseBattleEvent {
     kind: "action_declared";
@@ -49,12 +50,14 @@ export interface DamageEvent extends BaseBattleEvent {
     targetId: FighterId;
     amount: number;
     isCritical: boolean;
+    source?: "move" | "status" | "item" | "random_event";
 }
 export interface HealEvent extends BaseBattleEvent {
     kind: "heal";
     actorId: FighterId;
     targetId: FighterId;
     amount: number;
+    source?: "move" | "status" | "item" | "random_event";
 }
 export interface StatusAppliedEvent extends BaseBattleEvent {
     kind: "status_applied";
@@ -93,4 +96,25 @@ export interface BattleEndEvent extends BaseBattleEvent {
     kind: "battle_end";
     winner: "player1" | "player2" | "draw";
 }
-export type BattleEvent = ActionDeclaredEvent | MoveMissEvent | MoveHitEvent | ItemUsedEvent | DamageEvent | HealEvent | StatusAppliedEvent | StatusExpiredEvent | StatusTickEvent | FighterFaintedEvent | FighterSwitchedEvent | BattleEndEvent | StatsChangedEvent | BaseBattleEvent;
+export interface RandomEventTriggeredEvent extends BaseBattleEvent {
+    kind: "random_event_triggered";
+    eventId: string;
+    eventName: string;
+    eventDescription: string;
+    eventRarity: "common" | "rare" | "epic" | "legendary";
+    imageUrl?: string;
+    effects: Array<{
+        effectType: string;
+        target: string;
+        percentValue?: number;
+        statType?: string;
+        statChange?: number;
+    }>;
+}
+export interface RandomEventEffectEvent extends BaseBattleEvent {
+    kind: "random_event_effect";
+    eventId: string;
+    targetId: FighterId;
+    effectType: string;
+}
+export type BattleEvent = ActionDeclaredEvent | MoveMissEvent | MoveHitEvent | ItemUsedEvent | DamageEvent | HealEvent | StatusAppliedEvent | StatusExpiredEvent | StatusTickEvent | FighterFaintedEvent | FighterSwitchedEvent | BattleEndEvent | StatsChangedEvent | RandomEventTriggeredEvent | RandomEventEffectEvent | BaseBattleEvent;

package/dist/core/index.d.ts

@@ -1,11 +1,16 @@
 export * from "./actions.js";
-export * from "./amulets.js";
-export * from "./battleState.js";
+export * from "./randomEvents.js";
+export { CORE_RANDOM_EVENTS, POKEMON_RANDOM_EVENTS } from "./randomEventsList.js";
 export * from "./emotes.js";
 export * from "./events.js";
+export * from "./events.js";
 export * from "./fighters.js";
 export * from "./ids.js";
 export * from "./items.js";
 export * from "./moves.js";
 export * from "./status.js";
+export * from "./randomEventsList.js";
+export * from "./battleRuntime.js";
+export * from "./battleState.js";
+export * from "./amulets.js";
 export * from "./types.js";

package/dist/core/index.js

@@ -1,11 +1,16 @@
 export * from "./actions.js";
-export * from "./amulets.js";
-export * from "./battleState.js";
+export * from "./randomEvents.js";
+export { CORE_RANDOM_EVENTS, POKEMON_RANDOM_EVENTS } from "./randomEventsList.js";
 export * from "./emotes.js";
 export * from "./events.js";
+export * from "./events.js";
 export * from "./fighters.js";
 export * from "./ids.js";
 export * from "./items.js";
 export * from "./moves.js";
 export * from "./status.js";
+export * from "./randomEventsList.js";
+export * from "./battleRuntime.js";
+export * from "./battleState.js";
+export * from "./amulets.js";
 export * from "./types.js";

package/dist/core/randomEvents.d.ts

@@ -0,0 +1,27 @@
+export type EventRarity = "common" | "rare" | "epic" | "legendary";
+export type EventEffectType = "damage_percent" | "heal_percent" | "stat_change" | "apply_status" | "reset_stats" | "swap_hp";
+export type EventTarget = "both" | "self" | "opponent" | "random_one";
+export interface EventCondition {
+    type: "has_item" | "hp_below_percent" | "hp_above_percent" | "fighter_type" | "has_status" | "stat_stage_above" | "always";
+    value?: string | number;
+}
+export interface RandomEventEffect {
+    effectType: EventEffectType;
+    target: EventTarget;
+    condition?: EventCondition;
+    percentValue?: number;
+    statType?: "offense" | "defense" | "speed" | "crit" | "accuracy" | "evasion";
+    statChange?: number;
+    statusId?: string;
+    statusDuration?: number;
+    randomChoices?: RandomEventEffect[];
+}
+export interface RandomEventDefinition {
+    id: string;
+    name: string;
+    description: string;
+    rarity: EventRarity;
+    imageUrl?: string;
+    effects: RandomEventEffect[];
+}
+export declare const RARITY_WEIGHTS: Record<EventRarity, number>;

package/dist/core/randomEvents.js

@@ -0,0 +1,8 @@
+// @pokemon-io/combat-core/src/core/randomEvents.ts
+// Rarity weights for selection
+export const RARITY_WEIGHTS = {
+    common: 60,
+    rare: 25,
+    epic: 12,
+    legendary: 3,
+};

package/dist/core/randomEventsList.d.ts

@@ -0,0 +1,11 @@
+import type { RandomEventDefinition } from "./randomEvents.js";
+/**
+ * CORE Random Events - Generic events that work with any skin
+ * Phase 1 + Phase 2: 9 total CORE events
+ */
+export declare const CORE_RANDOM_EVENTS: RandomEventDefinition[];
+/**
+ * POKEMON-SPECIFIC Random Events
+ * These only appear when using the Pokemon skin
+ */
+export declare const POKEMON_RANDOM_EVENTS: RandomEventDefinition[];

package/dist/core/randomEventsList.js

@@ -0,0 +1,302 @@
+// @pokemon-io/combat-core/src/core/randomEventsList.ts
+/**
+ * CORE Random Events - Generic events that work with any skin
+ * Phase 1 + Phase 2: 9 total CORE events
+ */
+export const CORE_RANDOM_EVENTS = [
+    // ==================== COMMON (4 events) ====================
+    {
+        id: "fatigue",
+        name: "💤 Cansancio General",
+        description: "El cansancio afecta a ambos luchadores.",
+        rarity: "common",
+        effects: [
+            {
+                effectType: "stat_change",
+                target: "both",
+                statType: "speed",
+                statChange: -1,
+            },
+        ],
+    },
+    {
+        id: "refreshing_breeze",
+        name: "🍃 Brisa Refrescante",
+        description: "Una suave brisa restaura la calma.",
+        rarity: "common",
+        effects: [
+            {
+                effectType: "heal_percent",
+                target: "both",
+                percentValue: 5, // 5% HP
+            },
+        ],
+    },
+    {
+        id: "adrenaline_rush",
+        name: "⚡ Adrenalina",
+        description: "Una inyección de adrenalina aumenta la velocidad de ambos.",
+        rarity: "common",
+        effects: [
+            {
+                effectType: "stat_change",
+                target: "both",
+                statType: "speed",
+                statChange: 1,
+            },
+        ],
+    },
+    {
+        id: "intimidation",
+        name: "😨 Intimidación Mutua",
+        description: "Ambos luchadores se sienten intimidados.",
+        rarity: "common",
+        effects: [
+            {
+                effectType: "stat_change",
+                target: "both",
+                statType: "offense",
+                statChange: -1,
+            },
+        ],
+    },
+    // ==================== RARE (3 events) ====================
+    {
+        id: "police_raid",
+        name: "🚨 Redada Policial",
+        description: "¡La policía confisca objetos sospechosos!",
+        rarity: "rare",
+        effects: [
+            {
+                effectType: "stat_change",
+                target: "both",
+                statType: "offense",
+                statChange: -2,
+                condition: {
+                    type: "has_item",
+                },
+            },
+        ],
+    },
+    {
+        id: "meteor_shower",
+        name: "☄️ Lluvia de Meteoritos",
+        description: "¡Meteoritos caen del cielo dañando a ambos!",
+        rarity: "rare",
+        effects: [
+            {
+                effectType: "damage_percent",
+                target: "both",
+                percentValue: 10,
+            },
+        ],
+    },
+    {
+        id: "lucky_charm",
+        name: "🍀 Amuleto de la Suerte",
+        description: "Un luchador aleatorio se siente afortunado.",
+        rarity: "rare",
+        effects: [
+            {
+                effectType: "stat_change",
+                target: "random_one",
+                statType: "crit",
+                statChange: 2,
+            },
+        ],
+    },
+    // ==================== EPIC (2 events) ====================
+    {
+        id: "casino",
+        name: "🎰 Casino",
+        description: "Una ruleta aparece. La suerte está echada.",
+        rarity: "epic",
+        effects: [
+            {
+                effectType: "stat_change",
+                target: "random_one",
+                randomChoices: [
+                    {
+                        effectType: "stat_change",
+                        target: "self",
+                        statType: "offense",
+                        statChange: 3,
+                    },
+                    {
+                        effectType: "stat_change",
+                        target: "opponent",
+                        statType: "defense",
+                        statChange: -2,
+                    },
+                ],
+            },
+        ],
+    },
+    {
+        id: "reset_button",
+        name: "🔄 Botón de Reinicio",
+        description: "Todas las estadísticas vuelven a la normalidad.",
+        rarity: "epic",
+        effects: [
+            {
+                effectType: "reset_stats",
+                target: "both",
+            },
+        ],
+    },
+];
+/**
+ * POKEMON-SPECIFIC Random Events
+ * These only appear when using the Pokemon skin
+ */
+export const POKEMON_RANDOM_EVENTS = [
+    // ==================== COMMON (3 events) ====================
+    {
+        id: "pokemon_center",
+        name: "🏥 Centro Pokémon Móvil",
+        description: "Una enfermera Joy aparece y cura a ambos Pokémon.",
+        rarity: "common",
+        effects: [
+            {
+                effectType: "heal_percent",
+                target: "both",
+                percentValue: 15,
+            },
+        ],
+    },
+    {
+        id: "team_rocket",
+        name: "🚀 ¡Equipo Rocket!",
+        description: "¡Preparaos para los problemas! El ataque de ambos baja.",
+        rarity: "common",
+        effects: [
+            {
+                effectType: "stat_change",
+                target: "both",
+                statType: "offense",
+                statChange: -1,
+            },
+        ],
+    },
+    {
+        id: "rare_candy",
+        name: "🍬 Caramelo Raro",
+        description: "Un Pokémon aleatorio encuentra un caramelo y se fortalece.",
+        rarity: "common",
+        effects: [
+            {
+                effectType: "stat_change",
+                target: "random_one",
+                statType: "offense",
+                statChange: 1,
+            },
+            {
+                effectType: "stat_change",
+                target: "random_one",
+                statType: "defense",
+                statChange: 1,
+            },
+        ],
+    },
+    // ==================== RARE (4 events) ====================
+    {
+        id: "sandstorm",
+        name: "🌪️ Tormenta de Arena",
+        description: "Una tormenta de arena daña a todos los Pokémon.",
+        rarity: "rare",
+        effects: [
+            {
+                effectType: "damage_percent",
+                target: "both",
+                percentValue: 8,
+            },
+        ],
+    },
+    {
+        id: "professor_oak",
+        name: "👴 Profesor Oak",
+        description: "¡El Profesor Oak anima a tu Pokémon!",
+        rarity: "rare",
+        effects: [
+            {
+                effectType: "stat_change",
+                target: "random_one",
+                statType: "offense",
+                statChange: 2,
+            },
+            {
+                effectType: "stat_change",
+                target: "random_one",
+                statType: "speed",
+                statChange: 1,
+            },
+        ],
+    },
+    {
+        id: "dawn_stone",
+        name: "💎 Piedra Alba",
+        description: "Una piedra evolutiva aumenta la defensa de un Pokémon.",
+        rarity: "rare",
+        effects: [
+            {
+                effectType: "stat_change",
+                target: "random_one",
+                statType: "defense",
+                statChange: 3,
+            },
+        ],
+    },
+    {
+        id: "potion_spray",
+        name: "💊 Lluvia de Pociones",
+        description: "Pociones caen del cielo curando a ambos Pokémon.",
+        rarity: "rare",
+        effects: [
+            {
+                effectType: "heal_percent",
+                target: "both",
+                percentValue: 12,
+            },
+        ],
+    },
+    // ==================== EPIC (2 events) ====================
+    {
+        id: "legendary_appearance",
+        name: "✨ Aparición Legendaria",
+        description: "Un Pokémon legendario otorga poder a un luchador aleatorio.",
+        rarity: "epic",
+        effects: [
+            {
+                effectType: "stat_change",
+                target: "random_one",
+                statType: "offense",
+                statChange: 3,
+            },
+            {
+                effectType: "stat_change",
+                target: "random_one",
+                statType: "defense",
+                statChange: 2,
+            },
+            {
+                effectType: "stat_change",
+                target: "random_one",
+                statType: "speed",
+                statChange: 2,
+            },
+        ],
+    },
+    {
+        id: "max_revive",
+        name: "⚡ Revivir Máximo",
+        description: "El Pokémon con menos vida recupera un 30% de HP.",
+        rarity: "epic",
+        effects: [
+            {
+                effectType: "heal_percent",
+                target: "random_one", // TODO: Cambiar a "lowest_hp" cuando se implemente
+                percentValue: 30,
+            },
+        ],
+    },
+];

package/dist/engine/combat/stages.js

@@ -1,33 +1,38 @@
+// Balanced stat multipliers with gradual progression
+// Formula: Buffs = 1 + (stage × 0.33), Debuffs = 1 / (1 + |stage| × 0.33)
+// Max: +6 = 3.0x, Min: -6 = 0.43x
 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,
+    "-6": 1 / (1 + 6 * 0.33), // ≈ 0.43x
+    "-5": 1 / (1 + 5 * 0.33), // ≈ 0.48x
+    "-4": 1 / (1 + 4 * 0.33), // ≈ 0.54x
+    "-3": 1 / (1 + 3 * 0.33), // = 0.60x
+    "-2": 1 / (1 + 2 * 0.33), // ≈ 0.67x
+    "-1": 1 / (1 + 1 * 0.33), // ≈ 0.75x
+    0: 1.0,
+    1: 1 + 1 * 0.33, // ≈ 1.33x
+    2: 1 + 2 * 0.33, // ≈ 1.67x
+    3: 1 + 3 * 0.33, // = 2.00x
+    4: 1 + 4 * 0.33, // ≈ 2.33x
+    5: 1 + 5 * 0.33, // ≈ 2.67x
+    6: 1 + 6 * 0.33, // = 3.00x
 };
-// Accuracy/Evasion multipliers (3/3 base)
+// Accuracy/Evasion multipliers (using same balanced formula for consistency)
+// Formula: same as stats (1 + stage × 0.33 for buffs, 1/(1 + |stage| × 0.33) for debuffs)
+// Max: +6 = 3.0x, Min: -6 = 0.43x
 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,
+    "-6": 1 / (1 + 6 * 0.33), // ≈ 0.43x
+    "-5": 1 / (1 + 5 * 0.33), // ≈ 0.48x
+    "-4": 1 / (1 + 4 * 0.33), // ≈ 0.54x
+    "-3": 1 / (1 + 3 * 0.33), // = 0.60x
+    "-2": 1 / (1 + 2 * 0.33), // ≈ 0.67x
+    "-1": 1 / (1 + 1 * 0.33), // ≈ 0.75x
+    0: 1.0,
+    1: 1 + 1 * 0.33, // ≈ 1.33x
+    2: 1 + 2 * 0.33, // ≈ 1.67x
+    3: 1 + 3 * 0.33, // = 2.00x
+    4: 1 + 4 * 0.33, // ≈ 2.33x
+    5: 1 + 5 * 0.33, // ≈ 2.67x
+    6: 1 + 6 * 0.33, // = 3.00x
 };
 // Critical Hit Ratio (Table)
 // Stage 0: ~4.17% (1/24)

package/dist/engine/events/applyRandomEvent.d.ts

@@ -0,0 +1,11 @@
+import type { RandomEventDefinition } from "../../core/randomEvents.js";
+import type { BattleState } from "../../core/battleState.js";
+import type { BattleEvent } from "../../core/events.js";
+/**
+ * Apply a random event to the battle state
+ * Follows Single Responsibility - only handles event application
+ */
+export declare const applyRandomEvent: (state: BattleState, event: RandomEventDefinition) => {
+    state: BattleState;
+    events: BattleEvent[];
+};

package/dist/engine/events/applyRandomEvent.js

@@ -0,0 +1,229 @@
+// Simple ID generator (no external dependency)
+const generateId = () => `evt_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+/**
+ * Apply a random event to the battle state
+ * Follows Single Responsibility - only handles event application
+ */
+export const applyRandomEvent = (state, event) => {
+    const events = [];
+    // Announce event trigger
+    events.push({
+        id: generateId(),
+        turnNumber: state.turnNumber,
+        kind: "random_event_triggered",
+        eventId: event.id,
+        eventName: event.name,
+        eventDescription: event.description,
+        message: `🎲 ${event.name}: ${event.description}`,
+        timestamp: Date.now(),
+    });
+    let updatedState = state;
+    // Apply each effect
+    for (const effect of event.effects) {
+        const result = applyEventEffect(updatedState, effect);
+        updatedState = result.state;
+        events.push(...result.events);
+    }
+    return { state: updatedState, events };
+};
+/**
+ * Apply a single event effect
+ * Follows Open/Closed - easy to extend with new effect types
+ */
+const applyEventEffect = (state, effect) => {
+    const events = [];
+    // Handle random choice effects (casino-style)
+    if (effect.randomChoices && effect.randomChoices.length > 0) {
+        const chosen = effect.randomChoices[Math.floor(Math.random() * effect.randomChoices.length)];
+        return applyEventEffect(state, chosen);
+    }
+    let updatedState = state;
+    // Determine targets based on effect.target
+    const targets = determineTargets(state, effect);
+    // Apply effect to each target
+    for (const { fighter, playerKey } of targets) {
+        // Check if condition is met
+        if (effect.condition && !checkCondition(fighter, effect.condition)) {
+            continue;
+        }
+        const result = applySingleEffectToFighter(updatedState, playerKey, fighter, effect);
+        updatedState = result.state;
+        events.push(...result.events);
+    }
+    return { state: updatedState, events };
+};
+/**
+ * Determine which fighters should be affected by the effect
+ */
+const determineTargets = (state, effect) => {
+    const p1Active = state.player1.fighterTeam[state.player1.activeIndex];
+    const p2Active = state.player2.fighterTeam[state.player2.activeIndex];
+    switch (effect.target) {
+        case "both":
+            return [
+                { fighter: p1Active, playerKey: "player1" },
+                { fighter: p2Active, playerKey: "player2" },
+            ];
+        case "self":
+            return [{ fighter: p1Active, playerKey: "player1" }];
+        case "opponent":
+            return [{ fighter: p2Active, playerKey: "player2" }];
+        case "random_one":
+            return Math.random() < 0.5
+                ? [{ fighter: p1Active, playerKey: "player1" }]
+                : [{ fighter: p2Active, playerKey: "player2" }];
+        default:
+            return [];
+    }
+};
+/**
+ * Check if a condition is met for a fighter
+ * Follows Interface Segregation - simple condition checking
+ */
+const checkCondition = (fighter, condition) => {
+    switch (condition.type) {
+        case "always":
+            return true;
+        case "has_item":
+            // BattleFighter doesn't have inventory, items are in PlayerBattleState
+            // For now, ignore this condition (always false for fighters)
+            return false;
+        case "hp_below_percent":
+            if (typeof condition.value !== "number")
+                return false;
+            const maxHp = fighter.baseStats.offense + fighter.baseStats.defense;
+            const hpPercent = (fighter.currentHp / maxHp) * 100;
+            return hpPercent < condition.value;
+        case "hp_above_percent":
+            if (typeof condition.value !== "number")
+                return false;
+            const maxHp2 = fighter.baseStats.offense + fighter.baseStats.defense;
+            const hpPercent2 = (fighter.currentHp / maxHp2) * 100;
+            return hpPercent2 > condition.value;
+        case "fighter_type":
+            // BattleFighter uses classId, not types array
+            // Match against classId
+            if (typeof condition.value !== "string")
+                return false;
+            return fighter.classId === condition.value;
+        case "has_status":
+            return fighter.statuses && fighter.statuses.length > 0;
+        case "stat_stage_above":
+            if (typeof condition.value !== "number")
+                return false;
+            const totalStages = Object.values(fighter.statStages).reduce((sum, val) => sum + Math.abs(val), 0);
+            return totalStages > condition.value;
+        default:
+            return false;
+    }
+};
+/**
+ * Apply effect to a single fighter
+ * Follows Single Responsibility - one effect type at a time
+ */
+const applySingleEffectToFighter = (state, playerKey, fighter, effect) => {
+    const events = [];
+    let updatedFighter = fighter;
+    switch (effect.effectType) {
+        case "damage_percent":
+            if (effect.percentValue) {
+                const maxHp = fighter.baseStats.offense + fighter.baseStats.defense;
+                const damage = Math.floor(maxHp * (effect.percentValue / 100));
+                updatedFighter = {
+                    ...fighter,
+                    currentHp: Math.max(0, fighter.currentHp - damage),
+                };
+                events.push({
+                    id: generateId(),
+                    turnNumber: state.turnNumber,
+                    kind: "random_event_effect",
+                    eventId: "",
+                    targetId: fighter.fighterId,
+                    effectType: "damage",
+                    message: `${fighter.fighterId} recibió ${damage} de daño del evento`,
+                    timestamp: Date.now(),
+                });
+            }
+            break;
+        case "heal_percent":
+            if (effect.percentValue) {
+                const maxHp = fighter.baseStats.offense + fighter.baseStats.defense;
+                const heal = Math.floor(maxHp * (effect.percentValue / 100));
+                updatedFighter = {
+                    ...fighter,
+                    currentHp: Math.min(maxHp, fighter.currentHp + heal),
+                };
+                events.push({
+                    id: generateId(),
+                    turnNumber: state.turnNumber,
+                    kind: "random_event_effect",
+                    eventId: "",
+                    targetId: fighter.fighterId,
+                    effectType: "heal",
+                    message: `${fighter.fighterId} recuperó ${heal} HP`,
+                    timestamp: Date.now(),
+                });
+            }
+            break;
+        case "stat_change":
+            if (effect.statType && effect.statChange !== undefined) {
+                const currentStage = fighter.statStages[effect.statType];
+                const newStage = Math.max(-6, Math.min(6, currentStage + effect.statChange));
+                updatedFighter = {
+                    ...fighter,
+                    statStages: {
+                        ...fighter.statStages,
+                        [effect.statType]: newStage,
+                    },
+                };
+                const change = newStage - currentStage;
+                if (change !== 0) {
+                    events.push({
+                        id: generateId(),
+                        turnNumber: state.turnNumber,
+                        kind: "stats_changed",
+                        targetId: fighter.fighterId,
+                        changes: { [effect.statType]: change },
+                        message: `${fighter.fighterId} ${change > 0 ? "aumentó" : "redujo"} ${effect.statType} en ${Math.abs(change)}`,
+                        timestamp: Date.now(),
+                    });
+                }
+            }
+            break;
+        case "reset_stats":
+            updatedFighter = {
+                ...fighter,
+                statStages: {
+                    offense: 0,
+                    defense: 0,
+                    speed: 0,
+                    crit: 0,
+                    accuracy: 0,
+                    evasion: 0,
+                },
+            };
+            events.push({
+                id: generateId(),
+                turnNumber: state.turnNumber,
+                kind: "random_event_effect",
+                eventId: "",
+                targetId: fighter.fighterId,
+                effectType: "reset_stats",
+                message: `${fighter.fighterId} tuvo sus stats reseteadas`,
+                timestamp: Date.now(),
+            });
+            break;
+        default:
+            break;
+    }
+    // Update state with modified fighter
+    const activeIndex = state[playerKey].activeIndex;
+    const updatedState = {
+        ...state,
+        [playerKey]: {
+            ...state[playerKey],
+            fighterTeam: state[playerKey].fighterTeam.map((f, idx) => idx === activeIndex ? updatedFighter : f),
+        },
+    };
+    return { state: updatedState, events };
+};

package/dist/engine/events/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./randomEventTrigger.js";
+export * from "./applyRandomEvent.js";

package/dist/engine/events/index.js

@@ -0,0 +1,3 @@
+// @pokemon-io/combat-core/src/engine/events/index.ts
+export * from "./randomEventTrigger.js";
+export * from "./applyRandomEvent.js";

package/dist/engine/events/randomEventTrigger.d.ts

@@ -0,0 +1,16 @@
+import { type RandomEventDefinition } from "../../core/randomEvents.js";
+/**
+ * Determina si debe dispararse un evento aleatorio en este turno
+ *
+ * @param turnNumber - Número del turno actual
+ * @returns true si debe ocurrir un evento
+ */
+export declare function shouldTriggerRandomEvent(turnNumber: number): boolean;
+/**
+ * Selecciona un evento aleatorio basado en los pesos de rareza
+ * Usa "weighted random selection" para dar más probabilidad a eventos comunes
+ *
+ * @param events - Array de eventos disponibles
+ * @returns Evento seleccionado
+ */
+export declare function selectRandomEvent(events: RandomEventDefinition[]): RandomEventDefinition;

package/dist/engine/events/randomEventTrigger.js

@@ -0,0 +1,67 @@
+// @pokemon-io/combat-core/src/engine/events/randomEventTrigger.ts
+import { RARITY_WEIGHTS, } from "../../core/randomEvents.js";
+/**
+ * 🎲 LÓGICA DE PROBABILIDAD DE EVENTOS ALEATORIOS
+ *
+ * 1. TRIGGER (¿Ocurre un evento?):
+ *    - Se revisa cada 2 turnos (turno 2, 4, 6, etc.)
+ *    - Probabilidad: 50% (0.5) en producción
+ *    - DEBUG MODE: 100% para pruebas (línea 27)
+ *
+ * 2. SELECCIÓN (¿Qué evento ocurre?):
+ *    - Se usa "weighted random selection" basado en rareza
+ *    - Pesos definidos en RARITY_WEIGHTS:
+ *      • Common: 60% de probabilidad
+ *      • Rare: 25% de probabilidad
+ *      • Epic: 12% de probabilidad
+ *      • Legendary: 3% de probabilidad
+ */
+// 🔧 DEBUG: Cambia esto a false para volver a 50% de probabilidad
+const DEBUG_MODE = true;
+const TRIGGER_CHANCE = DEBUG_MODE ? 1.0 : 0.5; // 100% en debug, 50% en producción
+/**
+ * Determina si debe dispararse un evento aleatorio en este turno
+ *
+ * @param turnNumber - Número del turno actual
+ * @returns true si debe ocurrir un evento
+ */
+export function shouldTriggerRandomEvent(turnNumber) {
+    // Solo en turnos pares (2, 4, 6, ...)
+    if (turnNumber % 2 !== 0) {
+        console.log(`[Random Events] Turno ${turnNumber}: NO (turno impar)`);
+        return false;
+    }
+    // Probabilidad de trigger
+    const roll = Math.random();
+    const triggered = roll < TRIGGER_CHANCE;
+    console.log(`[Random Events] Turno ${turnNumber}: ${triggered ? '✅ SÍ' : '❌ NO'} ` +
+        `(roll=${roll.toFixed(3)}, threshold=${TRIGGER_CHANCE})`);
+    return triggered;
+}
+/**
+ * Selecciona un evento aleatorio basado en los pesos de rareza
+ * Usa "weighted random selection" para dar más probabilidad a eventos comunes
+ *
+ * @param events - Array de eventos disponibles
+ * @returns Evento seleccionado
+ */
+export function selectRandomEvent(events) {
+    // Calcular peso total
+    let totalWeight = 0;
+    for (const event of events) {
+        totalWeight += RARITY_WEIGHTS[event.rarity];
+    }
+    // Selección ponderada
+    let random = Math.random() * totalWeight;
+    console.log(`[Random Events] Seleccionando evento (totalWeight=${totalWeight}, roll=${random.toFixed(2)})`);
+    for (const event of events) {
+        random -= RARITY_WEIGHTS[event.rarity];
+        if (random <= 0) {
+            console.log(`[Random Events] Evento seleccionado: "${event.name}" (${event.rarity})`);
+            return event;
+        }
+    }
+    // Fallback (no debería ocurrir)
+    console.warn("[Random Events] Fallback al primer evento");
+    return events[0];
+}

package/dist/engine/index.d.ts

@@ -9,3 +9,4 @@ export * from './effects/index.js';
 export * from './fighters/index.js';
 export * from './status/index.js';
 export * from './turn/index.js';
+export * from './events/index.js';

package/dist/engine/index.js

@@ -9,3 +9,4 @@ export * from './effects/index.js';
 export * from './fighters/index.js';
 export * from './status/index.js';
 export * from './turn/index.js';
+export * from './events/index.js';

package/dist/engine/rules.d.ts

@@ -1,43 +1,5 @@
-import { AmuletDefinition, BattleState, FighterDefinition, ItemDefinition, ItemId, MoveDefinition, MoveId, StatusDefinition, StatusId, TypeDefinition, TypeEffectivenessMatrix, TypeId } from "../core/index.js";
-export interface BattleRules {
-    baseCritChance: number;
-    critPerStat: number;
-    critMultiplier: number;
-    stabMultiplier: number;
-    randomMinDamageFactor: number;
-    randomMaxDamageFactor: number;
-}
-export interface BattleRuntime {
-    rules: BattleRules;
-    typesById: Record<TypeId, TypeDefinition>;
-    movesById: Record<MoveId, MoveDefinition>;
-    itemsById: Record<ItemId, ItemDefinition>;
-    amuletsById: Record<string, AmuletDefinition>;
-    statusesById: Record<StatusId, StatusDefinition>;
-    typeEffectiveness: TypeEffectivenessMatrix;
-}
-export interface PlayerFighterBattleConfig {
-    fighter: FighterDefinition;
-    maxHp: number;
-    moves: MoveDefinition[];
-    amulet: AmuletDefinition | null;
-}
-export interface PlayerBattleConfig {
-    fighters: PlayerFighterBattleConfig[];
-    items: ItemDefinition[];
-    amulet: AmuletDefinition | null;
-}
-export interface BattleConfig {
-    types: TypeDefinition[];
-    typeEffectiveness: TypeEffectivenessMatrix;
-    moves: MoveDefinition[];
-    items: ItemDefinition[];
-    amulets: AmuletDefinition[];
-    statuses: StatusDefinition[];
-    player1: PlayerBattleConfig;
-    player2: PlayerBattleConfig;
-    rules?: Partial<BattleRules>;
-}
+import { BattleState, BattleRules, BattleRuntime } from "../core/index.js";
+export type { BattleRules, BattleRuntime, BattleConfig, PlayerBattleConfig, PlayerFighterBattleConfig, } from "../core/index.js";
 export interface RuntimeBattleState extends BattleState {
     runtime: BattleRuntime;
 }

package/dist/engine/turn/resolveTurn.js

@@ -10,6 +10,9 @@ import { recomputeEffectiveStatsForFighter } from "../fighters/fighter.js";
 import { getOpponentAndSelf } from "../fighters/selectors.js";
 import { applyEndOfTurnStatuses } from "../status/endOfTurn.js";
 import { hasHardCc } from "../status/hardCc.js";
+import { shouldTriggerRandomEvent, selectRandomEvent } from "../events/randomEventTrigger.js";
+import { applyRandomEvent } from "../events/applyRandomEvent.js";
+import { CORE_RANDOM_EVENTS } from "../../core/index.js";
 // ------------------------------------------------------
 // Helpers KO -> forced switch (estilo Pokémon real)
 // ------------------------------------------------------
@@ -267,6 +270,46 @@ export const resolveTurn = (state, actions) => {
             winner: winnerAtEnd,
         });
     }
+    // ✅ RANDOM EVENTS - Check and apply after forced switch and before turn_end
+    const shouldCheckRandomEvent = !currentState.forcedSwitch && // Skip if forced switch pending
+        winnerAtEnd === "none"; // Skip if battle ended
+    if (shouldCheckRandomEvent && shouldTriggerRandomEvent(currentState.turnNumber)) {
+        // Select random event
+        const availableEvents = [
+            ...CORE_RANDOM_EVENTS,
+            // TODO: Add skin-specific events (POKEMON_RANDOM_EVENTS)
+        ];
+        const randomEvent = selectRandomEvent(availableEvents);
+        // Emit banner event
+        events.push({
+            ...createBaseEvent(currentState.turnNumber, "random_event_triggered", randomEvent.description),
+            eventId: randomEvent.id,
+            eventName: randomEvent.name,
+            eventDescription: randomEvent.description,
+            eventRarity: randomEvent.rarity,
+            imageUrl: randomEvent.imageUrl,
+            effects: randomEvent.effects.map((effect) => ({
+                effectType: effect.effectType,
+                target: effect.target,
+                percentValue: effect.percentValue,
+                statType: effect.statType,
+                statChange: effect.statChange,
+            })),
+        });
+        // Apply random event effects
+        const effectsResult = applyRandomEvent(currentState, randomEvent);
+        currentState = effectsResult.state;
+        // Add effect events with source="random_event" marker
+        const markedEvents = effectsResult.events.map((event) => {
+            if (event.kind === "damage" ||
+                event.kind === "heal" ||
+                event.kind === "stats_changed") {
+                return { ...event, source: "random_event" };
+            }
+            return event;
+        });
+        events.push(...markedEvents);
+    }
     events.push({
         ...createBaseEvent(currentState.turnNumber, "turn_end", `Termina el turno ${currentState.turnNumber}`),
     });

package/package.json

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