pokemon-io-core 0.0.125 → 0.0.126

package/dist/core/ids.d.ts

@@ -1,6 +1,18 @@
-export type TypeId = string;
-export type FighterId = string;
-export type MoveId = string;
-export type ItemId = string;
-export type AmuletId = string;
-export type StatusId = string;
+declare const __brand: unique symbol;
+type Brand<T, TBrand extends string> = T & {
+    [__brand]: TBrand;
+};
+export type TypeId = Brand<string, 'TypeId'>;
+export type FighterId = Brand<string, 'FighterId'>;
+export type MoveId = Brand<string, 'MoveId'>;
+export type ItemId = Brand<string, 'ItemId'>;
+export type AmuletId = Brand<string, 'AmuletId'>;
+export type StatusId = Brand<string, 'StatusId'>;
+export declare const typeId: (id: string) => TypeId;
+export declare const fighterId: (id: string) => FighterId;
+export declare const moveId: (id: string) => MoveId;
+export declare const itemId: (id: string) => ItemId;
+export declare const amuletId: (id: string) => AmuletId;
+export declare const statusId: (id: string) => StatusId;
+export declare const SYSTEM_FIGHTER_ID: FighterId;
+export {};

package/dist/core/ids.js

@@ -1 +1,10 @@
-export {};
+// Helper functions to create branded IDs
+// Use these when defining data to get type safety
+export const typeId = (id) => id;
+export const fighterId = (id) => id;
+export const moveId = (id) => id;
+export const itemId = (id) => id;
+export const amuletId = (id) => id;
+export const statusId = (id) => id;
+// Special system IDs for events not caused by fighters
+export const SYSTEM_FIGHTER_ID = fighterId("__system__");

package/dist/core/index.d.ts

@@ -1,6 +1,6 @@
 export * from "./actions.js";
 export * from "./randomEvents.js";
-export { CORE_RANDOM_EVENTS, POKEMON_RANDOM_EVENTS } from "./randomEventsList.js";
+export { CORE_RANDOM_EVENTS, POKEMON_RANDOM_EVENTS, TRIBES_RANDOM_EVENTS, getRandomEventsForSkin } from "./randomEventsList.js";
 export * from "./emotes.js";
 export * from "./events.js";
 export * from "./events.js";
@@ -14,3 +14,4 @@ export * from "./battleRuntime.js";
 export * from "./battleState.js";
 export * from "./amulets.js";
 export * from "./types.js";
+export * from "./validation.js";

package/dist/core/index.js

@@ -1,6 +1,6 @@
 export * from "./actions.js";
 export * from "./randomEvents.js";
-export { CORE_RANDOM_EVENTS, POKEMON_RANDOM_EVENTS } from "./randomEventsList.js";
+export { CORE_RANDOM_EVENTS, POKEMON_RANDOM_EVENTS, TRIBES_RANDOM_EVENTS, getRandomEventsForSkin } from "./randomEventsList.js";
 export * from "./emotes.js";
 export * from "./events.js";
 export * from "./events.js";
@@ -14,3 +14,4 @@ export * from "./battleRuntime.js";
 export * from "./battleState.js";
 export * from "./amulets.js";
 export * from "./types.js";
+export * from "./validation.js";

package/dist/core/randomEvents.d.ts

@@ -1,10 +1,26 @@
+import { StatusId } from "./ids";
 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 type EventCondition = {
+    type: "has_item";
+} | {
+    type: "hp_below_percent";
+    value: number;
+} | {
+    type: "hp_above_percent";
+    value: number;
+} | {
+    type: "fighter_type";
+    value: string | string[];
+} | {
+    type: "has_status";
+} | {
+    type: "stat_stage_above";
+    value: number;
+} | {
+    type: "always";
+};
 export interface RandomEventEffect {
     effectType: EventEffectType;
     target: EventTarget;
@@ -12,7 +28,7 @@ export interface RandomEventEffect {
     percentValue?: number;
     statType?: "offense" | "defense" | "speed" | "crit" | "accuracy" | "evasion";
     statChange?: number;
-    statusId?: string;
+    statusId?: StatusId;
     statusDuration?: number;
     randomChoices?: RandomEventEffect[];
 }

package/dist/core/randomEvents.js

@@ -1,8 +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,
+    common: 45,
+    rare: 30,
+    epic: 15,
+    legendary: 10,
 };

package/dist/core/randomEventsList.d.ts

@@ -1,11 +1,17 @@
 import type { RandomEventDefinition } from "./randomEvents.js";
 /**
  * CORE Random Events - Generic events that work with any skin
- * Phase 1 + Phase 2: 9 total CORE events
+ * These events only use damage/heal effects and stat changes
+ * They don't reference any skin-specific types, statuses, or items
  */
 export declare const CORE_RANDOM_EVENTS: RandomEventDefinition[];
