pokemon-io-core 0.0.106 → 0.0.108

package/dist/api/battle.d.ts

@@ -60,6 +60,15 @@ export interface BattleView {
     turnStartHpByPlayerId: {
         [playerId: string]: number;
     };
+    turnStartStatusesByPlayerId?: Record<string, BattlePlayerStatusView[]>;
+    turnStartStatStagesByPlayerId?: Record<string, {
+        offense: number;
+        defense: number;
+        speed: number;
+        crit: number;
+        accuracy: number;
+        evasion: number;
+    }>;
     turnNumber: number;
     pendingActions?: {
         player1: boolean;

package/dist/engine/events/applyRandomEvent.js

@@ -1,4 +1,7 @@
 import { applyStatusToFighter } from "../status/apply.js";
+import { applyDamageToFighter } from "../combat/damage.js";
+import { applyHealToFighter } from "../combat/heal.js";
+import { createBaseEvent } from "../events.js";
 // Simple ID generator (no external dependency)
 const generateId = () => `evt_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
 /**
@@ -119,90 +122,71 @@ const applySingleEffectToFighter = (state, playerKey, fighter, effect) => {
             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(),
-                });
+                const res = applyDamageToFighter(state, updatedFighter, damage, "random_event", // attackerId for log
+                false);
+                updatedFighter = res.updatedDefender;
+                events.push(...res.events);
             }
             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(),
-                });
+                const healAmount = Math.floor(maxHp * (effect.percentValue / 100));
+                const res = applyHealToFighter(state, updatedFighter, healAmount, "random_event");
+                updatedFighter = res.updated;
+                events.push(...res.events);
             }
             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) {
+                    updatedFighter = {
+                        ...fighter,
+                        statStages: {
+                            ...fighter.statStages,
+                            [effect.statType]: newStage,
+                        },
+                    };
                     events.push({
-                        id: generateId(),
-                        turnNumber: state.turnNumber,
-                        kind: "stats_changed",
+                        ...createBaseEvent(state.turnNumber, "stats_changed", `${fighter.fighterId} ${change > 0 ? "aumentó" : "redujo"} ${effect.statType}`),
                         targetId: fighter.fighterId,
-                        changes: { [effect.statType]: change },
-                        message: `${fighter.fighterId} ${change > 0 ? "aumentó" : "redujo"} ${effect.statType} en ${Math.abs(change)}`,
-                        timestamp: Date.now(),
+                        changes: { [effect.statType]: change }
                     });
                 }
             }
             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(),
+        case "reset_stats": {
+            const changes = {};
+            const newStages = { ...fighter.statStages };
+            let hasChange = false;
+            // Reset all to 0 and record diff
+            Object.keys(newStages).forEach(stat => {
+                const currentVal = newStages[stat];
+                if (currentVal !== 0) {
+                    changes[stat] = -currentVal; // Apply inverse to reach 0
+                    newStages[stat] = 0;
+                    hasChange = true;
+                }
             });
+            if (hasChange) {
+                updatedFighter = {
+                    ...fighter,
+                    statStages: newStages
+                };
+                // Emit Granular Events for animation
+                Object.entries(changes).forEach(([stat, diff]) => {
+                    events.push({
+                        ...createBaseEvent(state.turnNumber, "stats_changed", `Stats reseteados: ${stat}`),
+                        targetId: fighter.fighterId,
+                        changes: { [stat]: diff }
+                    });
+                });
+            }
             break;
+        }
         case "apply_status":
             if (effect.statusId) {
                 // Cast state to RuntimeBattleState as required by status system

package/package.json

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