pokemon-io-core 0.0.115 → 0.0.117

package/dist/api/battle.d.ts

@@ -0,0 +1,90 @@
+import { BattleEvent, StatusId, VolatileStatus } from "../core/index.js";
+export interface BattlePlayerStatusView {
+    statusId: StatusId;
+    stacks: number;
+    remainingTurns: number;
+}
+export interface BattlePlayerMoveView {
+    moveId: string;
+    currentPP: number;
+    maxPP: number;
+}
+export interface BattlePlayerItemView {
+    itemId: string;
+    usesRemaining: number;
+    maxUses: number;
+}
+export interface BattleTeamSlotView {
+    fighterId: string;
+    hp: number;
+    isAlive: boolean;
+    statuses: BattlePlayerStatusView[];
+}
+export interface BattlePlayerView {
+    playerId: string;
+    nickname: string;
+    hp: number;
+    statuses: BattlePlayerStatusView[];
+    volatileStatus: VolatileStatus;
+    activeFighterId: string | null;
+    activeIndex: number;
+    activeMoves: BattlePlayerMoveView[];
+    inventory: BattlePlayerItemView[];
+    team: BattleTeamSlotView[];
+    statStages?: {
+        offense: number;
+        defense: number;
+        speed: number;
+        crit: number;
+        accuracy: number;
+        evasion: number;
+    };
+}
+export type BattleStatus = "ongoing" | "awaiting_forced_switch" | "finished";
+export type ForcedSwitchReason = "roar" | "faint";
+export interface ForcedSwitchView {
+    targetPlayerId: string;
+    sourcePlayerId: string;
+    reason: ForcedSwitchReason;
+    turnNumber: number;
+}
+export interface BattleView {
+    roomId: string;
+    status: BattleStatus;
+    winnerId: string | null;
+    currentTurnPlayerId: string | null;
+    startedAt: string;
+    players: BattlePlayerView[];
+    events: BattleEvent[];
+    turnStartActiveFighterIdByPlayerId?: Record<string, string | null>;
+    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;
+        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/room.d.ts

@@ -0,0 +1,29 @@
+export interface PlayerLoadoutFighterView {
+    fighterId: string;
+    moveIds: string[];
+}
+export interface PlayerLoadoutView {
+    fighters: PlayerLoadoutFighterView[];
+    itemIds: string[];
+    amuletId: string | null;
+}
+export interface PlayerView {
+    id: string;
+    nickname: string;
+    isOwner: boolean;
+    isSelf: boolean;
+    isReady: boolean;
+    loadout: PlayerLoadoutView | null;
+}
+export type RoomStatusView = "waiting" | "in_battle" | "finished";
+export interface RoomView {
+    id: string;
+    ownerId: string;
+    status: RoomStatusView;
+    fightersPerPlayer: number;
+    players: PlayerView[];
+    skinId: string;
+    stageId: string;
+    name: string;
+    hasPassword: boolean;
+}

package/dist/api/socketTypes.d.ts

@@ -0,0 +1,96 @@
+import { BattleView } from "./battle.js";
+import { RoomView } from "./room.js";
+import { EmoteId } from "../core/emotes.js";
+export interface ClientToServerEvents {
+    "room:create": (payload: {
+        nickname: string;
+        roomName: string;
+        password?: string | null;
+    }) => void;
+    "room:join": (payload: {
+        roomId: string;
+        nickname: string;
+        password?: string | null;
+    }) => void;
+    "room:leave": (payload: {
+        roomId: string;
+    }) => void;
+    "room:reconnect": (payload: {
+        roomId: string;
+        oldPlayerId: string;
+    }) => void;
+    "room:setLoadout": (payload: {
+        roomId: string;
+        fighters: {
+            fighterId: string;
+            moveIds: string[];
+        }[];
+        itemIds: string[];
+        amuletId?: string | null;
+    }) => void;
+    "room:startBattleRequest": (payload: {
+        roomId: string;
+    }) => void;
+    "room:setConfig": (payload: {
+        roomId: string;
+        skinId: string;
+        stageId: string;
+        fightersPerPlayer: number;
+    }) => void;
+    "room:list": () => void;
+    "battle:useMove": (payload: {
+        roomId: string;
+        moveIndex: number;
+    }) => void;
+    "battle:useItem": (payload: {
+        roomId: string;
+        itemIndex: number;
+    }) => void;
+    "battle:switchFighter": (payload: {
+        roomId: string;
+        newIndex: number;
+    }) => void;
+    "battle:chooseForcedSwitch": (payload: {
+        roomId: string;
+        newIndex: number;
+    }) => void;
+    "battle:rematchSameLoadout": (payload: {
+        roomId: string;
+    }) => void;
+    "battle:rematchChangeLoadout": (payload: {
+        roomId: string;
+    }) => void;
+    "battle:sendEmote": (payload: {
+        roomId: string;
+        emoteId: EmoteId;
+    }) => void;
+    "battle:acknowledgeRandomEvent": (payload: {
+        roomId: string;
+    }) => void;
+    ping: () => void;
+}
+export interface ServerToClientEvents {
+    "connection:state": (payload: {
+        isConnected: boolean;
+        socketId: string | null;
+    }) => void;
+    "room:list": (payload: RoomView[]) => void;
+    "room:state": (payload: RoomView) => void;
+    "room:error": (payload: {
+        code: string;
+        message: string;
+    }) => void;
+    "battle:state": (payload: BattleView) => void;
+    "battle:emote": (payload: {
+        playerId: string;
+        emoteId: EmoteId;
+        timestamp: number;
+    }) => void;
+    "battle:randomEventTriggered": (payload: {
+        eventId: string;
+        eventName: string;
+        eventDescription: string;
+        imageUrl?: string;
+    }) => void;
+    pong: (msg: string) => void;
+}

package/dist/core/actions.d.ts

@@ -0,0 +1,22 @@
+export type ActionKind = "use_move" | "use_item" | "switch_fighter" | "no_action";
+export interface UseMoveAction {
+    kind: "use_move";
+    moveIndex: number;
+}
+export interface UseItemAction {
+    kind: "use_item";
+    itemIndex: number;
+}
+export interface SwitchFighterAction {
+    kind: "switch_fighter";
+    newIndex: number;
+    forced?: boolean;
+}
+export interface NoAction {
+    kind: "no_action";
+}
+export type PlayerAction = UseMoveAction | UseItemAction | SwitchFighterAction | NoAction;
+export interface BattleActions {
+    player1: PlayerAction;
+    player2: PlayerAction;
+}

package/dist/core/amulets.d.ts

@@ -0,0 +1,18 @@
+import type { AmuletId, TypeId, StatusId } from "./ids.js";
+import type { EffectDefinition } from "./moves.js";
+export type PassiveTriggerKind = "always" | "on_hit" | "on_damage_taken" | "on_below_hp_threshold";
+export interface PassiveTriggerCondition {
+    kind: PassiveTriggerKind;
+    hpThresholdPercent?: number;
+}
+export interface PassiveEffectDefinition {
+    trigger: PassiveTriggerCondition;
+    effects: EffectDefinition[];
+    appliedStatusId?: StatusId;
+}
+export interface AmuletDefinition {
+    id: AmuletId;
+    name: string;
+    classId: TypeId | null;
+    passiveEffects: PassiveEffectDefinition[];
+}

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/emotes.d.ts

@@ -0,0 +1,13 @@
+export type EmoteCategory = "emotional" | "strategic" | "social";
+export type EmoteId = string;
+export interface EmoteDefinition {
+    id: EmoteId;
+    category: EmoteCategory;
+    emoji: string;
+    label: string;
+    description?: string;
+}
+export declare const EMOTES: EmoteDefinition[];
+export declare const getEmoteById: (id: EmoteId) => EmoteDefinition | undefined;
+export declare const getEmotesByCategory: (category: EmoteCategory) => EmoteDefinition[];
+export declare const isValidEmoteId: (id: string) => id is EmoteId;

package/dist/core/events.d.ts

@@ -0,0 +1,142 @@
+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" | "random_event_triggered" | "random_event_effect" | "battle_end";
+export interface BaseBattleEvent {
+    id: string;
+    turnNumber: number;
+    kind: BattleEventKind;
+    message: string;
+    timestamp: number;
+}
+export interface GenericBattleEvent extends BaseBattleEvent {
+    kind: Exclude<BattleEventKind, "stats_changed" | "action_declared" | "action_skipped_hard_cc" | "move_miss" | "move_hit" | "item_used" | "damage" | "heal" | "status_applied" | "fighter_switched" | "status_expired" | "status_tick" | "action_skipped_hard_cc" | "fighter_fainted" | "battle_end" | "random_event_effect" | "status_cleared">;
+}
+export interface StatsChangedEvent extends BaseBattleEvent {
+    kind: "stats_changed";
+    targetId: FighterId;
+    changes: {
+        offense?: number;
+        defense?: number;
+        speed?: number;
+        crit?: number;
+        accuracy?: number;
+        evasion?: number;
+    };
+    source?: "move" | "status" | "item" | "random_event";
+}
+export interface ActionDeclaredEvent extends BaseBattleEvent {
+    kind: "action_declared";
+    actorId: FighterId;
+    /**
+     * Optional custom list of narration lines.
+     * If present, the frontend should play these lines instead of the default message.
+     */
+    narration?: string[];
+    moveId?: MoveId;
+    itemId?: ItemId;
+    targetId?: FighterId;
+}
+export interface ActionSkippedHardCcEvent extends BaseBattleEvent {
+    kind: "action_skipped_hard_cc";
+    actorId: FighterId;
+    statusId: StatusId;
+}
+export interface MoveMissEvent extends BaseBattleEvent {
+    kind: "move_miss";
+    actorId: FighterId;
+    moveId: MoveId;
+    targetId: FighterId;
+}
+export interface MoveHitEvent extends BaseBattleEvent {
+    kind: "move_hit";
+    actorId: FighterId;
+    moveId: MoveId;
+    targetId: FighterId;
+    isCritical: boolean;
+    effectiveness: number;
+}
+export interface ItemUsedEvent extends BaseBattleEvent {
+    kind: "item_used";
+    actorId: FighterId;
+    itemId: ItemId;
+    targetId: FighterId;
+}
+export interface DamageEvent extends BaseBattleEvent {
+    kind: "damage";
+    actorId: FighterId;
+    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";
+    targetId: FighterId;
+    statusId: StatusId;
+    stacks: number;
+    durationTurns: number;
+}
+export interface FighterSwitchedEvent extends BaseBattleEvent {
+    kind: "fighter_switched";
+    fromFighterId: FighterId;
+    toFighterId: FighterId;
+    toHp: number;
+    toStatuses: {
+        statusId: string;
+        stacks: number;
+        remainingTurns: number;
+    }[];
+}
+export interface StatusClearedEvent extends BaseBattleEvent {
+    kind: "status_cleared";
+    targetId: FighterId;
+    statusIds: StatusId[];
+}
+export interface StatusExpiredEvent extends BaseBattleEvent {
+    kind: "status_expired";
+    targetId: FighterId;
+    statusId: StatusId;
+}
+export interface StatusTickEvent extends BaseBattleEvent {
+    kind: "status_tick";
+    targetId: FighterId;
+    statusId: StatusId;
+    stacks: number;
+}
+export interface FighterFaintedEvent extends BaseBattleEvent {
+    kind: "fighter_fainted";
+    fighterId: FighterId;
+}
+export interface BattleEndEvent extends BaseBattleEvent {
+    kind: "battle_end";
+    winner: "player1" | "player2" | "draw";
+}
+export interface RandomEventTriggeredEvent extends BaseBattleEvent {
+    kind: "random_event_triggered";
+    eventId: string;
+    eventName: string;
+    eventDescription: string;
+    narration?: 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 | ActionSkippedHardCcEvent | MoveMissEvent | MoveHitEvent | ItemUsedEvent | DamageEvent | HealEvent | StatusAppliedEvent | StatusClearedEvent | StatusExpiredEvent | StatusTickEvent | FighterFaintedEvent | FighterSwitchedEvent | BattleEndEvent | StatsChangedEvent | RandomEventTriggeredEvent | RandomEventEffectEvent | GenericBattleEvent;

package/dist/core/ids.d.ts

@@ -0,0 +1,6 @@
+export type TypeId = string;
+export type FighterId = string;
+export type MoveId = string;
+export type ItemId = string;
+export type AmuletId = string;
+export type StatusId = string;

package/dist/core/index.d.ts

@@ -0,0 +1,16 @@
+export * from "./actions.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/items.d.ts

@@ -0,0 +1,12 @@
+import type { ItemId } from "./ids.js";
+import type { EffectDefinition, TargetKind } from "./moves.js";
+export type ItemCategory = "damage" | "heal_shield" | "status_buff";
+export interface ItemDefinition {
+    id: ItemId;
+    name: string;
+    target: TargetKind;
+    maxUses: number;
+    image: string;
+    effects: EffectDefinition[];
+    narration?: string[];
+}

package/dist/core/moves.d.ts

@@ -0,0 +1,87 @@
+import type { MoveId, StatusId, TypeId } from "./ids.js";
+export type EffectTarget = "self" | "enemy";
+export type EffectKind = "damage" | "heal" | "shield" | "modify_stats" | "apply_status" | "clear_status" | "modify_hit_chance" | "modify_crit_chance" | "modify_priority" | "modify_effective_speed" | "force_switch";
+export type TargetKind = EffectTarget;
+interface BaseEffect {
+    target?: EffectTarget;
+    chance?: number;
+}
+export interface DamageEffect extends BaseEffect {
+    kind: "damage";
+    /**
+     * Daño “de fórmula” (stats + tipo + crit…).
+     * Si no se define, NO se llama a computeDamage.
+     */
+    basePower?: number;
+    /**
+     * Daño plano adicional.
+     * Se suma al daño de fórmula o se usa solo si no hay basePower.
+     */
+    flatAmount?: number;
+}
+export interface HealEffect extends BaseEffect {
+    kind: "heal";
+    amount: number;
+}
+export interface ShieldEffect extends BaseEffect {
+    kind: "shield";
+    amount: number;
+    durationTurns: number;
+}
+export interface ModifyStatsEffect extends BaseEffect {
+    kind: "modify_stats";
+    offenseDelta?: number;
+    defenseDelta?: number;
+    speedDelta?: number;
+    critDelta?: number;
+}
+export interface ApplyStatusEffect extends BaseEffect {
+    kind: "apply_status";
+    statusId: StatusId;
+}
+export interface ClearStatusEffect extends BaseEffect {
+    kind: "clear_status";
+    statusIds?: StatusId[];
+    kinds?: ("hard_cc" | "soft")[];
+    clearAll?: boolean;
+}
+export interface ModifyHitChanceEffect extends BaseEffect {
+    kind: "modify_hit_chance";
+    delta: number;
+}
+export interface ModifyCritChanceEffect extends BaseEffect {
+    kind: "modify_crit_chance";
+    delta: number;
+}
+export interface ModifyPriorityEffect extends BaseEffect {
+    kind: "modify_priority";
+    delta: number;
+}
+export interface ForceSwitchEffect extends BaseEffect {
+    kind: "force_switch";
+    /**
+     * Mensaje/razón opcional para debug/narración interna.
+     * Si no lo usas, lo puedes ignorar en el engine.
+     */
+    reason?: string;
+}
+export interface ModifyEffectiveSpeedEffect extends BaseEffect {
+    kind: "modify_effective_speed";
+    multiplier: number;
+}
+export type EffectDefinition = DamageEffect | HealEffect | ShieldEffect | ModifyStatsEffect | ApplyStatusEffect | ClearStatusEffect | ModifyHitChanceEffect | ModifyCritChanceEffect | ModifyPriorityEffect | ModifyEffectiveSpeedEffect | ForceSwitchEffect;
+export interface MoveDefinition {
+    id: MoveId;
+    name: string;
+    typeId: TypeId;
+    accuracy?: number;
+    maxPP: number;
+    priority?: number;
+    charge?: {
+        invulnerability?: string;
+    };
+    bypassInvulnerability?: string[];
+    effects: EffectDefinition[];
+    narration?: string[];
+}
+export {};

package/dist/core/randomEvents.d.ts

@@ -0,0 +1,28 @@
+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;
+    narration: string[];
+    rarity: EventRarity;
+    imageUrl?: string;
+    effects: RandomEventEffect[];
+}
+export declare const RARITY_WEIGHTS: Record<EventRarity, number>;

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/status.d.ts

@@ -0,0 +1,11 @@
+import type { StatusId } from "./ids.js";
+import type { EffectDefinition } from "./moves.js";
+export type StatusKind = "hard_cc" | "soft";
+export interface StatusDefinition {
+    id: StatusId;
+    name: string;
+    kind: StatusKind;
+    minDurationTurns: number;
+    maxDurationTurns: number;
+    effectsPerStack: EffectDefinition[];
+}

package/dist/core/types.d.ts

@@ -0,0 +1,14 @@
+import type { TypeId } from "./ids.js";
+export type Effectiveness = 0 | 0.9 | 1 | 1.1;
+export interface TypeDefinition {
+    id: TypeId;
+    displayName: string;
+    color?: string;
+}
+export type TypeEffectivenessMatrix = Record<TypeId, Record<TypeId, Effectiveness>>;
+export interface FighterStats {
+    offense: number;
+    defense: number;
+    speed: number;
+    crit: number;
+}

package/dist/engine/actions/forcedSwitch.d.ts

@@ -0,0 +1,5 @@
+import { BattleEvent, BattleState } from "../../core/index.js";
+export declare const applyForcedSwitchChoice: (state: BattleState, targetPlayer: "player1" | "player2", newIndex: number) => {
+    state: BattleState;
+    events: BattleEvent[];
+};

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

@@ -0,0 +1,5 @@
+export * from './forcedSwitch.js';
+export * from './item.js';
+export * from './move.js';
+export * from './priority.js';
+export * from './switch.js';

package/dist/engine/actions/item.d.ts

@@ -0,0 +1,6 @@
+import { BattleEvent, PlayerAction } from "../../core/index.js";
+import { RuntimeBattleState } from "../rules.js";
+export declare const resolveItemUse: (state: RuntimeBattleState, playerKey: "player1" | "player2", action: PlayerAction) => {
+    state: RuntimeBattleState;
+    events: BattleEvent[];
+};

package/dist/engine/actions/move.d.ts

@@ -0,0 +1,7 @@
+import { BattleEvent, PlayerAction } from "../../core/index.js";
+import { RuntimeBattleState } from "../rules.js";
+export declare const processNarration: (lines: string[], actorId: string, targetId: string) => string[];
+export declare const resolveDamageMove: (state: RuntimeBattleState, playerKey: "player1" | "player2", action: PlayerAction) => {
+    state: RuntimeBattleState;
+    events: BattleEvent[];
+};

package/dist/engine/actions/priority.d.ts

@@ -0,0 +1,6 @@
+import { PlayerAction } from "../../core/index.js";
+import { RuntimeBattleState } from "../rules.js";
+export declare const getMovePriorityAndSpeed: (state: RuntimeBattleState, playerKey: "player1" | "player2", action: PlayerAction) => {
+    priority: number;
+    speed: number;
+};

package/dist/engine/actions/switch.d.ts

@@ -0,0 +1,6 @@
+import { BattleEvent, PlayerAction } from "../../core/index.js";
+import { RuntimeBattleState } from "../rules.js";
+export declare const resolveSwitchFighter: (state: RuntimeBattleState, playerKey: "player1" | "player2", action: PlayerAction) => {
+    state: RuntimeBattleState;
+    events: BattleEvent[];
+};

package/dist/engine/combat/crit.d.ts

@@ -0,0 +1,2 @@
+import { BattleRules } from "../rules.js";
+export declare const computeCritChance: (rules: BattleRules, critStat: number) => number;

package/dist/engine/combat/damage.d.ts

@@ -0,0 +1,20 @@
+import { BattleEvent, BattleFighter, FighterId, TypeId } from "../../core/index.js";
+import { RuntimeBattleState } from "../rules.js";
+interface DamageComputationInput {
+    state: RuntimeBattleState;
+    attacker: BattleFighter;
+    defender: BattleFighter;
+    moveTypeId: TypeId;
+    basePower: number;
+    isCritical: boolean;
+}
+export declare const computeDamage: (input: DamageComputationInput) => {
+    damage: number;
+    effectiveness: number;
+};
+interface DamageApplyResult {
+    updatedDefender: BattleFighter;
+    events: BattleEvent[];
+}
+export declare const applyDamageToFighter: (state: RuntimeBattleState, defender: BattleFighter, amount: number, actorId: FighterId, isCritical: boolean) => DamageApplyResult;
+export {};

package/dist/engine/combat/heal.d.ts

@@ -0,0 +1,6 @@
+import { BattleEvent, BattleFighter, FighterId } from "../../core/index.js";
+import { RuntimeBattleState } from "../rules.js";
+export declare const applyHealToFighter: (state: RuntimeBattleState, target: BattleFighter, amount: number, sourceId: FighterId) => {
+    updated: BattleFighter;
+    events: BattleEvent[];
+};

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

@@ -0,0 +1,5 @@
+export * from './crit.js';
+export * from './damage.js';
+export * from './heal.js';
+export * from './typeEffectiveness.js';
+export * from './winner.js';

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/typeEffectiveness.d.ts

@@ -0,0 +1,3 @@
+import { TypeId } from "../../core/index.js";
+import { RuntimeBattleState } from "../rules.js";
+export declare const getTypeEffectiveness: (state: RuntimeBattleState, attackerTypeId: TypeId, defenderTypeId: TypeId) => number;

package/dist/engine/combat/winner.d.ts

@@ -0,0 +1,2 @@
+import { RuntimeBattleState } from "../rules.js";
+export declare const checkWinner: (state: RuntimeBattleState) => "none" | "player1" | "player2" | "draw";

package/dist/engine/debug.d.ts

@@ -0,0 +1 @@
+export declare const dbg: (...args: unknown[]) => void;

package/dist/engine/effects/applyEffects.d.ts

@@ -0,0 +1,7 @@
+import { BattleEvent, BattleFighter, EffectDefinition, TypeId } from "../../core/index.js";
+import { RuntimeBattleState } from "../rules.js";
+export declare const applyEffectsOnTarget: (state: RuntimeBattleState, actor: BattleFighter, target: BattleFighter, moveTypeId: TypeId | null, isCritical: boolean, effects: EffectDefinition[]) => {
+    actor: BattleFighter;
+    target: BattleFighter;
+    events: BattleEvent[];
+};

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

@@ -0,0 +1,2 @@
+export * from './applyEffects.js';
+export * from './target.js';

package/dist/engine/effects/target.d.ts

@@ -0,0 +1,6 @@
+import { BattleFighter, EffectDefinition, EffectKind, EffectTarget } from "../../core/index.js";
+export declare const defaultTargetForKind: (kind: EffectKind) => EffectTarget;
+export declare const resolveEffectTarget: (eff: EffectDefinition, actor: BattleFighter, target: BattleFighter) => {
+    primary: BattleFighter;
+    isSelf: boolean;
+};

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/index.d.ts

@@ -0,0 +1,2 @@
+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.d.ts

@@ -0,0 +1,8 @@
+import { BattleEvent } from "../core/index.js";
+export declare const createBaseEvent: <K extends BattleEvent["kind"]>(turnNumber: number, kind: K, message: string) => {
+    id: string;
+    turnNumber: number;
+    kind: K;
+    message: string;
+    timestamp: number;
+};

package/dist/engine/fighters/fighter.d.ts

@@ -0,0 +1,4 @@
+import { BattleFighter } from "../../core/index.js";
+import { PlayerFighterBattleConfig, RuntimeBattleState } from "../rules.js";
+export declare const createBattleFighter: (cfg: PlayerFighterBattleConfig) => BattleFighter;
+export declare const recomputeEffectiveStatsForFighter: (state: RuntimeBattleState, fighter: BattleFighter) => BattleFighter;

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

@@ -0,0 +1,3 @@
+export * from './fighter.js';
+export * from './selectors.js';
+export * from './update.js';

package/dist/engine/fighters/selectors.d.ts

@@ -0,0 +1,13 @@
+import { BattleFighter, PlayerBattleState } from "../../core/index.js";
+import { RuntimeBattleState } from "../rules.js";
+export declare const getActiveFighter: (player: PlayerBattleState) => BattleFighter;
+export declare const getOpponentAndSelf: (state: RuntimeBattleState, playerKey: "player1" | "player2") => {
+    self: BattleFighter;
+    opponent: BattleFighter;
+};
+export declare const getPlayersAndActives: (state: RuntimeBattleState, playerKey: "player1" | "player2") => {
+    selfPlayer: PlayerBattleState;
+    oppPlayer: PlayerBattleState;
+    self: BattleFighter;
+    opponent: BattleFighter;
+};

package/dist/engine/fighters/update.d.ts

@@ -0,0 +1,3 @@
+import { BattleFighter } from "../../core/index.js";
+import { RuntimeBattleState } from "../rules.js";
+export declare const updateFightersInState: (state: RuntimeBattleState, actingPlayerKey: "player1" | "player2", updatedSelf: BattleFighter, updatedOpponent: BattleFighter) => RuntimeBattleState;

package/dist/engine/index.d.ts

@@ -0,0 +1,12 @@
+export * from './debug.js';
+export * from './events.js';
+export * from './rng.js';
+export * from './rules.js';
+export * from './runtime.js';
+export * from './actions/index.js';
+export * from './combat/index.js';
+export * from './effects/index.js';
+export * from './fighters/index.js';
+export * from './status/index.js';
+export * from './events/index.js';
+export * from './turn/resolveTurn.js';

package/dist/engine/index.js

@@ -8,5 +8,5 @@ export * from './combat/index.js';
 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';
+export * from './turn/resolveTurn.js';

package/dist/engine/rng.d.ts

@@ -0,0 +1,2 @@
+export declare const randomInRange: (min: number, max: number) => number;
+export declare const chance: (probability: number) => boolean;

package/dist/engine/rules.d.ts

@@ -0,0 +1,6 @@
+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;
+}
+export declare const DEFAULT_RULES: BattleRules;

