230 lines
17 KiB
JavaScript
230 lines
17 KiB
JavaScript
// server/sim/content/kits/ops/op-thorns.js — 棘刺 (char_293_thorns) 自选 operator kit: 6★ 领主 (近卫), an owned-6★ pick of
|
||
// the tier-5 and tier-6 自选 slots; every skill, both talents, the trait and both modules (LOR-X, LOR-Δ) at every form.
|
||
// Kit contract and the 自选 rules: ../README.md ("How to add an operator (自选)").
|
||
//
|
||
// Forms (data/backups.json units.char_293_thorns, 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); the client's battle
|
||
// logic — buff_template_data (thorns_t_1, thorns_s_2, thorns_e_002_t / [mark] / _tr, thorns_e_003_t / _tr), his charpack
|
||
// (talent 1 `_additiveActiveBuffs` thorns_t_1: triggerInterval 1, waitFirstTriggerInterval, independentCharacterSource;
|
||
// talent 2 toggle `_disableWhenInAttackState` / `InCombatState`, `_restoreDelay` 2) and the skill prefabs (skchr_thorns_2
|
||
// Thorn: `_preDelay` 0.5, cooldown key `cooldown`, the trait's 0.8 scale, ground + air selector, `max_target`;
|
||
// skchr_thorns_3 [a] / [b] buffs), the module parts ([uc]equips thorns_equip_1_n / 2_n: the trait buffs, and from stage 2
|
||
// the talent overrides — LOR-X `_targetFamilyMask` 31, LOR-Δ 3) — and PRTS 棘刺 (talent 备注, S2 备注, S3 备注, LOR-X 特性
|
||
// "于计算伤害时触发").
|
||
// - Trait (领主) "可以进行远程攻击，但此时攻击力降低至80%": the lord profile (professions.js: ×atk_scale unless the target
|
||
// stands on his tile / the tile in front or he blocks it), range 3-12, hits air units (data canHitFly), blocks 2.
|
||
// Module LOR-X “盐与沙” adds "攻击附带10%攻击力的法术伤害" (trait atk_scale_m; thorns_e_002_tr: ON_CALCULATE_DAMAGE, attack
|
||
// type ADDITION — PRTS "造成预计算法术附加伤害"): atk_scale_m × ATK arts after every hit of his attacks (the trait's
|
||
// afterHit, as 拉普兰德 / 断崖 / 仇白 / 银灰 do it; tags module / addition) and of S2's spikes [ASSUMED: the Thorn ability
|
||
// calculates its damage like an attack; the fixed-value poison ticks do not]. Module LOR-Δ “沙蚀” adds
|
||
// "造成伤害时附带相当于10%伤害的神经损伤" (trait ep_damage_ratio; thorns_e_003_tr: ON_AFTER_OUTPUT_DAMAGE, every damage
|
||
// type): ep_damage_ratio × the HP damage of every damage instance he deals — attacks, spikes, LOR-X additions and the
|
||
// poison ticks — as 神经损伤 (docs/SIM.md §7.2 element conventions).
|
||
// - T1 神经腐蚀 "攻击使目标中毒，在3秒内每秒受到125点法术伤害（对会远程攻击的目标伤害加倍）" (full potential: 140): every
|
||
// hit of his attacks (and of the S2 spikes, PRTS "所有攻击均能附加") poisons the target — one poison per 棘刺
|
||
// (independentCharacterSource) for `duration` s, ticking every second, the first a second in (waitFirstTriggerInterval), damage[normal] or
|
||
// damage[ranged] (an enemy whose 攻击方式 includes 远程: data applyWay RANGED or ALL; PRTS "伤害加倍为数值提升") as a fixed
|
||
// arts 持续伤害 (FixedValueDamage MAGICAL, attack type BUFF: RES applies, no dodge, tags dot). A new hit refreshes the
|
||
// duration and keeps the damage value and the tick rhythm (PRTS "仅刷新持续时间而不改变伤害数值"). The ticks go on after
|
||
// he leaves the field [ASSUMED, as 伊芙利特's 灼伤]. A dodged hit poisons nothing (no `damaged`; 击中目标的攻击).
|
||
// LOR-X stage 2+ (thorns_e_002_t: no end of its own, cnt 1; every hit a new [mark] of `duration` s whose start adds 1
|
||
// to cnt up to max_cnt; a tick without a [mark] ends it — damage × cnt) "可叠加4次": the tick is the first application's
|
||
// value × the hits so far (≤ max_cnt; PRTS "以第一层的伤害数值为基础进行翻倍"), the poison ending `duration` s after the
|
||
// last hit; all his hits, spikes included (mask 31). LOR-Δ stage 2+ (thorns_e_003_t, ep_break_multi): on an enemy in its
|
||
// 神经损伤 burst (the `neuralBurst` lock, FilterEPBreakRecoveryType SANITY) the tick is ×ep_break_multi 元素伤害; only his
|
||
// normal attacks poison (mask 3; PRTS "仅有普通攻击能附加（意味着2技能不再附加中毒Buff）"), and that poison has no
|
||
// independentCharacterSource: one per enemy whoever applies it. At stage 1 both modules leave the talent as it is
|
||
// (battle_equip_table: no talent part in phase 1).
|
||
// - T2 故土潮声 "如果2秒内没有主动攻击过，每秒恢复最大生命3.5%的生命" (full potential: 4%): PRTS "增加“生命回复速度（百分比）”属性，
|
||
// 不受治疗加成和禁疗影响" — an hpRegenRatio buff (checklist 11, never battle.heal), on while his last attack is at least
|
||
// `delay` s old (the toggle's restoreDelay after the attack states) and from his deployment on [ASSUMED: no attack yet counts as
|
||
// "2秒内没有主动攻击过"]. The S2 spikes are no 主动攻击 (PRTS "不会使第二天赋效果中断").
|
||
// - S1 攻击力强化·γ型 (MANUAL, data DEFAULT): ATK +atk for `duration` s.
|
||
// - S2 护身尖刺 (MANUAL, 技能范围 3-1, data SKILL_RANGE): "停止攻击" (no normal attack; PRTS "技能期间，自身丢失全部视野"),
|
||
// ATK +atk, DEF +def; every 普通伤害 an enemy deals him (PRTS "指受到普通伤害（伤害类型），而非由普通攻击造成的伤害";
|
||
// thorns_s_2 FilterDamageModifer attack type NORMAL: not 溅射, not 持续 (dot / periodic), not 附加, not element damage,
|
||
// not a 流失, not 无来源) sets off the Thorn ability when its `cooldown` (0.8 / 0.75 s) is ready and he can act: 0.5 s
|
||
// later (its `_preDelay`) up to max_target enemies of the 3-1 — ground and air, the usual target order — each take ATK ×
|
||
// the trait's atk_scale (PRTS "始终受降低攻击倍率特性的影响") physical, a skill hit that is no normal attack (no `attack`
|
||
// event, no SP), cancelled when the skill has ended, he left or cannot act by then [ASSUMED]. The 3-1 is not his
|
||
// attack range: the card keeps his 3-12.
|
||
// - S3 至高之术 (MANUAL, attack SP, data ACTIVE_RANGE on its 3-3): range 3-3, ATK +atk, ASPD +attack_speed, every attack at
|
||
// full ATK ("远程攻击不再降低攻击力": the skill's attack profile has no 0.8 — dmgMul 1, as 领主·Sharp S1) for `duration` s;
|
||
// "第二次及以后使用时能力加成变为最初的两倍，且持续时间无限": from the second activation of a deployment on, the
|
||
// thorns_s_3[b] numbers (ATK / ASPD ×2) and no end until he leaves (a toggle; the first use counts its own 30 s down) —
|
||
// PRTS "每次部署棘刺时，重新计算该技能的使用次数": the count restarts with every deployment.
|
||
|
||
import { num, talentBb, traitBb, skillRec, up } from '../shared/tier1.js';
|
||
import { absoluteRangeKeys, sortEnemyTargets } from '../../../targeting.js';
|
||
import { hasHp, isHpLoss } from '../../../damage.js';
|
||
|
||
const S1 = 'skcom_atk_up[3]';
|
||
const S2 = 'skchr_thorns_2';
|
||
const S3 = 'skchr_thorns_3';
|
||
/** The skill ranges when a record carries none (data: 3-1, 3-3). */
|
||
const R3_1 = Object.freeze([[1, 0], [1, 1], [1, 2], [0, 0], [0, 1], [0, 2], [0, 3], [-1, 0], [-1, 1], [-1, 2]]);
|
||
const R3_3 = Object.freeze([[1, 0], [1, 1], [1, 2], [1, 3], [0, 0], [0, 1], [0, 2], [0, 3], [-1, 0], [-1, 1], [-1, 2], [-1, 3]]);
|
||
/** skchr_thorns_2 Thorn `_preDelay`: the spikes land this long after the hit that set them off. */
|
||
const SPIKE_DELAY = 0.5;
|
||
/** thorns_t_1 triggerInterval: a poison tick every second. */
|
||
const POISON_IV = 1;
|
||
const AIR = Object.freeze({ canHitFly: true });
|
||
const S3_BUFF = 'skill:thorns:destreza';
|
||
const REGEN_KEY = 'talent:thorns:tide';
|
||
|
||
const bbOf = (chess, id) => skillRec(chess, id)?.bb ?? {};
|
||
/** An enemy whose 攻击方式 includes 远程 (PRTS "图鉴中【攻击方式】包含远程的敌人"; data applyWay). */
|
||
const attacksRanged = (e) => { const w = String(e?.def?.applyWay ?? '').toUpperCase(); return w === 'RANGED' || w === 'ALL'; };
|
||
/**
|
||
* 普通伤害 (PRTS 伤害分类; thorns_s_2 FilterDamageModifer attack type NORMAL) an enemy dealt — not 溅射, 持续 (dot /
|
||
* periodic), 附加, element damage, a 流失 or 无来源 damage.
|
||
*/
|
||
function normalHitFromEnemy(c) {
|
||
const d = c.dmg;
|
||
if (!d || !c.source || c.source.side !== 'enemy' || d.sourceless || d.isSplash || isHpLoss(d)) return false;
|
||
if (c.type === 'element' || c.type === 'elemental') return false;
|
||
const tags = d.tags || [];
|
||
return !tags.includes('dot') && !tags.includes('periodic') && !tags.includes('addition');
|
||
}
|
||
|
||
export default {
|
||
char_293_thorns: (bb, chess) => {
|
||
const t0 = talentBb(chess, 0), t1 = talentBb(chess, 1);
|
||
const tb = traitBb(chess);
|
||
const b1 = bbOf(chess, S1), b2 = bbOf(chess, S2), b3 = bbOf(chess, S3);
|
||
const grid2 = skillRec(chess, S2)?.rangeGrid ?? R3_1, grid3 = skillRec(chess, S3)?.rangeGrid ?? R3_3;
|
||
const rangedScale = num(tb.atk_scale, 0.8);
|
||
const loreX = num(tb.atk_scale_m); // LOR-X: arts addition
|
||
const loreD = num(tb.ep_damage_ratio); // LOR-Δ: 神经损伤 rider
|
||
const maxCnt = Math.max(1, Math.floor(num(t0.max_cnt, 1))); // LOR-X stage 2+: 可叠加
|
||
const breakMul = num(t0.ep_break_multi); // LOR-Δ stage 2+: ×multi 元素伤害 in a 神经 burst
|
||
const spikesPoison = !(breakMul > 0); // LOR-Δ stage 2+: only normal attacks poison
|
||
|
||
/** LOR-X "攻击附带10%攻击力的法术伤害": the arts addition of one hit (PRTS: 预计算法术附加伤害). */
|
||
const addition = (battle, unit, target) => {
|
||
if (loreX > 0 && target && target.alive && target.side === 'enemy' && hasHp(target)) {
|
||
battle.dealDamage(unit, target, { amount: unit.s.atk * loreX, type: 'arts', tags: ['module', 'addition', 'thorns:lorx'] });
|
||
}
|
||
};
|
||
|
||
/** T1 神经腐蚀: poison `e` (one per 棘刺; a new hit refreshes it, LOR-X stage 2+ adds a layer). */
|
||
const poison = (battle, unit, e) => {
|
||
if (!e || !e.alive || e.side !== 'enemy' || !hasHp(e)) return;
|
||
const dur = num(t0.duration, 3);
|
||
const base = num(attacksRanged(e) ? t0['damage[ranged]'] : t0['damage[normal]']);
|
||
if (!(dur > 0) || !(base > 0)) return;
|
||
// one poison per 棘刺 (independentCharacterSource) — but the LOR-Δ stage 2+ one (thorns_e_003_t has no such flag)
|
||
const key = breakMul > 0 ? 'thorns:poison' : `thorns:poison:${unit.id}`;
|
||
const old = e.findBuff(key);
|
||
const b = battle.addBuff(e, {
|
||
key, duration: dur, refresh: 'extend', interval: POISON_IV, source: unit, tags: ['dot', 'talent'],
|
||
data: { base, cnt: 1 },
|
||
onTick({ battle: bt, unit: tgt, buff }) {
|
||
if (!tgt.alive || !hasHp(tgt)) return;
|
||
let amount = buff.data.base * (maxCnt > 1 ? buff.data.cnt : 1);
|
||
let type = 'arts';
|
||
if (breakMul > 0 && tgt.findBuff('neuralBurst')) { amount *= breakMul; type = 'elemental'; }
|
||
bt.dealDamage(unit, tgt, { amount, type, element: type === 'elemental' ? 'neural' : undefined, canDodge: false, tags: ['talent', 'dot', 'thorns:poison'] });
|
||
},
|
||
});
|
||
if (old && b === old && maxCnt > 1) old.data.cnt = Math.min(maxCnt, num(old.data.cnt, 1) + 1);
|
||
};
|
||
|
||
return {
|
||
trait: {
|
||
// LOR-X: every hit of his attacks carries the arts addition
|
||
afterHit(battle, u, target) { addition(battle, u, target); },
|
||
},
|
||
skills: {
|
||
[S1]: { kind: 'duration', mods: { atkPct: num(b1.atk) } },
|
||
[S2]: {
|
||
kind: 'duration',
|
||
mods: { atkPct: num(b2.atk), defPct: num(b2.def) },
|
||
attack: { noAttack: true }, // 停止攻击
|
||
},
|
||
[S3]: {
|
||
kind: 'toggle',
|
||
targeting: { rangeGrid: grid3 },
|
||
attack: { dmgMul: () => 1 }, // 远程攻击不再降低攻击力
|
||
onStart({ battle, unit, skill }) {
|
||
const n = (unit.mem.thornsS3Uses = num(unit.mem.thornsS3Uses) + 1);
|
||
const again = n >= 2;
|
||
const atk = again ? num(b3['thorns_s_3[b].atk'], 2 * num(b3.atk)) : num(b3.atk);
|
||
const aspd = again ? num(b3['thorns_s_3[b].attack_speed'], 2 * num(b3.attack_speed)) : num(b3.attack_speed);
|
||
battle.addBuff(unit, { key: S3_BUFF, mods: { atkPct: atk, aspd }, tags: ['skill'] });
|
||
// the first use runs `duration` s; from the second on "持续时间无限" ([b].duration −1)
|
||
skill.timeLeft = again && num(b3['thorns_s_3[b].duration'], -1) < 0 ? Infinity : Math.max(0.01, skill.duration);
|
||
},
|
||
onTick({ skill, dt }) {
|
||
if (!Number.isFinite(skill.timeLeft)) return;
|
||
skill.timeLeft -= dt;
|
||
if (skill.timeLeft <= 1e-9) skill.end('duration');
|
||
},
|
||
onEnd({ battle, unit }) { battle.removeBuff(unit, S3_BUFF); },
|
||
},
|
||
},
|
||
talents: [
|
||
{ install(battle, unit) { // 神经腐蚀: his attack hits (and the spikes, but under LOR-Δ stage 2+) poison
|
||
battle.on('damaged', (c) => {
|
||
if (c.source !== unit || !c.target || c.target.side !== 'enemy' || !c.dmg || c.type === 'element') return;
|
||
const tags = c.dmg.tags || [];
|
||
if (c.dmg.isAttack || (spikesPoison && tags.includes('thorns:spike'))) poison(battle, unit, c.target);
|
||
}, { owner: unit });
|
||
} },
|
||
{ install(battle, unit) { // 故土潮声: 生命回复速度 while no attack of his is younger than `delay` s
|
||
const r = num(t1.hp_recovery_per_sec_by_max_hp_ratio), delay = num(t1.delay, 2);
|
||
if (!(r > 0)) return;
|
||
unit.mem.thornsAttackAt = -Infinity;
|
||
battle.on('deploy', (c) => { if (c.unit === unit) unit.mem.thornsAttackAt = -Infinity; }, { owner: unit });
|
||
battle.on('attack', (c) => { if (c.attacker === unit) unit.mem.thornsAttackAt = battle.time; }, { owner: unit });
|
||
const apply = () => {
|
||
const want = up(unit) && battle.time - unit.mem.thornsAttackAt >= delay - 1e-9;
|
||
const has = unit.findBuff(REGEN_KEY);
|
||
if (want && !has) battle.addBuff(unit, { key: REGEN_KEY, mods: { hpRegenRatio: r }, tags: ['talent'] });
|
||
else if (!want && has) battle.removeBuff(unit, REGEN_KEY);
|
||
};
|
||
battle.on('tick', apply, { owner: unit });
|
||
battle.on('battleStart', apply, { owner: unit });
|
||
battle.on('deploy', (c) => { if (c.unit === unit && battle.started) apply(); }, { owner: unit });
|
||
} },
|
||
],
|
||
install(battle, unit) {
|
||
// S3: the use count restarts with every deployment (PRTS "每次部署棘刺时，重新计算该技能的使用次数")
|
||
battle.on('deploy', (c) => { if (c.unit === unit) unit.mem.thornsS3Uses = 0; }, { owner: unit });
|
||
// LOR-Δ: 神经损伤 = ep_damage_ratio × the HP damage of every damage instance he deals
|
||
if (loreD > 0) {
|
||
battle.on('damaged', (c) => {
|
||
if (c.source !== unit || !c.target || c.target.side !== 'enemy' || c.type === 'element' || !(c.amount > 0) || !hasHp(c.target)) return;
|
||
battle.dealDamage(unit, c.target, { type: 'element', element: 'neural', amount: c.amount * loreD, tags: ['module', 'thorns:lord'] });
|
||
}, { owner: unit });
|
||
}
|
||
if (unit.skill?.id !== S2) return;
|
||
// S2 护身尖刺: 普通伤害 from an enemy ⇒ the Thorn ability (cooldown), 0.5 s later up to max_target spikes on the 3-1
|
||
unit.mem.thornsSpikeAt = -Infinity;
|
||
const cd = num(b2.cooldown, 0.8), n = Math.max(1, Math.floor(num(b2.max_target, 4)));
|
||
battle.on('damaged', (c) => {
|
||
const sk = unit.skill;
|
||
if (c.target !== unit || !sk || !sk.active || !up(unit) || !unit.canAct || !normalHitFromEnemy(c)) return;
|
||
if (battle.time < unit.mem.thornsSpikeAt + cd - 1e-9) return;
|
||
unit.mem.thornsSpikeAt = battle.time;
|
||
const seq = unit.deploySeq, act = sk.activations;
|
||
battle.after(SPIKE_DELAY, () => {
|
||
if (!up(unit) || unit.deploySeq !== seq || !unit.canAct || !unit.skill?.active || unit.skill.activations !== act) return;
|
||
const list = battle.enemiesInKeys(absoluteRangeKeys(grid2, unit.tileR, unit.tileC, unit.dir, 0), unit, AIR);
|
||
sortEnemyTargets(battle, unit, list, null);
|
||
const targets = list.slice(0, n);
|
||
if (!targets.length) return;
|
||
battle.fx('thorns', { x: unit.x, y: unit.y, id: unit.id, n: targets.length });
|
||
for (const e of targets) {
|
||
if (!e.alive) continue;
|
||
battle.dealDamage(unit, e, { amount: unit.s.atk * rangedScale * unit.s.atkScaleMul, type: 'phys', isSkill: true, tags: ['skill', 'thorns:spike'] });
|
||
addition(battle, unit, e);
|
||
}
|
||
}, { owner: unit });
|
||
}, { owner: unit });
|
||
},
|
||
};
|
||
},
|
||
};
|