232 lines
16 KiB
JavaScript
232 lines
16 KiB
JavaScript
// server/sim/content/kits/ops/op-saga.js — 嵯峨 (char_362_saga) 自选 operator kit: 6★ 尖兵 (先锋), an owned-6★ pick of the
|
||
// tier-5 and tier-6 自选 slots; every skill, both talents, the trait and both modules at every form.
|
||
// Kit contract and the 自选 rules: ../README.md ("How to add an operator (自选)").
|
||
//
|
||
// Forms (data/backups.json units.char_362_saga, the DIY slot statuses): normal = E2 Lv1, skills at rank 4, no module;
|
||
// elite = E2 Lv60, rank 7, the picked module at stage 1 (tier 5) or 3 (tier 6). Full potential (the owner's decision of 2026-10-07).
|
||
// Sources: character_table / skill_table / battle_equip_table (zh_CN, as built into backups.json); gamedata_const ba.dying
|
||
// "重伤: 移速下降且无法被阻挡，10秒后自然死亡，被击杀后使击杀者回复数点技力"; PRTS 嵯峨 (劝善 备注 "本天赋第一部分实际效果为：
|
||
// 自身造成的伤害不会致命（至多使目标生命值降至1点），成功造成伤害后若目标生命值小于等于1则为目标附加重伤"; 清明 备注 "嵯峨每次
|
||
// 部署都可以触发一次本天赋"; S2 备注 "可选择重伤单位", "攻击附加延迟检测Buff：0.7s后进行检测，强制击杀持有重伤的目标（击杀来源为
|
||
// 嵯峨自身），随后解除目标的重伤"; S3 备注 "造成伤害前判断目标生命值"); PRTS 术语释义 重伤 ("重伤Buff包含：移动速度-80%，禁疗、
|
||
// 禁用近战，阻挡数、生命回复速度、生命回复速度（百分比）归零，从消失状态变为出现的瞬间立刻死亡（消失状态期间不会因重伤自然死亡）",
|
||
// "重伤造成的自然死亡为强制死亡（也即可以杀死持有不死的单位），视为无来源击杀", "重伤期间的单位无法再被施加重伤"); PRTS 异常效果
|
||
// 禁用近战 "敌人类单位无法进行阻挡攻击，无法被阻挡".
|
||
// - Trait (尖兵) "能够阻挡两个敌人": the profession default (block 2). SOL-X 何处寻驮？ "阻挡敌人时攻击力和防御力各+8％"
|
||
// (trait bb atk / def): +atk / +def while she blocks an enemy. SOL-Y 身向云泥 "首次部署时部署费用-4" (hidden
|
||
// runtime_cost −4): the first deployment of a battle costs nothing in this mode ⇒ no effect (as 推进之王's SOL-Y).
|
||
// - T1 劝善: her damage is never lethal to an enemy (a `fatal` hook keeps it at 1 HP — every damage of hers: attacks, 除恶;
|
||
// not a 无来源 one, which has no source); after a damage of hers an enemy at ≤ 1 HP becomes 重伤 (the DYING buff, once:
|
||
// none while it holds one): move speed ×(1 + move_speed) (−80 %), unblockable (禁用近战: released by its blocker, no
|
||
// block attack), 禁疗 (healFree / noHeal), its HP regeneration zeroed; it dies `interval` s later (10) — a forced, 无来源
|
||
// death (battle.kill with no killer: no SP, 不死 does not hold it) — not while it is 消失 (hidden), and at once when it
|
||
// comes back from 消失. Whoever kills a 重伤 enemy gets `sp` SP (2; "击杀者技力+2", giveSp: not during a timed skill).
|
||
// "嵯峨不攻击重伤单位": the kit trait `skipEnemy` (targeting.js canTargetEnemy) — no normal attack, block target or
|
||
// trigger target of hers is a 重伤 enemy. SOL-X stage 2+ "对生命值低于一半的单位造成的伤害提升15%" (hidden hp_ratio /
|
||
// damage_scale): ×damage_scale on every damage of hers whose target is below hp_ratio before it.
|
||
// A shared-pool leader (boss rounds: its HP is the pool's, damage.js runs no `fatal` step for it) is outside 劝善
|
||
// [ASSUMED: her damage there is ordinary].
|
||
// - T2 清明 "生命值低于40%时，仅一次获得70%物理闪避和每秒回复5%的最大生命，持续15秒" (full potential: 6 %, 17 s): once per deployment (PRTS 备注), the first
|
||
// time a damage leaves her below hp_ratio of her max HP: dodgePhys prob and hpRegenRatio for `duration` s — the
|
||
// blackboard key hp_recovery_per_sec_by_max_hp_ratio is the 生命回复速度（百分比） attribute (PRTS 异常效果 禁疗 / 术语释义
|
||
// 重伤 name it), as 宴 S1 / 山 / 幽灵鲨 / 蜜蜡 / 烛煌 apply it [ASSUMED: no 备注 of 清明 says so; 余's 闲云隐市 with the same
|
||
// key is still open, DESIGN 0.2.0.l3]. SOL-Y stage 2+: the talent change's numbers — at stage 3, full potential: 7 % per second for 20 s (text and
|
||
// blackboard 0.07 agree; at potential 0 the text read 6 % while the blackboard was 0.065: the game applies the blackboard).
|
||
// - S1 冲锋号令·γ型 (AUTO, no target): +cost DP at once; an AUTO skill acting on nobody fires as soon as its SP is full
|
||
// (`trigger: 'SP_FULL'`, as 推进之王's / 德克萨斯's kits cast the same skill — the owner's AUTO rule).
|
||
// - S2 除恶 (MANUAL, 2 charges, data SKILL_RANGE on its x-6 cross: any enemy there, 无视其不可选中): +cost DP; the up to
|
||
// S2_MAX (6, the text's — no blackboard key) selectable ground enemies of the cross ("地面敌人"; a 重伤 one included:
|
||
// "可选择重伤单位"), best targets first (her priority) [ASSUMED order], take atk_scale × ATK physical (a skill damage;
|
||
// 劝善 applies); S2_CHECK s later each of them still 重伤 is killed (killer 嵯峨: she gets its SP, stats and bounty; a
|
||
// forced kill — battle.kill, no `fatal` step), then its 重伤 is lifted (should a kill handler have revived it).
|
||
// - S3 怒目 (MANUAL, 20 s, data ACTIVE_RANGE on her 1-1 + 1): +cost DP every interval s while it runs (value in all; the
|
||
// rest of value at its natural end), attack interval +base_attack_time s (+0.5 on her 1.05), 攻击距离 +1
|
||
// (targeting.rangeExtend), ATK +atk, every enemy she blocks at once (hitAllBlocked; one target in range while she
|
||
// blocks none), and one more attack on each target that was below attack@hp_ratio before the hit (PRTS 备注: an HP
|
||
// snapshot at beforeAttack; the extra attack is a forced one a tick later, no 重伤 target).
|
||
// Melee physical, ground-only (canHitFly false), ground enemies target her normally (no 起飞 / 迷彩 / 隐匿).
|
||
|
||
import { num, talentBb, moduleBb, traitBb, skillRec, toggleBuff, batMod, giveSp, up } from '../shared/tier1.js';
|
||
import { absoluteRangeKeys, canTargetEnemy, sortEnemyTargets } from '../../../targeting.js';
|
||
|
||
const S1 = 'skcom_charge_cost[3]';
|
||
const S2 = 'skchr_saga_2';
|
||
const S3 = 'skchr_saga_3';
|
||
/** The 重伤 buff (gamedata_const ba.dying): one per enemy — "重伤期间的单位无法再被施加重伤". */
|
||
export const DYING = 'saga:dying';
|
||
/** S2 除恶 备注 "攻击附加延迟检测Buff：0.7s后进行检测" (no blackboard key). */
|
||
export const S2_CHECK = 0.7;
|
||
/** S2 除恶 "对十字范围内最多6名地面敌人" — the text's number when it cannot be read (no blackboard key). */
|
||
const S2_MAX = 6;
|
||
/** The x-6 cross (skill range) when the data carries no grid. */
|
||
const X6 = Object.freeze([[2, 0], [1, 0], [0, -2], [0, -1], [0, 0], [0, 1], [0, 2], [-1, 0], [-2, 0]]);
|
||
/** 除恶's selection: ground enemies only ("地面敌人"), 重伤 ones included (no skipEnemy). */
|
||
const GROUND = Object.freeze({ canHitFly: false, groundOnly: true });
|
||
|
||
/** Is `e` 重伤 (whoever put it there)? */
|
||
export const isDying = (e) => !!(e && typeof e.findBuff === 'function' && e.findBuff(DYING));
|
||
|
||
/**
|
||
* 重伤 on enemy `e` from `saga` (PRTS 术语释义 重伤): move speed ×(1 + ms), unblockable (禁用近战), 禁疗, no HP regeneration;
|
||
* a forced, 无来源 death `life` s later — never while 消失, at once when it comes back from 消失. The killer of a 重伤
|
||
* enemy gets `sp` SP (the talent's kill hook reads `data.sp`). Nothing when it already holds one.
|
||
*/
|
||
function applyDying(battle, saga, e, { sp, life, ms }) {
|
||
if (!e || !e.alive || isDying(e)) return;
|
||
battle.addBuff(e, {
|
||
key: DYING, source: saga, visible: true,
|
||
mods: { moveMul: Math.max(0, 1 + ms), hpRegen: -1e9 },
|
||
flags: { unblockable: true, healFree: true, noHeal: true },
|
||
data: { sp, until: battle.time + life, hidden: !!e.hidden },
|
||
onTick: ({ battle: b, unit: x, buff }) => {
|
||
const d = buff.data;
|
||
if ((d.hidden && !x.hidden) || (!x.hidden && b.time + 1e-9 >= d.until)) { b.kill(x, null); return; }
|
||
d.hidden = !!x.hidden;
|
||
},
|
||
});
|
||
battle.fx('dying', { x: e.x, y: e.y, id: e.id, from: saga.id });
|
||
}
|
||
|
||
export default {
|
||
char_362_saga: (bb, chess) => {
|
||
const b1 = skillRec(chess, S1)?.bb ?? {}, b2 = skillRec(chess, S2)?.bb ?? {}, b3 = skillRec(chess, S3)?.bb ?? {};
|
||
const s2 = skillRec(chess, S2);
|
||
const t0 = talentBb(chess, 0); // 劝善: move_speed, sp, interval
|
||
const t1 = talentBb(chess, 1); // 清明: hp_ratio, hp_recovery_per_sec_by_max_hp_ratio, prob, duration
|
||
const hidden = moduleBb(chess); // SOL-X stage 2+: hp_ratio, damage_scale; SOL-Y: runtime_cost (no effect)
|
||
const tb = traitBb(chess); // SOL-X: atk, def while blocking
|
||
const picked = chess?.skill?.skillId ?? null;
|
||
const maxHit = Math.max(1, Math.floor(num(/最多(\d+)名/.exec(String(s2?.desc ?? ''))?.[1], S2_MAX)));
|
||
return {
|
||
// 劝善 "嵯峨不攻击重伤单位"
|
||
trait: { skipEnemy: isDying },
|
||
skills: {
|
||
[S1]: {
|
||
kind: 'instant', trigger: 'SP_FULL',
|
||
onStart({ battle, unit }) {
|
||
const n = num(b1.cost);
|
||
battle.addDp(unit.ownerId, n);
|
||
battle.fx('dp', { x: unit.x, y: unit.y, n, id: unit.id });
|
||
},
|
||
},
|
||
[S2]: {
|
||
kind: num(s2?.maxChargeTime, 1) > 1 ? 'charges' : 'instant',
|
||
onStart({ battle, unit }) {
|
||
const n = num(b2.cost);
|
||
battle.addDp(unit.ownerId, n);
|
||
battle.fx('dp', { x: unit.x, y: unit.y, n, id: unit.id });
|
||
const keys = absoluteRangeKeys(s2?.rangeGrid ?? X6, unit.tileR, unit.tileC, unit.dir, 0);
|
||
const list = battle.enemiesInKeys(keys, unit, GROUND);
|
||
sortEnemyTargets(battle, unit, list, unit.profile?.priority ?? null);
|
||
const hit = list.slice(0, maxHit);
|
||
battle.fx('aoe', { x: unit.x, y: unit.y, radius: 2, id: unit.id, skill: 'saga:cleanse', n: hit.length });
|
||
for (const e of hit) {
|
||
battle.dealDamage(unit, e, { amount: unit.s.atk * num(b2.atk_scale, 1), type: 'phys', isSkill: true, tags: ['saga:s2'] });
|
||
if (!e.alive) continue;
|
||
battle.addBuff(e, {
|
||
key: 'saga:s2check', refresh: 'independent', maxStacks: 99, duration: S2_CHECK, source: unit,
|
||
onExpire: ({ battle: b, unit: x }) => {
|
||
if (!x.alive || !isDying(x)) return;
|
||
b.kill(x, unit);
|
||
if (x.alive) b.removeBuff(x, DYING);
|
||
},
|
||
});
|
||
}
|
||
},
|
||
},
|
||
[S3]: {
|
||
kind: 'duration',
|
||
mods: { atkPct: num(b3.atk), batPct: batMod(b3.base_attack_time, chess) },
|
||
targeting: { rangeExtend: num(b3.ability_range_forward_extend) },
|
||
attack: { hitAllBlocked: true },
|
||
onStart({ unit }) { unit.mem.sagaDp = { acc: 0, got: 0 }; },
|
||
onTick({ battle, unit, dt }) {
|
||
const st = unit.mem.sagaDp;
|
||
const iv = num(b3.interval, 1), n = num(b3.cost), total = num(b3.value);
|
||
if (!st || !(iv > 0) || !(n > 0)) return;
|
||
st.acc += dt;
|
||
while (st.acc + 1e-9 >= iv && st.got + n <= total + 1e-9) {
|
||
st.acc -= iv;
|
||
st.got += n;
|
||
battle.addDp(unit.ownerId, n);
|
||
}
|
||
},
|
||
onEnd({ battle, unit, reason }) {
|
||
const st = unit.mem.sagaDp;
|
||
unit.mem.sagaDp = null;
|
||
// the last grant falls on the very end of its 20 s
|
||
if (st && reason === 'duration' && num(b3.value) - st.got > 1e-9) battle.addDp(unit.ownerId, num(b3.value) - st.got);
|
||
},
|
||
},
|
||
},
|
||
talents: [
|
||
{ install(battle, unit) { // 劝善
|
||
const sp = num(t0.sp), life = num(t0.interval, 10), ms = num(t0.move_speed, -0.8);
|
||
// "自身造成的伤害不会致命（至多使目标生命值降至1点）" — before any other saver: it never was lethal
|
||
battle.on('fatal', (c) => {
|
||
if (c.source === unit && c.unit && c.unit.side === 'enemy' && !c.prevented) c.prevented = true;
|
||
}, { owner: unit, priority: 100 });
|
||
// "成功造成伤害后若目标生命值小于等于1则为目标附加重伤"
|
||
battle.on('damaged', (c) => {
|
||
const e = c.target;
|
||
if (c.source !== unit || !e || e.side !== 'enemy' || !e.alive || e.bossPool || c.type === 'element' || e.hp > 1) return;
|
||
applyDying(battle, unit, e, { sp, life, ms });
|
||
}, { owner: unit });
|
||
// "被击杀后使击杀者回复数点技力" — the killer of a 重伤 enemy she marked (none for the 无来源 natural death)
|
||
battle.on('kill', (c) => {
|
||
const d = c.victim && typeof c.victim.findBuff === 'function' ? c.victim.findBuff(DYING) : null;
|
||
if (!d || d.source !== unit || !c.killer || c.killer.side !== 'ally') return;
|
||
giveSp(c.killer, num(d.data?.sp));
|
||
}, { owner: unit });
|
||
// SOL-X stage 2+: "对生命值低于一半的单位造成的伤害提升15%"
|
||
const hr = num(hidden.hp_ratio), ds = num(hidden.damage_scale, 1);
|
||
if (hr > 0 && ds !== 1) {
|
||
battle.on('hit', (c) => {
|
||
if (c.source === unit && c.target && c.target.side === 'enemy' && c.target.hpRatio < hr) c.dmg.mul *= ds;
|
||
}, { owner: unit });
|
||
}
|
||
} },
|
||
{ install(battle, unit) { // 清明: once per deployment below hp_ratio — dodgePhys prob, hpRegenRatio, `duration` s
|
||
const hr = num(t1.hp_ratio), p = num(t1.prob), regen = num(t1.hp_recovery_per_sec_by_max_hp_ratio), dur = num(t1.duration);
|
||
if (!(hr > 0) || !(dur > 0)) return;
|
||
battle.on('damaged', (c) => {
|
||
if (c.target !== unit || !up(unit) || unit.mem.qingmingAt === unit.deploySeq) return;
|
||
if (!(unit.hp < unit.s.maxHp * hr)) return;
|
||
unit.mem.qingmingAt = unit.deploySeq;
|
||
battle.addBuff(unit, { key: 'talent:saga:qingming', duration: dur, mods: { dodgePhys: p, hpRegenRatio: regen }, visible: true, tags: ['talent'] });
|
||
battle.fx('buff', { x: unit.x, y: unit.y, id: unit.id, kind: 'saga:qingming' });
|
||
}, { owner: unit });
|
||
} },
|
||
],
|
||
install(battle, unit) {
|
||
// SOL-X 何处寻驮？: 阻挡敌人时攻击力和防御力各+8％
|
||
const ma = num(tb.atk), md = num(tb.def);
|
||
if (ma || md) toggleBuff(battle, unit, 'trait:saga:block', () => unit.blocking.length > 0, { atkPct: ma, defPct: md });
|
||
// 怒目: one more attack on each target below attack@hp_ratio (checked before the hit) — a forced attack a tick later
|
||
if (picked !== S3) return;
|
||
const hp3 = num(b3['attack@hp_ratio']);
|
||
if (!(hp3 > 0)) return;
|
||
let half = null;
|
||
battle.on('beforeAttack', (c) => {
|
||
if (c.attacker !== unit || unit.mem.sagaExtra || !unit.skill?.active) return;
|
||
half = (c.targets || []).filter((e) => e && e.side === 'enemy' && e.hpRatio < hp3);
|
||
}, { owner: unit, priority: -100 });
|
||
battle.on('attack', (c) => {
|
||
if (c.attacker !== unit || unit.mem.sagaExtra) return;
|
||
const list = half;
|
||
half = null;
|
||
if (!list || !list.length) return;
|
||
const dep = unit.deploySeq;
|
||
battle.after(0, () => {
|
||
if (!up(unit) || unit.deploySeq !== dep || !unit.canAct || unit.s.flags.disarm) return;
|
||
const t = list.filter((e) => e.alive && canTargetEnemy(unit, e, unit.profile));
|
||
if (!t.length) return;
|
||
unit.mem.sagaExtra = true;
|
||
try { battle.forceAttack(unit, t, { noAmmo: true }); } finally { unit.mem.sagaExtra = false; }
|
||
}, { owner: unit });
|
||
}, { owner: unit });
|
||
},
|
||
};
|
||
},
|
||
};
|