package/dist/engine/runtime.d.ts

@@ -0,0 +1,7 @@
+import { BattleState, FighterStats } from "../core/index.js";
+import { BattleConfig } from "./rules.js";
+export declare const buildMap: <T extends {
+    id: string;
+}>(list: T[]) => Record<string, T>;
+export declare const cloneStats: (stats: FighterStats) => FighterStats;
+export declare const createInitialBattleState: (config: BattleConfig) => BattleState;

package/dist/engine/status/apply.d.ts

@@ -0,0 +1,6 @@
+import { BattleEvent, BattleFighter, StatusId } from "../../core/index.js";
+import { RuntimeBattleState } from "../rules.js";
+export declare const applyStatusToFighter: (state: RuntimeBattleState, target: BattleFighter, statusId: StatusId) => {
+    updated: BattleFighter;
+    events: BattleEvent[];
+};

package/dist/engine/status/clear.d.ts

@@ -0,0 +1,6 @@
+import { BattleEvent, BattleFighter, ClearStatusEffect } from "../../core/index.js";
+import { RuntimeBattleState } from "../rules.js";
+export declare const clearStatusFromFighter: (state: RuntimeBattleState, target: BattleFighter, effect: ClearStatusEffect) => {
+    updated: BattleFighter;
+    events: BattleEvent[];
+};

