pokemon-io-core 0.0.100 → 0.0.101

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/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;
@@ -93,4 +93,16 @@ 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;
+}
+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

@@ -9,3 +9,5 @@ export * from "./items.js";
 export * from "./moves.js";
 export * from "./status.js";
 export * from "./types.js";
+export * from "./randomEvents.js";
+export * from "./randomEventsList.js";

package/dist/core/index.js

@@ -9,3 +9,5 @@ export * from "./items.js";
 export * from "./moves.js";
 export * from "./status.js";
 export * from "./types.js";
+export * from "./randomEvents.js";
+export * from "./randomEventsList.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,6 @@
+import type { RandomEventDefinition } from "./randomEvents.js";
+/**
+ * CORE Random Events - Generic events that work with any skin
+ * Phase 1: Initial 4 events for MVP
+ */
+export declare const CORE_RANDOM_EVENTS: RandomEventDefinition[];

package/dist/core/randomEventsList.js

@@ -0,0 +1,80 @@
+// @pokemon-io/combat-core/src/core/randomEventsList.ts
+/**
+ * CORE Random Events - Generic events that work with any skin
+ * Phase 1: Initial 4 events for MVP
+ */
+export const CORE_RANDOM_EVENTS = [
+    // ==================== COMMON ====================
+    {
+        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
+            },
+        ],
+    },
+    // ==================== RARE ====================
+    {
+        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",
+                },
+            },
+        ],
+    },
+    // ==================== EPIC ====================
+    {
+        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,
+                    },
+                ],
+            },
+        ],
+    },
+];

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,13 @@
+import type { RandomEventDefinition } from "../../core/randomEvents.js";
+/**
+ * Check if a random event should trigger
+ * @param turnNumber Current turn number
+ * @returns true if event should trigger (50% chance every 2 turns)
+ */
+export declare const shouldTriggerRandomEvent: (turnNumber: number) => boolean;
+/**
+ * Select a random event from available events based on rarity weights
+ * @param availableEvents List of available events
+ * @returns Selected event
+ */
+export declare const selectRandomEvent: (availableEvents: RandomEventDefinition[]) => RandomEventDefinition;

package/dist/engine/events/randomEventTrigger.js

@@ -0,0 +1,35 @@
+// @pokemon-io/combat-core/src/engine/events/randomEventTrigger.ts
+import { RARITY_WEIGHTS } from "../../core/randomEvents.js";
+/**
+ * Check if a random event should trigger
+ * @param turnNumber Current turn number
+ * @returns true if event should trigger (50% chance every 2 turns)
+ */
+export const shouldTriggerRandomEvent = (turnNumber) => {
+    // Only check on even turns
+    if (turnNumber % 2 !== 0) {
+        return false;
+    }
+    // 50% chance
+    return Math.random() < 0.5;
+};
+/**
+ * Select a random event from available events based on rarity weights
+ * @param availableEvents List of available events
+ * @returns Selected event
+ */
+export const selectRandomEvent = (availableEvents) => {
+    // Calculate total weight
+    const totalWeight = availableEvents.reduce((sum, event) => sum + RARITY_WEIGHTS[event.rarity], 0);
+    // Roll random number
+    let roll = Math.random() * totalWeight;
+    // Select event based on weight
+    for (const event of availableEvents) {
+        roll -= RARITY_WEIGHTS[event.rarity];
+        if (roll <= 0) {
+            return event;
+        }
+    }
+    // Fallback (shouldn't happen)
+    return availableEvents[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/package.json

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