hrbattle 0.1.0

package/dist/battle/script/designedScripts.js

@@ -0,0 +1,1013 @@
+import { monsterScripts16xx } from "./monsterScripts";
+import { monsterScripts18xx } from "./monsterScripts18xx";
+import { monsterScripts19xxPart1 } from "./monsterScripts19xx";
+import { monsterScripts19xxPart2 } from "./monsterScripts19xxPart2";
+const ailishaOriginalPositions = new Map();
+function buildEmptyResult(ctx, targets = ctx.targets) {
+    return {
+        skillId: ctx.skillId,
+        casterId: ctx.caster,
+        targets,
+        totalDamage: 0,
+        totalHeal: 0,
+        totalShield: 0,
+        triggeredBy: ctx.trigger
+    };
+}
+function buildDamageHit(ctx, targetId, finalValue) {
+    return {
+        targetId,
+        effectType: "damage",
+        element: ctx.api.getUnit(ctx.caster)?.element ?? "fire",
+        skillType: "basic",
+        isCritical: false,
+        baseValue: finalValue,
+        criticalValue: finalValue,
+        finalValue,
+        isRepression: 0,
+        damageBreakdown: {
+            preMitigation: finalValue,
+            postMitigation: finalValue,
+            shieldAbsorbed: 0,
+            hpDamage: finalValue
+        }
+    };
+}
+function buildBuffHit(ctx, targetId, buffId, resisted = false) {
+    return {
+        targetId,
+        effectType: "buff",
+        element: ctx.api.getUnit(ctx.caster)?.element ?? "fire",
+        skillType: "basic",
+        isCritical: false,
+        baseValue: 0,
+        criticalValue: 0,
+        finalValue: 0,
+        isRepression: 0,
+        appliedBuffId: resisted ? undefined : buffId,
+        resisted
+    };
+}
+function buildShieldHit(ctx, targetId, finalValue) {
+    return {
+        targetId,
+        effectType: "shield",
+        element: ctx.api.getUnit(ctx.caster)?.element ?? "fire",
+        skillType: "basic",
+        isCritical: false,
+        baseValue: finalValue,
+        criticalValue: finalValue,
+        finalValue,
+        isRepression: 0
+    };
+}
+function buildHealHit(ctx, targetId, finalValue) {
+    return {
+        targetId,
+        effectType: "heal",
+        element: ctx.api.getUnit(ctx.caster)?.element ?? "fire",
+        skillType: "basic",
+        isCritical: false,
+        baseValue: finalValue,
+        criticalValue: finalValue,
+        finalValue,
+        isRepression: 0
+    };
+}
+const bladeUltimateScript = {
+    onCast(ctx) {
+        const self = ctx.api.getUnit(ctx.caster);
+        const targetId = ctx.targets[0];
+        if (!self || !targetId) {
+            return buildEmptyResult(ctx, targetId ? [targetId] : []);
+        }
+        const target = ctx.api.getUnit(targetId);
+        let totalDamage = 0;
+        const hits = [];
+        if (target && target.runtime.Hp * 100 < target.stats.Mhp * 50) {
+            // 策划：对生命值低于50%的敌人额外造成20%伤害
+            const damage = ctx.api.damage(ctx.caster, targetId, Math.floor(self.stats.Att * 0.2));
+            totalDamage += damage;
+            hits.push(buildDamageHit(ctx, targetId, damage));
+        }
+        return {
+            ...buildEmptyResult(ctx, [targetId]),
+            totalDamage,
+            hits
+        };
+    }
+};
+// 布莱德/岚普攻：对生命值高于70%的敌人造成额外20%伤害
+const bladeBasicScript = {
+    onCast(ctx) {
+        const self = ctx.api.getUnit(ctx.caster);
+        const targetId = ctx.targets[0];
+        if (!self || !targetId) {
+            return buildEmptyResult(ctx, targetId ? [targetId] : []);
+        }
+        const target = ctx.api.getUnit(targetId);
+        let totalDamage = 0;
+        const hits = [];
+        if (target && target.runtime.Hp * 100 > target.stats.Mhp * 70) {
+            // 策划：对生命值高于70%的敌人造成额外20%伤害
+            const damage = ctx.api.damage(ctx.caster, targetId, Math.floor(self.stats.Att * 0.2));
+            totalDamage += damage;
+            hits.push(buildDamageHit(ctx, targetId, damage));
+        }
+        return {
+            ...buildEmptyResult(ctx, [targetId]),
+            totalDamage,
+            hits
+        };
+    }
+};
+const bladeCoreScript = {
+    onCast(ctx) {
+        const self = ctx.api.getUnit(ctx.caster);
+        if (!self) {
+            return buildEmptyResult(ctx, []);
+        }
+        const enemies = ctx.api.getAliveUnits().filter((unit) => unit.teamId !== self.teamId);
+        if (enemies.length === 0) {
+            return buildEmptyResult(ctx, []);
+        }
+        let totalDamage = 0;
+        const hitTargets = [];
+        const hits = [];
+        for (let i = 0; i < 3; i++) {
+            const target = enemies[ctx.api.randomInt(enemies.length)];
+            hitTargets.push(target.id);
+            const damage = ctx.api.damage(ctx.caster, target.id, Math.floor(self.stats.Att * 0.3));
+            totalDamage += damage;
+            hits.push(buildDamageHit(ctx, target.id, damage));
+            if (ctx.api.randomInt(10000) < 2000) {
+                ctx.api.gainEnergy(ctx.caster, 10);
+            }
+        }
+        return {
+            ...buildEmptyResult(ctx, hitTargets),
+            totalDamage,
+            hits
+        };
+    }
+};
+const luoluoBasicScript = {
+    onCast(ctx) {
+        ctx.api.addBuff(ctx.caster, ctx.caster, "will");
+        return {
+            skillId: ctx.skillId,
+            casterId: ctx.caster,
+            targets: ctx.targets,
+            totalDamage: 0,
+            totalHeal: 0,
+            totalShield: 0,
+            triggeredBy: ctx.trigger
+        };
+    }
+};
+// 洛洛核心技：获得10%生命值的护盾，每层【惩戒/意志】使护盾强度增加10%
+const luoluoCoreScript = {
+    onCast(ctx) {
+        const self = ctx.api.getUnit(ctx.caster);
+        let totalShield = 0;
+        const hits = [];
+        if (self) {
+            // 策划：10%Mhp护盾，每层意志增加10%
+            const willBuffs = ctx.api.getBuffs(ctx.caster).filter(b => b.id === "will");
+            const willStacks = willBuffs.reduce((sum, b) => sum + b.stacks, 0);
+            const shieldMultiplier = 1 + willStacks * 0.1;
+            const shield = Math.floor(self.stats.Mhp * 0.1 * shieldMultiplier);
+            ctx.api.shield(ctx.caster, shield);
+            totalShield += shield;
+            hits.push(buildShieldHit(ctx, ctx.caster, shield));
+        }
+        return {
+            ...buildEmptyResult(ctx, ctx.targets),
+            totalShield: totalShield,
+            hits
+        };
+    }
+};
+const miaoluoUltimateScript = {
+    onCast(ctx) {
+        const self = ctx.api.getUnit(ctx.caster);
+        const target = ctx.api
+            .getAliveUnits()
+            .filter((unit) => self && unit.teamId !== self.teamId)
+            .sort((a, b) => {
+            if (a.runtime.Hp !== b.runtime.Hp) {
+                return a.runtime.Hp - b.runtime.Hp;
+            }
+            return a.position - b.position;
+        })[0];
+        let totalDamage = 0;
+        const hits = [];
+        if (self && target) {
+            ctx.api.addBuff(ctx.caster, ctx.caster, "miaoluo-ultimate-focus");
+            hits.push(buildBuffHit(ctx, ctx.caster, "miaoluo-ultimate-focus"));
+            for (let i = 0; i < 3; i += 1) {
+                const damage = ctx.api.damage(ctx.caster, target.id, Math.floor(self.stats.Att * 0.6));
+                totalDamage += damage;
+                hits.push(buildDamageHit(ctx, target.id, damage));
+            }
+            if (ctx.api.hasBuff(target.id, "imbalance-vulnerability")) {
+                const damage = ctx.api.damage(ctx.caster, target.id, Math.floor(self.stats.Att * 0.3));
+                totalDamage += damage;
+                hits.push(buildDamageHit(ctx, target.id, damage));
+            }
+        }
+        return {
+            ...buildEmptyResult(ctx, target ? [target.id] : []),
+            totalDamage,
+            hits
+        };
+    }
+};
+const miaoluoBasicScript = {
+    onCast(ctx) {
+        const self = ctx.api.getUnit(ctx.caster);
+        const target = ctx.api
+            .getAliveUnits()
+            .filter((unit) => self && unit.teamId !== self.teamId)
+            .sort((a, b) => {
+            if (a.runtime.Hp !== b.runtime.Hp) {
+                return a.runtime.Hp - b.runtime.Hp;
+            }
+            return a.position - b.position;
+        })[0];
+        let totalDamage = 0;
+        const hits = [];
+        if (self && target) {
+            const damage = ctx.api.damage(ctx.caster, target.id, Math.floor(self.stats.Att * 0.5));
+            totalDamage += damage;
+            hits.push(buildDamageHit(ctx, target.id, damage));
+        }
+        return {
+            ...buildEmptyResult(ctx, target ? [target.id] : []),
+            totalDamage,
+            hits
+        };
+    }
+};
+const miaoluoCoreScript = {
+    onCast(ctx) {
+        const self = ctx.api.getUnit(ctx.caster);
+        const target = ctx.api
+            .getAliveUnits()
+            .filter((unit) => self && unit.teamId !== self.teamId)
+            .sort((a, b) => {
+            if (a.runtime.Hp !== b.runtime.Hp) {
+                return a.runtime.Hp - b.runtime.Hp;
+            }
+            return a.position - b.position;
+        })[0];
+        let totalDamage = 0;
+        const hits = [];
+        if (self && target) {
+            const damage = ctx.api.damage(ctx.caster, target.id, Math.floor(self.stats.Att * 0.8));
+            totalDamage += damage;
+            hits.push(buildDamageHit(ctx, target.id, damage));
+            ctx.api.addBuff(ctx.caster, target.id, "static");
+            hits.push(buildBuffHit(ctx, target.id, "static"));
+            ctx.api.addBuff(ctx.caster, ctx.caster, "flash");
+            hits.push(buildBuffHit(ctx, ctx.caster, "flash"));
+        }
+        return {
+            ...buildEmptyResult(ctx, target ? [target.id] : []),
+            totalDamage,
+            hits
+        };
+    }
+};
+const cookBasicScript = {
+    onCast(ctx) {
+        const self = ctx.api.getUnit(ctx.caster);
+        const targetId = ctx.targets[0];
+        let totalDamage = 0;
+        const hits = [];
+        if (self) {
+            const selfCost = Math.floor(self.runtime.Hp * 0.1);
+            if (selfCost > 0) {
+                const damage = ctx.api.damage(ctx.caster, ctx.caster, selfCost);
+                totalDamage += damage;
+                hits.push(buildDamageHit(ctx, ctx.caster, damage));
+                if (targetId) {
+                    const damage2 = ctx.api.damage(ctx.caster, targetId, Math.floor(selfCost * 0.5));
+                    totalDamage += damage2;
+                    hits.push(buildDamageHit(ctx, targetId, damage2));
+                }
+            }
+        }
+        return {
+            ...buildEmptyResult(ctx, ctx.targets),
+            totalDamage,
+            hits
+        };
+    }
+};
+const cookCoreScript = {
+    onCast(ctx) {
+        const self = ctx.api.getUnit(ctx.caster);
+        const enemies = ctx.api
+            .getAliveUnits()
+            .filter((unit) => self && unit.teamId !== self.teamId)
+            .sort((a, b) => {
+            if (b.runtime.Hp !== a.runtime.Hp) {
+                return b.runtime.Hp - a.runtime.Hp;
+            }
+            return a.position - b.position;
+        });
+        const target = enemies[0];
+        let totalDamage = 0;
+        const hits = [];
+        if (self && target) {
+            const lostHp = Math.max(0, self.stats.Mhp - self.runtime.Hp);
+            const lostStepCount = Math.floor((lostHp * 10) / Math.max(1, self.stats.Mhp));
+            const multiplier = 1 + lostStepCount * 0.05;
+            const damage = ctx.api.damage(ctx.caster, target.id, Math.floor(self.stats.Att * multiplier));
+            totalDamage += damage;
+            hits.push(buildDamageHit(ctx, target.id, damage));
+        }
+        return {
+            ...buildEmptyResult(ctx, target ? [target.id] : []),
+            totalDamage,
+            hits
+        };
+    }
+};
+const cookUltimateScript = {
+    onCast(ctx) {
+        const self = ctx.api.getUnit(ctx.caster);
+        let totalHeal = 0;
+        const hits = [];
+        if (self) {
+            const lostHp = Math.max(0, self.stats.Mhp - self.runtime.Hp);
+            const heal = ctx.api.heal(ctx.caster, Math.floor(lostHp * 0.2));
+            totalHeal += heal;
+            hits.push(buildHealHit(ctx, ctx.caster, heal));
+        }
+        return {
+            ...buildEmptyResult(ctx, ctx.targets),
+            totalHeal,
+            hits
+        };
+    }
+};
+const kesiCoreScript = {
+    onCast(ctx) {
+        const self = ctx.api.getUnit(ctx.caster);
+        if (!self) {
+            return buildEmptyResult(ctx, []);
+        }
+        const candidates = ctx.api.getAliveUnits().filter((unit) => unit.id !== ctx.caster);
+        if (candidates.length === 0) {
+            return buildEmptyResult(ctx, []);
+        }
+        const pool = [...candidates];
+        const hitTargets = [];
+        let totalDamage = 0;
+        const hits = [];
+        const hitCount = Math.min(4, pool.length);
+        for (let i = 0; i < hitCount; i++) {
+            const index = ctx.api.randomInt(pool.length);
+            const [target] = pool.splice(index, 1);
+            hitTargets.push(target.id);
+            const damage = ctx.api.damage(ctx.caster, target.id, Math.floor(self.stats.Att * 0.5));
+            totalDamage += damage;
+            hits.push(buildDamageHit(ctx, target.id, damage));
+            if (target.teamId === self.teamId) {
+                ctx.api.gainEnergy(ctx.caster, 10);
+            }
+        }
+        return {
+            ...buildEmptyResult(ctx, hitTargets),
+            totalDamage,
+            hits
+        };
+    }
+};
+const kesiUltimateScript = {
+    onCast(ctx) {
+        const self = ctx.api.getUnit(ctx.caster);
+        if (!self) {
+            return buildEmptyResult(ctx, []);
+        }
+        const enemies = ctx.api.getAliveUnits().filter((unit) => unit.teamId !== self.teamId);
+        if (enemies.length === 0) {
+            return buildEmptyResult(ctx, []);
+        }
+        let totalDamage = 0;
+        const hitTargets = [];
+        const attacked = new Set();
+        const hits = [];
+        for (let i = 0; i < 8; i++) {
+            const target = enemies[ctx.api.randomInt(enemies.length)];
+            hitTargets.push(target.id);
+            attacked.add(target.id);
+            const damage = ctx.api.damage(ctx.caster, target.id, Math.floor(self.stats.Att * 0.8));
+            totalDamage += damage;
+            hits.push(buildDamageHit(ctx, target.id, damage));
+        }
+        for (const targetId of attacked) {
+            const target = ctx.api.getUnit(targetId);
+            if (!target) {
+                continue;
+            }
+            const dotValue = ctx.api
+                .getBuffs(targetId)
+                .filter((buff) => buff.stacks > 0 && buff.config.dotRatio)
+                .reduce((sum, buff) => sum + Math.floor(target.stats.Att * (buff.config.dotRatio ?? 0) * buff.stacks), 0);
+            if (dotValue > 0) {
+                const damage = ctx.api.damage(ctx.caster, targetId, Math.floor(dotValue * 0.6));
+                totalDamage += damage;
+                hits.push(buildDamageHit(ctx, target.id, damage));
+            }
+        }
+        return {
+            ...buildEmptyResult(ctx, hitTargets),
+            totalDamage,
+            hits
+        };
+    }
+};
+const kleiwuBasicScript = {
+    onCast(ctx) {
+        const self = ctx.api.getUnit(ctx.caster);
+        const targetId = ctx.targets[0];
+        if (!self || !targetId) {
+            return buildEmptyResult(ctx, targetId ? [targetId] : []);
+        }
+        const hits = [];
+        // 50%概率施加侵蚀
+        if (ctx.api.randomInt(10000) < 5000) {
+            ctx.api.addBuff(ctx.caster, targetId, "erosion");
+            hits.push(buildBuffHit(ctx, targetId, "erosion"));
+        }
+        return {
+            ...buildEmptyResult(ctx, ctx.targets),
+            totalDamage: 0,
+            hits
+        };
+    }
+};
+const kleiwuCoreScript = {
+    onCast(ctx) {
+        const self = ctx.api.getUnit(ctx.caster);
+        const targetId = ctx.targets[0];
+        if (!self || !targetId) {
+            return buildEmptyResult(ctx, targetId ? [targetId] : []);
+        }
+        const hits = [];
+        // 赋予侵蚀
+        ctx.api.addBuff(ctx.caster, targetId, "erosion");
+        hits.push(buildBuffHit(ctx, targetId, "erosion"));
+        // 往前拉一格 - 位移
+        ctx.api.pushPosition(targetId, -1);
+        return {
+            ...buildEmptyResult(ctx, ctx.targets),
+            hits
+        };
+    }
+};
+const kleiwuPassiveScript = {
+    onCast(ctx) {
+        ctx.api.onAnyEvent(ctx.caster, "OnDamageDealt", (data) => {
+            const self = ctx.api.getUnit(ctx.caster);
+            if (!self)
+                return;
+            if (ctx.api.isUnitTurn(ctx.caster)) {
+                ctx.api.gainEnergy(ctx.caster, 8);
+                ctx.api.addBuff(ctx.caster, ctx.caster, "rage");
+            }
+        });
+        ctx.api.onAnyEvent(ctx.caster, "OnImbalanceBreak", (data) => {
+            const self = ctx.api.getUnit(ctx.caster);
+            const source = ctx.api.getUnit(data.sourceId);
+            const target = ctx.api.getUnit(data.targetId);
+            if (!self || !source || !target || !self.runtime.alive || !source.runtime.alive || !target.runtime.alive) {
+                return;
+            }
+            if (self.id === source.id || self.teamId !== source.teamId || self.teamId === target.teamId) {
+                return;
+            }
+            ctx.api.castSkill(ctx.caster, "11051", "chase", [target.id]);
+        });
+        return buildEmptyResult(ctx, [ctx.caster]);
+    }
+};
+const kleiwuUltimateScript = {
+    onCast(ctx) {
+        // 伤害和溅射由模板处理
+        // 额外累计30%失衡值由系统处理
+        return buildEmptyResult(ctx, ctx.targets);
+    }
+};
+const rudyCoreScript = {
+    onCast(ctx) {
+        const self = ctx.api.getUnit(ctx.caster);
+        if (!self) {
+            return buildEmptyResult(ctx, ctx.targets);
+        }
+        // 添加3层反击
+        for (let i = 0; i < 3; i++) {
+            ctx.api.addBuff(ctx.caster, ctx.caster, "counter");
+        }
+        return buildEmptyResult(ctx, ctx.targets);
+    }
+};
+// 鲁迪被动：拥有【反击】时首次受到致命伤时免死，恢复50%生命
+const rudyPassiveScript = {
+    onCast(ctx) {
+        // 监听OnDeath事件，在死亡时触发免死+回血
+        ctx.api.onAnyEvent(ctx.caster, "OnDeath", (data) => {
+            if (data.targetId !== ctx.caster)
+                return;
+            const self = ctx.api.getUnit(ctx.caster);
+            if (!self)
+                return;
+            // 检查是否拥有反击且未使用过免死
+            const hasCounter = ctx.api.getBuffs(ctx.caster).some(b => b.id === "counter" && b.stacks > 0);
+            if (hasCounter && !ctx.api.hasBuff(ctx.caster, "rudy-cheat-death")) {
+                // 免死：恢复alive状态并回血50%最大生命
+                ctx.api.preventDeath(ctx.caster);
+                ctx.api.heal(ctx.caster, Math.floor(self.stats.Mhp * 0.5));
+                ctx.api.addBuff(ctx.caster, ctx.caster, "rudy-cheat-death");
+            }
+        });
+        return buildEmptyResult(ctx, [ctx.caster]);
+    }
+};
+const rudyUltimateScript = {
+    onCast(ctx) {
+        const self = ctx.api.getUnit(ctx.caster);
+        if (!self) {
+            return buildEmptyResult(ctx, ctx.targets);
+        }
+        // 添加3层反击
+        for (let i = 0; i < 3; i++) {
+            ctx.api.addBuff(ctx.caster, ctx.caster, "counter");
+        }
+        // 护盾由模板处理
+        return buildEmptyResult(ctx, ctx.targets);
+    }
+};
+const ailishaCoreScript = {
+    onCast(ctx) {
+        const self = ctx.api.getUnit(ctx.caster);
+        if (self) {
+            for (const unit of ctx.api.getAliveUnits()) {
+                if (unit.id === self.id || unit.teamId !== self.teamId) {
+                    continue;
+                }
+                if (Math.abs(unit.position - self.position) <= 1) {
+                    ctx.api.addBuff(self.id, unit.id, "share-damage");
+                }
+            }
+        }
+        return {
+            skillId: ctx.skillId,
+            casterId: ctx.caster,
+            targets: ctx.targets,
+            totalDamage: 0,
+            totalHeal: 0,
+            totalShield: 0,
+            triggeredBy: ctx.trigger
+        };
+    }
+};
+// 艾莉莎大招：对生命值最高的敌人造成120%火属性伤害。消耗所有护盾恢复等量生命
+const ailishaUltimateScript = {
+    onCast(ctx) {
+        const self = ctx.api.getUnit(ctx.caster);
+        const hits = [];
+        let totalHeal = 0;
+        if (self && self.runtime.Shield > 0) {
+            // 策划：消耗所有护盾恢复等量生命
+            const healAmount = self.runtime.Shield;
+            self.runtime.Shield = 0;
+            const heal = ctx.api.heal(ctx.caster, healAmount);
+            totalHeal += heal;
+            hits.push(buildHealHit(ctx, ctx.caster, heal));
+        }
+        if (self) {
+            ctx.api.removeBuff(ctx.caster, "ailisha-rebirth");
+        }
+        return {
+            ...buildEmptyResult(ctx, ctx.targets),
+            totalHeal,
+            hits
+        };
+    }
+};
+const luolaiCoreScript = {
+    onCast(ctx) {
+        for (const unit of ctx.api.getAliveUnits()) {
+            if (unit.teamId !== ctx.api.getUnit(ctx.caster)?.teamId) {
+                continue;
+            }
+            ctx.api.addBuff(ctx.caster, unit.id, "condense");
+        }
+        return {
+            skillId: ctx.skillId,
+            casterId: ctx.caster,
+            targets: ctx.targets,
+            totalDamage: 0,
+            totalHeal: 0,
+            totalShield: 0,
+            triggeredBy: ctx.trigger
+        };
+    }
+};
+const luolaiBasicScript = {
+    onCast(ctx) {
+        const self = ctx.api.getUnit(ctx.caster);
+        if (!self) {
+            return buildEmptyResult(ctx, []);
+        }
+        const enemies = ctx.api.getAliveUnits().filter((unit) => unit.teamId !== self.teamId);
+        if (enemies.length === 0) {
+            return buildEmptyResult(ctx, []);
+        }
+        const target = enemies[ctx.api.randomInt(enemies.length)];
+        const allies = ctx.api.getAliveUnits()
+            .filter((unit) => unit.teamId === self.teamId)
+            .sort((a, b) => a.position - b.position);
+        const frontAlly = allies[0];
+        let totalDamage = 0;
+        let totalHeal = 0;
+        const hits = [];
+        const damage = ctx.api.damage(ctx.caster, target.id, Math.floor(self.stats.Att * 0.5));
+        totalDamage += damage;
+        hits.push(buildDamageHit(ctx, target.id, damage));
+        if (frontAlly) {
+            const heal = ctx.api.heal(frontAlly.id, Math.floor(damage * 0.5));
+            totalHeal += heal;
+            hits.push(buildHealHit(ctx, frontAlly.id, heal));
+        }
+        return {
+            ...buildEmptyResult(ctx, [target.id]),
+            totalDamage,
+            totalHeal,
+            hits
+        };
+    }
+};
+const luolaiUltimateScript = {
+    onCast(ctx) {
+        const self = ctx.api.getUnit(ctx.caster);
+        if (!self) {
+            return buildEmptyResult(ctx, []);
+        }
+        const allies = ctx.api.getAliveUnits()
+            .filter((unit) => unit.teamId === self.teamId)
+            .sort((a, b) => a.position - b.position);
+        const frontAlly = allies[0];
+        if (!frontAlly) {
+            return buildEmptyResult(ctx, []);
+        }
+        const heal = ctx.api.heal(frontAlly.id, Math.floor(self.stats.Mhp * 0.2));
+        return {
+            ...buildEmptyResult(ctx, [frontAlly.id]),
+            totalHeal: heal,
+            hits: [buildHealHit(ctx, frontAlly.id, heal)]
+        };
+    }
+};
+const pelaCoreScript = {
+    onCast(ctx) {
+        const self = ctx.api.getUnit(ctx.caster);
+        const target = ctx.api.getAliveUnits()
+            .filter((unit) => self && unit.teamId === self.teamId)
+            .sort((a, b) => b.position - a.position)[0];
+        if (target) {
+            ctx.api.addBuff(ctx.caster, target.id, "damage-up");
+            ctx.api.grantExtraTurn(target.id);
+        }
+        return {
+            skillId: ctx.skillId,
+            casterId: ctx.caster,
+            targets: ctx.targets,
+            totalDamage: 0,
+            totalHeal: 0,
+            totalShield: 0,
+            triggeredBy: ctx.trigger
+        };
+    }
+};
+// 佩拉大招：提高全体30%攻击力，附加自身10%暴击伤害持续2回合，赋予全体【行动提前】
+const pelaUltimateScript = {
+    onCast(ctx) {
+        const self = ctx.api.getUnit(ctx.caster);
+        const allies = ctx.api.getAliveUnits().filter((u) => self && u.teamId === self.teamId);
+        for (const ally of allies) {
+            ctx.api.addBuff(ctx.caster, ally.id, "attack-up");
+            // 策划：赋予全体行动提前
+            ctx.api.adjustActionProgress(ally.id, 0.2);
+        }
+        // 策划：附加自身10%暴击伤害持续2回合
+        ctx.api.addBuff(ctx.caster, ctx.caster, "pela-crit-up");
+        return {
+            skillId: ctx.skillId,
+            casterId: ctx.caster,
+            targets: ctx.targets,
+            totalDamage: 0,
+            totalHeal: 0,
+            totalShield: 0,
+            triggeredBy: ctx.trigger
+        };
+    }
+};
+const cookPassiveScript = {
+    onCast(ctx) {
+        ctx.api.onAnyEvent(ctx.caster, "OnAfterDamage", (data) => {
+            if (data.targetId !== ctx.caster || data.value <= 0 || data.sourceId === data.targetId) {
+                return;
+            }
+            const self = ctx.api.getUnit(ctx.caster);
+            if (!self || !self.runtime.alive) {
+                return;
+            }
+            ctx.api.addBuff(ctx.caster, ctx.caster, "cook-restraint");
+            ctx.api.addBuff(ctx.caster, ctx.caster, "cook-counter");
+        });
+        return buildEmptyResult(ctx, [ctx.caster]);
+    }
+};
+const miaoluoPassiveScript = {
+    onCast(ctx) {
+        ctx.api.onAnyEvent(ctx.caster, "OnAfterDamage", (data) => {
+            if (data.value <= 0 || data.sourceId === ctx.caster) {
+                return;
+            }
+            const self = ctx.api.getUnit(ctx.caster);
+            const source = ctx.api.getUnit(data.sourceId);
+            const target = ctx.api.getUnit(data.targetId);
+            if (!self || !source || !target || !self.runtime.alive || !source.runtime.alive || !target.runtime.alive) {
+                return;
+            }
+            if (self.teamId !== source.teamId || self.teamId === target.teamId) {
+                return;
+            }
+            if (!ctx.api.hasBuff(ctx.caster, "flash")) {
+                return;
+            }
+            ctx.api.castSkill(ctx.caster, "11021", "chase", [target.id]);
+        });
+        ctx.api.onAnyEvent(ctx.caster, "OnAfterDamage", (data) => {
+            if (data.sourceId !== ctx.caster || data.value <= 0) {
+                return;
+            }
+            const self = ctx.api.getUnit(ctx.caster);
+            const target = ctx.api.getUnit(data.targetId);
+            if (!self || !target || self.teamId === target.teamId || !ctx.api.hasBuff(ctx.caster, "miaoluo-ultimate-focus")) {
+                return;
+            }
+            ctx.api.addBuff(ctx.caster, target.id, "imbalance-vulnerability");
+        });
+        ctx.api.onAnyEvent(ctx.caster, "OnAfterCast", (data) => {
+            if (data.actorId !== ctx.caster || data.skillId !== "11024") {
+                return;
+            }
+            if (ctx.api.hasBuff(ctx.caster, "miaoluo-ultimate-focus")) {
+                ctx.api.removeBuff(ctx.caster, "miaoluo-ultimate-focus");
+            }
+        });
+        return buildEmptyResult(ctx, [ctx.caster]);
+    }
+};
+// 克丝被动：造成伤害时，概率施加【点燃】效果
+const kesiPassiveScript = {
+    onCast(ctx) {
+        ctx.api.onAnyEvent(ctx.caster, "OnAfterDamage", (data) => {
+            if (data.sourceId === ctx.caster && data.value > 0) {
+                const target = ctx.api.getUnit(data.targetId);
+                if (target && target.teamId !== ctx.api.getUnit(ctx.caster)?.teamId) {
+                    if (ctx.api.randomInt(10000) < 5000) {
+                        ctx.api.addBuff(ctx.caster, data.targetId, "burn");
+                    }
+                }
+            }
+        });
+        return buildEmptyResult(ctx, [ctx.caster]);
+    }
+};
+// 布莱德/岚被动：造成伤害时概率施加【点燃】效果，若击杀敌人则获得60%【行动提前】
+const bladePassiveScript = {
+    onCast(ctx) {
+        ctx.api.onAnyEvent(ctx.caster, "OnAfterDamage", (data) => {
+            if (data.sourceId === ctx.caster && data.value > 0) {
+                const target = ctx.api.getUnit(data.targetId);
+                if (target && target.teamId !== ctx.api.getUnit(ctx.caster)?.teamId) {
+                    if (ctx.api.randomInt(10000) < 5000) {
+                        ctx.api.addBuff(ctx.caster, data.targetId, "burn");
+                    }
+                }
+            }
+        });
+        ctx.api.onAnyEvent(ctx.caster, "OnKill", (data) => {
+            if (data.killerId === ctx.caster) {
+                ctx.api.adjustActionProgress(ctx.caster, 0.6);
+            }
+        });
+        return buildEmptyResult(ctx, [ctx.caster]);
+    }
+};
+// 洛洛被动：每次受到伤害时，获得【惩戒/意志】
+const luoluoPassiveScript = {
+    onCast(ctx) {
+        // 监听 OnAfterDamage 事件（battleCore中实际存在的事件名）
+        ctx.api.onAnyEvent(ctx.caster, "OnAfterDamage", (data) => {
+            if (data.targetId === ctx.caster && data.value > 0) {
+                ctx.api.addBuff(ctx.caster, ctx.caster, "will");
+            }
+        });
+        return buildEmptyResult(ctx, [ctx.caster]);
+    }
+};
+// 艾莉莎被动：血量低于30%时移至队尾无法行动1回合，获得60%最大生命护盾，护盾消失回原位，每场2次
+const ailishaPassiveScript = {
+    onCast(ctx) {
+        ctx.api.onAnyEvent(ctx.caster, "OnAfterDamage", (data) => {
+            if (data.targetId !== ctx.caster || data.value <= 0)
+                return;
+            const self = ctx.api.getUnit(ctx.caster);
+            if (!self || !self.runtime.alive)
+                return;
+            const rebirthStacks = ctx.api
+                .getBuffs(ctx.caster)
+                .filter((b) => b.id === "ailisha-rebirth")
+                .reduce((sum, item) => sum + item.stacks, 0);
+            if (rebirthStacks >= 2)
+                return;
+            if (self.runtime.Hp * 100 < self.stats.Mhp * 30) {
+                if (!ailishaOriginalPositions.has(ctx.caster)) {
+                    ailishaOriginalPositions.set(ctx.caster, self.position);
+                }
+                const shield = Math.floor(self.stats.Mhp * 0.6);
+                ctx.api.shield(ctx.caster, shield);
+                ctx.api.addBuff(ctx.caster, ctx.caster, "ailisha-rebirth");
+                ctx.api.addBuff(ctx.caster, ctx.caster, "ailisha-silent");
+                ctx.api.pushPosition(ctx.caster, 999);
+            }
+        });
+        ctx.api.onAnyEvent(ctx.caster, "OnTurnStart", (data) => {
+            if (data.actorId !== ctx.caster)
+                return;
+            const self = ctx.api.getUnit(ctx.caster);
+            const originalPosition = ailishaOriginalPositions.get(ctx.caster);
+            if (!self || originalPosition === undefined || self.runtime.Shield > 0) {
+                return;
+            }
+            if (self.position !== originalPosition) {
+                ctx.api.pushPosition(ctx.caster, originalPosition - self.position);
+            }
+        });
+        return buildEmptyResult(ctx, [ctx.caster]);
+    }
+};
+// 洛莱被动：治疗友军溢出的治疗量，转为友军伤害提升值，持续1回合
+const luolaiPassiveScript = {
+    onCast(ctx) {
+        // 溢出治疗转伤害提升的逻辑需要在治疗系统中实现
+        return buildEmptyResult(ctx, [ctx.caster]);
+    }
+};
+// 提尔大招：攻击最近的敌人造成250%风属性伤害，并有30%概率将敌人击退2格
+const tierUltimateScript = {
+    onCast(ctx) {
+        const targetId = ctx.targets[0];
+        if (!targetId)
+            return buildEmptyResult(ctx, []);
+        // 策划：30%概率击退2格
+        if (ctx.api.randomInt(10000) < 3000) {
+            ctx.api.pushPosition(targetId, 2);
+        }
+        return buildEmptyResult(ctx, [targetId]);
+    }
+};
+// 提尔被动：对敌人造成伤害时有50%概率将敌人部分负面效果扩散至相邻随机一名敌人
+const tierPassiveScript = {
+    onCast(ctx) {
+        ctx.api.onAnyEvent(ctx.caster, "OnAfterDamage", (data) => {
+            if (data.sourceId === ctx.caster && data.value > 0) {
+                if (ctx.api.randomInt(10000) < 5000) {
+                    const target = ctx.api.getUnit(data.targetId);
+                    if (target) {
+                        const debuffs = ctx.api.getBuffs(data.targetId).filter(b => b.stacks > 0);
+                        if (debuffs.length > 0) {
+                            const enemies = ctx.api.getAliveUnits().filter(u => u.teamId === target.teamId && u.id !== data.targetId);
+                            if (enemies.length > 0) {
+                                const randomEnemy = enemies[ctx.api.randomInt(enemies.length)];
+                                const randomDebuff = debuffs[ctx.api.randomInt(debuffs.length)];
+                                ctx.api.addBuff(ctx.caster, randomEnemy.id, randomDebuff.id);
+                            }
+                        }
+                    }
+                }
+            }
+        });
+        return buildEmptyResult(ctx, [ctx.caster]);
+    }
+};
+// 埃斯被动：攻击时概率施加【炫目】效果
+const esPassiveScript = {
+    onCast(ctx) {
+        ctx.api.onAnyEvent(ctx.caster, "OnAfterDamage", (data) => {
+            if (data.sourceId === ctx.caster && data.value > 0) {
+                const target = ctx.api.getUnit(data.targetId);
+                if (target && target.teamId !== ctx.api.getUnit(ctx.caster)?.teamId) {
+                    if (ctx.api.randomInt(10000) < 5000) {
+                        ctx.api.addBuff(ctx.caster, data.targetId, "dazzle");
+                    }
+                }
+            }
+        });
+        return buildEmptyResult(ctx, [ctx.caster]);
+    }
+};
+const esCoreScript = {
+    onCast(ctx) {
+        const self = ctx.api.getUnit(ctx.caster);
+        if (!self) {
+            return buildEmptyResult(ctx, []);
+        }
+        const enemies = ctx.api.getAliveUnits()
+            .filter((unit) => unit.teamId !== self.teamId)
+            .sort((a, b) => a.position - b.position)
+            .slice(0, 2);
+        let totalDamage = 0;
+        const hits = [];
+        for (const enemy of enemies) {
+            const damage = ctx.api.damage(ctx.caster, enemy.id, Math.floor(self.stats.Att * 0.35));
+            totalDamage += damage;
+            hits.push(buildDamageHit(ctx, enemy.id, damage));
+            const resisted = ctx.api.randomInt(10000) >= 5000;
+            if (!resisted) {
+                ctx.api.addBuff(ctx.caster, enemy.id, "dazzle");
+            }
+            hits.push(buildBuffHit(ctx, enemy.id, "dazzle", resisted));
+        }
+        return {
+            ...buildEmptyResult(ctx, enemies.map((item) => item.id)),
+            totalDamage,
+            hits
+        };
+    }
+};
+// 佩拉被动：每次普攻后，自身行动条提高15%
+const pelaPassiveScript = {
+    onCast(ctx) {
+        ctx.api.onAnyEvent(ctx.caster, "OnAfterDamage", (data) => {
+            if (data.sourceId === ctx.caster) {
+                // 判断是否是普攻（基础技能）
+                ctx.api.adjustActionProgress(ctx.caster, 0.15);
+            }
+        });
+        return buildEmptyResult(ctx, [ctx.caster]);
+    }
+};
+export const designedScripts = {
+    "blade.basic.script": bladeBasicScript,
+    "blade.core.script": bladeCoreScript,
+    "blade.ultimate.script": bladeUltimateScript,
+    "blade.passive.script": bladePassiveScript,
+    "kesi.core.script": kesiCoreScript,
+    "kesi.ultimate.script": kesiUltimateScript,
+    "kesi.passive.script": kesiPassiveScript,
+    "kleiwu.basic.script": kleiwuBasicScript,
+    "kleiwu.core.script": kleiwuCoreScript,
+    "kleiwu.passive.script": kleiwuPassiveScript,
+    "kleiwu.ultimate.script": kleiwuUltimateScript,
+    "luoluo.basic.script": luoluoBasicScript,
+    "luoluo.core.script": luoluoCoreScript,
+    "luoluo.passive.script": luoluoPassiveScript,
+    "miaoluo.basic.script": miaoluoBasicScript,
+    "miaoluo.core.script": miaoluoCoreScript,
+    "miaoluo.ultimate.script": miaoluoUltimateScript,
+    "miaoluo.passive.script": miaoluoPassiveScript,
+    "rudy.core.script": rudyCoreScript,
+    "rudy.passive.script": rudyPassiveScript,
+    "rudy.ultimate.script": rudyUltimateScript,
+    "ailisha.core.script": ailishaCoreScript,
+    "ailisha.ultimate.script": ailishaUltimateScript,
+    "ailisha.passive.script": ailishaPassiveScript,
+    "luolai.basic.script": luolaiBasicScript,
+    "luolai.core.script": luolaiCoreScript,
+    "luolai.ultimate.script": luolaiUltimateScript,
+    "luolai.passive.script": luolaiPassiveScript,
+    "pela.core.script": pelaCoreScript,
+    "pela.ultimate.script": pelaUltimateScript,
+    "pela.passive.script": pelaPassiveScript,
+    "cook.basic.script": cookBasicScript,
+    "cook.core.script": cookCoreScript,
+    "cook.ultimate.script": cookUltimateScript,
+    "cook.passive.script": cookPassiveScript,
+    "tier.passive.script": tierPassiveScript,
+    "es.core.script": esCoreScript,
+    "es.passive.script": esPassiveScript,
+    "tier.ultimate.script": tierUltimateScript,
+    ...monsterScripts16xx,
+    ...monsterScripts18xx,
+    ...monsterScripts19xxPart1,
+    ...monsterScripts19xxPart2,
+};