package/dist/engine/status/endOfTurn.d.ts

@@ -0,0 +1,6 @@
+import { BattleEvent } from "../../core/index.js";
+import { RuntimeBattleState } from "../rules.js";
+export declare const applyEndOfTurnStatuses: (state: RuntimeBattleState) => {
+    state: RuntimeBattleState;
+    events: BattleEvent[];
+};

package/dist/engine/status/hardCc.d.ts

@@ -0,0 +1,3 @@
+import { BattleFighter } from "../../core/index.js";
+import { RuntimeBattleState } from "../rules.js";
+export declare const hasHardCc: (state: RuntimeBattleState, fighter: BattleFighter) => boolean;

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

@@ -0,0 +1,4 @@
+export * from './apply.js';
+export * from './clear.js';
+export * from './endOfTurn.js';
+export * from './hardCc.js';

package/dist/engine/turn/resolveTurn.d.ts

@@ -0,0 +1,5 @@
+import { BattleActions, BattleEvent, BattleState } from "../../core/index.js";
+export declare const resolveTurn: (state: BattleState, actions: BattleActions) => {
+    newState: BattleState;
+    events: BattleEvent[];
+};

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./core/index.js";
+export * from "./api/battle.js";
+export * from "./api/room.js";
+export * from "./api/socketTypes.js";
+export * from "./skins/CombatSkin.js";
+export * from "./engine/index.js";

