hrbattle 0.1.0

package/dist/battle/skillEngine.d.ts

@@ -0,0 +1,36 @@
+import type { BattleScriptApi, ElementType, ISkillScript, ScriptRuntimeContext, SkillDefinition, SkillResult, SkillTemplate, TriggerContext, UnitModel } from "./types";
+import { SeedRng } from "./random";
+interface SkillEngineDeps {
+    rng: SeedRng;
+    getUnits: () => UnitModel[];
+    applyDamage: (sourceId: string, targetId: string, value: number, staggerElement?: ElementType) => number;
+    applyHeal: (targetId: string, value: number) => number;
+    applyShield: (targetId: string, value: number) => number;
+    applyBuff: (sourceId: string, targetId: string, buffId: string) => void;
+    getEffectiveStats: (unit: UnitModel) => UnitModel["stats"];
+    createScriptApi: (skillElement: ElementType) => BattleScriptApi;
+}
+export declare class ScriptSkillEngine {
+    private scripts;
+    registerScript(scriptId: string, script: ISkillScript): void;
+    cast(scriptId: string, ctx: ScriptRuntimeContext): SkillResult;
+}
+export declare class ConfigSkillEngine {
+    private templates;
+    private normalizeSkillLevel;
+    private getLevelIndex;
+    private resolveLevelValue;
+    private resolveStepRatio;
+    private resolveStepFlat;
+    private resolveStepFixedProb;
+    private resolveBuffApplyProb;
+    registerTemplates(templates: SkillTemplate[]): void;
+    cast(skill: SkillDefinition, caster: UnitModel, deps: SkillEngineDeps, selectedTargets?: UnitModel[]): SkillResult;
+}
+export declare class SkillExecutor {
+    private readonly configEngine;
+    private readonly scriptEngine;
+    constructor(configEngine: ConfigSkillEngine, scriptEngine: ScriptSkillEngine);
+    execute(skill: SkillDefinition, caster: UnitModel, deps: SkillEngineDeps, trigger: SkillResult["triggeredBy"], triggerCtx?: TriggerContext, selectedTargetsOverride?: UnitModel[]): SkillResult;
+}
+export {};

package/dist/battle/skillEngine.js

