pokemon-io-core 0.0.82 → 0.0.84

package/dist/engine/debug.js

@@ -0,0 +1,6 @@
+const DEBUG_BATTLE = true;
+export const dbg = (...args) => {
+    if (!DEBUG_BATTLE)
+        return;
+    console.log("[BATTLE]", ...args);
+};

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

@@ -0,0 +1,7 @@
+import { BattleEvent, BattleFighter, EffectDefinition, TypeId } from "../../core";
+import { RuntimeBattleState } from "../rules";
+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/applyEffects.js

@@ -0,0 +1,103 @@
+import { applyDamageToFighter, computeDamage } from "../combat/damage";
+import { applyHealToFighter } from "../combat/heal";
+import { dbg } from "../debug";
+import { applyStatusToFighter } from "../status/apply";
+import { clearStatusFromFighter } from "../status/clear";
+import { resolveEffectTarget } from "./target";
+export const applyEffectsOnTarget = (state, actor, target, moveTypeId, isCritical, effects) => {
+    dbg("applyEffectsOnTarget", {
+        actorId: actor.fighterId,
+        targetId: target.fighterId,
+        moveTypeId,
+        isCritical,
+        effects,
+    });
+    let currentActor = actor;
+    let currentTarget = target;
+    const events = [];
+    dbg("APPLY_EFFECTS_START", {
+        actorId: actor.fighterId,
+        targetId: target.fighterId,
+        moveTypeId,
+        isCritical,
+        effectsCount: effects?.length ?? 0,
+    });
+    for (const eff of effects) {
+        dbg("EFFECT_LOOP", eff);
+        switch (eff.kind) {
+            case "heal": {
+                dbg("EFFECT_HEAL_START", {
+                    amount: eff.amount,
+                    targetDefault: eff.target,
+                });
+                const { primary, isSelf } = resolveEffectTarget(eff, currentActor, currentTarget);
+                const res = applyHealToFighter(state, primary, eff.amount, actor.fighterId);
+                if (isSelf)
+                    currentActor = res.updated;
+                else
+                    currentTarget = res.updated;
+                events.push(...res.events);
+                break;
+            }
+            case "apply_status": {
+                dbg("EFFECT_APPLY_STATUS_START", {
+                    statusId: eff.statusId,
+                    targetDefault: eff.target,
+                });
+                const { primary, isSelf } = resolveEffectTarget(eff, currentActor, currentTarget);
+                const res = applyStatusToFighter(state, primary, eff.statusId);
+                if (isSelf)
+                    currentActor = res.updated;
+                else
+                    currentTarget = res.updated;
+                events.push(...res.events);
+                break;
+            }
+            case "clear_status": {
+                dbg("debemos eliminar status");
+                const { primary, isSelf } = resolveEffectTarget(eff, currentActor, currentTarget);
+                const res = clearStatusFromFighter(state, primary, eff);
+                if (isSelf)
+                    currentActor = res.updated;
+                else
+                    currentTarget = res.updated;
+                events.push(...res.events);
+                break;
+            }
+            case "damage": {
+                dbg("debemos hacer daño");
+                const { primary, isSelf } = resolveEffectTarget(eff, currentActor, currentTarget);
+                let totalDamage = 0;
+                // Daño de fórmula (stats + tipo + crit…)
+                if (eff.basePower && moveTypeId) {
+                    const { damage } = computeDamage({
+                        state,
+                        attacker: currentActor,
+                        defender: primary,
+                        moveTypeId,
+                        basePower: eff.basePower,
+                        isCritical,
+                    });
+                    totalDamage += damage;
+                }
+                // Daño plano adicional
+                if (eff.flatAmount && eff.flatAmount > 0) {
+                    totalDamage += eff.flatAmount;
+                }
+                if (totalDamage > 0) {
+                    const res = applyDamageToFighter(state, primary, totalDamage, currentActor.fighterId, isCritical);
+                    if (isSelf)
+                        currentActor = res.updatedDefender;
+                    else
+                        currentTarget = res.updatedDefender;
+                    events.push(...res.events);
+                }
+                break;
+            }
+            // TODO: conectar shield, modify_stats, etc.
+            default:
+                break;
+        }
+    }
+    return { actor: currentActor, target: currentTarget, events };
+};

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

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

package/dist/engine/effects/index.js

@@ -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";
+export declare const defaultTargetForKind: (kind: EffectKind) => EffectTarget;
+export declare const resolveEffectTarget: (eff: EffectDefinition, actor: BattleFighter, target: BattleFighter) => {
+    primary: BattleFighter;
+    isSelf: boolean;
+};

package/dist/engine/effects/target.js

@@ -0,0 +1,26 @@
+export const defaultTargetForKind = (kind) => {
+    switch (kind) {
+        case "damage":
+        case "apply_status":
+            return "enemy";
+        case "heal":
+        case "clear_status":
+        case "modify_stats":
+        case "modify_hit_chance":
+        case "modify_crit_chance":
+        case "modify_priority":
+        case "modify_effective_speed":
+        case "shield":
+            return "self";
+        default:
+            return "self";
+    }
+};
+export const resolveEffectTarget = (eff, actor, target) => {
+    const t = eff.target ?? defaultTargetForKind(eff.kind);
+    const isSelf = t === "self";
+    return {
+        primary: isSelf ? actor : target,
+        isSelf,
+    };
+};

package/dist/engine/engine.d.ts

@@ -0,0 +1,53 @@
+import { type BattleState, type FighterDefinition, type MoveDefinition, type ItemDefinition, type AmuletDefinition, type StatusDefinition, type TypeDefinition, type TypeEffectivenessMatrix, type BattleActions, type BattleEvent, type MoveId, type ItemId, type StatusId, type TypeId } from "../core/index.js";
+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>;
+}
+export interface RuntimeBattleState extends BattleState {
+    runtime: BattleRuntime;
+}
+export declare const createInitialBattleState: (config: BattleConfig) => BattleState;
+export declare const applyForcedSwitchChoice: (state: BattleState, targetPlayer: "player1" | "player2", newIndex: number) => {
+    state: BattleState;
+    events: BattleEvent[];
+};
+export declare const resolveTurn: (state: BattleState, actions: BattleActions) => {
+    newState: BattleState;
+    events: BattleEvent[];
+};
+export {};