package/dist/skins/CombatSkin.d.ts

@@ -0,0 +1,21 @@
+import type { TypeDefinition, TypeEffectivenessMatrix, MoveDefinition, ItemDefinition, AmuletDefinition, StatusDefinition } from "../core/index.js";
+import { PlayerBattleConfig } from "../engine/rules.js";
+export interface TeamFighterLoadout {
+    fighterId: string | null;
+    moveIds: string[];
+}
+export interface PlayerTeamLoadout {
+    fighters: TeamFighterLoadout[];
+    itemIds: string[];
+    amuletId: string | null;
+}
+export interface CombatSkin {
+    readonly id: string;
+    getTypes(): TypeDefinition[];
+    getTypeEffectiveness(): TypeEffectivenessMatrix;
+    getMoves(): MoveDefinition[];
+    getItems(): ItemDefinition[];
+    getAmulets(): AmuletDefinition[];
+    getStatuses(): StatusDefinition[];
+    buildPlayerConfig(loadout: PlayerTeamLoadout): PlayerBattleConfig;
+}

package/dist/skins/cliches/clicheSkin.d.ts

@@ -0,0 +1,14 @@
+import { ItemDefinition, MoveDefinition } from "../../core/index.js";
+import { PlayerBattleConfig } from "../../engine/rules.js";
+import type { CombatSkin, PlayerTeamLoadout } from "../CombatSkin.js";
+export declare class TribeSkin implements CombatSkin {
+    readonly id = "tribe";
+    getTypes(): import("../../index.js").TypeDefinition[];
+    getTypeEffectiveness(): import("../../index.js").TypeEffectivenessMatrix;
+    getMoves(): MoveDefinition[];
+    getItems(): ItemDefinition[];
+    getAmulets(): never[];
+    getStatuses(): import("../../index.js").StatusDefinition[];
+    buildPlayerConfig(loadout: PlayerTeamLoadout): PlayerBattleConfig;
+}
+export declare const createTribeSkin: () => CombatSkin;