@@ -0,0 +1,246 @@
+import { calcDamage, calcEffectProbability, calcHealOrShield } from "./formula";
+import { selectTargets } from "./targeting";
+export class ScriptSkillEngine {
+    scripts = new Map();
+    registerScript(scriptId, script) {
+        this.scripts.set(scriptId, script);
+    }
+    cast(scriptId, ctx) {
+        const script = this.scripts.get(scriptId);
+        if (!script) {
+            return {
+                skillId: ctx.skillId,
+                casterId: ctx.caster,
+                targets: ctx.targets,
+                totalDamage: 0,
+                totalHeal: 0,
+                totalShield: 0,
+                triggeredBy: "normal",
+                hits: []
+            };
+        }
+        script.onPreCast?.(ctx);
+        const result = script.onCast(ctx);
+        script.onPostCast?.(ctx, result);
+        return result;
+    }
+}
+export class ConfigSkillEngine {
+    templates = new Map();
+    normalizeSkillLevel(level) {
+        return Math.max(1, Math.floor(level ?? 1));
+    }
+    getLevelIndex(skillLevel) {
+        return Math.max(0, this.normalizeSkillLevel(skillLevel) - 1);
+    }
+    resolveLevelValue(values, fallback, skillLevel) {
+        if (!values || values.length === 0) {
+            return fallback;
+        }
+        const levelIndex = this.getLevelIndex(skillLevel);
+        const clampedIndex = Math.min(levelIndex, values.length - 1);
+        return values[clampedIndex] ?? fallback;
+    }
+    resolveStepRatio(step, skillLevel) {
+        return this.resolveLevelValue(step.ratioByLevel, step.ratio, skillLevel);
+    }
+    resolveStepFlat(step, skillLevel) {
+        return this.resolveLevelValue(step.flatByLevel, step.flat ?? 0, skillLevel);
+    }
+    resolveStepFixedProb(step, skillLevel) {
+        if (step.fixedProbByLevel && step.fixedProbByLevel.length > 0) {
+            return this.resolveLevelValue(step.fixedProbByLevel, step.fixedProb ?? 10000, skillLevel);
+        }
+        return step.fixedProb;
+    }
+    resolveBuffApplyProb(stepFixedProb, skill, skillLevel) {
+        const levelParams = skill.levelParams ?? {};
+        const baseProb = stepFixedProb ?? 10000;
+        const probDeltaPerLevel = levelParams.effectProbDeltaPerLevel ?? 0;
+        return baseProb + Math.max(0, skillLevel - 1) * probDeltaPerLevel;
+    }
+    registerTemplates(templates) {
+        for (const template of templates) {
+            this.templates.set(template.id, template);
+        }
+    }
+    cast(skill, caster, deps, selectedTargets) {
+        const template = skill.configTemplateId ? this.templates.get(skill.configTemplateId) : undefined;
+        if (!template) {
+            return {
+                skillId: skill.id,
+                casterId: caster.id,
+                targets: [],
+                totalDamage: 0,
+                totalHeal: 0,
+                totalShield: 0,
+                triggeredBy: "normal",
+                hits: []
+            };
+        }
+        const units = deps.getUnits();
+        const targets = selectedTargets ?? selectTargets(skill.targetRule, caster, units, deps.rng);
+        let totalDamage = 0;
+        let totalHeal = 0;
+        let totalShield = 0;
+        const skillLevel = this.normalizeSkillLevel(skill.level);
+        const hits = [];
+        for (const step of template.steps) {
+            const stepRatio = this.resolveStepRatio(step, skillLevel);
+            const stepFlat = this.resolveStepFlat(step, skillLevel);
+            const stepFixedProb = this.resolveStepFixedProb(step, skillLevel);
+            const repeat = Math.max(1, step.repeat ?? 1);
+            for (const target of targets) {
+                if (!target.runtime.alive) {
+                    continue;
+                }
+                for (let i = 0; i < repeat; i++) {
+                    const scaleStat = step.scaleStat ?? "Att";
+                    const effectiveCaster = deps.getEffectiveStats(caster);
+                    const effectiveTarget = deps.getEffectiveStats(target);
+                    const baseScale = effectiveCaster[scaleStat];
+                    const raw = Math.floor(baseScale * stepRatio + stepFlat);
+                    if (step.kind === "damage") {
+                        const shieldBefore = target.runtime.Shield;
+                        const damageRes = calcDamage({ ...caster, stats: effectiveCaster }, { ...target, stats: effectiveTarget }, raw, skill.type, skill.element, deps.rng);
+                        const done = deps.applyDamage(caster.id, target.id, damageRes.finalDam, skill.element);
+                        const shieldAbsorbed = Math.min(shieldBefore, damageRes.finalDam);
+                        totalDamage += done;
+                        hits.push({
+                            targetId: target.id,
+                            effectType: "damage",
+                            element: skill.element,
+                            skillType: skill.type,
+                            isCritical: damageRes.isCritical,
+                            baseValue: damageRes.baseDam,
+                            criticalValue: damageRes.critDam,
+                            finalValue: done,
+                            isRepression: damageRes.isRepression,
+                            damageBreakdown: {
+                                preMitigation: raw,
+                                postMitigation: damageRes.finalDam,
+                                shieldAbsorbed,
+                                hpDamage: done
+                            }
+                        });
+                    }
+                    else if (step.kind === "heal") {
+                        const healRes = calcHealOrShield({ ...caster, stats: effectiveCaster }, { ...target, stats: effectiveTarget }, raw, deps.rng);
+                        const applied = deps.applyHeal(target.id, healRes.finalValue);
+                        totalHeal += applied;
+                        hits.push({
+                            targetId: target.id,
+                            effectType: "heal",
+                            element: skill.element,
+                            skillType: skill.type,
+                            isCritical: healRes.isCritical,
+                            baseValue: healRes.baseValue,
+                            criticalValue: healRes.critValue,
+                            finalValue: applied,
+                            isRepression: 0
+                        });
+                    }
+                    else if (step.kind === "shield") {
+                        const shieldRes = calcHealOrShield({ ...caster, stats: effectiveCaster }, { ...target, stats: effectiveTarget }, raw, deps.rng);
+                        const applied = deps.applyShield(target.id, shieldRes.finalValue);
+                        totalShield += applied;
+                        hits.push({
+                            targetId: target.id,
+                            effectType: "shield",
+                            element: skill.element,
+                            skillType: skill.type,
+                            isCritical: shieldRes.isCritical,
+                            baseValue: shieldRes.baseValue,
+                            criticalValue: shieldRes.critValue,
+                            finalValue: applied,
+                            isRepression: 0
+                        });
+                    }
+                    else if (step.kind === "buff" && step.buffId) {
+                        const baseProb = this.resolveBuffApplyProb(stepFixedProb, skill, skillLevel);
+                        const canApply = calcEffectProbability(baseProb, stepFixedProb !== undefined, { ...caster, stats: effectiveCaster }, { ...target, stats: effectiveTarget }, deps.rng);
+                        if (canApply) {
+                            deps.applyBuff(caster.id, target.id, step.buffId);
+                        }
+                        hits.push({
+                            targetId: target.id,
+                            effectType: "buff",
+                            element: skill.element,
+                            skillType: skill.type,
+                            isCritical: false,
+                            baseValue: 0,
+                            criticalValue: 0,
+                            finalValue: 0,
+                            isRepression: 0,
+                            appliedBuffId: canApply ? step.buffId : undefined,
+                            resisted: !canApply
+                        });
+                    }
+                }
+            }
+        }
+        return {
+            skillId: skill.id,
+            casterId: caster.id,
+            targets: targets.map((t) => t.id),
+            totalDamage,
+            totalHeal,
+            totalShield,
+            triggeredBy: "normal",
+            hits
+        };
+    }
+}
+export class SkillExecutor {
+    configEngine;
+    scriptEngine;
+    constructor(configEngine, scriptEngine) {
+        this.configEngine = configEngine;
+        this.scriptEngine = scriptEngine;
+    }
+    execute(skill, caster, deps, trigger, triggerCtx, selectedTargetsOverride) {
+        const selectedTargets = selectedTargetsOverride ?? selectTargets(skill.targetRule, caster, deps.getUnits(), deps.rng);
+        let result = {
+            skillId: skill.id,
+            casterId: caster.id,
+            targets: selectedTargets.map((item) => item.id),
+            totalDamage: 0,
+            totalHeal: 0,
+            totalShield: 0,
+            triggeredBy: trigger,
+            hits: []
+        };
+        if (skill.mode === "config" || skill.mode === "hybrid") {
+            result = this.configEngine.cast(skill, caster, deps, selectedTargets);
+            result.triggeredBy = trigger;
+        }
+        if ((skill.mode === "script" || skill.mode === "hybrid") && skill.scriptId) {
+            const scriptCtx = {
+                caster: caster.id,
+                targets: result.targets,
+                skillId: skill.id,
+                trigger,
+                triggerContext: triggerCtx,
+                api: deps.createScriptApi(skill.element),
+                level: skill.level ?? 1,
+                levelParams: skill.levelParams ?? {}
+            };
+            const scriptRes = this.scriptEngine.cast(skill.scriptId, scriptCtx);
+            const resolvedTargets = skill.mode === "script"
+                ? (scriptRes.targets.length > 0 ? scriptRes.targets : result.targets)
+                : (result.targets.length > 0 ? result.targets : scriptRes.targets);
+            result = {
+                ...result,
+                targets: resolvedTargets,
+                totalDamage: result.totalDamage + scriptRes.totalDamage,
+                totalHeal: result.totalHeal + scriptRes.totalHeal,
+                totalShield: result.totalShield + scriptRes.totalShield,
+                hits: [...(result.hits ?? []), ...(scriptRes.hits ?? [])]
+            };
+        }
+        if (triggerCtx && result.targets.length === 0) {
+            result.targets = [...triggerCtx.sourceTargets];
+        }
+        return result;
+    }
+}

