hrbattle 0.1.0

package/dist/battle/battleCore.js

@@ -0,0 +1,779 @@
+import { BattleEventBus } from "./eventBus";
+import { EffectSystem } from "./effectSystem";
+import { BattleLogger } from "./logger";
+import { SeedRng } from "./random";
+import { repression } from "./formula";
+import { ConfigSkillEngine, ScriptSkillEngine, SkillExecutor } from "./skillEngine";
+import { TurnBarSystem } from "./turnbar";
+export class BattleCore {
+    initUnits;
+    config;
+    units;
+    rng;
+    eventBus = new BattleEventBus();
+    turnBar = new TurnBarSystem();
+    logger = new BattleLogger();
+    effectSystem = new EffectSystem(this.eventBus);
+    configSkillEngine = new ConfigSkillEngine();
+    scriptSkillEngine = new ScriptSkillEngine();
+    skillExecutor = new SkillExecutor(this.configSkillEngine, this.scriptSkillEngine);
+    skillSlots = new Map();
+    chasePredicates = [];
+    chaseSkillResolvers = [];
+    pendingImbalanceClear = new Set();
+    pendingReactiveCounters = [];
+    scriptPassivesInitialized = false;
+    activeSkillContext = null;
+    turn = 0;
+    actionCount = 0;
+    constructor(initUnits, config) {
+        this.initUnits = initUnits;
+        this.config = config;
+        this.rng = new SeedRng(config.seed);
+        this.units = initUnits.map((u) => ({
+            id: u.id,
+            name: u.name,
+            teamId: u.teamId,
+            position: u.position,
+            element: u.element,
+            stats: { ...u.stats },
+            runtime: {
+                Hp: u.stats.Mhp,
+                AP: 0,
+                Energy: 0,
+                EnergyMax: this.maxUltimateCost(u.skills),
+                Shield: 0,
+                Imbalance: 0,
+                alive: true,
+                stunned: false
+            },
+            skills: u.skills.map((s) => ({
+                id: s.id,
+                type: s.type,
+                cooldown: s.cooldown,
+                energyCost: s.energyCost,
+                energyGain: s.energyGain
+            }))
+        }));
+        for (const unit of this.units) {
+            this.skillSlots.set(unit.id, initUnits
+                .find((u) => u.id === unit.id)
+                .skills.map((d) => ({
+                definition: d,
+                cooldownRemain: 0
+            })));
+        }
+        this.registerConfiguredChaseRules();
+        this.registerReactiveCounterRules();
+    }
+    getEventBus() {
+        return this.eventBus;
+    }
+    getLogger() {
+        return this.logger;
+    }
+    getEffectSystem() {
+        return this.effectSystem;
+    }
+    getConfigSkillEngine() {
+        return this.configSkillEngine;
+    }
+    getScriptSkillEngine() {
+        return this.scriptSkillEngine;
+    }
+    getUnitById(unitId) {
+        return this.units.find((u) => u.id === unitId);
+    }
+    addBuffToUnit(sourceId, targetId, buffId) {
+        this.applyBuff(sourceId, targetId, buffId);
+    }
+    /** 动态召唤一个新单位加入战斗 */
+    spawnUnit(initUnit) {
+        // 检查同队存活单位数量，最多4个
+        const teamAlive = this.units.filter((u) => u.teamId === initUnit.teamId && u.runtime.alive);
+        if (teamAlive.length >= 4) {
+            return null;
+        }
+        const position = (teamAlive.length + 1);
+        const unit = {
+            id: initUnit.id,
+            name: initUnit.name,
+            teamId: initUnit.teamId,
+            position,
+            element: initUnit.element,
+            stats: { ...initUnit.stats },
+            runtime: {
+                Hp: initUnit.stats.Mhp,
+                AP: 0,
+                Energy: 0,
+                EnergyMax: this.maxUltimateCost(initUnit.skills),
+                Shield: 0,
+                Imbalance: 0,
+                alive: true,
+                stunned: false
+            },
+            skills: initUnit.skills.map((s) => ({
+                id: s.id,
+                type: s.type,
+                cooldown: s.cooldown,
+                energyCost: s.energyCost,
+                energyGain: s.energyGain
+            }))
+        };
+        this.units.push(unit);
+        this.skillSlots.set(unit.id, initUnit.skills.map((d) => ({
+            definition: d,
+            cooldownRemain: 0
+        })));
+        // 初始化被动技能
+        const passiveSlots = this.getSlots(unit.id).filter((slot) => slot.definition.type === "passive" && slot.definition.mode === "script" && slot.definition.activateOnBattleStart);
+        for (const passiveSlot of passiveSlots) {
+            this.executeSkill(unit, passiveSlot.definition, "assist");
+        }
+        this.rearrangePositions();
+        return unit;
+    }
+    /** 延长目标单位所有主动技能的冷却回合数 */
+    extendCooldown(unitId, delta) {
+        const slots = this.skillSlots.get(unitId);
+        if (!slots) {
+            return;
+        }
+        for (const slot of slots) {
+            if (slot.definition.type === "basic" || slot.definition.type === "core" || slot.definition.type === "ultimate") {
+                slot.cooldownRemain = Math.max(0, slot.cooldownRemain + delta);
+            }
+        }
+    }
+    /** 击杀指定单位 */
+    killUnit(unitId) {
+        const unit = this.getUnitById(unitId);
+        if (!unit || !unit.runtime.alive) {
+            return;
+        }
+        unit.runtime.Hp = 0;
+        unit.runtime.alive = false;
+        this.eventBus.emit({ name: "OnDeath", payload: { targetId: unit.id, sourceId: unit.id } });
+        this.rearrangePositions();
+    }
+    grantActionProgress(unitId, ratio) {
+        const unit = this.getUnitById(unitId);
+        if (!unit || !unit.runtime.alive) {
+            return;
+        }
+        this.turnBar.grantActionProgress(unit, ratio);
+    }
+    registerSkillScript(scriptId, script) {
+        this.scriptSkillEngine.registerScript(scriptId, script);
+    }
+    registerChase(predicate, resolver) {
+        this.chasePredicates.push(predicate);
+        this.chaseSkillResolvers.push(resolver);
+    }
+    registerReactiveCounterRules() {
+        this.eventBus.on("OnAfterDamage", ({ sourceId, targetId, value }) => {
+            if (value <= 0 || sourceId === targetId || this.activeSkillContext?.trigger === "counter") {
+                return;
+            }
+            const source = this.units.find((u) => u.id === sourceId);
+            const target = this.units.find((u) => u.id === targetId);
+            if (!source || !target || !source.runtime.alive || !target.runtime.alive) {
+                return;
+            }
+            const reactiveCounterBuff = this.effectSystem
+                .getBuffs(target.id)
+                .filter((buff) => buff.stacks > 0 && buff.config.reactiveCounter)
+                .sort((a, b) => (b.config.reactiveCounterPriority ?? 0) - (a.config.reactiveCounterPriority ?? 0))[0];
+            if (!reactiveCounterBuff) {
+                return;
+            }
+            const basic = this.getSlots(target.id).find((slot) => slot.definition.type === "basic")?.definition;
+            if (!basic) {
+                return;
+            }
+            this.consumeBuffStack(target, reactiveCounterBuff.id);
+            this.pendingReactiveCounters.push({
+                sourceId,
+                targetId,
+                turn: this.turn,
+                sourceSkillId: this.activeSkillContext?.skillId ?? basic.id,
+                sourceTriggeredBy: this.activeSkillContext?.trigger
+            });
+        }, 0);
+    }
+    processPendingReactiveCounters() {
+        while (this.pendingReactiveCounters.length > 0) {
+            const pending = this.pendingReactiveCounters.shift();
+            const source = this.units.find((u) => u.id === pending.sourceId);
+            const target = this.units.find((u) => u.id === pending.targetId);
+            if (!source || !target || !source.runtime.alive || !target.runtime.alive) {
+                continue;
+            }
+            const basic = this.getSlots(target.id).find((slot) => slot.definition.type === "basic")?.definition;
+            if (!basic) {
+                continue;
+            }
+            const counterCtx = {
+                turn: pending.turn,
+                sourceActorId: source.id,
+                sourceSkillId: pending.sourceSkillId || basic.id,
+                sourceTargets: [target.id],
+                sourceTriggeredBy: pending.sourceTriggeredBy
+            };
+            const counterResult = this.executeSkill(target, basic, "counter", counterCtx, [source]);
+            this.logger.logAction({
+                turn: pending.turn,
+                actorId: target.id,
+                skillId: basic.id,
+                triggeredBy: "counter",
+                result: counterResult
+            });
+            this.logger.logSnapshot(pending.turn, "afterSkill", this.units, (unit) => this.effectSystem.getEffectiveStats(unit), (unit) => this.snapshotBuffs(unit), (unit) => this.computeImbalanceMax(unit));
+        }
+    }
+    consumeBuffStack(owner, buffId) {
+        const buff = this.effectSystem.getBuffs(owner.id).find((item) => item.id === buffId);
+        if (!buff) {
+            return;
+        }
+        if (buff.stacks <= 1) {
+            this.effectSystem.removeBuff(owner, buffId);
+            return;
+        }
+        buff.stacks -= 1;
+    }
+    registerConfiguredChaseRules() {
+        for (const unit of this.units) {
+            const slots = this.getSlots(unit.id);
+            for (const slot of slots) {
+                const rule = slot.definition.chaseRule;
+                if (!rule || rule.enabled === false) {
+                    continue;
+                }
+                this.registerChase((ctx, actor) => {
+                    if (actor.id !== unit.id || !actor.runtime.alive) {
+                        return false;
+                    }
+                    if (!(rule.allowSelfTrigger ?? false) && ctx.sourceActorId === actor.id) {
+                        return false;
+                    }
+                    if (rule.triggerSourceSkillIds && rule.triggerSourceSkillIds.length > 0 && !rule.triggerSourceSkillIds.includes(ctx.sourceSkillId)) {
+                        return false;
+                    }
+                    if (rule.triggerSourceTriggers && rule.triggerSourceTriggers.length > 0) {
+                        if (!ctx.sourceTriggeredBy || !rule.triggerSourceTriggers.includes(ctx.sourceTriggeredBy)) {
+                            return false;
+                        }
+                    }
+                    if (rule.requireSourceTargets ?? true) {
+                        if ((ctx.sourceTargets?.length ?? 0) === 0) {
+                            return false;
+                        }
+                    }
+                    if (rule.sameTeamOnly ?? true) {
+                        const sourceActor = this.units.find((u) => u.id === ctx.sourceActorId);
+                        if (!sourceActor || sourceActor.teamId !== actor.teamId) {
+                            return false;
+                        }
+                    }
+                    const chance = Math.min(10000, Math.max(0, Math.floor(rule.chance ?? 10000)));
+                    return Math.floor(this.rng.next() * 10000) < chance;
+                }, (actor) => {
+                    const useSkillId = rule.useSkillId ?? slot.definition.id;
+                    return this.getSlots(actor.id).find((s) => s.definition.id === useSkillId)?.definition;
+                });
+            }
+        }
+    }
+    run() {
+        this.initializeScriptPassives();
+        while (!this.winner() && this.actionCount < this.config.maxTurns) {
+            const actor = this.turnBar.fillUntilAction(this.units);
+            if (!actor) {
+                break;
+            }
+            this.turn += 1;
+            this.actionCount += 1;
+            this.logger.logSnapshot(this.turn, "beforeAction", this.units, (unit) => this.effectSystem.getEffectiveStats(unit), (unit) => this.snapshotBuffs(unit), (unit) => this.computeImbalanceMax(unit));
+            this.eventBus.emit({ name: "OnTurnStart", payload: { actorId: actor.id, turn: this.turn } });
+            this.applyTurnStart(actor);
+            this.processPendingReactiveCounters();
+            if (actor.runtime.alive && !actor.runtime.stunned) {
+                this.performAction(actor);
+            }
+            this.eventBus.emit({ name: "OnTurnEnd", payload: { actorId: actor.id, turn: this.turn } });
+            this.applyTurnEnd(actor);
+            this.decrementAllCooldowns(actor.id);
+            this.turnBar.consumeAction(actor);
+            this.logger.logSnapshot(this.turn, "turnEnd", this.units, (unit) => this.effectSystem.getEffectiveStats(unit), (unit) => this.snapshotBuffs(unit), (unit) => this.computeImbalanceMax(unit));
+        }
+        return {
+            winner: this.resolveWinnerByRule(),
+            totalTurns: this.actionCount,
+            logs: this.logger
+        };
+    }
+    initializeScriptPassives() {
+        if (this.scriptPassivesInitialized) {
+            return;
+        }
+        this.scriptPassivesInitialized = true;
+        for (const unit of this.units) {
+            const passiveSlots = this.getSlots(unit.id).filter((slot) => slot.definition.type === "passive" && slot.definition.mode === "script" && slot.definition.activateOnBattleStart);
+            for (const passiveSlot of passiveSlots) {
+                this.executeSkill(unit, passiveSlot.definition, "assist");
+            }
+        }
+    }
+    performAction(actor) {
+        const slots = this.getSlots(actor.id);
+        const skillOrder = ["ultimate", "core", "basic"];
+        const chaseUsed = new Set();
+        for (const type of skillOrder) {
+            if (!actor.runtime.alive) {
+                break;
+            }
+            const slot = slots.find((s) => s.definition.type === type);
+            if (!slot) {
+                continue;
+            }
+            const canCast = this.canCast(actor, slot);
+            if (!canCast) {
+                continue;
+            }
+            slot.cooldownRemain = slot.definition.cooldown;
+            if (slot.definition.type === "ultimate") {
+                actor.runtime.Energy = Math.max(0, actor.runtime.Energy - slot.definition.energyCost);
+            }
+            const result = this.executeSkill(actor, slot.definition, "normal");
+            this.logger.logAction({
+                turn: this.turn,
+                actorId: actor.id,
+                skillId: slot.definition.id,
+                triggeredBy: "normal",
+                result
+            });
+            if (slot.definition.type !== "ultimate") {
+                this.gainEnergy(actor, slot.definition.energyGain);
+            }
+            this.logger.logSnapshot(this.turn, "afterSkill", this.units, (unit) => this.effectSystem.getEffectiveStats(unit), (unit) => this.snapshotBuffs(unit), (unit) => this.computeImbalanceMax(unit));
+            this.processPendingReactiveCounters();
+            this.rearrangePositions();
+            if (!actor.runtime.alive) {
+                break;
+            }
+            this.tryChaseAndAssist(actor, result, chaseUsed);
+            if (this.winner()) {
+                break;
+            }
+        }
+    }
+    canCast(actor, slot) {
+        if (!actor.runtime.alive || actor.runtime.stunned) {
+            return false;
+        }
+        if (slot.cooldownRemain > 0) {
+            return false;
+        }
+        if (slot.definition.type === "ultimate") {
+            return actor.runtime.Energy >= slot.definition.energyCost;
+        }
+        return true;
+    }
+    executeSkill(actor, skill, trigger, triggerCtx, selectedTargetsOverride) {
+        this.eventBus.emit({ name: "OnBeforeCast", payload: { actorId: actor.id, skillId: skill.id, trigger } });
+        const previousSkillContext = this.activeSkillContext;
+        this.activeSkillContext = { actorId: actor.id, skillId: skill.id, trigger };
+        const result = (() => {
+            try {
+                return this.skillExecutor.execute(skill, actor, {
+                    rng: this.rng,
+                    getUnits: () => this.units,
+                    applyDamage: (sourceId, targetId, value, staggerElement) => this.applyDamage(sourceId, targetId, value, staggerElement),
+                    applyHeal: (targetId, value) => this.applyHeal(targetId, value),
+                    applyShield: (targetId, value) => this.applyShield(targetId, value),
+                    applyBuff: (sourceId, targetId, buffId) => this.applyBuff(sourceId, targetId, buffId),
+                    getEffectiveStats: (unit) => this.effectSystem.getEffectiveStats(unit),
+                    createScriptApi: (skillElement) => ({
+                        damage: (sourceId, targetId, value) => this.applyDamage(sourceId, targetId, value, skillElement),
+                        heal: (targetId, value) => this.applyHeal(targetId, value),
+                        shield: (targetId, value) => this.applyShield(targetId, value),
+                        adjustImbalance: (targetId, delta) => {
+                            const sourceActorId = this.activeSkillContext?.actorId ?? actor.id;
+                            const sourceSkillId = this.activeSkillContext?.skillId ?? skill.id;
+                            return this.applyImbalanceDelta(sourceActorId, sourceSkillId, targetId, delta, "skill_effect");
+                        },
+                        addBuff: (sourceId, targetId, buffId) => this.applyBuff(sourceId, targetId, buffId),
+                        removeBuff: (targetId, buffId) => {
+                            const target = this.getUnitById(targetId);
+                            if (target) {
+                                this.effectSystem.removeBuff(target, buffId);
+                            }
+                        },
+                        grantExtraTurn: (unitId) => this.turnBar.grantExtraTurn(unitId),
+                        adjustActionProgress: (unitId, ratio) => this.grantActionProgress(unitId, ratio),
+                        gainEnergy: (unitId, value) => this.gainEnergyToUnit(unitId, value),
+                        getUnit: (unitId) => this.units.find((u) => u.id === unitId),
+                        getAliveUnits: () => this.units.filter((u) => u.runtime.alive),
+                        hasBuff: (unitId, buffId) => this.effectSystem.hasBuff(unitId, buffId),
+                        getBuffs: (unitId) => this.effectSystem.getBuffs(unitId),
+                        randomInt: (maxExclusive) => (maxExclusive <= 0 ? 0 : this.rng.nextInt(maxExclusive)),
+                        pushPosition: (unitId, delta) => {
+                            const unit = this.getUnitById(unitId);
+                            if (unit) {
+                                unit.position = Math.max(1, Math.min(4, unit.position + delta));
+                            }
+                        },
+                        preventDeath: (unitId) => {
+                            const unit = this.getUnitById(unitId);
+                            if (unit && unit.runtime.Hp <= 0) {
+                                unit.runtime.Hp = 1;
+                                unit.runtime.alive = true;
+                            }
+                        },
+                        isUnitTurn: (unitId) => {
+                            return this.activeSkillContext?.actorId === unitId;
+                        },
+                        castSkill: (actorId, skillId, trigger, targetIds) => {
+                            const castActor = this.getUnitById(actorId);
+                            if (!castActor || !castActor.runtime.alive) {
+                                return null;
+                            }
+                            const castSkill = this.getSlots(actorId).find((slot) => slot.definition.id === skillId)?.definition;
+                            if (!castSkill) {
+                                return null;
+                            }
+                            const selectedTargets = (targetIds ?? [])
+                                .map((id) => this.getUnitById(id))
+                                .filter((u) => Boolean(u && u.runtime.alive));
+                            const triggerCtx = {
+                                turn: this.turn,
+                                sourceActorId: this.activeSkillContext?.actorId ?? actorId,
+                                sourceSkillId: this.activeSkillContext?.skillId ?? skillId,
+                                sourceTargets: selectedTargets.map((u) => u.id),
+                                sourceTriggeredBy: this.activeSkillContext?.trigger
+                            };
+                            const castResult = this.executeSkill(castActor, castSkill, trigger, triggerCtx, selectedTargets.length > 0 ? selectedTargets : undefined);
+                            this.logger.logAction({
+                                turn: this.turn,
+                                actorId,
+                                skillId,
+                                triggeredBy: trigger,
+                                result: castResult
+                            });
+                            this.logger.logSnapshot(this.turn, "afterSkill", this.units, (u) => this.effectSystem.getEffectiveStats(u), (u) => this.snapshotBuffs(u), (u) => this.computeImbalanceMax(u));
+                            this.processPendingReactiveCounters();
+                            return castResult;
+                        },
+                        onAnyEvent: (listenerUnitId, eventName, handler) => {
+                            this.eventBus.on(eventName, handler);
+                        },
+                        spawnUnit: (initUnit) => this.spawnUnit(initUnit),
+                        extendCooldown: (unitId, delta) => this.extendCooldown(unitId, delta),
+                        killUnit: (unitId) => this.killUnit(unitId)
+                    })
+                }, trigger, triggerCtx, selectedTargetsOverride);
+            }
+            finally {
+                this.activeSkillContext = previousSkillContext;
+            }
+        })();
+        this.eventBus.emit({ name: "OnAfterCast", payload: { actorId: actor.id, skillId: skill.id, trigger, result } });
+        return result;
+    }
+    tryChaseAndAssist(actor, result, chaseUsed) {
+        const triggerCtx = {
+            turn: this.turn,
+            sourceActorId: actor.id,
+            sourceSkillId: result.skillId,
+            sourceTargets: result.targets,
+            sourceTriggeredBy: result.triggeredBy
+        };
+        for (const unit of this.units.filter((u) => u.runtime.alive && !chaseUsed.has(u.id))) {
+            for (let i = 0; i < this.chasePredicates.length; i++) {
+                if (!this.chasePredicates[i](triggerCtx, unit)) {
+                    continue;
+                }
+                const skill = this.chaseSkillResolvers[i](unit);
+                if (!skill) {
+                    continue;
+                }
+                const chaseResult = this.executeSkill(unit, skill, "chase", triggerCtx);
+                this.logger.logAction({
+                    turn: this.turn,
+                    actorId: unit.id,
+                    skillId: skill.id,
+                    triggeredBy: "chase",
+                    result: chaseResult
+                });
+                this.logger.logSnapshot(this.turn, "afterSkill", this.units, (u) => this.effectSystem.getEffectiveStats(u), (u) => this.snapshotBuffs(u), (u) => this.computeImbalanceMax(u));
+                this.processPendingReactiveCounters();
+                chaseUsed.add(unit.id);
+            }
+        }
+        if (result.targets.length === 0) {
+            return;
+        }
+        const firstTarget = this.units.find((u) => u.id === result.targets[0] && u.runtime.alive);
+        if (!firstTarget) {
+            return;
+        }
+        const allies = this.units.filter((u) => u.teamId === actor.teamId && u.id !== actor.id && u.runtime.alive);
+        for (const ally of allies) {
+            const chance = Math.min(10000, Math.max(0, Math.floor(ally.stats.pAR)));
+            if (Math.floor(this.rng.next() * 10000) >= chance) {
+                continue;
+            }
+            const basic = this.getSlots(ally.id).find((s) => s.definition.type === "basic")?.definition;
+            if (!basic) {
+                continue;
+            }
+            const assistRes = this.executeSkill(ally, basic, "assist", {
+                ...triggerCtx,
+                sourceTargets: [firstTarget.id]
+            });
+            this.logger.logAction({
+                turn: this.turn,
+                actorId: ally.id,
+                skillId: basic.id,
+                triggeredBy: "assist",
+                result: assistRes
+            });
+            this.logger.logSnapshot(this.turn, "afterSkill", this.units, (u) => this.effectSystem.getEffectiveStats(u), (u) => this.snapshotBuffs(u), (u) => this.computeImbalanceMax(u));
+            this.processPendingReactiveCounters();
+        }
+    }
+    applyDamage(sourceId, targetId, value, staggerElement, skipShare = false) {
+        const target = this.mustUnit(targetId);
+        const source = this.mustUnit(sourceId);
+        this.eventBus.emit({ name: "OnBeforeDamage", payload: { sourceId, targetId, value } });
+        this.eventBus.emit({ name: "OnDamageDealt", payload: { sourceId, targetId, value } });
+        let damage = Math.max(0, Math.floor(value));
+        if (!skipShare && sourceId !== targetId) {
+            const shareBuff = this.effectSystem.getBuffs(target.id).find((buff) => buff.stacks > 0 && (buff.config.damageShareToSourceRatio ?? 0) > 0);
+            if (shareBuff && shareBuff.sourceId !== target.id) {
+                const shareTo = this.units.find((unit) => unit.id === shareBuff.sourceId && unit.runtime.alive);
+                if (shareTo) {
+                    const ratio = Math.max(0, Math.min(1, shareBuff.config.damageShareToSourceRatio ?? 0));
+                    const sharedDamage = Math.floor(damage * ratio);
+                    if (sharedDamage > 0) {
+                        this.applyDamage(sourceId, shareTo.id, sharedDamage, undefined, true);
+                        damage -= sharedDamage;
+                    }
+                }
+            }
+        }
+        if (target.runtime.Shield > 0) {
+            const absorbed = Math.min(target.runtime.Shield, damage);
+            target.runtime.Shield -= absorbed;
+            damage -= absorbed;
+        }
+        target.runtime.Hp = Math.max(0, target.runtime.Hp - damage);
+        if (target.runtime.Hp === 0) {
+            target.runtime.alive = false;
+            this.eventBus.emit({ name: "OnDeath", payload: { targetId: target.id, sourceId: source.id } });
+            this.eventBus.emit({ name: "OnKill", payload: { killerId: source.id, targetId: target.id } });
+        }
+        this.eventBus.emit({ name: "OnAfterDamage", payload: { sourceId, targetId, value: damage } });
+        if (staggerElement && sourceId !== targetId && target.runtime.alive) {
+            this.accumulateStagger(source, target, staggerElement);
+        }
+        return damage;
+    }
+    applyHeal(targetId, value) {
+        const target = this.mustUnit(targetId);
+        if (!target.runtime.alive) {
+            return 0;
+        }
+        const heal = Math.max(0, Math.floor(value));
+        const old = target.runtime.Hp;
+        target.runtime.Hp = Math.min(target.stats.Mhp, target.runtime.Hp + heal);
+        return target.runtime.Hp - old;
+    }
+    applyShield(targetId, value) {
+        const target = this.mustUnit(targetId);
+        if (!target.runtime.alive) {
+            return 0;
+        }
+        const shield = Math.max(0, Math.floor(value));
+        target.runtime.Shield += shield;
+        return shield;
+    }
+    applyImbalanceDelta(sourceActorId, sourceSkillId, targetId, delta, reason) {
+        const target = this.mustUnit(targetId);
+        if (!target.runtime.alive || delta === 0) {
+            return 0;
+        }
+        const max = this.computeImbalanceMax(target);
+        const from = target.runtime.Imbalance;
+        const to = Math.max(0, Math.min(max, from + Math.floor(delta)));
+        target.runtime.Imbalance = to;
+        const applied = to - from;
+        if (applied !== 0) {
+            this.logger.logImbalanceChange(target.id, applied, reason, sourceActorId, sourceSkillId);
+        }
+        if (to < max && this.pendingImbalanceClear.has(target.id)) {
+            this.pendingImbalanceClear.delete(target.id);
+        }
+        return applied;
+    }
+    computeImbalanceMax(unit) {
+        const effectiveStats = this.effectSystem.getEffectiveStats(unit);
+        return Math.floor(Math.floor(unit.stats.Mhp * 6000 / 10000) * (10000 + effectiveStats.pITM) / 10000);
+    }
+    accumulateStagger(source, target, skillElement) {
+        if (this.pendingImbalanceClear.has(target.id)) {
+            return;
+        }
+        const effectiveSource = this.effectSystem.getEffectiveStats(source);
+        const baseStagger = effectiveSource.Att;
+        let stagger = Math.floor(baseStagger * (10000 + effectiveSource.pIM) / 10000);
+        const rep = repression(source.element, target.element);
+        if (rep === 1) {
+            stagger = Math.floor(stagger * 13000 / 10000);
+        }
+        else if (rep === -1) {
+            stagger = Math.floor(stagger * 7000 / 10000);
+        }
+        const max = this.computeImbalanceMax(target);
+        const from = target.runtime.Imbalance;
+        target.runtime.Imbalance = Math.min(max, from + stagger);
+        const applied = target.runtime.Imbalance - from;
+        if (applied !== 0) {
+            this.logger.logImbalanceChange(target.id, applied, "skill_effect", this.activeSkillContext?.actorId ?? source.id, this.activeSkillContext?.skillId);
+        }
+        if (target.runtime.Imbalance >= max) {
+            this.onImbalanceBreak(source, target, skillElement);
+        }
+    }
+    onImbalanceBreak(source, target, element) {
+        const max = this.computeImbalanceMax(target);
+        target.runtime.Imbalance = max;
+        this.pendingImbalanceClear.add(target.id);
+        const breakBuffs = this.effectSystem
+            .getBuffConfigs()
+            .filter((buff) => buff.applyOnImbalanceBreak || buff.applyOnElementBreakElements?.includes(element));
+        const appliedBuffIds = new Set();
+        for (const breakBuff of breakBuffs) {
+            if (appliedBuffIds.has(breakBuff.id)) {
+                continue;
+            }
+            appliedBuffIds.add(breakBuff.id);
+            this.applyBuff(source.id, target.id, breakBuff.id);
+        }
+        this.eventBus.emit({ name: "OnImbalanceBreak", payload: { sourceId: source.id, targetId: target.id, element } });
+        this.logger.logImbalanceBreak(target.id, source.id, element);
+    }
+    applyBuff(sourceId, targetId, buffId) {
+        const target = this.mustUnit(targetId);
+        this.effectSystem.addBuff(target, sourceId, buffId);
+    }
+    applyTurnStart(actor) {
+        if (this.pendingImbalanceClear.has(actor.id)) {
+            const from = actor.runtime.Imbalance;
+            actor.runtime.Imbalance = 0;
+            this.pendingImbalanceClear.delete(actor.id);
+            this.logger.logImbalanceChange(actor.id, -from, "turn_start_clear", actor.id);
+        }
+        const dotEvents = this.effectSystem.onTurnStart(actor, this.units);
+        for (const dot of dotEvents) {
+            this.applyDamage(actor.id, dot.targetId, dot.value);
+            // 记录DOT伤害到logger，用于飘字展示
+            this.logger.logDotDamage(dot.targetId, dot.value, dot.buffId, dot.element);
+        }
+        this.rearrangePositions();
+    }
+    applyTurnEnd(actor) {
+        this.effectSystem.onTurnEnd(actor, this.units);
+        this.rearrangePositions();
+    }
+    gainEnergy(actor, value) {
+        this.gainEnergyToUnit(actor.id, value);
+    }
+    gainEnergyToUnit(unitId, value) {
+        const actor = this.mustUnit(unitId);
+        const ratio = 10000 + actor.stats.pER;
+        const gain = Math.floor((Math.max(0, value) * ratio) / 10000);
+        actor.runtime.Energy = Math.min(actor.runtime.EnergyMax, actor.runtime.Energy + gain);
+    }
+    decrementAllCooldowns(actorId) {
+        for (const [id, slots] of this.skillSlots.entries()) {
+            if (id !== actorId) {
+                continue;
+            }
+            for (const slot of slots) {
+                slot.cooldownRemain = Math.max(0, slot.cooldownRemain - 1);
+            }
+        }
+    }
+    getSlots(unitId) {
+        return this.skillSlots.get(unitId) ?? [];
+    }
+    rearrangePositions() {
+        for (const teamId of [1, 2]) {
+            const alive = this.units.filter((u) => u.teamId === teamId && u.runtime.alive).sort((a, b) => a.position - b.position);
+            alive.forEach((u, idx) => {
+                u.position = (idx + 1);
+            });
+        }
+    }
+    winner() {
+        const t1Alive = this.units.some((u) => u.teamId === 1 && u.runtime.alive);
+        const t2Alive = this.units.some((u) => u.teamId === 2 && u.runtime.alive);
+        if (!t1Alive && !t2Alive) {
+            return 0;
+        }
+        if (!t1Alive) {
+            return 2;
+        }
+        if (!t2Alive) {
+            return 1;
+        }
+        return 0;
+    }
+    resolveWinnerByRule() {
+        const w = this.winner();
+        if (w) {
+            return w;
+        }
+        const t1 = this.hpRatio(1);
+        const t2 = this.hpRatio(2);
+        if (t1 > t2) {
+            return 1;
+        }
+        if (t2 > t1) {
+            return 2;
+        }
+        return 2;
+    }
+    hpRatio(teamId) {
+        const team = this.units.filter((u) => u.teamId === teamId);
+        const hp = team.reduce((sum, u) => sum + Math.max(0, u.runtime.Hp), 0);
+        const mhp = team.reduce((sum, u) => sum + u.stats.Mhp, 0);
+        return mhp > 0 ? hp / mhp : 0;
+    }
+    mustUnit(id) {
+        const unit = this.units.find((u) => u.id === id);
+        if (!unit) {
+            throw new Error(`unit-not-found:${id}`);
+        }
+        return unit;
+    }
+    maxUltimateCost(skills) {
+        const ult = skills.find((s) => s.type === "ultimate");
+        return ult ? ult.energyCost : 100;
+    }
+    snapshotBuffs(unit) {
+        return this.effectSystem
+            .getBuffs(unit.id)
+            .filter((b) => b.stacks > 0 && b.remainingRounds > 0)
+            .sort((a, b) => a.id.localeCompare(b.id))
+            .map((b) => ({
+            id: b.id,
+            name: b.config.name,
+            stacks: b.stacks,
+            remainingRounds: b.remainingRounds,
+            sourceId: b.sourceId
+        }));
+    }
+}