package/dist/skins/cliches/fighters.d.ts

@@ -0,0 +1,2 @@
+import type { FighterDefinition } from "../../core/index.js";
+export declare const TRIBE_FIGHTERS: FighterDefinition[];

package/dist/skins/cliches/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./fighters.js";
+export * from "./moves.js";
+export * from "./clicheSkin.js";
+export * from "./statuses.js";
+export * from "./types.js";

package/dist/skins/cliches/items.d.ts

@@ -0,0 +1,2 @@
+import { ItemDefinition } from "../../core/index.js";
+export declare const POKEMON_ITEMS: ItemDefinition[];

package/dist/skins/cliches/moves.d.ts

@@ -0,0 +1,2 @@
+import type { MoveDefinition } from "../../core/index.js";
+export declare const TRIBE_MOVES: MoveDefinition[];

package/dist/skins/cliches/statuses.d.ts

@@ -0,0 +1,2 @@
+import type { StatusDefinition } from "../../core/index.js";
+export declare const TRIBE_STATUSES: StatusDefinition[];

package/dist/skins/cliches/types.d.ts

@@ -0,0 +1,13 @@
+import type { TypeDefinition, TypeEffectivenessMatrix, TypeId } from "../../core/index.js";
+export declare const TRIBE_TYPE_IDS: {
+    readonly canallita: "canallita";
+    readonly cayetano: "cayetano";
+    readonly perroflauta: "perroflauta";
+    readonly cryptobro: "cryptobro";
+    readonly cunado: "cunado";
+    readonly gymbro: "gymbro";
+};
+export type TribeTypeId = (typeof TRIBE_TYPE_IDS)[keyof typeof TRIBE_TYPE_IDS];
+export declare const TRIBE_TYPES: TypeDefinition[];
+export declare const TRIBE_TYPE_MATRIX: TypeEffectivenessMatrix;
+export declare const getTribeTypeEffectiveness: (attackerTypeId: TypeId, defenderTypeId: TypeId) => number;

