hrbattle 1.0.8 → 1.0.9

package/dist/battle/battleCore.js

@@ -1,3 +1,41 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
 import { BattleEventBus } from "./eventBus.js";
 import { EffectSystem } from "./effectSystem.js";
 import { BattleLogger } from "./logger.js";
@@ -5,103 +43,116 @@ import { SeedRng } from "./random.js";
 import { repression } from "./formula.js";
 import { ConfigSkillEngine, ScriptSkillEngine, SkillExecutor } from "./skillEngine.js";
 import { TurnBarSystem } from "./turnbar.js";
-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) {
+var BattleCore = /** @class */ (function () {
+    function BattleCore(initUnits, config) {
+        var e_1, _a;
+        var _this = this;
         this.initUnits = initUnits;
         this.config = config;
+        this.eventBus = new BattleEventBus();
+        this.turnBar = new TurnBarSystem();
+        this.logger = new BattleLogger();
+        this.effectSystem = new EffectSystem(this.eventBus);
+        this.configSkillEngine = new ConfigSkillEngine();
+        this.scriptSkillEngine = new ScriptSkillEngine();
+        this.skillExecutor = new SkillExecutor(this.configSkillEngine, this.scriptSkillEngine);
+        this.skillSlots = new Map();
+        this.chasePredicates = [];
+        this.chaseSkillResolvers = [];
+        this.pendingImbalanceClear = new Set();
+        this.pendingReactiveCounters = [];
+        this.scriptPassivesInitialized = false;
+        this.activeSkillContext = null;
+        this.turn = 0;
+        this.actionCount = 0;
         this.rng = new SeedRng(config.seed);
-        this.units = initUnits.map((u) => ({
+        this.units = initUnits.map(function (u) { return ({
             id: u.id,
             name: u.name,
             teamId: u.teamId,
             position: u.position,
             element: u.element,
-            stats: { ...u.stats },
+            stats: __assign({}, u.stats),
             runtime: {
                 Hp: u.stats.Mhp,
                 AP: 0,
                 Energy: 0,
-                EnergyMax: this.maxUltimateCost(u.skills),
+                EnergyMax: _this.maxUltimateCost(u.skills),
                 Shield: 0,
                 Imbalance: 0,
                 alive: true,
                 stunned: false
             },
-            skills: u.skills.map((s) => ({
+            skills: u.skills.map(function (s) { return ({
                 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) => ({
+            }); })
+        }); });
+        var _loop_1 = function (unit) {
+            this_1.skillSlots.set(unit.id, initUnits
+                .find(function (u) { return u.id === unit.id; })
+                .skills.map(function (d) { return ({
                 definition: d,
                 cooldownRemain: 0
-            })));
+            }); }));
+        };
+        var this_1 = this;
+        try {
+            for (var _b = __values(this.units), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var unit = _c.value;
+                _loop_1(unit);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
         }
         this.registerConfiguredChaseRules();
         this.registerReactiveCounterRules();
     }
-    getEventBus() {
+    BattleCore.prototype.getEventBus = function () {
         return this.eventBus;
-    }
-    getLogger() {
+    };
+    BattleCore.prototype.getLogger = function () {
         return this.logger;
-    }
-    getEffectSystem() {
+    };
+    BattleCore.prototype.getEffectSystem = function () {
         return this.effectSystem;
-    }
-    getConfigSkillEngine() {
+    };
+    BattleCore.prototype.getConfigSkillEngine = function () {
         return this.configSkillEngine;
-    }
-    getScriptSkillEngine() {
+    };
+    BattleCore.prototype.getScriptSkillEngine = function () {
         return this.scriptSkillEngine;
-    }
-    getUnitById(unitId) {
-        return this.units.find((u) => u.id === unitId);
-    }
-    addBuffToUnit(sourceId, targetId, buffId) {
+    };
+    BattleCore.prototype.getUnitById = function (unitId) {
+        return this.units.find(function (u) { return u.id === unitId; });
+    };
+    BattleCore.prototype.addBuffToUnit = function (sourceId, targetId, buffId) {
         this.applyBuff(sourceId, targetId, buffId);
-    }
+    };
     /** 动态召唤一个新单位加入战斗 */
-    spawnUnit(initUnit) {
+    BattleCore.prototype.spawnUnit = function (initUnit) {
+        var e_2, _a;
         // 检查同队存活单位数量，最多4个
-        const teamAlive = this.units.filter((u) => u.teamId === initUnit.teamId && u.runtime.alive);
+        var teamAlive = this.units.filter(function (u) { return u.teamId === initUnit.teamId && u.runtime.alive; });
         if (teamAlive.length >= 4) {
             return null;
         }
-        const position = (teamAlive.length + 1);
-        const unit = {
+        var position = (teamAlive.length + 1);
+        var unit = {
             id: initUnit.id,
             name: initUnit.name,
             teamId: initUnit.teamId,
-            position,
+            position: position,
             element: initUnit.element,
-            stats: { ...initUnit.stats },
+            stats: __assign({}, initUnit.stats),
             runtime: {
                 Hp: initUnit.stats.Mhp,
                 AP: 0,
@@ -112,42 +163,63 @@ export class BattleCore {
                 alive: true,
                 stunned: false
             },
-            skills: initUnit.skills.map((s) => ({
+            skills: initUnit.skills.map(function (s) { return ({
                 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) => ({
+        this.skillSlots.set(unit.id, initUnit.skills.map(function (d) { return ({
             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");
+        var passiveSlots = this.getSlots(unit.id).filter(function (slot) { return slot.definition.type === "passive" && slot.definition.mode === "script" && slot.definition.activateOnBattleStart; });
+        try {
+            for (var passiveSlots_1 = __values(passiveSlots), passiveSlots_1_1 = passiveSlots_1.next(); !passiveSlots_1_1.done; passiveSlots_1_1 = passiveSlots_1.next()) {
+                var passiveSlot = passiveSlots_1_1.value;
+                this.executeSkill(unit, passiveSlot.definition, "assist");
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (passiveSlots_1_1 && !passiveSlots_1_1.done && (_a = passiveSlots_1.return)) _a.call(passiveSlots_1);
+            }
+            finally { if (e_2) throw e_2.error; }
         }
         this.rearrangePositions();
         return unit;
-    }
+    };
     /** 延长目标单位所有主动技能的冷却回合数 */
-    extendCooldown(unitId, delta) {
-        const slots = this.skillSlots.get(unitId);
+    BattleCore.prototype.extendCooldown = function (unitId, delta) {
+        var e_3, _a;
+        var 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);
+        try {
+            for (var slots_1 = __values(slots), slots_1_1 = slots_1.next(); !slots_1_1.done; slots_1_1 = slots_1.next()) {
+                var slot = slots_1_1.value;
+                if (slot.definition.type === "basic" || slot.definition.type === "core" || slot.definition.type === "ultimate") {
+                    slot.cooldownRemain = Math.max(0, slot.cooldownRemain + delta);
+                }
             }
         }
-    }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (slots_1_1 && !slots_1_1.done && (_a = slots_1.return)) _a.call(slots_1);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+    };
     /** 击杀指定单位 */
-    killUnit(unitId) {
-        const unit = this.getUnitById(unitId);
+    BattleCore.prototype.killUnit = function (unitId) {
+        var unit = this.getUnitById(unitId);
         if (!unit || !unit.runtime.alive) {
             return;
         }
@@ -155,84 +227,93 @@ export class BattleCore {
         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);
+    };
+    BattleCore.prototype.grantActionProgress = function (unitId, ratio) {
+        var unit = this.getUnitById(unitId);
         if (!unit || !unit.runtime.alive) {
             return;
         }
         this.turnBar.grantActionProgress(unit, ratio);
-    }
-    registerSkillScript(scriptId, script) {
+    };
+    BattleCore.prototype.registerSkillScript = function (scriptId, script) {
         this.scriptSkillEngine.registerScript(scriptId, script);
-    }
-    registerChase(predicate, resolver) {
+    };
+    BattleCore.prototype.registerChase = function (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") {
+    };
+    BattleCore.prototype.registerReactiveCounterRules = function () {
+        var _this = this;
+        this.eventBus.on("OnAfterDamage", function (_a) {
+            var _b, _c, _d, _e, _f;
+            var sourceId = _a.sourceId, targetId = _a.targetId, value = _a.value;
+            if (value <= 0 || sourceId === targetId || ((_b = _this.activeSkillContext) === null || _b === void 0 ? void 0 : _b.trigger) === "counter") {
                 return;
             }
-            const source = this.units.find((u) => u.id === sourceId);
-            const target = this.units.find((u) => u.id === targetId);
+            var source = _this.units.find(function (u) { return u.id === sourceId; });
+            var target = _this.units.find(function (u) { return u.id === targetId; });
             if (!source || !target || !source.runtime.alive || !target.runtime.alive) {
                 return;
             }
-            const reactiveCounterBuff = this.effectSystem
+            var 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];
+                .filter(function (buff) { return buff.stacks > 0 && buff.config.reactiveCounter; })
+                .sort(function (a, b) { var _a, _b; return ((_a = b.config.reactiveCounterPriority) !== null && _a !== void 0 ? _a : 0) - ((_b = a.config.reactiveCounterPriority) !== null && _b !== void 0 ? _b : 0); })[0];
             if (!reactiveCounterBuff) {
                 return;
             }
-            const basic = this.getSlots(target.id).find((slot) => slot.definition.type === "basic")?.definition;
+            var basic = (_c = _this.getSlots(target.id).find(function (slot) { return slot.definition.type === "basic"; })) === null || _c === void 0 ? void 0 : _c.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
+            _this.consumeBuffStack(target, reactiveCounterBuff.id);
+            _this.pendingReactiveCounters.push({
+                sourceId: sourceId,
+                targetId: targetId,
+                turn: _this.turn,
+                sourceSkillId: (_e = (_d = _this.activeSkillContext) === null || _d === void 0 ? void 0 : _d.skillId) !== null && _e !== void 0 ? _e : basic.id,
+                sourceTriggeredBy: (_f = _this.activeSkillContext) === null || _f === void 0 ? void 0 : _f.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);
+    };
+    BattleCore.prototype.processPendingReactiveCounters = function () {
+        var _this = this;
+        var _a;
+        var _loop_2 = function () {
+            var pending = this_2.pendingReactiveCounters.shift();
+            var source = this_2.units.find(function (u) { return u.id === pending.sourceId; });
+            var target = this_2.units.find(function (u) { return u.id === pending.targetId; });
             if (!source || !target || !source.runtime.alive || !target.runtime.alive) {
-                continue;
+                return "continue";
             }
-            const basic = this.getSlots(target.id).find((slot) => slot.definition.type === "basic")?.definition;
+            var basic = (_a = this_2.getSlots(target.id).find(function (slot) { return slot.definition.type === "basic"; })) === null || _a === void 0 ? void 0 : _a.definition;
             if (!basic) {
-                continue;
+                return "continue";
             }
-            const counterCtx = {
+            var 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({
+            var counterResult = this_2.executeSkill(target, basic, "counter", counterCtx, [source]);
+            this_2.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));
+            this_2.logger.logSnapshot(pending.turn, "afterSkill", this_2.units, function (unit) { return _this.effectSystem.getEffectiveStats(unit); }, function (unit) { return _this.snapshotBuffs(unit); }, function (unit) { return _this.computeImbalanceMax(unit); });
+        };
+        var this_2 = this;
+        while (this.pendingReactiveCounters.length > 0) {
+            _loop_2();
         }
-    }
-    consumeBuffStack(owner, buffId) {
-        const buff = this.effectSystem.getBuffs(owner.id).find((item) => item.id === buffId);
+    };
+    BattleCore.prototype.consumeBuffStack = function (owner, buffId) {
+        var buff = this.effectSystem.getBuffs(owner.id).find(function (item) { return item.id === buffId; });
         if (!buff) {
             return;
         }
@@ -241,20 +322,24 @@ export class BattleCore {
             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;
+    };
+    BattleCore.prototype.registerConfiguredChaseRules = function () {
+        var e_4, _a;
+        var _this = this;
+        var _loop_3 = function (unit) {
+            var e_5, _d;
+            var slots = this_3.getSlots(unit.id);
+            var _loop_4 = function (slot) {
+                var rule = slot.definition.chaseRule;
                 if (!rule || rule.enabled === false) {
-                    continue;
+                    return "continue";
                 }
-                this.registerChase((ctx, actor) => {
+                this_3.registerChase(function (ctx, actor) {
+                    var _a, _b, _c, _d, _e, _f;
                     if (actor.id !== unit.id || !actor.runtime.alive) {
                         return false;
                     }
-                    if (!(rule.allowSelfTrigger ?? false) && ctx.sourceActorId === actor.id) {
+                    if (!((_a = rule.allowSelfTrigger) !== null && _a !== void 0 ? _a : false) && ctx.sourceActorId === actor.id) {
                         return false;
                     }
                     if (rule.triggerSourceSkillIds && rule.triggerSourceSkillIds.length > 0 && !rule.triggerSourceSkillIds.includes(ctx.sourceSkillId)) {
@@ -265,36 +350,65 @@ export class BattleCore {
                             return false;
                         }
                     }
-                    if (rule.requireSourceTargets ?? true) {
-                        if ((ctx.sourceTargets?.length ?? 0) === 0) {
+                    if ((_b = rule.requireSourceTargets) !== null && _b !== void 0 ? _b : true) {
+                        if (((_d = (_c = ctx.sourceTargets) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0) === 0) {
                             return false;
                         }
                     }
-                    if (rule.sameTeamOnly ?? true) {
-                        const sourceActor = this.units.find((u) => u.id === ctx.sourceActorId);
+                    if ((_e = rule.sameTeamOnly) !== null && _e !== void 0 ? _e : true) {
+                        var sourceActor = _this.units.find(function (u) { return 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;
+                    var chance = Math.min(10000, Math.max(0, Math.floor((_f = rule.chance) !== null && _f !== void 0 ? _f : 10000)));
+                    return Math.floor(_this.rng.next() * 10000) < chance;
+                }, function (actor) {
+                    var _a, _b;
+                    var useSkillId = (_a = rule.useSkillId) !== null && _a !== void 0 ? _a : slot.definition.id;
+                    return (_b = _this.getSlots(actor.id).find(function (s) { return s.definition.id === useSkillId; })) === null || _b === void 0 ? void 0 : _b.definition;
                 });
+            };
+            try {
+                for (var slots_2 = (e_5 = void 0, __values(slots)), slots_2_1 = slots_2.next(); !slots_2_1.done; slots_2_1 = slots_2.next()) {
+                    var slot = slots_2_1.value;
+                    _loop_4(slot);
+                }
+            }
+            catch (e_5_1) { e_5 = { error: e_5_1 }; }
+            finally {
+                try {
+                    if (slots_2_1 && !slots_2_1.done && (_d = slots_2.return)) _d.call(slots_2);
+                }
+                finally { if (e_5) throw e_5.error; }
+            }
+        };
+        var this_3 = this;
+        try {
+            for (var _b = __values(this.units), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var unit = _c.value;
+                _loop_3(unit);
             }
         }
-    }
-    run() {
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+    };
+    BattleCore.prototype.run = function () {
+        var _this = this;
         this.initializeScriptPassives();
         while (!this.winner() && this.actionCount < this.config.maxTurns) {
-            const actor = this.turnBar.fillUntilAction(this.units);
+            var 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.logger.logSnapshot(this.turn, "beforeAction", this.units, function (unit) { return _this.effectSystem.getEffectiveStats(unit); }, function (unit) { return _this.snapshotBuffs(unit); }, function (unit) { return _this.computeImbalanceMax(unit); });
             this.eventBus.emit({ name: "OnTurnStart", payload: { actorId: actor.id, turn: this.turn } });
             this.applyTurnStart(actor);
             this.processPendingReactiveCounters();
@@ -305,70 +419,109 @@ export class BattleCore {
             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));
+            this.logger.logSnapshot(this.turn, "turnEnd", this.units, function (unit) { return _this.effectSystem.getEffectiveStats(unit); }, function (unit) { return _this.snapshotBuffs(unit); }, function (unit) { return _this.computeImbalanceMax(unit); });
         }
         return {
             winner: this.resolveWinnerByRule(),
             totalTurns: this.actionCount,
             logs: this.logger
         };
-    }
-    initializeScriptPassives() {
+    };
+    BattleCore.prototype.initializeScriptPassives = function () {
+        var e_6, _a, e_7, _b;
         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");
+        try {
+            for (var _c = __values(this.units), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var unit = _d.value;
+                var passiveSlots = this.getSlots(unit.id).filter(function (slot) { return slot.definition.type === "passive" && slot.definition.mode === "script" && slot.definition.activateOnBattleStart; });
+                try {
+                    for (var passiveSlots_2 = (e_7 = void 0, __values(passiveSlots)), passiveSlots_2_1 = passiveSlots_2.next(); !passiveSlots_2_1.done; passiveSlots_2_1 = passiveSlots_2.next()) {
+                        var passiveSlot = passiveSlots_2_1.value;
+                        this.executeSkill(unit, passiveSlot.definition, "assist");
+                    }
+                }
+                catch (e_7_1) { e_7 = { error: e_7_1 }; }
+                finally {
+                    try {
+                        if (passiveSlots_2_1 && !passiveSlots_2_1.done && (_b = passiveSlots_2.return)) _b.call(passiveSlots_2);
+                    }
+                    finally { if (e_7) throw e_7.error; }
+                }
             }
         }
-    }
-    performAction(actor) {
-        const slots = this.getSlots(actor.id);
-        const skillOrder = ["ultimate", "core", "basic"];
-        const chaseUsed = new Set();
-        for (const type of skillOrder) {
+        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_6) throw e_6.error; }
+        }
+    };
+    BattleCore.prototype.performAction = function (actor) {
+        var e_8, _a;
+        var _this = this;
+        var slots = this.getSlots(actor.id);
+        var skillOrder = ["ultimate", "core", "basic"];
+        var chaseUsed = new Set();
+        var _loop_5 = function (type) {
             if (!actor.runtime.alive) {
-                break;
+                return "break";
             }
-            const slot = slots.find((s) => s.definition.type === type);
+            var slot = slots.find(function (s) { return s.definition.type === type; });
             if (!slot) {
-                continue;
+                return "continue";
             }
-            const canCast = this.canCast(actor, slot);
+            var canCast = this_4.canCast(actor, slot);
             if (!canCast) {
-                continue;
+                return "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,
+            var result = this_4.executeSkill(actor, slot.definition, "normal");
+            this_4.logger.logAction({
+                turn: this_4.turn,
                 actorId: actor.id,
                 skillId: slot.definition.id,
                 triggeredBy: "normal",
-                result
+                result: result
             });
             if (slot.definition.type !== "ultimate") {
-                this.gainEnergy(actor, slot.definition.energyGain);
+                this_4.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();
+            this_4.logger.logSnapshot(this_4.turn, "afterSkill", this_4.units, function (unit) { return _this.effectSystem.getEffectiveStats(unit); }, function (unit) { return _this.snapshotBuffs(unit); }, function (unit) { return _this.computeImbalanceMax(unit); });
+            this_4.processPendingReactiveCounters();
+            this_4.rearrangePositions();
             if (!actor.runtime.alive) {
-                break;
+                return "break";
             }
-            this.tryChaseAndAssist(actor, result, chaseUsed);
-            if (this.winner()) {
-                break;
+            this_4.tryChaseAndAssist(actor, result, chaseUsed);
+            if (this_4.winner()) {
+                return "break";
+            }
+        };
+        var this_4 = this;
+        try {
+            for (var skillOrder_1 = __values(skillOrder), skillOrder_1_1 = skillOrder_1.next(); !skillOrder_1_1.done; skillOrder_1_1 = skillOrder_1.next()) {
+                var type = skillOrder_1_1.value;
+                var state_1 = _loop_5(type);
+                if (state_1 === "break")
+                    break;
             }
         }
-    }
-    canCast(actor, slot) {
+        catch (e_8_1) { e_8 = { error: e_8_1 }; }
+        finally {
+            try {
+                if (skillOrder_1_1 && !skillOrder_1_1.done && (_a = skillOrder_1.return)) _a.call(skillOrder_1);
+            }
+            finally { if (e_8) throw e_8.error; }
+        }
+    };
+    BattleCore.prototype.canCast = function (actor, slot) {
         if (!actor.runtime.alive || actor.runtime.stunned) {
             return false;
         }
@@ -379,186 +532,212 @@ export class BattleCore {
             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 = (() => {
+    };
+    BattleCore.prototype.executeSkill = function (actor, skill, trigger, triggerCtx, selectedTargetsOverride) {
+        var _this = this;
+        this.eventBus.emit({ name: "OnBeforeCast", payload: { actorId: actor.id, skillId: skill.id, trigger: trigger } });
+        var previousSkillContext = this.activeSkillContext;
+        this.activeSkillContext = { actorId: actor.id, skillId: skill.id, trigger: trigger };
+        var result = (function () {
             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) => {
-                            const r = this.applyDamage(sourceId, targetId, value, skillElement);
+                return _this.skillExecutor.execute(skill, actor, {
+                    rng: _this.rng,
+                    getUnits: function () { return _this.units; },
+                    applyDamage: function (sourceId, targetId, value, staggerElement) { return _this.applyDamage(sourceId, targetId, value, staggerElement); },
+                    applyHeal: function (targetId, value) { return _this.applyHeal(targetId, value); },
+                    applyShield: function (targetId, value) { return _this.applyShield(targetId, value); },
+                    applyBuff: function (sourceId, targetId, buffId) { return _this.applyBuff(sourceId, targetId, buffId); },
+                    getEffectiveStats: function (unit) { return _this.effectSystem.getEffectiveStats(unit); },
+                    createScriptApi: function (skillElement) { return ({
+                        damage: function (sourceId, targetId, value) {
+                            var r = _this.applyDamage(sourceId, targetId, value, skillElement);
                             return { damage: r.damage, imbalanceDelta: r.imbalanceDelta, triggeredImbalanceBreak: r.triggeredImbalanceBreak };
                         },
-                        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");
+                        heal: function (targetId, value) { return _this.applyHeal(targetId, value); },
+                        shield: function (targetId, value) { return _this.applyShield(targetId, value); },
+                        adjustImbalance: function (targetId, delta) {
+                            var _a, _b, _c, _d;
+                            var sourceActorId = (_b = (_a = _this.activeSkillContext) === null || _a === void 0 ? void 0 : _a.actorId) !== null && _b !== void 0 ? _b : actor.id;
+                            var sourceSkillId = (_d = (_c = _this.activeSkillContext) === null || _c === void 0 ? void 0 : _c.skillId) !== null && _d !== void 0 ? _d : 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);
+                        addBuff: function (sourceId, targetId, buffId) { return _this.applyBuff(sourceId, targetId, buffId); },
+                        removeBuff: function (targetId, buffId) {
+                            var target = _this.getUnitById(targetId);
                             if (target) {
-                                this.effectSystem.removeBuff(target, buffId);
+                                _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);
+                        grantExtraTurn: function (unitId) { return _this.turnBar.grantExtraTurn(unitId); },
+                        adjustActionProgress: function (unitId, ratio) { return _this.grantActionProgress(unitId, ratio); },
+                        gainEnergy: function (unitId, value) { return _this.gainEnergyToUnit(unitId, value); },
+                        getUnit: function (unitId) { return _this.units.find(function (u) { return u.id === unitId; }); },
+                        getAliveUnits: function () { return _this.units.filter(function (u) { return u.runtime.alive; }); },
+                        hasBuff: function (unitId, buffId) { return _this.effectSystem.hasBuff(unitId, buffId); },
+                        getBuffs: function (unitId) { return _this.effectSystem.getBuffs(unitId); },
+                        randomInt: function (maxExclusive) { return (maxExclusive <= 0 ? 0 : _this.rng.nextInt(maxExclusive)); },
+                        pushPosition: function (unitId, delta) {
+                            var unit = _this.getUnitById(unitId);
                             if (unit) {
                                 unit.position = Math.max(1, Math.min(4, unit.position + delta));
                             }
                         },
-                        preventDeath: (unitId) => {
-                            const unit = this.getUnitById(unitId);
+                        preventDeath: function (unitId) {
+                            var 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;
+                        isUnitTurn: function (unitId) {
+                            var _a;
+                            return ((_a = _this.activeSkillContext) === null || _a === void 0 ? void 0 : _a.actorId) === unitId;
                         },
-                        castSkill: (actorId, skillId, trigger, targetIds) => {
-                            const castActor = this.getUnitById(actorId);
+                        castSkill: function (actorId, skillId, trigger, targetIds) {
+                            var _a, _b, _c, _d, _e, _f;
+                            var castActor = _this.getUnitById(actorId);
                             if (!castActor || !castActor.runtime.alive) {
                                 return null;
                             }
-                            const castSkill = this.getSlots(actorId).find((slot) => slot.definition.id === skillId)?.definition;
+                            var castSkill = (_a = _this.getSlots(actorId).find(function (slot) { return slot.definition.id === skillId; })) === null || _a === void 0 ? void 0 : _a.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
+                            var selectedTargets = (targetIds !== null && targetIds !== void 0 ? targetIds : [])
+                                .map(function (id) { return _this.getUnitById(id); })
+                                .filter(function (u) { return Boolean(u && u.runtime.alive); });
+                            var triggerCtx = {
+                                turn: _this.turn,
+                                sourceActorId: (_c = (_b = _this.activeSkillContext) === null || _b === void 0 ? void 0 : _b.actorId) !== null && _c !== void 0 ? _c : actorId,
+                                sourceSkillId: (_e = (_d = _this.activeSkillContext) === null || _d === void 0 ? void 0 : _d.skillId) !== null && _e !== void 0 ? _e : skillId,
+                                sourceTargets: selectedTargets.map(function (u) { return u.id; }),
+                                sourceTriggeredBy: (_f = _this.activeSkillContext) === null || _f === void 0 ? void 0 : _f.trigger
                             };
-                            const castResult = this.executeSkill(castActor, castSkill, trigger, triggerCtx, selectedTargets.length > 0 ? selectedTargets : undefined);
-                            this.logger.logAction({
-                                turn: this.turn,
-                                actorId,
-                                skillId,
+                            var castResult = _this.executeSkill(castActor, castSkill, trigger, triggerCtx, selectedTargets.length > 0 ? selectedTargets : undefined);
+                            _this.logger.logAction({
+                                turn: _this.turn,
+                                actorId: actorId,
+                                skillId: 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();
+                            _this.logger.logSnapshot(_this.turn, "afterSkill", _this.units, function (u) { return _this.effectSystem.getEffectiveStats(u); }, function (u) { return _this.snapshotBuffs(u); }, function (u) { return _this.computeImbalanceMax(u); });
+                            _this.processPendingReactiveCounters();
                             return castResult;
                         },
-                        onAnyEvent: (listenerUnitId, eventName, handler) => {
-                            this.eventBus.on(eventName, handler);
+                        onAnyEvent: function (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)
-                    })
+                        spawnUnit: function (initUnit) { return _this.spawnUnit(initUnit); },
+                        extendCooldown: function (unitId, delta) { return _this.extendCooldown(unitId, delta); },
+                        killUnit: function (unitId) { return _this.killUnit(unitId); }
+                    }); }
                 }, trigger, triggerCtx, selectedTargetsOverride);
             }
             finally {
-                this.activeSkillContext = previousSkillContext;
+                _this.activeSkillContext = previousSkillContext;
             }
         })();
-        this.eventBus.emit({ name: "OnAfterCast", payload: { actorId: actor.id, skillId: skill.id, trigger, result } });
+        this.eventBus.emit({ name: "OnAfterCast", payload: { actorId: actor.id, skillId: skill.id, trigger: trigger, result: result } });
         return result;
-    }
-    tryChaseAndAssist(actor, result, chaseUsed) {
-        const triggerCtx = {
+    };
+    BattleCore.prototype.tryChaseAndAssist = function (actor, result, chaseUsed) {
+        var e_9, _a, e_10, _b;
+        var _this = this;
+        var _c;
+        var 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;
+        try {
+            for (var _d = __values(this.units.filter(function (u) { return u.runtime.alive && !chaseUsed.has(u.id); })), _e = _d.next(); !_e.done; _e = _d.next()) {
+                var unit = _e.value;
+                for (var i = 0; i < this.chasePredicates.length; i++) {
+                    if (!this.chasePredicates[i](triggerCtx, unit)) {
+                        continue;
+                    }
+                    var skill = this.chaseSkillResolvers[i](unit);
+                    if (!skill) {
+                        continue;
+                    }
+                    var 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, function (u) { return _this.effectSystem.getEffectiveStats(u); }, function (u) { return _this.snapshotBuffs(u); }, function (u) { return _this.computeImbalanceMax(u); });
+                    this.processPendingReactiveCounters();
+                    chaseUsed.add(unit.id);
                 }
-                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);
             }
         }
+        catch (e_9_1) { e_9 = { error: e_9_1 }; }
+        finally {
+            try {
+                if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+            }
+            finally { if (e_9) throw e_9.error; }
+        }
         if (result.targets.length === 0) {
             return;
         }
-        const firstTarget = this.units.find((u) => u.id === result.targets[0] && u.runtime.alive);
+        var firstTarget = this.units.find(function (u) { return 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;
+        var allies = this.units.filter(function (u) { return u.teamId === actor.teamId && u.id !== actor.id && u.runtime.alive; });
+        try {
+            for (var allies_1 = __values(allies), allies_1_1 = allies_1.next(); !allies_1_1.done; allies_1_1 = allies_1.next()) {
+                var ally = allies_1_1.value;
+                var chance = Math.min(10000, Math.max(0, Math.floor(ally.stats.pAR)));
+                if (Math.floor(this.rng.next() * 10000) >= chance) {
+                    continue;
+                }
+                var basic = (_c = this.getSlots(ally.id).find(function (s) { return s.definition.type === "basic"; })) === null || _c === void 0 ? void 0 : _c.definition;
+                if (!basic) {
+                    continue;
+                }
+                var assistRes = this.executeSkill(ally, basic, "assist", __assign(__assign({}, 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, function (u) { return _this.effectSystem.getEffectiveStats(u); }, function (u) { return _this.snapshotBuffs(u); }, function (u) { return _this.computeImbalanceMax(u); });
+                this.processPendingReactiveCounters();
             }
-            const basic = this.getSlots(ally.id).find((s) => s.definition.type === "basic")?.definition;
-            if (!basic) {
-                continue;
+        }
+        catch (e_10_1) { e_10 = { error: e_10_1 }; }
+        finally {
+            try {
+                if (allies_1_1 && !allies_1_1.done && (_b = allies_1.return)) _b.call(allies_1);
             }
-            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();
+            finally { if (e_10) throw e_10.error; }
         }
-    }
-    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));
+    };
+    BattleCore.prototype.applyDamage = function (sourceId, targetId, value, staggerElement, skipShare) {
+        var _a;
+        if (skipShare === void 0) { skipShare = false; }
+        var target = this.mustUnit(targetId);
+        var source = this.mustUnit(sourceId);
+        this.eventBus.emit({ name: "OnBeforeDamage", payload: { sourceId: sourceId, targetId: targetId, value: value } });
+        this.eventBus.emit({ name: "OnDamageDealt", payload: { sourceId: sourceId, targetId: targetId, value: value } });
+        var 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);
+            var shareBuff_1 = this.effectSystem.getBuffs(target.id).find(function (buff) { var _a; return buff.stacks > 0 && ((_a = buff.config.damageShareToSourceRatio) !== null && _a !== void 0 ? _a : 0) > 0; });
+            if (shareBuff_1 && shareBuff_1.sourceId !== target.id) {
+                var shareTo = this.units.find(function (unit) { return unit.id === shareBuff_1.sourceId && unit.runtime.alive; });
                 if (shareTo) {
-                    const ratio = Math.max(0, Math.min(1, shareBuff.config.damageShareToSourceRatio ?? 0));
-                    const sharedDamage = Math.floor(damage * ratio);
+                    var ratio = Math.max(0, Math.min(1, (_a = shareBuff_1.config.damageShareToSourceRatio) !== null && _a !== void 0 ? _a : 0));
+                    var sharedDamage = Math.floor(damage * ratio);
                     if (sharedDamage > 0) {
                         this.applyDamage(sourceId, shareTo.id, sharedDamage, undefined, true);
                         damage -= sharedDamage;
@@ -567,7 +746,7 @@ export class BattleCore {
             }
         }
         if (target.runtime.Shield > 0) {
-            const absorbed = Math.min(target.runtime.Shield, damage);
+            var absorbed = Math.min(target.runtime.Shield, damage);
             target.runtime.Shield -= absorbed;
             damage -= absorbed;
         }
@@ -577,45 +756,45 @@ export class BattleCore {
             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 } });
-        let imbalanceDelta = 0;
-        let triggeredImbalanceBreak = false;
+        this.eventBus.emit({ name: "OnAfterDamage", payload: { sourceId: sourceId, targetId: targetId, value: damage } });
+        var imbalanceDelta = 0;
+        var triggeredImbalanceBreak = false;
         if (staggerElement && sourceId !== targetId && target.runtime.alive) {
-            const staggerResult = this.accumulateStagger(source, target, staggerElement);
+            var staggerResult = this.accumulateStagger(source, target, staggerElement);
             imbalanceDelta = staggerResult.applied;
             triggeredImbalanceBreak = staggerResult.broke;
         }
-        return { damage, imbalanceDelta, triggeredImbalanceBreak };
-    }
-    applyHeal(targetId, value) {
-        const target = this.mustUnit(targetId);
+        return { damage: damage, imbalanceDelta: imbalanceDelta, triggeredImbalanceBreak: triggeredImbalanceBreak };
+    };
+    BattleCore.prototype.applyHeal = function (targetId, value) {
+        var target = this.mustUnit(targetId);
         if (!target.runtime.alive) {
             return 0;
         }
-        const heal = Math.max(0, Math.floor(value));
-        const old = target.runtime.Hp;
+        var heal = Math.max(0, Math.floor(value));
+        var 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);
+    };
+    BattleCore.prototype.applyShield = function (targetId, value) {
+        var target = this.mustUnit(targetId);
         if (!target.runtime.alive) {
             return 0;
         }
-        const shield = Math.max(0, Math.floor(value));
+        var shield = Math.max(0, Math.floor(value));
         target.runtime.Shield += shield;
         return shield;
-    }
-    applyImbalanceDelta(sourceActorId, sourceSkillId, targetId, delta, reason) {
-        const target = this.mustUnit(targetId);
+    };
+    BattleCore.prototype.applyImbalanceDelta = function (sourceActorId, sourceSkillId, targetId, delta, reason) {
+        var 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)));
+        var max = this.computeImbalanceMax(target);
+        var from = target.runtime.Imbalance;
+        var to = Math.max(0, Math.min(max, from + Math.floor(delta)));
         target.runtime.Imbalance = to;
-        const applied = to - from;
+        var applied = to - from;
         if (applied !== 0) {
             this.logger.logImbalanceChange(target.id, applied, reason, sourceActorId, sourceSkillId);
         }
@@ -623,115 +802,175 @@ export class BattleCore {
             this.pendingImbalanceClear.delete(target.id);
         }
         return applied;
-    }
-    computeImbalanceMax(unit) {
-        const effectiveStats = this.effectSystem.getEffectiveStats(unit);
+    };
+    BattleCore.prototype.computeImbalanceMax = function (unit) {
+        var effectiveStats = this.effectSystem.getEffectiveStats(unit);
         return Math.floor(Math.floor(unit.stats.Mhp * 6000 / 10000) * (10000 + effectiveStats.pITM) / 10000);
-    }
-    accumulateStagger(source, target, skillElement) {
+    };
+    BattleCore.prototype.accumulateStagger = function (source, target, skillElement) {
+        var _a, _b, _c;
         if (this.pendingImbalanceClear.has(target.id)) {
             return { applied: 0, broke: false };
         }
-        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);
+        var effectiveSource = this.effectSystem.getEffectiveStats(source);
+        var baseStagger = effectiveSource.Att;
+        var stagger = Math.floor(baseStagger * (10000 + effectiveSource.pIM) / 10000);
+        var 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 takenRate = 10000 + this.effectSystem.getImbalanceTakenRate(target.id);
+        var takenRate = 10000 + this.effectSystem.getImbalanceTakenRate(target.id);
         stagger = Math.max(0, Math.floor(stagger * takenRate / 10000));
-        const max = this.computeImbalanceMax(target);
-        const from = target.runtime.Imbalance;
+        var max = this.computeImbalanceMax(target);
+        var from = target.runtime.Imbalance;
         target.runtime.Imbalance = Math.min(max, from + stagger);
-        const applied = target.runtime.Imbalance - from;
+        var applied = target.runtime.Imbalance - from;
         if (applied !== 0) {
-            this.logger.logImbalanceChange(target.id, applied, "skill_effect", this.activeSkillContext?.actorId ?? source.id, this.activeSkillContext?.skillId);
+            this.logger.logImbalanceChange(target.id, applied, "skill_effect", (_b = (_a = this.activeSkillContext) === null || _a === void 0 ? void 0 : _a.actorId) !== null && _b !== void 0 ? _b : source.id, (_c = this.activeSkillContext) === null || _c === void 0 ? void 0 : _c.skillId);
         }
-        let broke = false;
+        var broke = false;
         if (target.runtime.Imbalance >= max) {
             broke = true;
             this.onImbalanceBreak(source, target, skillElement);
         }
-        return { applied, broke };
-    }
-    onImbalanceBreak(source, target, element) {
-        const max = this.computeImbalanceMax(target);
+        return { applied: applied, broke: broke };
+    };
+    BattleCore.prototype.onImbalanceBreak = function (source, target, element) {
+        var e_11, _a;
+        var max = this.computeImbalanceMax(target);
         target.runtime.Imbalance = max;
         this.pendingImbalanceClear.add(target.id);
-        const breakBuffs = this.effectSystem
+        var 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;
+            .filter(function (buff) { var _a; return buff.applyOnImbalanceBreak || ((_a = buff.applyOnElementBreakElements) === null || _a === void 0 ? void 0 : _a.includes(element)); });
+        var appliedBuffIds = new Set();
+        try {
+            for (var breakBuffs_1 = __values(breakBuffs), breakBuffs_1_1 = breakBuffs_1.next(); !breakBuffs_1_1.done; breakBuffs_1_1 = breakBuffs_1.next()) {
+                var breakBuff = breakBuffs_1_1.value;
+                if (appliedBuffIds.has(breakBuff.id)) {
+                    continue;
+                }
+                appliedBuffIds.add(breakBuff.id);
+                this.applyBuff(source.id, target.id, breakBuff.id);
             }
-            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 } });
+        catch (e_11_1) { e_11 = { error: e_11_1 }; }
+        finally {
+            try {
+                if (breakBuffs_1_1 && !breakBuffs_1_1.done && (_a = breakBuffs_1.return)) _a.call(breakBuffs_1);
+            }
+            finally { if (e_11) throw e_11.error; }
+        }
+        this.eventBus.emit({ name: "OnImbalanceBreak", payload: { sourceId: source.id, targetId: target.id, element: element } });
         this.logger.logImbalanceBreak(target.id, source.id, element);
-    }
-    applyBuff(sourceId, targetId, buffId) {
-        const target = this.mustUnit(targetId);
+    };
+    BattleCore.prototype.applyBuff = function (sourceId, targetId, buffId) {
+        var target = this.mustUnit(targetId);
         this.effectSystem.addBuff(target, sourceId, buffId);
-    }
-    applyTurnStart(actor) {
+    };
+    BattleCore.prototype.applyTurnStart = function (actor) {
+        var e_12, _a;
         if (this.pendingImbalanceClear.has(actor.id)) {
-            const from = actor.runtime.Imbalance;
+            var 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);
+        var dotEvents = this.effectSystem.onTurnStart(actor, this.units);
+        try {
+            for (var dotEvents_1 = __values(dotEvents), dotEvents_1_1 = dotEvents_1.next(); !dotEvents_1_1.done; dotEvents_1_1 = dotEvents_1.next()) {
+                var dot = dotEvents_1_1.value;
+                this.applyDamage(actor.id, dot.targetId, dot.value);
+                // 记录DOT伤害到logger，用于飘字展示
+                this.logger.logDotDamage(dot.targetId, dot.value, dot.buffId, dot.element);
+            }
+        }
+        catch (e_12_1) { e_12 = { error: e_12_1 }; }
+        finally {
+            try {
+                if (dotEvents_1_1 && !dotEvents_1_1.done && (_a = dotEvents_1.return)) _a.call(dotEvents_1);
+            }
+            finally { if (e_12) throw e_12.error; }
         }
         this.rearrangePositions();
-    }
-    applyTurnEnd(actor) {
+    };
+    BattleCore.prototype.applyTurnEnd = function (actor) {
         this.effectSystem.onTurnEnd(actor, this.units);
         this.rearrangePositions();
-    }
-    gainEnergy(actor, value) {
+    };
+    BattleCore.prototype.gainEnergy = function (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);
+    };
+    BattleCore.prototype.gainEnergyToUnit = function (unitId, value) {
+        var actor = this.mustUnit(unitId);
+        var ratio = 10000 + actor.stats.pER;
+        var 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;
+    };
+    BattleCore.prototype.decrementAllCooldowns = function (actorId) {
+        var e_13, _a, e_14, _b;
+        try {
+            for (var _c = __values(this.skillSlots.entries()), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var _e = __read(_d.value, 2), id = _e[0], slots = _e[1];
+                if (id !== actorId) {
+                    continue;
+                }
+                try {
+                    for (var slots_3 = (e_14 = void 0, __values(slots)), slots_3_1 = slots_3.next(); !slots_3_1.done; slots_3_1 = slots_3.next()) {
+                        var slot = slots_3_1.value;
+                        slot.cooldownRemain = Math.max(0, slot.cooldownRemain - 1);
+                    }
+                }
+                catch (e_14_1) { e_14 = { error: e_14_1 }; }
+                finally {
+                    try {
+                        if (slots_3_1 && !slots_3_1.done && (_b = slots_3.return)) _b.call(slots_3);
+                    }
+                    finally { if (e_14) throw e_14.error; }
+                }
             }
-            for (const slot of slots) {
-                slot.cooldownRemain = Math.max(0, slot.cooldownRemain - 1);
+        }
+        catch (e_13_1) { e_13 = { error: e_13_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
             }
+            finally { if (e_13) throw e_13.error; }
         }
-    }
-    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) => {
+    };
+    BattleCore.prototype.getSlots = function (unitId) {
+        var _a;
+        return (_a = this.skillSlots.get(unitId)) !== null && _a !== void 0 ? _a : [];
+    };
+    BattleCore.prototype.rearrangePositions = function () {
+        var e_15, _a;
+        var _loop_6 = function (teamId) {
+            var alive = this_5.units.filter(function (u) { return u.teamId === teamId && u.runtime.alive; }).sort(function (a, b) { return a.position - b.position; });
+            alive.forEach(function (u, idx) {
                 u.position = (idx + 1);
             });
+        };
+        var this_5 = this;
+        try {
+            for (var _b = __values([1, 2]), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var teamId = _c.value;
+                _loop_6(teamId);
+            }
         }
-    }
-    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);
+        catch (e_15_1) { e_15 = { error: e_15_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_15) throw e_15.error; }
+        }
+    };
+    BattleCore.prototype.winner = function () {
+        var t1Alive = this.units.some(function (u) { return u.teamId === 1 && u.runtime.alive; });
+        var t2Alive = this.units.some(function (u) { return u.teamId === 2 && u.runtime.alive; });
         if (!t1Alive && !t2Alive) {
             return 0;
         }
@@ -742,14 +981,14 @@ export class BattleCore {
             return 1;
         }
         return 0;
-    }
-    resolveWinnerByRule() {
-        const w = this.winner();
+    };
+    BattleCore.prototype.resolveWinnerByRule = function () {
+        var w = this.winner();
         if (w) {
             return w;
         }
-        const t1 = this.hpRatio(1);
-        const t2 = this.hpRatio(2);
+        var t1 = this.hpRatio(1);
+        var t2 = this.hpRatio(2);
         if (t1 > t2) {
             return 1;
         }
@@ -757,35 +996,37 @@ export class BattleCore {
             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);
+    };
+    BattleCore.prototype.hpRatio = function (teamId) {
+        var team = this.units.filter(function (u) { return u.teamId === teamId; });
+        var hp = team.reduce(function (sum, u) { return sum + Math.max(0, u.runtime.Hp); }, 0);
+        var mhp = team.reduce(function (sum, u) { return sum + u.stats.Mhp; }, 0);
         return mhp > 0 ? hp / mhp : 0;
-    }
-    mustUnit(id) {
-        const unit = this.units.find((u) => u.id === id);
+    };
+    BattleCore.prototype.mustUnit = function (id) {
+        var unit = this.units.find(function (u) { return u.id === id; });
         if (!unit) {
-            throw new Error(`unit-not-found:${id}`);
+            throw new Error("unit-not-found:".concat(id));
         }
         return unit;
-    }
-    maxUltimateCost(skills) {
-        const ult = skills.find((s) => s.type === "ultimate");
+    };
+    BattleCore.prototype.maxUltimateCost = function (skills) {
+        var ult = skills.find(function (s) { return s.type === "ultimate"; });
         return ult ? ult.energyCost : 100;
-    }
-    snapshotBuffs(unit) {
+    };
+    BattleCore.prototype.snapshotBuffs = function (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) => ({
+            .filter(function (b) { return b.stacks > 0 && b.remainingRounds > 0; })
+            .sort(function (a, b) { return a.id.localeCompare(b.id); })
+            .map(function (b) { return ({
             id: b.id,
             name: b.config.name,
             stacks: b.stacks,
             remainingRounds: b.remainingRounds,
             sourceId: b.sourceId
-        }));
-    }
-}
+        }); });
+    };
+    return BattleCore;
+}());
+export { BattleCore };