package/dist/battle/targeting.d.ts

@@ -0,0 +1,3 @@
+import { SeedRng } from "./random";
+import type { TargetRule, UnitModel } from "./types";
+export declare function selectTargets(rule: TargetRule, caster: UnitModel, allUnits: UnitModel[], rng: SeedRng): UnitModel[];

package/dist/battle/targeting.js

@@ -0,0 +1,38 @@
+function living(units) {
+    return units.filter((u) => u.runtime.alive);
+}
+export function selectTargets(rule, caster, allUnits, rng) {
+    const allies = living(allUnits.filter((u) => u.teamId === caster.teamId)).sort((a, b) => a.position - b.position);
+    const enemies = living(allUnits.filter((u) => u.teamId !== caster.teamId)).sort((a, b) => a.position - b.position);
+    if (rule === "self") {
+        return [caster];
+    }
+    if (rule === "allEnemies") {
+        return enemies;
+    }
+    if (rule === "allAllies") {
+        return allies;
+    }
+    if (rule === "lowestHp" || rule === "lowestHpEnemy") {
+        const target = enemies.sort((a, b) => a.runtime.Hp - b.runtime.Hp)[0];
+        return target ? [target] : [];
+    }
+    if (rule === "highestHpEnemy") {
+        const target = enemies.sort((a, b) => b.runtime.Hp - a.runtime.Hp)[0];
+        return target ? [target] : [];
+    }
+    if (rule === "randomSingleEnemy") {
+        if (enemies.length === 0) {
+            return [];
+        }
+        return [enemies[rng.nextInt(enemies.length)]];
+    }
+    if (rule === "enemyAdjacent") {
+        if (enemies.length <= 2) {
+            return enemies;
+        }
+        const anchor = enemies[0];
+        return enemies.filter((u) => Math.abs(u.position - anchor.position) <= 1);
+    }
+    return enemies.length > 0 ? [enemies[0]] : [];
+}