package/dist/skins/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./pokemon/index.js";
+export * from "./cliches/index.js";
+export * from "./CombatSkin.js";

package/dist/skins/pokemon/fighters.d.ts

@@ -0,0 +1,2 @@
+import type { FighterDefinition } from "../../core/index.js";
+export declare const POKEMON_FIGHTERS: FighterDefinition[];

package/dist/skins/pokemon/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./fighters.js";
+export * from "./items.js";
+export * from "./moves.js";
+export * from "./pokemonSkin.js";
+export * from "./statuses.js";
+export * from "./types.js";

package/dist/skins/pokemon/items.d.ts

@@ -0,0 +1,2 @@
+import { ItemDefinition } from "../../core/index.js";
+export declare const POKEMON_ITEMS: ItemDefinition[];

package/dist/skins/pokemon/moves.d.ts

@@ -0,0 +1,2 @@
+import type { MoveDefinition } from "../../core/index.js";
+export declare const POKEMON_MOVES: MoveDefinition[];

package/dist/skins/pokemon/pokemonSkin.d.ts

@@ -0,0 +1,14 @@
+import { ItemDefinition, MoveDefinition } from "../../core/index.js";
+import { PlayerBattleConfig } from "../../engine/rules.js";
+import type { CombatSkin, PlayerTeamLoadout } from "../CombatSkin.js";
+export declare class PokemonSkin implements CombatSkin {
+    readonly id = "pokemon";
+    getTypes(): import("../../index.js").TypeDefinition[];
+    getTypeEffectiveness(): import("../../index.js").TypeEffectivenessMatrix;
+    getMoves(): MoveDefinition[];
+    getItems(): ItemDefinition[];
+    getAmulets(): never[];
+    getStatuses(): import("../../index.js").StatusDefinition[];
+    buildPlayerConfig(loadout: PlayerTeamLoadout): PlayerBattleConfig;
+}
+export declare const createPokemonSkin: () => CombatSkin;

package/dist/skins/pokemon/statuses.d.ts

@@ -0,0 +1,2 @@
+import type { StatusDefinition } from "../../core/index.js";
+export declare const POKEMON_STATUSES: StatusDefinition[];

package/dist/skins/pokemon/types.d.ts

@@ -0,0 +1,13 @@
+import type { TypeDefinition, TypeEffectivenessMatrix, TypeId } from "../../core/index.js";
+export declare const POKEMON_TYPE_IDS: {
+    readonly fire: "fire";
+    readonly water: "water";
+    readonly grass: "grass";
+    readonly electric: "electric";
+    readonly psychic: "psychic";
+    readonly rock: "rock";
+};
+export type PokemonTypeId = (typeof POKEMON_TYPE_IDS)[keyof typeof POKEMON_TYPE_IDS];
+export declare const POKEMON_TYPES: TypeDefinition[];
+export declare const POKEMON_TYPE_MATRIX: TypeEffectivenessMatrix;
+export declare const getPokemonTypeEffectiveness: (attackerTypeId: TypeId, defenderTypeId: TypeId) => number;

package/package.json

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