1311 lines
70 KiB
JavaScript
1311 lines
70 KiB
JavaScript
// Tier-4 operator loadouts (DESIGN §16): every selectable NON-default skill of every visible tier-4 chess has a
|
||
// hand-authored spec in its kit file (server/sim/content/kits/ops/, `skills[skillId]`), proven here by its signature effect for
|
||
// the normal (Lv4) and the elite (Lv7) chess; non-default modules (and 'none') change what their text says. Numbers
|
||
// are read back from the data blackboards (the SELECTED skill's `bb`), real battles through the harness.
|
||
import { test } from 'node:test';
|
||
import assert from 'node:assert/strict';
|
||
import { makeBattle, enemyRec, checkInvariants } from '../helpers/battleHarness.js';
|
||
import { getDefaultSource } from '../../server/sim/simdata.js';
|
||
import { loadoutOptions } from '../../shared/protocol.js';
|
||
import { skillSpecSource } from '../../server/sim/content/index.js';
|
||
import { kitCoverage } from '../../tools/kit-coverage.mjs';
|
||
import { canTargetAlly } from '../../server/sim/targeting.js';
|
||
import { aggregateMods } from '../../server/sim/buffs.js';
|
||
|
||
const ds = getDefaultSource();
|
||
const C = ds.raw.chess;
|
||
const approx = (a, b, eps = 1e-6, msg = '') => assert.ok(Math.abs(a - b) <= eps * Math.max(1, Math.abs(b)), `${msg} ${a} ≈ ${b}`);
|
||
const dummy = (o = {}) => enemyRec({ key: 'enemy_dummy', hp: 1e8, speed: 0, ...o });
|
||
const gold = (id) => id.replace(/_a$/, '_b');
|
||
/** Both chess of a base id: [normal, elite]. */
|
||
const pair = (base) => [base, gold(base)];
|
||
/** Resolved def of a chess for a loadout. */
|
||
const D = (id, skillIndex, moduleId) => ds.getChess(id, { skillIndex, ...(moduleId ? { moduleId } : {}) });
|
||
/** Harness unit entry with a loadout. */
|
||
const U = (chessId, row, col, skillIndex = null, moduleId = null, extra = {}) =>
|
||
({ chessId, row, col, ...(skillIndex != null ? { skillIndex } : {}), ...(moduleId ? { moduleId } : {}), ...extra });
|
||
const dmgBy = (h, u, pred = () => true) => h.hooksOf('damaged').filter((c) => c.source === u && pred(c));
|
||
const tagged = (tag) => (c) => (c.dmg?.tags || []).includes(tag);
|
||
const T4 = Object.values(C).filter((c) => c.tier === 4 && !c.isGolden && c.visible).map((c) => c.chessId).sort();
|
||
|
||
function battle(units, o = {}) {
|
||
return makeBattle({
|
||
defs: { enemies: { enemy_dummy: dummy(), ...(o.enemies || {}) } },
|
||
units, timeLimit: o.timeLimit ?? 300, hooks: o.hooks ?? ['damaged', 'attack', 'skillStart', 'skillEnd', 'heal', 'death', 'deploy', 'dodge', 'spGain'],
|
||
captureNoisy: true, seed: o.seed ?? 3, flags: o.flags, ...(o.extra || {}),
|
||
});
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------------------------------------------
|
||
// coverage + smoke
|
||
|
||
test('tier4 loadouts: every selectable skill of every visible chess is hand-authored (normal + elite)', () => {
|
||
const rep = kitCoverage({ tier: 4 });
|
||
assert.equal(rep.summary.chess, 22);
|
||
assert.equal(rep.summary.covered, rep.summary.skills, JSON.stringify(rep.chess.flatMap((r) => r.skills.filter((s) => !s.covered).map((s) => `${r.name} S${s.index + 1}`))));
|
||
for (const base of T4) {
|
||
const { skills } = loadoutOptions(C[base], C[gold(base)]);
|
||
for (const i of skills) {
|
||
if (C[base].skills.find((s) => s.index === i).isDefault) continue;
|
||
for (const id of pair(base)) assert.equal(skillSpecSource(D(id, i)), 'skills', `${id} S${i + 1}`);
|
||
}
|
||
}
|
||
});
|
||
|
||
test('tier4 loadouts: every chess × selectable skill × module fights a mixed wave without content errors', () => {
|
||
const runs = [];
|
||
for (const base of T4) {
|
||
const { skills } = loadoutOptions(C[base], C[gold(base)]);
|
||
const mods = [null, 'none', ...(C[gold(base)].modules || []).filter((m) => !m.isDefault).map((m) => m.uniEquipId)];
|
||
for (const i of skills) {
|
||
runs.push([base, i, null]);
|
||
for (const m of mods) runs.push([gold(base), i, m]);
|
||
}
|
||
}
|
||
for (const [id, i, m] of runs) {
|
||
const h = makeBattle({
|
||
defs: { enemies: {
|
||
e_walk: enemyRec({ key: 'e_walk', hp: 6000, atk: 300, def: 100, res: 20, speed: 1, bat: 1.5 }),
|
||
e_fly: enemyRec({ key: 'e_fly', hp: 3000, atk: 150, motion: 'FLY', speed: 1, range: 1.5 }),
|
||
e_elite: enemyRec({ key: 'e_elite', rank: 'ELITE', hp: 9000, atk: 400, def: 200, speed: 0.8, bat: 2 }),
|
||
} },
|
||
units: [U(id, 9, 6, i, m), U('chess_char_1_02_a', 10, 6), U('chess_char_1_01_a', 11, 5), U('chess_char_4_17_a', 12, 7)],
|
||
enemies: [{ key: 'e_walk', route: 0, count: 6, interval: 3 }, { key: 'e_walk', route: 1, count: 4, interval: 4 },
|
||
{ key: 'e_fly', route: 2, count: 3, interval: 5 }, { key: 'e_elite', route: 0, time: 8 }],
|
||
timeLimit: 70, seed: 5, hooks: [],
|
||
});
|
||
const u = h.unit(id);
|
||
assert.equal(u.def.loadout?.skillIndex ?? u.def.skill.index, i, `${id} S${i + 1} selected`);
|
||
u.skill.gainSp?.(1000, 'test');
|
||
h.runToEnd(80);
|
||
assert.equal(h.b.errorCount, 0, `${id} S${i + 1} ${m}: ${JSON.stringify(h.b.errors.map((e) => e.label + ' ' + e.message))}`);
|
||
checkInvariants(h.b);
|
||
}
|
||
});
|
||
|
||
// ---------------------------------------------------------------------------------------------------------------
|
||
// 信仰搅拌机
|
||
|
||
test('信仰搅拌机 S1 铳骑主考官 (自动触发 ⇒ DEFAULT: hurt SP, fires with the next attack); next attack = 3 hits × atk_scale; reloads one adjacent 拉特兰 ammo skill', () => {
|
||
for (const id of pair('chess_char_4_01_a')) {
|
||
const bb = D(id, 0).skill.bb;
|
||
const h = battle([U(id, 9, 5, 0, gold(id) === id ? 'none' : null), U('chess_char_1_01_a', 10, 4)], {
|
||
enemies: { enemy_hitter: dummy({ key: 'enemy_hitter', atk: 50, bat: 1 }) },
|
||
});
|
||
h.step();
|
||
const u = h.unit(id), ins = h.unit('chess_char_1_01_a');
|
||
assert.equal(u.skill.id, 'skchr_rmixer_1');
|
||
assert.equal(u.skill.rule, 'DEFAULT', 'an AUTO skill takes no 技能策略 (the 重装 row is for MANUAL skills)');
|
||
assert.ok(ins.skill.activate('test', { free: true }));
|
||
u.skill.gainSp(1000);
|
||
const ammo0 = ins.skill.ammoLeft;
|
||
h.hooksOf('attack').length = 0;
|
||
h.spawn('enemy_hitter', { pos: [9, 5] });
|
||
assert.ok(h.runUntil(() => h.hooksOf('skillStart').some((c) => c.unit === u), 10), `${id} S1 cast with the next attack`);
|
||
assert.ok(h.runUntil(() => h.hooksOf('skillEnd').some((c) => c.unit === u), 10), 'the armed attack happened');
|
||
const skillHits = dmgBy(h, u, (c) => c.dmg.isAttack && c.dmg.isSkill);
|
||
assert.equal(skillHits.length, 3, `${id}: triple hit`);
|
||
assert.equal(new Set(skillHits.map((c) => c.dmg.attackId)).size, 1, 'one attack');
|
||
for (const c of skillHits) approx(c.amount, u.s.atk * bb.atk_scale, 1e-6, `${id} hit`);
|
||
const shots = h.hooksOf('attack').filter((c) => c.attacker === ins).length;
|
||
assert.equal(ins.skill.ammoLeft, ammo0 - shots + bb.charge, `${id} reloaded ${bb.charge} bullet(s)`);
|
||
checkInvariants(h.b);
|
||
}
|
||
});
|
||
|
||
test('信仰搅拌机 S2 八臂电锯侠: ammo skill, ATK/DEF up; a lethal hit is negated for ammo_cost bullets; with fewer it is still negated, every bullet goes and the skill ends (PRTS 备注)', () => {
|
||
for (const id of pair('chess_char_4_01_a')) {
|
||
const bb = D(id, 1).skill.bb;
|
||
for (const enough of [true, false]) {
|
||
const h = battle([U(id, 9, 5, 1)], { enemies: { enemy_killer: dummy({ key: 'enemy_killer', atk: 1e6, bat: 2 }) } });
|
||
h.step();
|
||
const u = h.unit(id);
|
||
assert.ok(u.skill.activate('test', { free: true }));
|
||
assert.equal(u.skill.kind, 'ammo');
|
||
assert.equal(u.skill.ammoLeft, bb['attack@trigger_time']);
|
||
approx(u.s.atk, u.base.atk * (1 + bb.atk), 1e-6, 'ATK');
|
||
approx(u.s.def, u.base.def * (1 + bb.def), 1e-6, 'DEF');
|
||
if (!enough) u.skill.ammoLeft = bb.ammo_cost - 1;
|
||
u.hp = 500;
|
||
const before = u.skill.ammoLeft;
|
||
h.spawn('enemy_killer', { pos: [9, 5] });
|
||
h.runUntil(() => h.hooksOf('damaged').some((c) => c.target === u) || !u.alive, 10);
|
||
if (enough) {
|
||
assert.ok(u.alive, `${id}: lethal hit negated`);
|
||
approx(u.hp, 500, 1e-9, 'HP kept');
|
||
const shots = h.hooksOf('attack').filter((c) => c.attacker === u).length;
|
||
assert.equal(u.skill.ammoLeft, before - bb.ammo_cost - shots, `${bb.ammo_cost} bullets spent`);
|
||
} else {
|
||
// PRTS 备注 "弹药量不足时仍可抵挡致命伤害，此时将消耗所有剩余弹药并退出技能状态" (0.1.0: [ASSUMED] no guard)
|
||
assert.ok(u.alive, `${id}: fewer than ${bb.ammo_cost} bullets still block the lethal hit`);
|
||
approx(u.hp, 500, 1e-9, 'HP kept');
|
||
assert.equal(u.skill.ammoLeft, 0, 'every bullet spent');
|
||
assert.equal(u.skill.active, false, 'the skill ends');
|
||
}
|
||
}
|
||
}
|
||
});
|
||
|
||
test('信仰搅拌机 modules: SPT-Y 老朋友 = range +1 and no reveal; SPT-X (default) reveals', () => {
|
||
const size = (m) => {
|
||
const h = battle([U('chess_char_4_01_b', 10, 5, null, m)]);
|
||
h.step();
|
||
const u = h.unit('chess_char_4_01_b');
|
||
const e = h.spawn('enemy_dummy', { pos: [10, 6] });
|
||
h.b.applyStatus(e, 'stealth', { duration: 30 });
|
||
h.run(0.5);
|
||
return { n: u.rangeKeys.length, reveal: !!e.s.flags.reveal };
|
||
};
|
||
const def = size(null), y = size('uniequip_003_rmixer'), none = size('none');
|
||
assert.ok(y.n > def.n, `range ${def.n} → ${y.n}`);
|
||
assert.equal(def.n, none.n);
|
||
assert.deepEqual([def.reveal, y.reveal, none.reveal], [true, false, false]);
|
||
});
|
||
|
||
// ---------------------------------------------------------------------------------------------------------------
|
||
// 莫斯提马
|
||
|
||
test('莫斯提马 S1 攻击力强化·γ型: ATK +45 %/+60 %; talent 2 slow is NOT tripled (S3 only)', () => {
|
||
for (const id of pair('chess_char_4_02_a')) {
|
||
const bb = D(id, 0).skill.bb, t1 = D(id, 0).talents[1].bb;
|
||
const h = battle([U(id, 10, 3, 0)]);
|
||
h.step();
|
||
const u = h.unit(id);
|
||
const e = h.spawn('enemy_dummy', { pos: [10, 4] });
|
||
assert.ok(u.skill.activate('test', { free: true }));
|
||
h.run(0.5);
|
||
approx(u.s.atk, u.base.atk * (1 + bb.atk), 1e-6, `${id} ATK`);
|
||
approx(e.findBuff(`mostma:slow:${u.id}`).mods.moveMul, 1 + t1.move_speed, 1e-9, 'plain talent slow');
|
||
approx(u.skill.timeLeft, D(id, 0).skill.duration - 0.5, 0.05);
|
||
}
|
||
});
|
||
|
||
test('莫斯提马 S2 荒时之锁: every enemy in range stunned until the skill ends, atk_scale arts per second', () => {
|
||
for (const id of pair('chess_char_4_02_a')) {
|
||
const sk = D(id, 1).skill, bb = sk.bb;
|
||
const h = battle([U(id, 10, 3, 1)]);
|
||
h.step();
|
||
const u = h.unit(id);
|
||
const es = [h.spawn('enemy_dummy', { pos: [10, 4] }), h.spawn('enemy_dummy', { pos: [9, 5] }), h.spawn('enemy_dummy', { pos: [11, 5] })];
|
||
const far = h.spawn('enemy_dummy', { pos: [10, 9] });
|
||
assert.ok(u.skill.activate('test', { free: true }));
|
||
h.run(0.2);
|
||
for (const e of es) assert.ok(e.s.flags.stun, `${id}: enemy in range stunned`);
|
||
assert.ok(!far.s.flags.stun, 'enemy out of range not stunned');
|
||
h.runUntil(() => !u.skill.active, 20);
|
||
const lock = dmgBy(h, u, tagged('timeLock'));
|
||
for (const e of es) {
|
||
const mine = lock.filter((c) => c.target === e);
|
||
assert.equal(mine.length, Math.floor(sk.duration + 1e-6), `${id}: one tick per second (${sk.duration} s)`);
|
||
approx(mine[0].amount, u.s.atk * bb.atk_scale, 1e-6, 'arts tick');
|
||
}
|
||
assert.ok(!lock.some((c) => c.target === far));
|
||
h.run(0.2);
|
||
for (const e of es) assert.ok(!e.s.flags.stun, 'stun ends with the skill');
|
||
checkInvariants(h.b);
|
||
}
|
||
});
|
||
|
||
test('莫斯提马 module SPC-X 资深万国信使定制斗篷: 攻击范围扩大 (default SPC-Y and none do not)', () => {
|
||
const n = (m) => { const h = battle([U('chess_char_4_02_b', 10, 3, null, m)]); h.step(); return h.unit('chess_char_4_02_b').rangeKeys.length; };
|
||
assert.ok(n('uniequip_003_mostma') > n(null));
|
||
assert.equal(n(null), n('none'));
|
||
});
|
||
|
||
test('莫斯提马 SPC-X: the range becomes the module grid (only the centre tile [0,3] added, no rangeExtend); S3 keeps its own range', () => {
|
||
const id = 'chess_char_4_02_b';
|
||
const modGrid = C[id].modules.find((m) => m.uniEquipId === 'uniequip_003_mostma').talentChanges.find((t) => t.rangeGrid).rangeGrid;
|
||
const rel = (u) => u.rangeKeys.map((k) => `${Math.floor(k / 21) - u.tileR},${(k % 21) - u.tileC}`).sort();
|
||
const run = (m) => {
|
||
const h = battle([U(id, 10, 3, null, m)]);
|
||
h.step();
|
||
const u = h.unit(id);
|
||
const base = rel(u), initial = u.baseRangeKeys.length, ext = u.s.rangeExtend;
|
||
assert.ok(u.skill.activate('test', { free: true }));
|
||
h.step();
|
||
return { base, initial, ext, skill: rel(u) };
|
||
};
|
||
const x = run('uniequip_003_mostma'), def = run(null);
|
||
assert.deepEqual(x.base, modGrid.map(([r, c]) => `${r},${c}`).sort(), 'own range = module grid');
|
||
assert.equal(x.base.length, C[id].rangeGrid.length + 1, 'exactly one tile more');
|
||
assert.ok(x.base.includes('0,3') && !x.base.includes('1,3') && !x.base.includes('-1,3'));
|
||
assert.equal(x.initial, x.base.length, 'DEFAULT trigger range follows');
|
||
assert.equal(x.ext, 0, 'no forward extension');
|
||
assert.deepEqual(x.skill, def.skill, 'S3 range unchanged by the module');
|
||
assert.equal(x.skill.length, D(id, 2).skill.rangeGrid.length);
|
||
});
|
||
|
||
// ---------------------------------------------------------------------------------------------------------------
|
||
// 伊内丝
|
||
|
||
test('伊内丝 S1 淬影突袭: next attack +2 DP and a 3 s non-stacking arts DoT of 40 %/55 % ATK per second', () => {
|
||
for (const id of pair('chess_char_4_04_a')) {
|
||
const bb = D(id, 0).skill.bb;
|
||
const h = battle([U(id, 10, 4, 0)], { flags: { dpPerSec: 0 } });
|
||
h.step();
|
||
const u = h.unit(id);
|
||
const e = h.spawn('enemy_dummy', { pos: [10, 5] });
|
||
h.run(1.5); // first damage: 影织 binds + steals ATK (her ATK is stable afterwards)
|
||
const dp0 = h.b.getPlayer('p1').dp;
|
||
assert.ok(u.skill.activate('test', { free: true }));
|
||
assert.ok(h.runUntil(() => !u.skill.active, 10));
|
||
h.run(0.4); // the bolt lands
|
||
assert.equal(h.b.getPlayer('p1').dp, dp0 + bb.cost, `${id}: +${bb.cost} DP`);
|
||
assert.ok(e.findBuff(`ines:bleed:${u.id}`), 'DoT applied');
|
||
h.run(bb.bleed_duration + 0.5);
|
||
const dot = dmgBy(h, u, tagged('dot'));
|
||
assert.equal(dot.length, bb.bleed_duration, `${id}: ${bb.bleed_duration} ticks`);
|
||
for (const c of dot) approx(c.amount, u.s.atk * bb.bleed_atk_scale, 1e-6, 'arts per second');
|
||
assert.ok(e.buffs.filter((b) => b.key === `ines:bleed:${u.id}`).length <= 1, '不叠加');
|
||
}
|
||
});
|
||
|
||
test('伊内丝 S3 独影归途: first deployment leaves a sentry and retreats; the redeploy recalls it through ≤ 4/5 enemies; ATK up; +1 DP per damage', () => {
|
||
for (const id of pair('chess_char_4_04_a')) {
|
||
const sk = D(id, 2).skill, bb = sk.bb;
|
||
const h = battle([U(id, 10, 5, 2)], { flags: { dpInit: 99, dpPerSec: 0 } });
|
||
const u = h.unit(id);
|
||
h.b.start();
|
||
assert.equal(u.skill.kind, 'duration');
|
||
assert.equal(u.skill.active, false, 'first deployment does not activate the skill');
|
||
assert.equal(u.skill.activations, 0);
|
||
assert.equal(h.hooksOf('skillStart').filter((c) => c.unit === u).length, 0, 'placing a sentry emits no skillStart');
|
||
assert.equal(u.skill.timeLeft, 0, 'first deployment places the sentry without a full effect window');
|
||
assert.equal(u.findBuff('ines:s3'), null);
|
||
const near = [];
|
||
for (let i = 0; i < 3; i++) near.push(h.spawn('enemy_dummy', { pos: [10, 6] }), h.spawn('enemy_dummy', { pos: [10, 4] }));
|
||
const far = h.spawn('enemy_dummy', { pos: [10, 8] });
|
||
h.step(3);
|
||
const left = h.hooksOf('death').find((c) => c.unit === u);
|
||
assert.ok(left && left.reason === 'retreat', `${id}: leaves right after the first deployment`);
|
||
assert.ok(h.runUntil(() => u.alive && u.deployed, 2), 'redeploy timer refreshed: back at once');
|
||
const buff = u.findBuff('ines:s3');
|
||
assert.ok(buff, 'ATK effect on the redeploy');
|
||
approx(buff.mods.atkPct, bb.atk, 1e-9);
|
||
approx(u.skill.timeLeft, sk.duration, 0.1);
|
||
assert.equal(u.skill.active, true);
|
||
assert.equal(u.skill.activations, 1);
|
||
assert.equal(h.hooksOf('skillStart').filter((c) => c.unit === u).length, 1, 'the redeployment starts the skill once');
|
||
assert.equal(u.skill.ready, false);
|
||
assert.equal(h.snapshot().units.find((t) => t[0] === u.id)[6], sk.duration);
|
||
const recall = dmgBy(h, u, tagged('sentryRecall'));
|
||
assert.equal(recall.length, bb.max_target, `${id}: recall hits ≤ ${bb.max_target} of 6`);
|
||
assert.ok(recall.every((c) => near.includes(c.target)) && !recall.some((c) => c.target === far));
|
||
for (const c of recall) approx(c.amount, u.base.atk * (1 + bb.atk) * bb.atk_scale, 1e-6, 'recall damage');
|
||
assert.equal(u.mem.sentry, null, 'sentry recalled');
|
||
const dpAt = h.b.getPlayer('p1').dp, tAt = h.b.time;
|
||
h.run(3);
|
||
const hits = h.hooksOf('damaged').filter((c) => c.source === u && c.t >= tAt - 1e-9 && c.amount > 0 && c.target.side === 'enemy').length;
|
||
assert.ok(hits > 0);
|
||
assert.equal(h.b.getPlayer('p1').dp, dpAt + hits * bb.cost, 'one DP per damage while the passive lasts');
|
||
assert.equal(h.hooksOf('death').filter((c) => c.unit === u).length, 1, 'only the first deployment leaves');
|
||
h.run(sk.duration);
|
||
assert.equal(u.skill.active, false);
|
||
assert.equal(u.skill.ready, false);
|
||
assert.equal(u.findBuff('ines:s3'), null);
|
||
const dpEnd = h.b.getPlayer('p1').dp;
|
||
h.run(2);
|
||
assert.equal(h.b.getPlayer('p1').dp, dpEnd, 'no skill DP after the actual window ends');
|
||
assert.equal(h.hooksOf('death').filter((c) => c.unit === u).length, 1, 'stays deployed after the window');
|
||
assert.deepEqual(h.hooksOf('skillEnd').filter((c) => c.unit === u).map((c) => c.reason), ['duration']);
|
||
checkInvariants(h.b);
|
||
}
|
||
});
|
||
|
||
test('伊内丝 module none: the first retreat keeps its full redeploy time (AGE-Y shortens it by 35 %)', () => {
|
||
const wait = (m) => {
|
||
const h = battle([U('chess_char_4_04_b', 10, 5, null, m)]);
|
||
h.step();
|
||
const u = h.unit('chess_char_4_04_b');
|
||
h.b.retreat(u);
|
||
return u.respawnAt - u.deathAt;
|
||
};
|
||
approx(wait(null), wait('none') * (1 + C.chess_char_4_04_b.modules[0].traitOverride.bb.respawn_time), 1e-6);
|
||
});
|
||
|
||
// ---------------------------------------------------------------------------------------------------------------
|
||
// 寒芒克洛丝 / 风笛
|
||
|
||
test('寒芒克洛丝 S1 无痕: ATK up, every attack is a double shot, 迷彩 (ranged enemies cannot target her); no S2 hit counting', () => {
|
||
for (const id of pair('chess_char_4_06_a')) {
|
||
const bb = D(id, 0).skill.bb;
|
||
const h = battle([U(id, 10, 4, 0)]);
|
||
h.step();
|
||
const u = h.unit(id);
|
||
const e = h.spawn('enemy_dummy', { pos: [10, 6] });
|
||
assert.ok(u.skill.activate('test', { free: true }));
|
||
assert.equal(u.skill.kind, 'duration');
|
||
approx(u.s.atk, u.base.atk * (1 + bb.atk), 1e-6, `${id} ATK`);
|
||
assert.ok(u.s.flags.camou && !u.s.flags.stealth, '迷彩 (not 隐匿)');
|
||
assert.equal(canTargetAlly(e, u, true), false, 'not a ranged target');
|
||
h.run(3);
|
||
const shots = dmgBy(h, u, (c) => c.dmg.isAttack);
|
||
const per = new Map();
|
||
for (const c of shots) per.set(c.dmg.attackId, (per.get(c.dmg.attackId) ?? 0) + 1);
|
||
assert.ok(per.size >= 2 && [...per.values()].every((n) => n === 2), `${id}: 2 shots per attack`);
|
||
assert.equal(u.mem.kroosHits ?? 0, 0, 'S2 hit counter untouched');
|
||
h.runUntil(() => !u.skill.active, 30);
|
||
assert.ok(!u.s.flags.camou);
|
||
}
|
||
});
|
||
|
||
test('风笛 S1 迅捷打击·γ型 (ATK/ASPD) and S3 闭膛连发 (BAT +0.7 s, block +1, ATK/DEF up, triple hits)', () => {
|
||
for (const id of pair('chess_char_4_07_a')) {
|
||
const b1 = D(id, 0).skill.bb, b3 = D(id, 2).skill.bb;
|
||
let h = battle([U(id, 10, 4, 0)]);
|
||
h.step();
|
||
let u = h.unit(id);
|
||
assert.ok(u.skill.activate('test', { free: true }));
|
||
approx(u.s.atk, u.base.atk * (1 + b1.atk), 1e-6, 'S1 ATK');
|
||
assert.equal(u.s.aspd, u.base.aspd + b1.attack_speed);
|
||
h = battle([U(id, 10, 4, 2)]);
|
||
h.step();
|
||
u = h.unit(id);
|
||
h.spawn('enemy_dummy', { pos: [10, 5] });
|
||
assert.ok(u.skill.activate('test', { free: true }));
|
||
approx(u.s.atk, u.base.atk * (1 + b3.atk), 1e-6, 'S3 ATK');
|
||
approx(u.s.def, u.base.def * (1 + b3.def), 1e-6, 'S3 DEF');
|
||
assert.equal(u.s.blockCnt, u.base.blockCnt + b3.block_cnt);
|
||
approx(u.s.interval, (u.base.bat + b3.base_attack_time) * 100 / u.s.aspd, 1e-6, 'BAT +0.7 s');
|
||
h.run(4);
|
||
const per = new Map();
|
||
for (const c of dmgBy(h, u, (c) => c.dmg.isAttack && c.dmg.isSkill)) per.set(`${c.dmg.attackId}:${c.target.id}`, (per.get(`${c.dmg.attackId}:${c.target.id}`) ?? 0) + 1);
|
||
assert.ok(per.size >= 2 && [...per.values()].every((n) => n === 3), `${id}: three hits per target per attack`);
|
||
}
|
||
});
|
||
|
||
test('风笛 module CHG-Y “棍棒与口袋”: attacks on enemies below 40 % HP use 115 % ATK (default / none do not)', () => {
|
||
const minHit = (m, low) => {
|
||
const h = battle([U('chess_char_4_07_b', 10, 4, 0, m)]);
|
||
h.step();
|
||
const u = h.unit('chess_char_4_07_b');
|
||
const e = h.spawn('enemy_dummy', { pos: [10, 5] });
|
||
if (low) e.hp = e.s.maxHp * 0.3;
|
||
h.run(6);
|
||
const hits = dmgBy(h, u, (c) => c.dmg.isAttack && c.target === e).map((c) => c.amount / u.s.atk);
|
||
assert.ok(hits.length >= 3);
|
||
return Math.min(...hits);
|
||
};
|
||
const tb = C.chess_char_4_07_b.modules.find((m) => m.uniEquipId === 'uniequip_003_bpipe').traitOverride.bb;
|
||
approx(minHit('uniequip_003_bpipe', true), tb.atk_scale, 1e-6, 'low HP ×1.15');
|
||
approx(minHit('uniequip_003_bpipe', false), 1, 1e-6, 'healthy target ×1');
|
||
approx(minHit(null, true), 1, 1e-6, 'default module: no bonus');
|
||
});
|
||
|
||
// ---------------------------------------------------------------------------------------------------------------
|
||
// 水月 / 阿罗玛 / 凯瑟琳
|
||
|
||
test('水月 S1 唤醒: charges; the next attack hits every enemy in range for atk_scale and talent 1 deals ×talent_scale', () => {
|
||
for (const id of pair('chess_char_4_09_a')) {
|
||
const d = D(id, 0), bb = d.skill.bb, t0 = d.talents[0].bb;
|
||
const h = battle([U(id, 10, 4, 0)]);
|
||
h.step();
|
||
const u = h.unit(id);
|
||
assert.equal(u.skill.maxCharges, bb.cnt);
|
||
const es = [h.spawn('enemy_dummy', { pos: [10, 5] }), h.spawn('enemy_dummy', { pos: [9, 5] })];
|
||
assert.ok(u.skill.activate('test', { free: true }));
|
||
assert.ok(h.runUntil(() => !u.skill.active, 10));
|
||
const sk = dmgBy(h, u, (c) => c.dmg.isAttack && c.dmg.isSkill);
|
||
assert.deepEqual(new Set(sk.map((c) => c.target)), new Set(es), `${id}: every enemy in range`);
|
||
for (const c of sk) approx(c.amount, u.s.atk * bb.atk_scale, 1e-6, 'skill hit');
|
||
const tal = dmgBy(h, u, tagged('talent'));
|
||
assert.equal(tal.length, 1);
|
||
approx(tal[0].amount, u.s.atk * t0['attack@mizuki_t_1.atk_scale'] * bb.talent_scale, 1e-6, 'talent ×2');
|
||
h.run(8);
|
||
for (const c of dmgBy(h, u, tagged('talent')).slice(1)) approx(c.amount, u.s.atk * t0['attack@mizuki_t_1.atk_scale'], 1e-6, 'plain talent afterwards');
|
||
}
|
||
});
|
||
|
||
test('水月 S3 镜花水月: wider range, ATK up, talent 1 +2 targets with stun; an attack hitting < 3 enemies costs 15 % max HP', () => {
|
||
for (const id of pair('chess_char_4_09_a')) {
|
||
const bb = D(id, 2).skill.bb;
|
||
for (const n of [1, 3]) {
|
||
const h = battle([U(id, 10, 4, 2)]);
|
||
h.step();
|
||
const u = h.unit(id);
|
||
const base = u.rangeKeys.length;
|
||
const es = [];
|
||
for (let i = 0; i < n; i++) es.push(h.spawn('enemy_dummy', { pos: [10 + (i === 1 ? -1 : i === 2 ? 1 : 0), 5] }));
|
||
assert.ok(u.skill.activate('test', { free: true }));
|
||
assert.ok(u.rangeKeys.length > base, 'range widened');
|
||
approx(u.s.atk, u.base.atk * (1 + bb.atk) * (u.findBuff('mizuki:t2') ? 1 + D(id, 2).talents[1].bb.atk : 1), 1e-6);
|
||
const hp0 = u.hp;
|
||
assert.ok(h.runUntil(() => h.hooksOf('attack').some((c) => c.attacker === u), 10));
|
||
const tal = dmgBy(h, u, tagged('talent'));
|
||
assert.equal(tal.length, Math.min(n, 1 + bb['attack@max_target']), `${id}: talent hits ${Math.min(n, 3)}`);
|
||
for (const c of tal) assert.ok(c.target.s.flags.stun, 'talent stun');
|
||
if (n < 3) approx(hp0 - u.hp, u.s.maxHp * bb['attack@hp_ratio'], 1e-6, 'HP loss');
|
||
else assert.equal(u.hp, hp0, 'no loss with ≥ 3 enemies hit');
|
||
}
|
||
}
|
||
});
|
||
|
||
test('水月 module AMB-Y 深蓝之籽: 65 % physical and arts dodge (default AMB-X: 50 % + slow aura)', () => {
|
||
const dodge = (m) => { const h = battle([U('chess_char_4_09_b', 10, 4, null, m)]); h.step(); return h.unit('chess_char_4_09_b').s.dodgePhys; };
|
||
approx(dodge('uniequip_003_mizuki'), 0.65, 1e-9);
|
||
approx(dodge(null), 0.5, 1e-9);
|
||
});
|
||
|
||
test('阿罗玛 S1 强效清洁: charges; next blast atk_scale arts, flying victims take +atk_scale_to_fly', () => {
|
||
for (const id of pair('chess_char_4_10_a')) {
|
||
const bb = D(id, 0).skill.bb;
|
||
const h = battle([U(id, 10, 3, 0, gold(id) === id ? 'none' : null)], { enemies: { enemy_flyer: dummy({ key: 'enemy_flyer', motion: 'FLY' }) } });
|
||
h.step();
|
||
const u = h.unit(id);
|
||
const g = h.spawn('enemy_dummy', { pos: [10, 6] }), f = h.spawn('enemy_flyer', { pos: [10, 6] });
|
||
h.run(4); // the talent's first-hit bonus / levitation are spent
|
||
assert.ok(u.skill.activate('test', { free: true }));
|
||
assert.ok(h.runUntil(() => !u.skill.active, 10));
|
||
h.run(1);
|
||
const sk = dmgBy(h, u, (c) => c.dmg.isAttack && c.dmg.isSkill);
|
||
assert.deepEqual(new Set(sk.map((c) => c.target)), new Set([g, f]));
|
||
for (const c of sk) approx(c.amount, u.s.atk * bb.atk_scale, 1e-6, `${id} blast`);
|
||
const aa = dmgBy(h, u, tagged('antiAir'));
|
||
assert.equal(aa.length, 1);
|
||
assert.equal(aa[0].target, f, 'only the flyer');
|
||
approx(aa[0].amount, u.s.atk * bb.atk_scale_to_fly, 1e-6, 'anti-air bonus');
|
||
}
|
||
});
|
||
|
||
test('凯瑟琳 S1 岁月锻打: passive ATK/DEF up for her and every operator holding a device shield; the hand card is her deploy limit', () => {
|
||
for (const id of pair('chess_char_4_11_a')) {
|
||
const bb = D(id, 0).skill.bb;
|
||
// her device is a placed piece (user playtest #6): facing 4_17 on its right
|
||
const dev = { kind: 'token', tokenId: 'token_10041_cathy_catsld', ownerUid: 1, row: 10, col: 5, dir: 'RIGHT' };
|
||
const h = battle([U(id, 10, 4, 0, null, { uid: 1 }), U('chess_char_4_17_a', 10, 6), U('chess_char_1_01_a', 12, 3), dev]);
|
||
h.run(1);
|
||
const u = h.unit(id), hs = h.unit('chess_char_4_17_a'), ins = h.unit('chess_char_1_01_a');
|
||
assert.equal(u.skill.kind, 'passive');
|
||
approx(u.s.atk, u.base.atk * (1 + bb.s1_atk), 1e-6, `${id} own ATK`);
|
||
approx(u.s.def, u.base.def * (1 + bb.s1_def), 1e-6, 'own DEF');
|
||
for (const a of [hs, ins]) {
|
||
const f = a.findBuff(`cathy:forge:${u.id}`);
|
||
assert.equal(!!f, !!a.findBuff('cathy:shield'), `${a.name}: forge buff iff device shield`);
|
||
if (f) approx(f.mods.atkPct, bb.s1_atk, 1e-9);
|
||
}
|
||
assert.ok(hs.findBuff(`cathy:forge:${u.id}`), 'the shielded blocker gets it');
|
||
}
|
||
// the module changes how many devices she carries (none 3, CRA-X 4); the hand gets the deploy limit (2) either way
|
||
// (PRTS 卫戍协议/帮助 "根据召唤物部署数量上限（非初始持有量），发送等量召唤物至手牌区")
|
||
assert.deepEqual([C.chess_char_4_11_b.talentsBase[0].bb.cnt, C.chess_char_4_11_b.talents[0].bb.cnt], [3, 4]);
|
||
for (const id of pair('chess_char_4_11_a')) assert.equal(ds.raw.tokens.token_10041_cathy_catsld.variants[id].stats.deployLimit, 2, `${id}: deploy limit`);
|
||
});
|
||
|
||
// ---------------------------------------------------------------------------------------------------------------
|
||
// 歌蕾蒂娅 / 灵知 / 莱恩哈特
|
||
|
||
test('歌蕾蒂娅 S1 缺水的大洋裂断: charges; next attack atk_scale (×1.3 vs weight ≤ 3) and pulls the target to her front', () => {
|
||
for (const id of pair('chess_char_4_12_a')) {
|
||
const d = D(id, 0), bb = d.skill.bb, t1 = d.talents[1].bb;
|
||
const h = battle([U(id, 10, 3, 0)]);
|
||
h.step();
|
||
const u = h.unit(id);
|
||
const e = h.spawn('enemy_dummy', { pos: [10, 6] });
|
||
const x0 = e.x;
|
||
assert.ok(u.skill.activate('test', { free: true }));
|
||
assert.ok(h.runUntil(() => !u.skill.active, 10));
|
||
h.run(0.5);
|
||
const sk = dmgBy(h, u, (c) => c.dmg.isAttack && c.dmg.isSkill);
|
||
assert.equal(sk.length, 1);
|
||
approx(sk[0].amount, u.s.atk * bb.atk_scale * t1.atk_scale, 1e-6, `${id} hit`);
|
||
assert.ok(e.x < x0 - 0.5, `${id}: pulled towards her (${x0} → ${e.x})`);
|
||
// 中力 vs weight 1 (受力等级 0): "必定拉至身前" — to the 急停 radius 0.6708 around her centre (PRTS 推与拉), never past it
|
||
approx(e.x, u.x + 0.6708, 1e-6, `${id}: stops at her front`);
|
||
}
|
||
});
|
||
|
||
test('歌蕾蒂娅 S2 缺水的掌握怒海: BAT +0.5 s, wider range, 2 targets at attack@atk_scale, both pulled to her front', () => {
|
||
for (const id of pair('chess_char_4_12_a')) {
|
||
const d = D(id, 1), bb = d.skill.bb, t1 = d.talents[1].bb;
|
||
const h = battle([U(id, 10, 3, 1)]);
|
||
h.step();
|
||
const u = h.unit(id);
|
||
const es = [h.spawn('enemy_dummy', { pos: [10, 6] }), h.spawn('enemy_dummy', { pos: [11, 6] }), h.spawn('enemy_dummy', { pos: [9, 6] })];
|
||
assert.ok(u.skill.activate('test', { free: true }));
|
||
approx(u.s.interval, (u.base.bat + bb.base_attack_time) * 100 / u.s.aspd, 1e-6, 'BAT +0.5 s');
|
||
assert.ok(h.runUntil(() => h.hooksOf('attack').some((c) => c.attacker === u), 10));
|
||
const atk = h.hooksOf('attack').find((c) => c.attacker === u);
|
||
assert.equal(atk.targets.length, bb['attack@max_target'], `${id}: two targets`);
|
||
h.run(0.6);
|
||
const hits = dmgBy(h, u, (c) => c.dmg.isAttack && c.dmg.attackId === dmgBy(h, u)[0].dmg.attackId);
|
||
assert.equal(hits.length, bb['attack@max_target']);
|
||
for (const c of hits) approx(c.amount, u.s.atk * bb['attack@atk_scale'] * t1.atk_scale, 1e-6);
|
||
for (const e of atk.targets) assert.ok(e.x < 6 - 0.4, `pulled (${e.x})`);
|
||
}
|
||
});
|
||
|
||
test('歌蕾蒂娅 module HOK-Y 淡金坠饰: pulling a far enemy (> 2.5 tiles) to herself is one force level stronger', () => {
|
||
// a weight-2 enemy: 中力 (1) − 2 = 受力等级 −1 ⇒ 35 % of the way; +1 level (HOK-Y) ⇒ 0 ⇒ all the way (PRTS 推与拉)
|
||
const moved = (m) => {
|
||
const h = battle([U('chess_char_4_12_b', 10, 3, 0, m)], { enemies: { enemy_heavy: dummy({ key: 'enemy_heavy', mass: 2 }) } });
|
||
h.step();
|
||
const u = h.unit('chess_char_4_12_b');
|
||
const e = h.spawn('enemy_heavy', { pos: [10, 6] });
|
||
assert.ok(u.skill.activate('test', { free: true }));
|
||
h.runUntil(() => !u.skill.active, 10);
|
||
h.run(0.5);
|
||
return 6 - e.x;
|
||
};
|
||
const y = moved('uniequip_003_glady'), x = moved(null);
|
||
assert.ok(y > x + 0.2, `HOK-Y ${y} > HOK-X ${x}`);
|
||
approx(x, moved('none'), 1e-9);
|
||
});
|
||
|
||
test('灵知 S1 高速思考: next attack hits twice for atk_scale arts', () => {
|
||
for (const id of pair('chess_char_4_13_a')) {
|
||
const bb = D(id, 0).skill.bb;
|
||
const h = battle([U(id, 10, 4, 0)]);
|
||
h.step();
|
||
const u = h.unit(id);
|
||
h.spawn('enemy_dummy', { pos: [10, 5] });
|
||
assert.ok(u.skill.activate('test', { free: true }));
|
||
assert.ok(h.runUntil(() => !u.skill.active, 10));
|
||
h.run(0.5);
|
||
const sk = dmgBy(h, u, (c) => c.dmg.isAttack && c.dmg.isSkill);
|
||
assert.equal(sk.length, 2, `${id}: two hits`);
|
||
assert.equal(sk[0].dmg.attackId, sk[1].dmg.attackId);
|
||
for (const c of sk) { assert.equal(c.type, 'arts'); approx(c.amount, u.s.atk * bb.atk_scale, 1e-6); }
|
||
}
|
||
});
|
||
|
||
test('灵知 S3 失温症: ASPD up, 2 targets (unfrozen first), freezes held until the end, then atk_scale arts on the frozen and thaw', () => {
|
||
for (const id of pair('chess_char_4_13_a')) {
|
||
const sk = D(id, 2).skill, bb = sk.bb;
|
||
const h = battle([U(id, 10, 4, 2)]);
|
||
h.step();
|
||
const u = h.unit(id);
|
||
const frozenOne = h.spawn('enemy_dummy', { pos: [10, 5] });
|
||
const others = [h.spawn('enemy_dummy', { pos: [10, 6] }), h.spawn('enemy_dummy', { pos: [9, 5] })];
|
||
h.b.applyStatus(frozenOne, 'freeze', { duration: 1 });
|
||
assert.ok(u.skill.activate('test', { free: true }));
|
||
assert.equal(u.s.aspd, u.base.aspd + bb.attack_speed);
|
||
assert.ok(h.runUntil(() => h.hooksOf('attack').some((c) => c.attacker === u), 5));
|
||
const first = h.hooksOf('attack').find((c) => c.attacker === u);
|
||
assert.equal(first.targets.length, bb.max_target);
|
||
assert.ok(!first.targets.includes(frozenOne), 'unfrozen targets first');
|
||
h.run(2);
|
||
assert.ok(frozenOne.findBuff('freeze'), `${id}: freeze held past its own 1 s`);
|
||
approx(frozenOne.findBuff('freeze').timeLeft, u.skill.timeLeft, 0.1, 'until the skill ends');
|
||
const atkEnd = u.s.atk;
|
||
assert.ok(h.runUntil(() => !u.skill.active, 20));
|
||
const shatter = dmgBy(h, u, tagged('shatter'));
|
||
assert.ok(shatter.some((c) => c.target === frozenOne), 'end burst on the frozen enemy');
|
||
for (const c of shatter) assert.ok(c.amount >= atkEnd * bb.atk_scale - 1e-6, 'atk_scale arts (× fragile)');
|
||
for (const c of shatter) assert.ok(!c.target.findBuff('freeze'), 'thawed');
|
||
}
|
||
});
|
||
|
||
test('灵知 module UMD-Y 一号项目模型: +0.25 SP/s while an elite enemy is in range (default UMD-X: weaken on hit)', () => {
|
||
const rate = (m, rank) => {
|
||
const h = battle([U('chess_char_4_13_b', 10, 4, null, m)], { enemies: { enemy_r: dummy({ key: 'enemy_r', rank }) } });
|
||
h.step();
|
||
h.spawn('enemy_r', { pos: [10, 6] });
|
||
h.run(0.5);
|
||
return h.unit('chess_char_4_13_b').s.spRecovery;
|
||
};
|
||
const tb = C.chess_char_4_13_b.modules.find((m) => m.uniEquipId === 'uniequip_003_gnosis').traitOverride.bb;
|
||
approx(rate('uniequip_003_gnosis', 'ELITE'), 1 + tb.sp_recovery_per_sec, 1e-9);
|
||
approx(rate('uniequip_003_gnosis', 'NORMAL'), 1, 1e-9);
|
||
approx(rate(null, 'ELITE'), 1, 1e-9);
|
||
});
|
||
|
||
test('莱恩哈特 S1 攻击力强化·γ型: ATK up for 30 s; module none: no range bonus', () => {
|
||
for (const id of pair('chess_char_4_14_a')) {
|
||
const d = D(id, 0);
|
||
const h = battle([U(id, 10, 4, 0)]);
|
||
h.step();
|
||
const u = h.unit(id);
|
||
assert.ok(u.skill.activate('test', { free: true }));
|
||
approx(u.s.atk, u.base.atk * (1 + d.skill.bb.atk), 1e-6);
|
||
approx(u.skill.timeLeft, d.skill.duration, 1e-6);
|
||
}
|
||
const n = (m) => { const h = battle([U('chess_char_4_14_b', 10, 4, null, m)]); h.step(); return h.unit('chess_char_4_14_b').rangeKeys.length; };
|
||
assert.ok(n(null) > n('none'));
|
||
});
|
||
|
||
// ---------------------------------------------------------------------------------------------------------------
|
||
// 缄默德克萨斯 / 星熊 / 泥岩
|
||
|
||
test('缄默德克萨斯 S1 细雨无声: passive ATK up for its duration; hits silence 5 s/8 s with a fixed arts DoT per second', () => {
|
||
for (const id of pair('chess_char_4_16_a')) {
|
||
const sk = D(id, 0).skill, bb = sk.bb;
|
||
const h = battle([U(id, 10, 4, 0)]);
|
||
h.step();
|
||
const u = h.unit(id);
|
||
assert.equal(u.skill.kind, 'duration');
|
||
assert.equal(u.skill.active, true);
|
||
assert.equal(u.skill.charges, 0);
|
||
approx(u.skill.spec.mods.atkPct, bb.atk + D(id, 0).talents[0].bb.atk, 1e-9, 'skill and 德克萨斯传统 ATK');
|
||
assert.equal(h.snapshot().units.find((t) => t[0] === u.id)[6], sk.duration);
|
||
const e = h.spawn('enemy_dummy', { pos: [10, 5] });
|
||
h.run(3);
|
||
assert.ok(e.s.flags.silence, 'hit target silenced (失去特殊能力)');
|
||
approx(e.findBuff('silence').timeLeft, bb['attack@silence'], 1.5);
|
||
const dot = dmgBy(h, u, tagged('dot'));
|
||
assert.ok(dot.length >= 2, `a DoT tick every second although she re-hits faster (${dot.length})`);
|
||
for (const c of dot) approx(c.amount, bb['attack@texas2_s_1[dot].dot_damage'], 1e-9, 'fixed arts per second (RES 0)');
|
||
h.run(sk.duration);
|
||
assert.equal(u.skill.active, false, 'ends with the skill duration');
|
||
assert.equal(u.skill.ready, false);
|
||
assert.equal(h.hooksOf('skillEnd').filter((c) => c.unit === u && c.reason === 'duration').length, 1);
|
||
assert.ok(e.s.flags.silence && e.findBuff(`texas2:drizzleDot:${u.id}`), 'applied enemy effects keep their own duration');
|
||
h.run(bb['attack@silence'] + 1);
|
||
assert.ok(!e.s.flags.silence && !e.findBuff(`texas2:drizzleDot:${u.id}`), 'no new silence / DoT after the passive');
|
||
}
|
||
});
|
||
|
||
test('缄默德克萨斯 S2: two copies cut the RES of an enemy around both once (同名效果取最高, DESIGN §20.10)', () => {
|
||
const id = 'chess_char_4_16_a', bb = D(id, 1).skill.bb;
|
||
const h = battle([U(id, 10, 4, 1), U(id, 11, 4, 1)], { enemies: { enemy_res: dummy({ key: 'enemy_res', res: 50 }) } });
|
||
h.step();
|
||
const two = h.b.allyUnits.filter((u) => u.def.id === id);
|
||
assert.equal(two.length, 2);
|
||
const e = h.spawn('enemy_res', { pos: [10, 5] });
|
||
for (const u of two) { h.b.retreat(u); assert.ok(h.b.redeploy(u)); }
|
||
assert.equal(dmgBy(h, two[0], tagged('burst')).length + dmgBy(h, two[1], tagged('burst')).length, 2, 'both bursts hit it');
|
||
assert.equal(e.buffs.filter((b) => String(b.key).startsWith('texas2:resDown')).length, 1, 'one RES cut');
|
||
approx(e.s.res, 50 * (1 + bb.magic_resistance), 1e-6, 'once, not twice');
|
||
});
|
||
|
||
test('缄默德克萨斯 S2 阵雨连绵: deploy burst atk_scale arts + RES down around her; ATK up; attacks become arts double hits', () => {
|
||
for (const id of pair('chess_char_4_16_a')) {
|
||
const sk = D(id, 1).skill, bb = sk.bb;
|
||
const h = battle([U(id, 10, 4, 1)], { enemies: { enemy_res: dummy({ key: 'enemy_res', res: 50 }) } });
|
||
h.step();
|
||
const u = h.unit(id);
|
||
const e = h.spawn('enemy_res', { pos: [10, 5] });
|
||
const far = h.spawn('enemy_res', { pos: [10, 8] });
|
||
h.b.retreat(u);
|
||
assert.ok(h.b.redeploy(u));
|
||
const burst = dmgBy(h, u, tagged('burst'));
|
||
assert.deepEqual(burst.map((c) => c.target), [e], `${id}: only enemies around her`);
|
||
approx(burst[0].amount, u.s.atk * bb.atk_scale * 0.5, 1e-6, 'arts burst vs RES 50');
|
||
approx(e.s.res, 50 * (1 + bb.magic_resistance), 1e-6, 'RES down');
|
||
assert.equal(far.s.res, 50);
|
||
approx(u.skill.spec.mods.atkPct, bb.atk + D(id, 1).talents[0].bb.atk, 1e-9);
|
||
approx(u.skill.timeLeft, sk.duration, 1e-6);
|
||
h.run(2);
|
||
const hits = dmgBy(h, u, (c) => c.dmg.isAttack);
|
||
assert.ok(hits.length >= 2 && hits.every((c) => c.type === 'arts'), 'arts attacks');
|
||
const per = new Map();
|
||
for (const c of hits) per.set(c.dmg.attackId, (per.get(c.dmg.attackId) ?? 0) + 1);
|
||
assert.ok([...per.values()].every((v) => v === 2), 'double hits');
|
||
h.run(sk.duration);
|
||
assert.equal(u.skill.active, false);
|
||
assert.equal(u.skill.ready, false);
|
||
const n0 = dmgBy(h, u, (c) => c.dmg.isAttack).length;
|
||
h.run(3);
|
||
const late = dmgBy(h, u, (c) => c.dmg.isAttack).slice(n0);
|
||
assert.ok(late.length >= 1 && late.every((c) => c.type === 'phys'), 'back to single phys hits after the duration');
|
||
}
|
||
});
|
||
|
||
test('缄默德克萨斯 S1/S2/S3: first kill reopens a full window, including a kill inside the deployment burst', () => {
|
||
for (const id of pair('chess_char_4_16_a')) for (const index of [0, 1, 2]) {
|
||
const life = [];
|
||
const h = battle([U(id, 10, 4, index)], { extra: { setup(b) {
|
||
for (const name of ['skillStart', 'skillEnd']) b.on(name, (c) => life.push([name, c.reason]), { priority: 1000 });
|
||
} } });
|
||
h.b.start();
|
||
const u = h.unit(id), sk = u.skill;
|
||
h.run(2);
|
||
u.hp = u.s.maxHp / 2;
|
||
const e = h.spawn('enemy_dummy', { pos: [10, 5] });
|
||
h.b.kill(e, u);
|
||
assert.equal(u.mem.texasKilled, true);
|
||
approx(u.hpRatio, 1);
|
||
assert.equal(u.findBuff('texas2:swordplay'), null);
|
||
assert.equal(sk.activations, 2);
|
||
approx(sk.timeLeft, sk.duration);
|
||
assert.equal(sk.charges, 0);
|
||
assert.equal(sk.ready, false);
|
||
assert.deepEqual(h.hooksOf('skillEnd').map((c) => c.reason), ['recast']);
|
||
h.b.kill(h.spawn('enemy_dummy', { pos: [10, 5] }), u);
|
||
assert.equal(sk.activations, 2, 'only first kill recasts');
|
||
h.run(sk.duration + 0.1);
|
||
assert.equal(sk.active, false);
|
||
assert.deepEqual(h.hooksOf('skillEnd').map((c) => c.reason), ['recast', 'duration']);
|
||
assert.deepEqual(h.hooksOf('skillStart').map((c) => c.reason), ['deploy', 'kill']);
|
||
h.b.retreat(u);
|
||
const lifeAt = life.length;
|
||
const weak = h.spawn('enemy_dummy', { pos: [10, 5] });
|
||
weak.hp = 1;
|
||
assert.ok(h.b.redeploy(u, { free: true }));
|
||
if (index === 0) h.b.kill(weak, u); // S1 has no deployment burst
|
||
assert.equal(u.mem.texasKilled, true);
|
||
assert.equal(sk.activations, 4, 'new deployment and first-kill recast, including synchronous burst reentry');
|
||
assert.deepEqual(life.slice(lifeAt), [['skillStart', 'deploy'], ['skillEnd', 'recast'], ['skillStart', 'kill']]);
|
||
assert.equal(u.findBuff('texas2:swordplay'), null);
|
||
approx(sk.timeLeft, sk.duration);
|
||
if (index === 2) {
|
||
const target = h.spawn('enemy_dummy', { pos: [10, 5] });
|
||
h.run(sk.duration + 0.1);
|
||
const waves = new Set(dmgBy(h, u, tagged('swordRain')).filter((c) => c.target === target).map((c) => c.t));
|
||
assert.equal(waves.size, sk.duration, 'reentrant deployment keeps a full set of rain waves');
|
||
const n = dmgBy(h, u, tagged('swordRain')).length;
|
||
h.run(2);
|
||
assert.equal(dmgBy(h, u, tagged('swordRain')).length, n, 'rain stops at skill end');
|
||
assert.ok(target.alive);
|
||
}
|
||
checkInvariants(h.b);
|
||
}
|
||
});
|
||
|
||
test('缄默德克萨斯 module none: no ATK +10 % when alone (EXE-Y default has it)', () => {
|
||
const has = (m) => { const h = battle([U('chess_char_4_16_b', 10, 4, null, m)]); h.run(0.5); return !!h.unit('chess_char_4_16_b').findBuff('texas2:module'); };
|
||
assert.equal(has(null), true);
|
||
assert.equal(has('none'), false);
|
||
assert.equal(has('uniequip_003_texas2'), false);
|
||
});
|
||
|
||
test('星熊 S1 战意 (TAKE_DAMAGE: DEF/ATK up, no thorns) and S3 力之锯 (ATK/DEF up, cuts every enemy in front)', () => {
|
||
for (const id of pair('chess_char_4_17_a')) {
|
||
const b1 = D(id, 0).skill.bb, b3 = D(id, 2).skill.bb;
|
||
let h = battle([U(id, 10, 4, 0)], { enemies: { enemy_hitter: dummy({ key: 'enemy_hitter', atk: 300, bat: 1 }) } });
|
||
h.step();
|
||
let u = h.unit(id);
|
||
assert.equal(u.skill.rule, 'TAKE_DAMAGE');
|
||
u.skill.gainSp(1000);
|
||
h.spawn('enemy_hitter', { pos: [10, 4] });
|
||
assert.ok(h.runUntil(() => u.skill.active, 5), `${id}: armed by a hit`);
|
||
approx(u.s.def, u.base.def * (1 + b1.def + (u.findBuff('hsguma:def') ? D(id, 0).talents[1].bb.def : 0)), 1e-6, 'DEF');
|
||
approx(u.s.atk, u.base.atk * (1 + b1.atk), 1e-6, 'ATK');
|
||
h.run(3);
|
||
assert.equal(dmgBy(h, u, tagged('counter')).length, 0, 'thorns belong to S2 only');
|
||
h = battle([U(id, 10, 4, 2)]);
|
||
h.step();
|
||
u = h.unit(id);
|
||
const es = [h.spawn('enemy_dummy', { pos: [10, 5] }), h.spawn('enemy_dummy', { pos: [10, 5] }), h.spawn('enemy_dummy', { pos: [10, 5] })];
|
||
assert.ok(u.skill.activate('test', { free: true }));
|
||
approx(u.s.atk, u.base.atk * (1 + b3.atk), 1e-6, 'S3 ATK');
|
||
assert.ok(h.runUntil(() => h.hooksOf('attack').some((c) => c.attacker === u), 5));
|
||
assert.equal(h.hooksOf('attack').find((c) => c.attacker === u).targets.length, es.length, 'all enemies in front');
|
||
}
|
||
});
|
||
|
||
test('星熊 module PRO-X 护身符: DEF +20 % while blocking', () => {
|
||
const def = (m, block) => {
|
||
const h = battle([U('chess_char_4_17_b', 10, 4, null, m)]);
|
||
h.step();
|
||
const u = h.unit('chess_char_4_17_b');
|
||
if (block) h.spawn('enemy_dummy', { pos: [10, 4] });
|
||
h.run(0.5);
|
||
return u.s.def / u.base.def;
|
||
};
|
||
const tb = C.chess_char_4_17_b.modules.find((m) => m.uniEquipId === 'uniequip_003_hsguma').traitOverride.bb;
|
||
approx(def('uniequip_003_hsguma', true) - def('uniequip_003_hsguma', false), tb.def, 1e-9);
|
||
approx(def(null, true), def(null, false), 1e-9);
|
||
});
|
||
|
||
test('泥岩 S1 防御力强化·γ型 (TAKE_DAMAGE) and S3 秽壤的血脉 (闭锁: invulnerable, no attack, blocks nobody — the enemies she held walk on —, slow; then stun, buffs, hits all blocked)', () => {
|
||
for (const id of pair('chess_char_4_18_a')) {
|
||
const b1 = D(id, 0).skill.bb, sk = D(id, 2).skill, b3 = sk.bb;
|
||
let h = battle([U(id, 10, 4, 0)], { enemies: { enemy_hitter: dummy({ key: 'enemy_hitter', atk: 300, bat: 1 }) } });
|
||
h.step();
|
||
let u = h.unit(id);
|
||
assert.equal(u.skill.rule, 'TAKE_DAMAGE');
|
||
u.skill.gainSp(1000);
|
||
h.spawn('enemy_hitter', { pos: [10, 4] });
|
||
assert.ok(h.runUntil(() => u.skill.active, 5));
|
||
approx(u.s.def, u.base.def * (1 + b1.def), 1e-6);
|
||
h = battle([U(id, 9, 5, 2)], { enemies: { e_walk: enemyRec({ key: 'e_walk', hp: 1e8, atk: 500, speed: 1, bat: 1 }) } });
|
||
for (let i = 0; i < 3; i++) h.spawn('e_walk', { routeIndex: 0 });
|
||
u = h.unit(id);
|
||
assert.ok(h.runUntil(() => u.blocking.length === 3, 30), 'blocks three walkers');
|
||
const walkers = u.blocking.slice();
|
||
const hp0 = u.hp;
|
||
assert.ok(u.skill.activate('test', { free: true }));
|
||
const t0 = h.b.time;
|
||
h.step();
|
||
// 闭锁 (PRTS 备注 "实际将会进入闭锁状态"; PRTS 异常效果 闭锁 = 强制缴械 + 无敌 + 不可阻挡, 不可阻挡 "无法阻挡/被阻挡，自动解除阻挡")
|
||
assert.ok(u.blocking.length === 0 && walkers.every((e) => e.blockedBy !== u), `${id}: 闭锁 lets go of the enemies she held`);
|
||
assert.ok(walkers.every((e) => e.findBuff(`mudrok:slow:${u.id}`)), 'enemies around slowed');
|
||
const x0 = walkers.map((e) => e.x);
|
||
h.run(1);
|
||
assert.ok(walkers.every((e, i) => e.removed || e.x < x0[i] - 0.05), `${id}: they walk on`);
|
||
h.run(b3.sleep - 2.5);
|
||
assert.equal(u.hp >= hp0 - 1e-6, true, `${id}: no damage while dormant`);
|
||
assert.equal(u.blocking.length, 0, `${id}: blocks nobody while dormant`);
|
||
assert.equal(h.hooksOf('attack').filter((c) => c.attacker === u && c.t > t0).length, 0, 'cannot act');
|
||
const near = [0, 1, 2].map(() => h.spawn('enemy_dummy', { pos: [9, 5] })); // on her tile before she wakes
|
||
h.step();
|
||
assert.equal(u.blocking.length, 0, `${id}: not blocked before she wakes`);
|
||
assert.ok(h.runUntil(() => !!u.findBuff('mudrok:awake'), 2), 'awake');
|
||
h.run(0.2);
|
||
for (const e of near) assert.ok(e.s.flags.stun, 'ground enemies around stunned');
|
||
approx(u.s.atk, u.base.atk * (1 + b3.atk) * (u.findBuff('mudrok:module') ? 1 + (u.def.traitBb.atk ?? 0) : 1), 1e-6, 'ATK');
|
||
approx(u.s.interval, (u.base.bat + b3.base_attack_time) * 100 / u.s.aspd, 1e-6, 'BAT −0.3 s');
|
||
assert.ok(h.runUntil(() => h.hooksOf('attack').some((c) => c.attacker === u && c.t > t0), 5));
|
||
assert.equal(h.hooksOf('attack').find((c) => c.attacker === u && c.t > t0).targets.length, 3, 'attacks every blocked enemy');
|
||
assert.ok(h.runUntil(() => u.blocking.length === 3, 4), `${id}: she blocks again once awake (their stun over)`);
|
||
h.runUntil(() => !u.skill.active, sk.duration);
|
||
assert.ok(!u.findBuff('mudrok:awake'));
|
||
checkInvariants(h.b);
|
||
}
|
||
});
|
||
|
||
test('泥岩 module UNY-Y 沃土的愿景: ATK/DEF +8 % with no ally on the 8 tiles around', () => {
|
||
const buffed = (m, near) => {
|
||
const h = battle([U('chess_char_4_18_b', 10, 4, null, m), ...(near ? [U('chess_char_1_01_a', 11, 5)] : [])]);
|
||
h.run(0.5);
|
||
return !!h.unit('chess_char_4_18_b').findBuff('mudrok:module');
|
||
};
|
||
assert.deepEqual([buffed('uniequip_003_mudrok', false), buffed('uniequip_003_mudrok', true), buffed(null, false)], [true, false, false]);
|
||
});
|
||
|
||
// ---------------------------------------------------------------------------------------------------------------
|
||
// 焰尾 / 远牙 / 白面鸮 / 银灰
|
||
|
||
test('焰尾 S1 迅敏直觉: +6 DP and the next physical attack on her is dodged (feeding 前锋剑术)', () => {
|
||
for (const id of pair('chess_char_4_19_a')) {
|
||
const bb = D(id, 0).skill.bb;
|
||
const h = battle([U(id, 10, 4, 0)], { flags: { dpPerSec: 0 }, enemies: { enemy_hitter: dummy({ key: 'enemy_hitter', atk: 300, bat: 1 }) } });
|
||
h.step();
|
||
const u = h.unit(id);
|
||
const dp0 = h.b.getPlayer('p1').dp;
|
||
assert.ok(u.skill.activate('test', { free: true }));
|
||
assert.equal(h.b.getPlayer('p1').dp, dp0 + bb.cost, `${id}: +${bb.cost} DP`);
|
||
assert.ok(u.findBuff('flamtl:evade'));
|
||
h.spawn('enemy_hitter', { pos: [10, 4] });
|
||
assert.ok(h.runUntil(() => h.hooksOf('dodge').some((c) => c.target === u), 5), 'dodged');
|
||
assert.ok(!u.findBuff('flamtl:evade'), 'only the next attack');
|
||
assert.equal(h.hooksOf('damaged').filter((c) => c.target === u && c.source?.side === 'enemy').length, 0, 'no damage from the dodged hit');
|
||
assert.ok(u.mem.riposte || u.mem.riposteNow || dmgBy(h, u, tagged('riposte')).length > 0, '前锋剑术 armed');
|
||
}
|
||
});
|
||
|
||
test('焰尾 S1 迅敏直觉 (AUTO): fires as soon as SP is full — no enemy, no attack needed (like 伺夜 S1; playtest #6 review)', () => {
|
||
for (const id of pair('chess_char_4_19_a')) {
|
||
const h = battle([U(id, 10, 4, 0)], { flags: { dpPerSec: 0 } });
|
||
h.step();
|
||
const u = h.unit(id);
|
||
assert.equal(u.skill.rule, 'SP_FULL');
|
||
const due = h.b.time + (u.skill.spCost - u.skill.sp) / u.s.spRecovery;
|
||
assert.ok(h.runUntil(() => u.skill.activations === 1, 40), `${id}: cast with no enemy on the field`);
|
||
const st = h.hooksOf('skillStart').find((c) => c.unit === u);
|
||
assert.ok(Math.abs(st.t - due) <= 0.05, `${id}: at full SP (${st.t} vs ${due})`);
|
||
}
|
||
});
|
||
|
||
test('焰尾 S2 “红松林”: +11/12 DP; ≤ 6 enemies around: 2 × atk_scale phys + stun; allies around +40 %/45 % phys dodge 10 s', () => {
|
||
for (const id of pair('chess_char_4_19_a')) {
|
||
const bb = D(id, 1).skill.bb;
|
||
const h = battle([U(id, 10, 5, 1), U('chess_char_1_01_a', 10, 4)], { flags: { dpPerSec: 0 } });
|
||
h.step();
|
||
const u = h.unit(id), ally = h.unit('chess_char_1_01_a');
|
||
for (let i = 0; i < 7; i++) h.spawn('enemy_dummy', { pos: [10, 6] });
|
||
const dp0 = h.b.getPlayer('p1').dp;
|
||
assert.ok(u.skill.activate('test', { free: true }));
|
||
assert.equal(h.b.getPlayer('p1').dp, dp0 + bb.cost);
|
||
const hits = dmgBy(h, u, tagged('redPine'));
|
||
const victims = new Set(hits.map((c) => c.target));
|
||
assert.equal(victims.size, bb.max_target, `${id}: ≤ ${bb.max_target} enemies`);
|
||
assert.equal(hits.length, 2 * bb.max_target, 'two hits each');
|
||
for (const c of hits) approx(c.amount, u.s.atk * bb.atk_scale, 1e-6);
|
||
for (const e of victims) assert.ok(e.s.flags.stun);
|
||
for (const a of [u, ally]) {
|
||
const b = a.findBuff('flamtl:redPine');
|
||
assert.ok(b, `${a.name} dodge buff`);
|
||
approx(b.mods.dodgePhys, bb['flamtl_s_2.prob'], 1e-9);
|
||
approx(b.timeLeft, bb['flamtl_s_2.duration'], 1e-6);
|
||
}
|
||
}
|
||
});
|
||
|
||
test('焰尾 module SOL-X 她们的未来: ATK/DEF +8 % while blocking', () => {
|
||
const on = (m, block) => {
|
||
const h = battle([U('chess_char_4_19_b', 10, 4, null, m)]);
|
||
h.step();
|
||
if (block) h.spawn('enemy_dummy', { pos: [10, 4] });
|
||
h.run(0.5);
|
||
return !!h.unit('chess_char_4_19_b').findBuff('flamtl:module');
|
||
};
|
||
assert.deepEqual([on('uniequip_003_flamtl', true), on('uniequip_003_flamtl', false), on(null, true)], [true, false, false]);
|
||
});
|
||
|
||
test('远牙 S1 迅捷打击·γ型 / S2 同盟支援: taunt −1 with any skill (屏息); S2 reaches enemies blocked anywhere on the field', () => {
|
||
for (const id of pair('chess_char_4_20_a')) {
|
||
const b1 = D(id, 0).skill.bb, b2 = D(id, 1).skill.bb;
|
||
let h = battle([U(id, 12, 3, 0)]);
|
||
h.step();
|
||
let u = h.unit(id);
|
||
assert.ok(u.skill.activate('test', { free: true }));
|
||
approx(u.s.atk, u.base.atk * (1 + b1.atk + (u.findBuff('fartth:focus') ? D(id, 0).talents[0].bb.atk : 0)), 1e-6, 'S1 ATK (+ 凝神)');
|
||
assert.equal(u.s.aspd, u.base.aspd + b1.attack_speed);
|
||
assert.equal(u.s.taunt, -1, '屏息');
|
||
h = battle([U(id, 12, 3, 1), U('chess_char_4_17_a', 9, 9)], { enemies: { e_walk: enemyRec({ key: 'e_walk', hp: 1e8, atk: 10, speed: 1, bat: 5 }) } });
|
||
u = h.unit(id);
|
||
h.spawn('e_walk', { routeIndex: 0 });
|
||
const e = h.enemies()[0];
|
||
assert.ok(h.runUntil(() => e.blockedBy && e.blockedBy.defId === 'chess_char_4_17_a', 20), 'blocked by 星熊 far away');
|
||
h.run(2);
|
||
assert.equal(dmgBy(h, u, (c) => c.target === e).length, 0, 'out of her range without S2');
|
||
assert.ok(u.skill.activate('test', { free: true }));
|
||
assert.equal(u.s.aspd, u.base.aspd + b2.attack_speed);
|
||
assert.equal(u.s.taunt, -1);
|
||
h.run(4);
|
||
assert.ok(dmgBy(h, u, (c) => c.target === e).length > 0, `${id}: S2 hits the blocked enemy`);
|
||
h.runUntil(() => !u.skill.active, 40);
|
||
assert.equal(u.extraRangeKeys, null, 'extra range cleared');
|
||
}
|
||
});
|
||
|
||
test('远牙 S2 同盟支援: an UNBLOCKED enemy on a blocked enemy\'s tile outside her range is never a target', () => {
|
||
for (const id of pair('chess_char_4_20_a')) {
|
||
const h = battle([U(id, 12, 3, 1), U('chess_char_4_17_a', 9, 9)], { enemies: {
|
||
e_walk: enemyRec({ key: 'e_walk', hp: 1e8, atk: 10, def: 800, speed: 1, bat: 5 }),
|
||
e_fly: dummy({ key: 'e_fly', motion: 'FLY', def: 0 }),
|
||
} });
|
||
const u = h.unit(id);
|
||
h.spawn('e_walk', { routeIndex: 0 });
|
||
const e = h.enemies()[0];
|
||
assert.ok(h.runUntil(() => e.blockedBy && e.blockedBy.defId === 'chess_char_4_17_a', 20), 'blocked by 星熊 far away');
|
||
const fly = h.spawn('e_fly', { pos: [Math.round(e.y), Math.round(e.x)] });
|
||
assert.ok(fly.isFlying && !fly.blockedBy, 'setup: unblocked flyer (lower DEF: her lowDef priority would pick it)');
|
||
assert.ok(u.skill.activate('test', { free: true }));
|
||
h.run(4);
|
||
assert.ok(dmgBy(h, u, (c) => c.target === e).length > 0, `${id}: S2 hits the blocked enemy`);
|
||
assert.equal(dmgBy(h, u, (c) => c.target === fly).length, 0, `${id}: not the unblocked flyer on its tile`);
|
||
checkInvariants(h.b);
|
||
}
|
||
});
|
||
|
||
test('远牙 module DEA-Y 支持者来信: +1 SP whenever the attacked enemy survives', () => {
|
||
const gains = (m) => {
|
||
const h = battle([U('chess_char_4_20_b', 10, 3, null, m)]);
|
||
h.step();
|
||
h.spawn('enemy_dummy', { pos: [10, 5] });
|
||
h.run(8);
|
||
return h.hooksOf('spGain').filter((c) => c.reason === 'module').length;
|
||
};
|
||
assert.ok(gains('uniequip_003_fartth') >= 2);
|
||
assert.equal(gains(null), 0);
|
||
});
|
||
|
||
test('远牙 module DEA-Y: the hit that defeats its target gives no SP (未被击倒时 only; `damaged` precedes the kill)', () => {
|
||
const id = 'chess_char_4_20_b';
|
||
const h = battle([U(id, 10, 3, null, 'uniequip_003_fartth')], { enemies: { enemy_weak: dummy({ key: 'enemy_weak', hp: 1 }) } });
|
||
h.step();
|
||
const u = h.unit(id);
|
||
const weak = [h.spawn('enemy_weak', { pos: [10, 5] }), h.spawn('enemy_weak', { pos: [10, 6] })];
|
||
assert.ok(h.runUntil(() => weak.every((e) => !e.alive), 10), 'both one-HP enemies fall');
|
||
assert.ok(dmgBy(h, u, (c) => c.dmg?.isAttack && weak.includes(c.target)).length >= 2, 'killed by her attacks');
|
||
assert.equal(h.hooksOf('spGain').filter((c) => c.unit === u && c.reason === 'module').length, 0, 'no SP for a killing hit');
|
||
checkInvariants(h.b);
|
||
});
|
||
|
||
test('白面鸮 S1 治疗强化·γ型: ATK up while healing; module none: no range bonus', () => {
|
||
for (const id of pair('chess_char_4_21_a')) {
|
||
const d = D(id, 0);
|
||
const h = battle([U(id, 10, 3, 0), U('chess_char_4_17_a', 10, 4)]);
|
||
h.step();
|
||
const u = h.unit(id), hs = h.unit('chess_char_4_17_a');
|
||
hs.hp = hs.s.maxHp * 0.3;
|
||
u.skill.gainSp(1000);
|
||
assert.ok(h.runUntil(() => u.skill.active, 5), 'heal skill fires on an injured ally');
|
||
approx(u.s.atk, u.base.atk * (1 + d.skill.bb.atk), 1e-6);
|
||
}
|
||
const n = (m) => { const h = battle([U('chess_char_4_21_b', 10, 3, null, m)]); h.step(); return h.unit('chess_char_4_21_b').rangeKeys.length; };
|
||
assert.ok(n(null) > n('none'));
|
||
});
|
||
|
||
test('银灰 S1 强力击·γ型: every 4th attack deals atk_scale; S2 雪境生存法则: toggled on for good — small range, DEF up, HP regen', () => {
|
||
for (const id of pair('chess_char_4_22_a')) {
|
||
const b1 = D(id, 0).skill.bb, s2 = D(id, 1).skill;
|
||
let h = battle([U(id, 10, 4, 0, gold(id) === id ? 'none' : null)]);
|
||
h.step();
|
||
let u = h.unit(id);
|
||
h.spawn('enemy_dummy', { pos: [10, 5] });
|
||
h.run(12);
|
||
const atks = dmgBy(h, u, (c) => c.dmg.isAttack);
|
||
const sk = atks.filter((c) => c.dmg.isSkill);
|
||
assert.ok(sk.length >= 2, `${id}: S1 fired`);
|
||
for (const c of sk) approx(c.amount, u.s.atk * b1.atk_scale, 1e-6);
|
||
for (const c of atks.filter((x) => !x.dmg.isSkill)) approx(c.amount, u.s.atk, 1e-6);
|
||
const i1 = atks.indexOf(sk[0]), i2 = atks.indexOf(sk[1]);
|
||
assert.equal(i2 - i1, D(id, 0).skill.spCost + 1, 'cost-3 attack SP: every 4th attack');
|
||
h = battle([U(id, 10, 4, 1)]);
|
||
h.step();
|
||
u = h.unit(id);
|
||
const n0 = u.rangeKeys.length;
|
||
h.spawn('enemy_dummy', { pos: [10, 5] });
|
||
u.skill.gainSp(1000);
|
||
assert.ok(h.runUntil(() => u.skill.active, 5));
|
||
assert.equal(u.skill.kind, 'toggle');
|
||
assert.equal(u.rangeKeys.length, s2.rangeGrid.length, 'smaller range');
|
||
assert.ok(n0 > u.rangeKeys.length);
|
||
approx(u.s.def, u.base.def * (1 + s2.bb.def), 1e-6);
|
||
approx(u.s.hpRegen, u.s.maxHp * s2.bb.hp_recovery_per_sec_by_max_hp_ratio, 1e-6);
|
||
h.run(60);
|
||
assert.ok(u.skill.active, 'stays on');
|
||
}
|
||
});
|
||
|
||
test('银灰 module none: no 10 % ATK arts rider on attacks (LOR-X default has it)', () => {
|
||
const rider = (m) => {
|
||
const h = battle([U('chess_char_4_22_b', 10, 4, 1, m)]);
|
||
h.step();
|
||
h.spawn('enemy_dummy', { pos: [10, 5] });
|
||
h.run(4);
|
||
return dmgBy(h, h.unit('chess_char_4_22_b'), tagged('module')).length;
|
||
};
|
||
assert.ok(rider(null) > 0);
|
||
assert.equal(rider('none'), 0);
|
||
});
|
||
|
||
// ---------------------------------------------------------------------------------------------------------------
|
||
// 百炼嘉维尔 / 卡涅利安 / 魔王 / 华法琳
|
||
|
||
test('百炼嘉维尔 S1 精准痛击: ATK up, heals herself heal_scale of the damage dealt (× 医学背景); no S3 damage deferral', () => {
|
||
for (const id of pair('chess_char_4_23_a')) {
|
||
const d = D(id, 0), bb = d.skill.bb, t1 = d.talents[1].bb;
|
||
const h = battle([U(id, 10, 4, 0)], { enemies: { enemy_hitter: dummy({ key: 'enemy_hitter', atk: 400, bat: 1 }) } });
|
||
h.step();
|
||
const u = h.unit(id);
|
||
const e = h.spawn('enemy_dummy', { pos: [10, 4] });
|
||
assert.ok(h.runUntil(() => e.blockedBy === u, 2));
|
||
assert.ok(u.skill.activate('test', { free: true }));
|
||
u.hp = u.s.maxHp * 0.3;
|
||
const hp0 = u.hp, t0 = h.b.time;
|
||
assert.ok(h.runUntil(() => h.hooksOf('attack').some((c) => c.attacker === u && c.t >= t0), 5));
|
||
const dealt = dmgBy(h, u, (c) => c.dmg.isAttack && c.t >= t0).reduce((a, c) => a + c.amount, 0);
|
||
assert.ok(dealt > 0);
|
||
approx(u.hp - hp0, dealt * bb.heal_scale * t1.heal_scale_2, 1e-6, `${id}: self heal`);
|
||
const hit = h.spawn('enemy_hitter', { pos: [10, 4] });
|
||
h.run(2);
|
||
assert.equal(u.mem.gvialDebt ?? 0, 0, 'no S3 deferral');
|
||
assert.ok(hit.alive);
|
||
}
|
||
});
|
||
|
||
test('百炼嘉维尔 S2 链锯强袭: wider range, ATK/DEF up, unblocked enemies it hits are pulled to her front', () => {
|
||
for (const id of pair('chess_char_4_23_a')) {
|
||
const bb = D(id, 1).skill.bb;
|
||
const h = battle([U(id, 10, 4, 1)]);
|
||
h.step();
|
||
const u = h.unit(id);
|
||
const e = h.spawn('enemy_dummy', { pos: [10, 6] });
|
||
h.run(0.2);
|
||
assert.equal(dmgBy(h, u).length, 0, 'out of the normal range');
|
||
assert.ok(u.skill.activate('test', { free: true }));
|
||
approx(u.s.atk, u.base.atk * (1 + bb.atk + D(id, 1).talents[0].bb.atk), 1e-6, 'ATK (+ 战地巨斧)');
|
||
assert.ok(h.runUntil(() => dmgBy(h, u).length > 0, 5), `${id}: reaches 2 tiles ahead`);
|
||
assert.ok(e.x < 6 - 0.4, `pulled (${e.x})`);
|
||
}
|
||
});
|
||
|
||
test('百炼嘉维尔 module CEN-Y 好锯多磨: −20 % physical damage taken above 50 % HP', () => {
|
||
const taken = (m, ratio) => {
|
||
const h = battle([U('chess_char_4_23_b', 10, 4, 0, m)], { enemies: { enemy_hitter: dummy({ key: 'enemy_hitter', atk: 3000, bat: 1 }) } });
|
||
h.step();
|
||
const u = h.unit('chess_char_4_23_b');
|
||
u.hp = u.s.maxHp * ratio;
|
||
h.spawn('enemy_hitter', { pos: [10, 4] });
|
||
h.runUntil(() => h.hooksOf('damaged').some((c) => c.target === u && c.amount > 0), 5);
|
||
return h.hooksOf('damaged').find((c) => c.target === u && c.amount > 0).amount;
|
||
};
|
||
const tb = C.chess_char_4_23_b.modules.find((m) => m.uniEquipId === 'uniequip_003_gvial2').traitOverride.bb;
|
||
approx(taken('uniequip_003_gvial2', 0.9) / taken('uniequip_003_gvial2', 0.4), 1 - tb.damage_resistance, 1e-6, 'reduced above half HP');
|
||
approx(taken(null, 0.9), taken(null, 0.4), 1e-6, 'default CEN-X: no reduction');
|
||
});
|
||
|
||
test('卡涅利安 S1 沙暴守卫: SEARCH; ATK/DEF up; charged keeps the trait guard; 生命之餐 heals 40 %/80 %', () => {
|
||
for (const id of pair('chess_char_4_24_a')) {
|
||
const d = D(id, 0), bb = d.skill.bb, t0 = d.talents[0].bb;
|
||
for (const charged of [false, true]) {
|
||
const h = battle([U(id, 10, 4, 0, gold(id) === id ? 'none' : null)]);
|
||
h.step();
|
||
const u = h.unit(id);
|
||
assert.equal(u.skill.rule, 'SEARCH');
|
||
u.hp = u.s.maxHp * 0.1;
|
||
u.skill.addCharge(charged ? 2 : 1);
|
||
assert.ok(u.skill.activate('test'));
|
||
assert.equal(!!u.findBuff('billro:s1guard'), charged, `${id}: guard kept iff charged`);
|
||
const guard = charged ? u.profile.guardDef : 0;
|
||
approx(u.s.def, u.base.def * (1 + bb.def + guard), 1e-6, 'DEF');
|
||
approx(u.s.atk, u.base.atk * (1 + bb.atk), 1e-6, 'ATK');
|
||
approx(u.hp, u.s.maxHp * (0.1 + (charged ? t0['billro_t_1[enhance].heal_scale'] : t0.heal_scale)), 1e-6, '生命之餐');
|
||
h.runUntil(() => !u.skill.active, 30);
|
||
assert.ok(!u.findBuff('billro:s1guard'));
|
||
}
|
||
}
|
||
});
|
||
|
||
test('卡涅利安 S3 食噬之印: wider range, ATK ramps to +atk over the skill; charged hits mark (+20 %/mark, ≤ 5) until it ends', () => {
|
||
for (const id of pair('chess_char_4_24_a')) {
|
||
const sk = D(id, 2).skill, bb = sk.bb;
|
||
const h = battle([U(id, 10, 4, 2, gold(id) === id ? 'none' : null)]);
|
||
h.step();
|
||
const u = h.unit(id);
|
||
const n0 = u.rangeKeys.length;
|
||
const e = h.spawn('enemy_dummy', { pos: [10, 5] });
|
||
u.skill.addCharge(2);
|
||
assert.ok(u.skill.activate('test'));
|
||
u.skill.charges = 0; // (the spare charge would re-cast right after the end)
|
||
u.skill.sp = 0;
|
||
assert.ok(u.rangeKeys.length > n0);
|
||
h.run(sk.duration / 2);
|
||
approx(u.findBuff('billro:s3atk').mods.atkPct, bb.atk * 0.5, 0.02, `${id}: half-way ramp`);
|
||
const m = e.findBuff('billro:mark');
|
||
assert.ok(m && m.stacks === 5 && m.source === u, `${id}: marks capped at 5 (${m?.stacks})`);
|
||
const hits = dmgBy(h, u, (c) => c.dmg.isAttack && c.target === e);
|
||
const last = hits[hits.length - 1];
|
||
approx(last.amount / (u.s.atk), 1 + bb['attack@damage_scale'] * 5, 0.05, '+100 % with 5 marks');
|
||
h.runUntil(() => !u.skill.active, sk.duration);
|
||
assert.ok(!e.findBuff('billro:mark'), 'marks end with the skill');
|
||
assert.ok(!u.findBuff('billro:s3atk'));
|
||
}
|
||
});
|
||
|
||
test('卡涅利安 module PLX-Y 乡音: +3 % damage per enemy in range (≤ 5); PLX-X keeps part of the guard during any skill', () => {
|
||
const ratio = (m) => {
|
||
const h = battle([U('chess_char_4_24_b', 10, 4, 1, m)]);
|
||
h.step();
|
||
const u = h.unit('chess_char_4_24_b');
|
||
for (let i = 0; i < 3; i++) h.spawn('enemy_dummy', { pos: [10, 5] });
|
||
u.skill.addCharge(1);
|
||
assert.ok(u.skill.activate('test'));
|
||
h.runUntil(() => dmgBy(h, u, (c) => c.dmg.isAttack).length > 0, 5);
|
||
const c = dmgBy(h, u, (c) => c.dmg.isAttack)[0];
|
||
return { r: c.amount / u.s.atk, keep: !!u.findBuff('billro:keep') };
|
||
};
|
||
const mb = C.chess_char_4_24_b.modules.find((m) => m.uniEquipId === 'uniequip_003_billro').talentChanges[0].bb;
|
||
const y = ratio('uniequip_003_billro'), x = ratio(null), none = ratio('none');
|
||
approx(y.r, 1 + mb.damage_scale * 3, 1e-6, 'three enemies');
|
||
approx(none.r, 1, 1e-6);
|
||
assert.deepEqual([x.keep, y.keep, none.keep], [true, false, false]);
|
||
const s1keep = (charges) => { const h = battle([U('chess_char_4_24_b', 10, 4, 0)]); h.step(); const u = h.unit('chess_char_4_24_b'); u.skill.addCharge(charges); u.skill.activate('test'); return !!u.findBuff('billro:keep'); };
|
||
assert.equal(s1keep(1), true, 'uncharged S1 keeps the PLX-X part');
|
||
assert.equal(s1keep(2), false, 'charged S1 keeps the whole guard instead');
|
||
});
|
||
|
||
test('魔王 S1 往昔萦绕身旁: SP_FULL toggle — trait ratio raised for good, motes come back after talent_cool_down', () => {
|
||
for (const id of pair('chess_char_4_25_a')) {
|
||
const bb = D(id, 0).skill.bb;
|
||
const h = battle([U(id, 10, 4, 0), U('chess_char_4_17_a', 10, 5)]);
|
||
h.step();
|
||
const u = h.unit(id), hs = h.unit('chess_char_4_17_a');
|
||
assert.equal(u.skill.rule, 'SP_FULL');
|
||
u.skill.gainSp(1000);
|
||
h.step();
|
||
assert.ok(u.skill.active && u.skill.kind === 'toggle');
|
||
assert.equal(u.profile.auraRatio, bb['attack@atk_to_hp_recovery_ratio']);
|
||
hs.hp = hs.s.maxHp * 0.5;
|
||
h.run(0.5);
|
||
const t = Math.max(...u.mem.motes.filter((x) => Number.isFinite(x)));
|
||
assert.ok(Number.isFinite(t), 'a mote touched the operator');
|
||
assert.ok(t - h.b.time <= bb.talent_cool_down + 1e-6, `${id}: faster mote respawn`);
|
||
h.run(40);
|
||
assert.ok(u.skill.active, 'duration unlimited');
|
||
}
|
||
});
|
||
|
||
test('魔王 S2 明日渺远不及: 6 motes that hit enemies within 2 tiles (true damage + bind), not operators; 鼓舞 ATK to allies in range', () => {
|
||
for (const id of pair('chess_char_4_25_a')) {
|
||
const bb = D(id, 1).skill.bb;
|
||
const h = battle([U(id, 10, 4, 1), U('chess_char_4_17_a', 10, 5)]);
|
||
h.step();
|
||
const u = h.unit(id), hs = h.unit('chess_char_4_17_a');
|
||
const es = [h.spawn('enemy_dummy', { pos: [10, 6] }), h.spawn('enemy_dummy', { pos: [11, 5] })];
|
||
assert.ok(u.skill.activate('test', { free: true }));
|
||
assert.equal(u.mem.motes.length, D(id, 1).talents[0].bb.cnt + 3, '上限+3');
|
||
h.run(1);
|
||
const hits = dmgBy(h, u, tagged('mote'));
|
||
assert.ok(es.every((e) => hits.some((c) => c.target === e)), `${id}: both enemies hit`);
|
||
for (const c of hits) { assert.equal(c.type, 'true'); approx(c.amount, u.s.atk * bb.atk_scale, 1e-6); }
|
||
for (const e of es) assert.ok(e.s.flags.bind, 'bound');
|
||
assert.ok(!hs.findBuff(`cetsyr:mote:${u.id}`), 'motes no longer touch operators');
|
||
const insp = hs.findBuff('inspire');
|
||
assert.ok(insp, '鼓舞');
|
||
approx(insp.data.val, u.s.atk * bb['attack@atk'], 1e-6);
|
||
// 鼓舞 is added on top of the target's ATK multipliers: an ATK +100 % buff does not double it
|
||
h.b.addBuff(hs, { key: 'test:atkUp', mods: { atkPct: 1 } });
|
||
h.step();
|
||
const { add, mul } = aggregateMods(hs.buffs.filter((x) => x.key !== 'inspire'));
|
||
const own = (hs.base.atk + (add.atkFlat ?? 0)) * (1 + (add.atkPct ?? 0)) * (mul.atkMul ?? 1);
|
||
approx(hs.s.atk, own + u.s.atk * bb['attack@atk'], 1e-6, `${id}: final ATK = own ATK + 鼓舞`);
|
||
h.b.removeBuff(hs, 'test:atkUp');
|
||
h.runUntil(() => !u.skill.active, 40);
|
||
assert.equal(u.mem.motes.length, D(id, 1).talents[0].bb.cnt, 'cap back to normal');
|
||
}
|
||
});
|
||
|
||
test('魔王 鼓舞: strongest source wins (never summed), a bard never receives it (自身不受鼓舞影响); S3 HP 鼓舞 on top of HP%', () => {
|
||
const [na, el] = pair('chess_char_4_25_a');
|
||
const h = battle([U(na, 10, 4, 1), U(el, 10, 5, 1), U('chess_char_4_17_a', 11, 4)]);
|
||
h.step();
|
||
const a = h.unit(na), b = h.unit(el), hs = h.unit('chess_char_4_17_a');
|
||
assert.ok(a.skill.activate('test', { free: true }) && b.skill.activate('test', { free: true }));
|
||
h.run(0.5);
|
||
assert.ok(!a.findBuff('inspire') && !b.findBuff('inspire'), 'bards get no 鼓舞 from each other');
|
||
const inRangeOfBoth = h.b.alliesInGrid(a).includes(hs) && h.b.alliesInGrid(b).includes(hs);
|
||
assert.ok(inRangeOfBoth, 'setup: 星熊 inside both ranges');
|
||
const va = a.s.atk * D(na, 1).skill.bb['attack@atk'], vb = b.s.atk * D(el, 1).skill.bb['attack@atk'];
|
||
assert.equal(hs.buffs.filter((x) => x.key === 'inspire' || x.key.startsWith('cetsyr:inspire')).length, 1, 'one 鼓舞 buff');
|
||
approx(hs.findBuff('inspire').data.val, Math.max(va, vb), 1e-6, 'the stronger one');
|
||
// S3 (default): max-HP 鼓舞 is not scaled by the target's HP% buffs
|
||
const h3 = battle([U(el, 10, 4), U('chess_char_4_17_a', 10, 5)]);
|
||
h3.step();
|
||
const m = h3.unit(el), t = h3.unit('chess_char_4_17_a');
|
||
h3.b.addBuff(t, { key: 'test:hpUp', mods: { hpPct: 0.5 } });
|
||
assert.ok(m.skill.activate('test', { free: true }));
|
||
h3.run(0.3);
|
||
const { add, mul } = aggregateMods(t.buffs.filter((x) => x.key !== 'inspire:hp'));
|
||
approx(t.s.maxHp, (t.base.maxHp + (add.hpFlat ?? 0)) * (1 + (add.hpPct ?? 0)) * (mul.hpMul ?? 1) + m.s.maxHp * D(el).skill.bb.max_hp, 1e-6, 'max HP + 鼓舞');
|
||
checkInvariants(h.b);
|
||
});
|
||
|
||
test('华法琳 S2 不稳定血浆: she and one random ally in range: ATK up, 3 % max HP lost per second for 15 s; no S1 bandage', () => {
|
||
for (const id of pair('chess_char_4_26_a')) {
|
||
const bb = D(id, 1).skill.bb;
|
||
const h = battle([U(id, 10, 3, 1), U('chess_char_4_17_a', 10, 4)]);
|
||
h.step();
|
||
const u = h.unit(id), hs = h.unit('chess_char_4_17_a');
|
||
hs.hp = hs.s.maxHp * 0.4;
|
||
u.skill.gainSp(1000);
|
||
assert.ok(h.runUntil(() => u.skill.activations > 0, 5), 'fires on an injured ally in range');
|
||
for (const a of [u, hs]) {
|
||
const b = a.findBuff('bldsk:plasma');
|
||
assert.ok(b, `${a.name}: plasma`);
|
||
approx(b.mods.atkPct, bb.atk, 1e-9);
|
||
}
|
||
h.run(3.05);
|
||
const loss = h.hooksOf('damaged').filter((c) => c.target === u && (c.dmg?.tags || []).includes('plasma'));
|
||
assert.equal(loss.length, 3, `${id}: one loss per second`);
|
||
for (const c of loss) approx(c.amount, u.s.maxHp * bb.hp_ratio, 1e-6);
|
||
assert.equal(u.mem.bandage ?? null, null, 'S1 logic not installed');
|
||
}
|
||
});
|
||
|
||
test('module none on single-module elites removes the module effect (寒芒克洛丝 / 阿罗玛 / 魔王 / 华法琳)', () => {
|
||
const unit = (id, m, extra = []) => { const h = battle([U(id, 10, 3, null, m), ...extra]); h.run(0.5); return { h, u: h.unit(id) }; };
|
||
// 寒芒克洛丝 MAR-X: 攻击空中单位时攻击力提升至110%
|
||
assert.equal(unit('chess_char_4_06_b', null).u.profile.flyScale, C.chess_char_4_06_b.trait.bb.atk_scale);
|
||
assert.equal(unit('chess_char_4_06_b', 'none').u.profile.flyScale, 1);
|
||
// 阿罗玛 BLA-X: farther targets take more damage
|
||
const blast = (m) => {
|
||
const { h, u } = unit('chess_char_4_10_b', m);
|
||
const e = h.spawn('enemy_dummy', { pos: [10, 7] });
|
||
h.run(6);
|
||
const hits = dmgBy(h, u, (c) => c.dmg.isAttack && c.target === e).map((c) => c.amount / u.s.atk);
|
||
return Math.min(...hits);
|
||
};
|
||
assert.ok(blast(null) > blast('none') + 0.05, 'distance bonus only with the module');
|
||
approx(blast('none'), 1, 1e-6);
|
||
// 魔王 BAR-X: ATK +8 % with ≥ 2 other operators in range
|
||
const ops = [U('chess_char_4_17_a', 10, 4), U('chess_char_1_01_a', 11, 3)];
|
||
assert.ok(unit('chess_char_4_25_b', null, ops).u.findBuff('cetsyr:module'));
|
||
assert.ok(!unit('chess_char_4_25_b', 'none', ops).u.findBuff('cetsyr:module'));
|
||
// 华法琳 PHY-X: heals on allies below 50 % HP +15 %
|
||
const heal = (m) => {
|
||
const { h, u } = unit('chess_char_4_26_b', m, [U('chess_char_4_17_a', 10, 4)]);
|
||
const hs = h.unit('chess_char_4_17_a');
|
||
hs.hp = hs.s.maxHp * 0.2;
|
||
u.skill.charges = 0; u.skill.sp = 0;
|
||
const n0 = h.hooksOf('heal').length;
|
||
h.runUntil(() => h.hooksOf('heal').slice(n0).some((c) => c.source === u && c.target === hs), 5);
|
||
return h.hooksOf('heal').slice(n0).find((c) => c.source === u && c.target === hs).amount / u.s.atk;
|
||
};
|
||
approx(heal(null) / heal('none'), C.chess_char_4_26_b.trait.bb.heal_scale, 1e-6);
|
||
});
|