package/dist/battle/turnbar.d.ts

@@ -0,0 +1,8 @@
+import type { UnitModel, UnitId } from "./types";
+export declare class TurnBarSystem {
+    private extraTurnQueue;
+    grantExtraTurn(unitId: UnitId): void;
+    grantActionProgress(unit: UnitModel, ratio: number): void;
+    fillUntilAction(units: UnitModel[]): UnitModel | undefined;
+    consumeAction(unit: UnitModel): void;
+}

package/dist/battle/turnbar.js

@@ -0,0 +1,40 @@
+const ACTION_THRESHOLD = 1000000;
+export class TurnBarSystem {
+    extraTurnQueue = [];
+    grantExtraTurn(unitId) {
+        this.extraTurnQueue.push(unitId);
+    }
+    grantActionProgress(unit, ratio) {
+        const clampedRatio = Math.max(0, Math.floor(ratio));
+        const progress = Math.floor((ACTION_THRESHOLD * clampedRatio) / 10000);
+        unit.runtime.AP = Math.min(ACTION_THRESHOLD, unit.runtime.AP + progress);
+    }
+    fillUntilAction(units) {
+        const aliveUnits = units.filter((u) => u.runtime.alive);
+        if (aliveUnits.length === 0) {
+            return undefined;
+        }
+        if (this.extraTurnQueue.length > 0) {
+            const targetId = this.extraTurnQueue.shift();
+            const target = aliveUnits.find((u) => u.id === targetId);
+            if (target) {
+                target.runtime.AP = ACTION_THRESHOLD;
+                return target;
+            }
+        }
+        while (true) {
+            let acted = aliveUnits
+                .filter((u) => u.runtime.AP >= ACTION_THRESHOLD)
+                .sort((a, b) => b.runtime.AP - a.runtime.AP || b.stats.Spd - a.stats.Spd)[0];
+            if (acted) {
+                return acted;
+            }
+            for (const unit of aliveUnits) {
+                unit.runtime.AP += Math.max(1, unit.stats.Spd);
+            }
+        }
+    }
+    consumeAction(unit) {
+        unit.runtime.AP = 0;
+    }
+}