+export { POKEMON_RANDOM_EVENTS } from "../skins/pokemon/randomEvents.js";
+export { TRIBES_RANDOM_EVENTS } from "../skins/cliches/randomEvents.js";
 /**
- * POKEMON-SPECIFIC Random Events
- * These only appear when using the Pokemon skin
+ * Get all random events for a specific skin
+ * Combines core events with skin-specific events
+ *
+ * @param skinId - The ID of the skin (e.g., "pokemon", "tribes")
+ * @returns Array of all available random events for that skin
  */
-export declare const POKEMON_RANDOM_EVENTS: RandomEventDefinition[];
+export declare function getRandomEventsForSkin(skinId: string): RandomEventDefinition[];

package/dist/core/randomEventsList.js

@@ -1,7 +1,10 @@
 // @pokemon-io/combat-core/src/core/randomEventsList.ts
+import { POKEMON_RANDOM_EVENTS } from "../skins/pokemon/randomEvents.js";
+import { TRIBES_RANDOM_EVENTS } from "../skins/cliches/randomEvents.js";
 /**
  * CORE Random Events - Generic events that work with any skin
- * Phase 1 + Phase 2: 9 total CORE events
+ * These events only use damage/heal effects and stat changes
+ * They don't reference any skin-specific types, statuses, or items
  */
 export const CORE_RANDOM_EVENTS = [
     // ==================== COMMON (4 events) ====================
@@ -162,167 +165,25 @@ export const CORE_RANDOM_EVENTS = [
         ],
     },
 ];