package/dist/battle/types.d.ts

@@ -0,0 +1,302 @@
+export type TeamId = 1 | 2;
+export type UnitId = string;
+export type ElementType = "fire" | "thunder" | "water" | "rock" | "wind" | "light" | "dark";
+export type SkillType = "basic" | "core" | "ultimate";
+export type SkillExecMode = "config" | "script" | "hybrid";
+export type BattleEventName = "OnTurnStart" | "OnTurnEnd" | "OnBeforeCast" | "OnAfterCast" | "OnBeforeDamage" | "OnAfterDamage" | "OnKill" | "OnDeath" | "OnBuffAdd" | "OnBuffRemove" | "OnExtraTurnGranted" | "OnImbalanceBreak" | "OnDamageDealt" | "BeforeDamageTaken";
+export interface UnitStats {
+    Mhp: number;
+    Def: number;
+    Att: number;
+    Spd: number;
+    pER: number;
+    pAR: number;
+    pEHR: number;
+    pERes: number;
+    pBSDI: number;
+    pESDI: number;
+    pFSDI: number;
+    pCTR: number;
+    pCTD: number;
+    pCTR_Def: number;
+    pCTD_Def: number;
+    pHE: number;
+    pFDI: number;
+    pFDI_Def: number;
+    pTDI: number;
+    pTDI_Def: number;
+    pWDI: number;
+    pWDI_Def: number;
+    pRDI: number;
+    pRDI_Def: number;
+    pADI: number;
+    pADI_Def: number;
+    pLDI: number;
+    pLDI_Def: number;
+    pDDI: number;
+    pDDI_Def: number;
+    pIM: number;
+    pITM: number;
+    pVulnerability: number;
+}
+export interface RuntimeState {
+    Hp: number;
+    AP: number;
+    Energy: number;
+    EnergyMax: number;
+    Shield: number;
+    Imbalance: number;
+    alive: boolean;
+    stunned: boolean;
+}
+export interface UnitSkillSlot {
+    id: string;
+    type: SkillType;
+    cooldown: number;
+    energyCost: number;
+    energyGain: number;
+}
+export interface UnitModel {
+    id: UnitId;
+    name: string;
+    teamId: TeamId;
+    position: 1 | 2 | 3 | 4;
+    element: ElementType;
+    stats: UnitStats;
+    runtime: RuntimeState;
+    skills: UnitSkillSlot[];
+}
+export interface BuffConfig {
+    id: string;
+    name: string;
+    maxStacks: number;
+    durationPerStack: number;
+    expireRounds?: number;
+    onRoundEndDelta: number;
+    stun?: boolean;
+    taunt?: boolean;
+    dotRatio?: number;
+    dotElement?: ElementType;
+    speedDelta?: number;
+    attackDelta?: number;
+    defDelta?: number;
+    speedRateDelta?: number;
+    attackRateDelta?: number;
+    defenseRateDelta?: number;
+    critRateDelta?: number;
+    critDamageDelta?: number;
+    healEffectDelta?: number;
+    effectHitDelta?: number;
+    damageRateDelta?: number;
+    effectResDelta?: number;
+    energyRecoveryRateDelta?: number;
+    vulnerabilityDelta?: number;
+    imbalanceRateDelta?: number;
+    damageShareToSourceRatio?: number;
+    reactiveCounter?: boolean;
+    reactiveCounterPriority?: number;
+    applyOnImbalanceBreak?: boolean;
+    applyOnElementBreakElements?: ElementType[];
+}
+export interface BuffInstance {
+    id: string;
+    ownerId: UnitId;
+    stacks: number;
+    remainingRounds: number;
+    config: BuffConfig;
+    sourceId: UnitId;
+}
+export interface SkillDefinition {
+    id: string;
+    mode: SkillExecMode;
+    type: SkillType;
+    configTemplateId?: string;
+    scriptId?: string;
+    energyCost: number;
+    energyGain: number;
+    cooldown: number;
+    targetRule: TargetRule;
+    element: ElementType;
+    /** 技能等级，用于数值升级 */
+    level?: number;
+    /** 技能升级参数，传递给脚本使用 */
+    levelParams?: Record<string, number>;
+    activateOnBattleStart?: boolean;
+    chaseRule?: {
+        enabled?: boolean;
+        triggerSourceSkillIds?: string[];
+        triggerSourceTriggers?: Array<"normal" | "chase" | "assist" | "counter">;
+        sameTeamOnly?: boolean;
+        allowSelfTrigger?: boolean;
+        requireSourceTargets?: boolean;
+        chance?: number;
+        useSkillId?: string;
+    };
+}
+export interface SkillTemplateStep {
+    kind: "damage" | "heal" | "shield" | "buff";
+    ratio: number;
+    ratioByLevel?: number[];
+    buffId?: string;
+    fixedProb?: number;
+    fixedProbByLevel?: number[];
+    canCrit?: boolean;
+    scaleStat?: "Att" | "Def" | "Mhp";
+    flat?: number;
+    flatByLevel?: number[];
+    repeat?: number;
+}
+export interface SkillTemplate {
+    id: string;
+    steps: SkillTemplateStep[];
+}
+export type TargetRule = "nearest" | "lowestHp" | "lowestHpEnemy" | "highestHpEnemy" | "randomSingleEnemy" | "lastRowEnemy" | "firstAndLastEnemy" | "enemyAdjacent" | "allEnemies" | "allAllies" | "self" | "selfWithAdjacent";
+export interface SkillResult {
+    skillId: string;
+    casterId: UnitId;
+    targets: UnitId[];
+    totalDamage: number;
+    totalHeal: number;
+    totalShield: number;
+    triggeredBy: "normal" | "chase" | "assist" | "counter";
+    hits?: SkillHitDetail[];
+}
+export interface SkillHitDetail {
+    targetId: UnitId;
+    effectType: "damage" | "heal" | "shield" | "buff";
+    element: ElementType;
+    skillType: SkillType;
+    isCritical: boolean;
+    baseValue: number;
+    criticalValue: number;
+    finalValue: number;
+    isRepression: -1 | 0 | 1;
+    appliedBuffId?: string;
+    resisted?: boolean;
+    damageBreakdown?: {
+        preMitigation: number;
+        postMitigation: number;
+        shieldAbsorbed: number;
+        hpDamage: number;
+    };
+}
+export interface BattleEvent<T = unknown> {
+    name: BattleEventName;
+    payload: T;
+    priority?: number;
+}
+export interface BattleActionLog {
+    turn: number;
+    actorId: UnitId;
+    skillId: string;
+    triggeredBy: SkillResult["triggeredBy"];
+    result: SkillResult;
+}
+export interface BattleSnapshot {
+    turn: number;
+    phase: "beforeAction" | "afterSkill" | "turnEnd";
+    units: Array<{
+        id: UnitId;
+        hp: number;
+        shield: number;
+        ap: number;
+        energy: number;
+        alive: boolean;
+        position: number;
+        effectiveAllStats: UnitStats;
+        buffs: Array<{
+            id: string;
+            name: string;
+            stacks: number;
+            remainingRounds: number;
+            sourceId: UnitId;
+        }>;
+        imbalance: number;
+        imbalanceMax: number;
+    }>;
+    /** 回合开始时触发的DOT伤害记录，用于飘字展示 */
+    dotDamages?: Array<{
+        targetId: UnitId;
+        value: number;
+        buffId: string;
+        element?: ElementType;
+    }>;
+    /** 失衡破击记录 */
+    imbalanceBreaks?: Array<{
+        targetId: UnitId;
+        attackerId: UnitId;
+        element: ElementType;
+    }>;
+    /** 失衡值变化来源记录 */
+    imbalanceChanges?: Array<{
+        targetId: UnitId;
+        delta: number;
+        reason: "turn_start_clear" | "skill_effect";
+        sourceActorId?: UnitId;
+        sourceSkillId?: string;
+    }>;
+}
+export interface BattleInitUnit {
+    id: string;
+    name: string;
+    teamId: TeamId;
+    position: 1 | 2 | 3 | 4;
+    element: ElementType;
+    stats: UnitStats;
+    skills: SkillDefinition[];
+}
+export interface BattleConfig {
+    maxTurns: number;
+    seed: number;
+}
+export interface TriggerContext {
+    turn: number;
+    sourceSkillId: string;
+    sourceActorId: UnitId;
+    sourceTargets: UnitId[];
+    sourceTriggeredBy?: SkillResult["triggeredBy"];
+}
+export interface ScriptRuntimeContext {
+    caster: UnitId;
+    targets: UnitId[];
+    skillId: string;
+    trigger: SkillResult["triggeredBy"];
+    api: BattleScriptApi;
+    triggerContext?: TriggerContext;
+    /** 技能等级 */
+    level: number;
+    /** 技能升级参数 */
+    levelParams: Record<string, number>;
+}
+export interface BattleScriptApi {
+    damage(sourceId: UnitId, targetId: UnitId, value: number): number;
+    heal(targetId: UnitId, value: number): number;
+    shield(targetId: UnitId, value: number): number;
+    adjustImbalance(targetId: UnitId, delta: number): number;
+    addBuff(sourceId: UnitId, targetId: UnitId, buffId: string): void;
+    removeBuff(targetId: UnitId, buffId: string): void;
+    grantExtraTurn(unitId: UnitId): void;
+    adjustActionProgress(unitId: UnitId, ratio: number): void;
+    gainEnergy(unitId: UnitId, value: number): void;
+    getUnit(unitId: UnitId): UnitModel | undefined;
+    getAliveUnits(): UnitModel[];
+    hasBuff(unitId: UnitId, buffId: string): boolean;
+    getBuffs(unitId: UnitId): BuffInstance[];
+    randomInt(maxExclusive: number): number;
+    pushPosition(unitId: UnitId, delta: number): void;
+    preventDeath(unitId: UnitId): void;
+    isUnitTurn(unitId: UnitId): boolean;
+    castSkill(actorId: UnitId, skillId: string, trigger: SkillResult["triggeredBy"], targetIds?: UnitId[]): SkillResult | null;
+    onAnyEvent(listenerUnitId: UnitId, eventName: BattleEventName, handler: (payload: any) => void): void;
+    /** 动态召唤一个新单位加入战斗 */
+    spawnUnit(initUnit: BattleInitUnit): UnitModel | null;
+    /** 延长目标单位所有主动技能的冷却回合数 */
+    extendCooldown(unitId: UnitId, delta: number): void;
+    /** 击杀指定单位（将其HP设为0并标记死亡） */
+    killUnit(unitId: UnitId): void;
+}
+export interface ISkillScript {
+    onPreCast?(ctx: ScriptRuntimeContext): void;
+    onCast(ctx: ScriptRuntimeContext): SkillResult;
+    onPostCast?(ctx: ScriptRuntimeContext, result: SkillResult): void;
+}

package/dist/battle/types.js

@@ -0,0 +1 @@
+export {};

package/dist/cocos-adapter/BattleFacade.d.ts

@@ -0,0 +1,8 @@
+import { BattleCore, type BattleResult } from "../battle/battleCore";
+import type { BattleConfig, BattleInitUnit } from "../battle/types";
+export declare class BattleFacade {
+    private core;
+    start(units: BattleInitUnit[], config: BattleConfig, initialize?: (core: BattleCore) => void): BattleResult;
+    stop(): void;
+    private toInstanceId;
+}