+// Export skin-specific events
+export { POKEMON_RANDOM_EVENTS } from "../skins/pokemon/randomEvents.js";
+export { TRIBES_RANDOM_EVENTS } from "../skins/cliches/randomEvents.js";
 /**
- * POKEMON-SPECIFIC Random Events
- * These only appear when using the Pokemon skin
+ * Get all random events for a specific skin
+ * Combines core events with skin-specific events
+ *
+ * @param skinId - The ID of the skin (e.g., "pokemon", "tribes")
+ * @returns Array of all available random events for that 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.",
-        narration: ["¡Suena una música familiar!", "¡La Enfermera Joy ha venido a ayudar!"],
-        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.",
-        narration: ["¡Prepárense para los problemas!", "¡Y más vale que teman!"],
-        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.",
-        narration: ["¡Un objeto brillante aparece!", "¡Es un Caramelo Raro!"],
-        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.",
-        narration: ["¡El viento empieza a soplar con fuerza!", "¡Una tormenta de arena azota el combate!"],
-        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!",
-        narration: ["¡Un mensaje del laboratorio!", "¡El Profesor Oak envía sus ánimos!"],
-        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.",
-        narration: ["¡Una extraña piedra emite luz!", "¡El poder de la Piedra Alba se manifiesta!"],
-        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.",
-        narration: ["¡Empieza a llover... ¿medicina?!", "¡Una lluvia de pociones cubre el estadio!"],
-        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.",
-        narration: ["¡UNA PRESENCIA ABRUMADORA SE SIENTE!", "¡Un Pokémon Legendario observa el combate!"],
-        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.",
-        narration: ["¡Un cristal amarillo brilla con intensidad!", "¡El poder del Revivir Máximo restaura la energía!"],
-        rarity: "epic",
-        effects: [
-            {
-                effectType: "heal_percent",
-                target: "random_one", // TODO: Cambiar a "lowest_hp" cuando se implemente
-                percentValue: 30,
-            },
-        ],
-    },
-];
+export function getRandomEventsForSkin(skinId) {
+    const coreEvents = CORE_RANDOM_EVENTS;
+    switch (skinId) {
+        case "pokemon":
+            return [...coreEvents, ...POKEMON_RANDOM_EVENTS];
+        case "tribes":
+            return [...coreEvents, ...TRIBES_RANDOM_EVENTS];
+        default:
+            // For unknown skins, return only core events
+            return coreEvents;
+    }
+}

package/dist/core/status.d.ts

@@ -5,6 +5,7 @@ export interface StatusDefinition {
     id: StatusId;
     name: string;
     kind: StatusKind;
+    color?: string;
     minDurationTurns: number;
     maxDurationTurns: number;
     effectsPerStack: EffectDefinition[];

package/dist/core/validation.d.ts

@@ -0,0 +1,21 @@
+import type { CombatSkin } from "../skins/CombatSkin.js";
+export declare class SkinValidationError extends Error {
+    skinId: string;
+    entityType: string;
+    entityId: string;
+    issue: string;
+    constructor(skinId: string, entityType: string, entityId: string, issue: string);
+}
+export interface ValidationResult {
+    valid: boolean;
+    errors: SkinValidationError[];
+    warnings: string[];
+}
+export declare class SkinValidator {
+    validate(skin: CombatSkin): ValidationResult;
+    private validateFighters;
+    private validateMoves;
+    private validateStatuses;
+    private validateTypeEffectiveness;
+    private checkDuplicates;
+}

package/dist/core/validation.js

@@ -0,0 +1,183 @@
+export class SkinValidationError extends Error {
+    skinId;
+    entityType;
+    entityId;
+    issue;
+    constructor(skinId, entityType, entityId, issue) {
+        super(`[${skinId}] ${entityType} "${entityId}": ${issue}`);
+        this.skinId = skinId;
+        this.entityType = entityType;
+        this.entityId = entityId;
+        this.issue = issue;
+        this.name = 'SkinValidationError';
+    }
+}
+export class SkinValidator {
+    validate(skin) {
+        const errors = [];
+        const warnings = [];
+        const types = skin.getTypes();
+        const moves = skin.getMoves();
+        const fighters = skin.getFighters ? skin.getFighters() : [];
+        const statuses = skin.getStatuses();
+        const items = skin.getItems();
+        // Create sets for fast lookups
+        const typeIds = new Set(types.map((t) => t.id));
+        const moveIds = new Set(moves.map((m) => m.id));
+        const fighterIds = new Set(fighters.map((f) => f.id));
+        const statusIds = new Set(statuses.map((s) => s.id));
+        const itemIds = new Set(items.map((i) => i.id));
+        // Validate fighters
+        this.validateFighters(skin.id, fighters, typeIds, moveIds, itemIds, errors);
+        // Validate moves
+        this.validateMoves(skin.id, moves, typeIds, statusIds, fighterIds, errors);
+        // Validate statuses
+        this.validateStatuses(skin.id, statuses, errors);
+        // Validate type effectiveness matrix
+        this.validateTypeEffectiveness(skin.id, types, skin.getTypeEffectiveness(), warnings);
+        // Check for duplicate IDs
+        this.checkDuplicates('Type', types.map((t) => t.id), skin.id, errors);
+        this.checkDuplicates('Fighter', fighters.map((f) => f.id), skin.id, errors);
+        this.checkDuplicates('Move', moves.map((m) => m.id), skin.id, errors);
+        this.checkDuplicates('Status', statuses.map((s) => s.id), skin.id, errors);
+        this.checkDuplicates('Item', items.map((i) => i.id), skin.id, errors);
+        return {
+            valid: errors.length === 0,
+            errors,
+            warnings
+        };
+    }
+    validateFighters(skinId, fighters, typeIds, moveIds, itemIds, errors) {
+        for (const fighter of fighters) {
+            // Validate types
+            if (!fighter.classIds || fighter.classIds.length === 0) {
+                errors.push(new SkinValidationError(skinId, 'Fighter', fighter.id, 'Must have at least one type'));
+            }
+            else {
+                for (const typeId of fighter.classIds) {
+                    if (!typeIds.has(typeId)) {
+                        errors.push(new SkinValidationError(skinId, 'Fighter', fighter.id, `Invalid type "${typeId}"`));
+                    }
+                }
+            }
+            // Validate recommended moves
+            if (fighter.recommendedMoves) {
+                for (const moveId of fighter.recommendedMoves) {
+                    if (!moveIds.has(moveId)) {
+                        errors.push(new SkinValidationError(skinId, 'Fighter', fighter.id, `Invalid recommended move "${moveId}"`));
+                    }
+                }
+            }
+            // Validate recommended items
+            if (fighter.recommendedItems) {
+                for (const itemId of fighter.recommendedItems) {
+                    if (!itemIds.has(itemId)) {
+                        errors.push(new SkinValidationError(skinId, 'Fighter', fighter.id, `Invalid recommended item "${itemId}"`));
+                    }
+                }
+            }
+            // Validate base stats
+            if (!fighter.baseStats) {
+                errors.push(new SkinValidationError(skinId, 'Fighter', fighter.id, 'Missing base stats'));
+            }
+            else {
+                const { offense, defense, speed, crit } = fighter.baseStats;
+                if (offense < 0 || defense < 0 || speed < 0 || crit < 0) {
+                    errors.push(new SkinValidationError(skinId, 'Fighter', fighter.id, 'Stats cannot be negative'));
+                }
+            }
+        }
+    }
+    validateMoves(skinId, moves, typeIds, statusIds, fighterIds, errors) {
+        for (const move of moves) {
+            // Validate type
+            if (!typeIds.has(move.typeId)) {
+                errors.push(new SkinValidationError(skinId, 'Move', move.id, `Invalid type "${move.typeId}"`));
+            }
+            // Validate effects
+            if (!move.effects || move.effects.length === 0) {
+                errors.push(new SkinValidationError(skinId, 'Move', move.id, 'Must have at least one effect'));
+            }
+            else {
+                for (let i = 0; i < move.effects.length; i++) {
+                    const effect = move.effects[i];
+                    // Validate apply_status effects
+                    if (effect.kind === 'apply_status' && effect.statusId) {
+                        if (!statusIds.has(effect.statusId)) {
+                            errors.push(new SkinValidationError(skinId, 'Move', move.id, `Invalid status "${effect.statusId}" in effect ${i + 1}`));
+                        }
+                    }
+                    // Validate clear_status effects
+                    if (effect.kind === 'clear_status' && effect.statusIds) {
+                        for (const statusId of effect.statusIds) {
+                            if (!statusIds.has(statusId)) {
+                                errors.push(new SkinValidationError(skinId, 'Move', move.id, `Invalid status "${statusId}" in clear_status effect`));
+                            }
+                        }
+                    }
+                }
+            }
+            // Validate onlyForFighterIds
+            if (move.onlyForFighterIds) {
+                for (const fighterId of move.onlyForFighterIds) {
+                    if (!fighterIds.has(fighterId)) {
+                        errors.push(new SkinValidationError(skinId, 'Move', move.id, `Invalid fighter restriction "${fighterId}"`));
+                    }
+                }
+            }
+            // Validate accuracy
+            if (move.accuracy !== undefined && (move.accuracy < 0 || move.accuracy > 100)) {
+                errors.push(new SkinValidationError(skinId, 'Move', move.id, `Accuracy must be between 0 and 100, got ${move.accuracy}`));
+            }
+            // Validate maxPP
+            if (move.maxPP <= 0) {
+                errors.push(new SkinValidationError(skinId, 'Move', move.id, `maxPP must be positive, got ${move.maxPP}`));
+            }
+        }
+    }
+    validateStatuses(skinId, statuses, errors) {
+        for (const status of statuses) {
+            // Validate duration
+            if (status.minDurationTurns < 0) {
+                errors.push(new SkinValidationError(skinId, 'Status', status.id, `minDurationTurns cannot be negative`));
+            }
+            if (status.maxDurationTurns < status.minDurationTurns) {
+                errors.push(new SkinValidationError(skinId, 'Status', status.id, `maxDurationTurns (${status.maxDurationTurns}) must be >= minDurationTurns (${status.minDurationTurns})`));
+            }
+            // Validate kind
+            if (status.kind !== 'hard_cc' && status.kind !== 'soft') {
+                errors.push(new SkinValidationError(skinId, 'Status', status.id, `Invalid kind "${status.kind}", must be "hard_cc" or "soft"`));
+            }
+        }
+    }
+    validateTypeEffectiveness(skinId, types, effectiveness, warnings) {
+        for (const attackerType of types) {
+            if (!effectiveness[attackerType.id]) {
+                warnings.push(`Type "${attackerType.id}" missing from effectiveness matrix`);
+                continue;
+            }
+            for (const defenderType of types) {
+                const value = effectiveness[attackerType.id][defenderType.id];
+                if (value === undefined) {
+                    warnings.push(`Missing effectiveness: ${attackerType.id} vs ${defenderType.id}`);
+                }
+                else if (![0, 0.8, 0.9, 1, 1.1, 1.2].includes(value)) {
+                    warnings.push(`Unusual effectiveness value ${value} for ${attackerType.id} vs ${defenderType.id}`);
+                }
+            }
+        }
+    }
+    checkDuplicates(entityType, ids, skinId, errors) {
+        const seen = new Set();
+        const duplicates = new Set();
+        for (const id of ids) {
+            if (seen.has(id)) {
+                duplicates.add(id);
+            }
+            seen.add(id);
+        }
+        for (const duplicate of duplicates) {
+            errors.push(new SkinValidationError(skinId, entityType, duplicate, `Duplicate ID found`));
+        }
+    }
+}

package/dist/engine/combat/damage.js

@@ -1,3 +1,4 @@
+import { TRIBE_STATUS_IDS } from "../../skins/cliches/constants.js";
 import { dbg } from "../debug.js";
 import { createBaseEvent } from "../events.js";
 import { randomInRange } from "../rng.js";
@@ -63,7 +64,7 @@ export const applyDamageToFighter = (state, defender, amount, actorId, isCritica
         events.push({
             ...createBaseEvent(state.turnNumber, "status_cleared", `${defender.fighterId} se despierta por el golpe`),
             targetId: defender.fighterId,
-            statusIds: ["sleep"],
+            statusIds: [TRIBE_STATUS_IDS.SLEEP],
         });
     }
     events.push({

package/dist/engine/events/applyRandomEvent.js

@@ -1,3 +1,4 @@
+import { SYSTEM_FIGHTER_ID } from "../../core/ids.js";
 import { applyStatusToFighter } from "../status/apply.js";
 import { applyDamageToFighter } from "../combat/damage.js";
 import { applyHealToFighter } from "../combat/heal.js";
@@ -93,10 +94,17 @@ const checkCondition = (fighter, condition) => {
             const maxHp2 = fighter.baseStats.offense + fighter.baseStats.defense;
             const hpPercent2 = (fighter.currentHp / maxHp2) * 100;
             return hpPercent2 > condition.value;
-        case "fighter_type":
-            if (typeof condition.value !== "string")
+        case "fighter_type": {
+            const { value } = condition;
+            if (!value)
                 return false;
-            return fighter.classIds.includes(condition.value);
+            // Handle array of types (fighter matches if it has ANY of the types)
+            if (Array.isArray(value)) {
+                return value.some(typeId => fighter.classIds.includes(typeId));
+            }
+            // Handle single type
+            return fighter.classIds.includes(value);
+        }
         case "has_status":
             return fighter.statuses && fighter.statuses.length > 0;
         case "stat_stage_above":
@@ -120,8 +128,7 @@ 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));
-                const res = applyDamageToFighter(state, updatedFighter, damage, "random_event", // attackerId for log
-                false);
+                const res = applyDamageToFighter(state, updatedFighter, damage, SYSTEM_FIGHTER_ID, false);
                 updatedFighter = res.updatedDefender;
                 events.push(...res.events);
             }
@@ -130,7 +137,7 @@ const applySingleEffectToFighter = (state, playerKey, fighter, effect) => {
             if (effect.percentValue) {
                 const maxHp = fighter.baseStats.offense + fighter.baseStats.defense;
                 const healAmount = Math.floor(maxHp * (effect.percentValue / 100));
-                const res = applyHealToFighter(state, updatedFighter, healAmount, "random_event");
+                const res = applyHealToFighter(state, updatedFighter, healAmount, SYSTEM_FIGHTER_ID);
                 updatedFighter = res.updated;
                 events.push(...res.events);
             }

package/dist/engine/turn/resolveTurn.js

@@ -13,6 +13,7 @@ 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";
+import { TRIBE_STATUS_IDS } from "../../skins/cliches/constants.js";
 // ------------------------------------------------------
 // Helpers KO -> forced switch (estilo Pokémon real)
 // ------------------------------------------------------
@@ -153,7 +154,7 @@ export const resolveTurn = (state, actions) => {
             events.push({
                 ...createBaseEvent(currentState.turnNumber, "action_skipped_hard_cc", `${self.fighterId} está paralizado y no puede moverse`),
                 actorId: self.fighterId,
-                statusId: "paralysis",
+                statusId: TRIBE_STATUS_IDS.PARALYSIS,
             });
             continue;
         }
@@ -190,7 +191,7 @@ export const resolveTurn = (state, actions) => {
                     freeze: `${self.fighterId} está congelado y no puede actuar`,
                     flinch: `${self.fighterId} se acobarda y no puede atacar`,
                 };
-                const statusId = ccStatus?.statusId || "unknown";
+                const statusId = ccStatus?.statusId || TRIBE_STATUS_IDS.SLEEP;
                 const message = statusMessages[statusId] ||
                     `${self.fighterId} no puede actuar por control total`;
                 events.push({

package/dist/skins/CombatSkin.d.ts

@@ -13,6 +13,7 @@ export interface CombatSkin {
     readonly id: string;
     getTypes(): TypeDefinition[];
     getTypeEffectiveness(): TypeEffectivenessMatrix;
+    getFighters(): any[];
     getMoves(): MoveDefinition[];
     getItems(): ItemDefinition[];
     getAmulets(): AmuletDefinition[];

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

@@ -1,9 +1,10 @@
-import { ItemDefinition, MoveDefinition } from "../../core/index.js";
+import { FighterDefinition, 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[];
+    getFighters(): FighterDefinition[];
     getTypeEffectiveness(): import("../../index.js").TypeEffectivenessMatrix;
     getMoves(): MoveDefinition[];
     getItems(): ItemDefinition[];