feedback5: merge O1 — 自选 kits for 伊芙利特, 谬因 (with her 中继器) and 林; golden: only diy moved
This commit is contained in:
sganggs committed
commit
fef4ea3d4b
8 files changed
+1936
-120
No files matched your search
@@ -0,0 +1,277 @@
|
||||
// test/content/op_aphris.test.js — the 自选 operator kit of 谬因 (char_4229_aphris, 6★ 轰击术师; kit
|
||||
// server/sim/content/kits/ops/op-aphris.js) and her summon “中继器” (token_10070_aphris_pc), fielded the production way (a DIY
|
||||
// slot + its `diy` pick, simdata getDiy; the 中继器 as a token piece of hers) in every form: tiers 5 / 6, normal (E2 Lv1,
|
||||
// skill rank 4, no module) and elite (E2 Lv60, rank 7) with no module or BLA-Y “第三相态” at stage 1 (tier 5) / 3 (tier 6).
|
||||
// Every number is read back from data/backups.json (the form of that slot status, the token's variant); the fidelity
|
||||
// checklist of kits/README.md item by item.
|
||||
// Run: node --test test/content/op_aphris.test.js
|
||||
|
||||
import { test } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { readFileSync } from 'node:fs';
|
||||
import { makeBattle, enemyRec, checkInvariants } from '../helpers/battleHarness.js';
|
||||
import { KITTED_CHARS, OPERATOR_KITS, KITS } from '../../server/sim/content/kits/index.js';
|
||||
import { diyPool, validateDiyPicks } from '../../shared/diy.js';
|
||||
|
||||
const load = (f) => JSON.parse(readFileSync(new URL(`../../data/${f}.json`, import.meta.url), 'utf8'));
|
||||
const CHESS = load('chess');
|
||||
const BACKUPS = load('backups');
|
||||
const APHRIS = 'char_4229_aphris';
|
||||
const RELAY = 'token_10070_aphris_pc';
|
||||
const FORMS = BACKUPS.units[APHRIS].forms;
|
||||
const TOKEN = BACKUPS.tokens[RELAY];
|
||||
const SLOT = { 5: 'chess_char_5_diy1_a', 6: 'chess_char_6_diy1_a' };
|
||||
const BLAY = 'uniequip_002_aphris';
|
||||
const S1 = 'skchr_aphris_1', S2 = 'skchr_aphris_2', S3 = 'skchr_aphris_3';
|
||||
const statusKey = (tier, elite) => (elite ? (tier === 5 ? '2/60/7/1' : '2/60/7/3') : '2/1/4/0');
|
||||
const formOf = (tier, elite) => FORMS[statusKey(tier, elite)];
|
||||
const skillOf = (tier, elite, id) => formOf(tier, elite).skills.find((s) => s.skillId === id);
|
||||
const modOf = (tier, mod) => (mod ? formOf(tier, true).modules.find((m) => m.uniEquipId === mod) : null);
|
||||
const approx = (a, b, msg, eps = 1e-6) => assert.ok(Math.abs(a - b) <= eps * Math.max(1, Math.abs(b)), `${msg}: ${a} vs ${b}`);
|
||||
const dummy = (key, o = {}) => enemyRec({ key, hp: 1e9, speed: 0, mass: 0, ...o });
|
||||
const ENEMIES = { enemy_dummy: dummy('enemy_dummy'), enemy_fly: dummy('enemy_fly', { motion: 'FLY' }), enemy_hitter: dummy('enemy_hitter', { atk: 500, range: 3, bat: 1 }) };
|
||||
const FORMS_ALL = [[5, false, null], [6, false, null], ...[5, 6].flatMap((t) => [null, BLAY].map((m) => [t, true, m]))];
|
||||
const label = ([tier, elite, mod]) => `T${tier} ${elite ? 'elite' : 'normal'} ${mod ?? 'none'}`;
|
||||
const K = (r, c) => r * 21 + c;
|
||||
const sortN = (a) => [...a].sort((x, y) => x - y);
|
||||
/** 谬因 at (9, 2) facing RIGHT; her own line (9, 2) … (9, 7). */
|
||||
const OWN = [[9, 2], [9, 3], [9, 4], [9, 5], [9, 6], [9, 7]];
|
||||
/** With her 中继器 on (9, 4) facing UP: two steps to it, then 5 more (5 + 2) turned up. */
|
||||
const BENT = [[9, 2], [9, 3], [9, 4], [10, 4], [11, 4], [12, 4], [13, 4], [14, 4]];
|
||||
|
||||
/** A battle with 谬因 as uid 1 at (9, 2) facing RIGHT (`relay`: her piece as uid 2 at relay.row / col / dir), plus `others`. */
|
||||
function field({ tier = 5, elite = false, mod = null, skill = 1, relay = null, others = [], seed = 5, dp = 99 } = {}) {
|
||||
const units = [{ uid: 1, diy: { slot: SLOT[tier], charId: APHRIS, skillIndex: skill, uniEquipId: mod }, elite, row: 9, col: 2 }];
|
||||
if (relay) units.push({ uid: 2, kind: 'token', tokenId: RELAY, ownerUid: 1, row: relay.row, col: relay.col, dir: relay.dir });
|
||||
const h = makeBattle({
|
||||
defs: { enemies: ENEMIES }, timeLimit: 900, autoFinish: false, seed,
|
||||
flags: { dpInit: dp, dpPerSec: 0, dpMax: 999 }, hooks: ['damaged', 'skillStart', 'skillEnd', 'statusApplied', 'death', 'deploy'], captureNoisy: true,
|
||||
units: [...units, ...others],
|
||||
});
|
||||
h.step();
|
||||
return { h, u: h.unit(1), r: relay ? h.unit(2) : null };
|
||||
}
|
||||
const UP4 = { row: 9, col: 4, dir: 'UP' };
|
||||
const atkHits = (h, u) => h.hooksOf('damaged').filter((c) => c.source === u && c.dmg?.isAttack);
|
||||
const tagged = (h, u, tag) => h.hooksOf('damaged').filter((c) => c.source === u && c.dmg?.tags?.includes(tag));
|
||||
function done(h) {
|
||||
checkInvariants(h.b);
|
||||
assert.equal(h.b.errors.length, 0, JSON.stringify(h.b.errors[0]));
|
||||
}
|
||||
|
||||
test('谬因 in every 自选 form: her operator kit (all three skills authored), the form\'s stats + module attributes (BLA-Y: 部署费用 −8), 5-1 line without a 中继器, 轰击术师, no 特质', () => {
|
||||
assert.equal(OPERATOR_KITS[APHRIS], KITS[APHRIS]);
|
||||
for (const f of FORMS_ALL) {
|
||||
const [tier, elite, mod] = f;
|
||||
for (const skill of [0, 1, 2]) {
|
||||
const { h, u } = field({ tier, elite, mod, skill });
|
||||
const form = formOf(tier, elite), m = elite ? modOf(tier, mod) : null;
|
||||
assert.deepEqual([u.def.charId, u.def.diyFor, u.skill.id, !!u.kit.generic, u.kit.skillSource], [APHRIS, SLOT[tier], form.skills[skill].skillId, false, 'skills'], label(f));
|
||||
assert.deepEqual([u.base.maxHp, u.base.atk, u.base.def, u.base.cost], [form.stats.maxHp + (m?.attr.maxHp ?? 0), form.stats.atk + (m?.attr.atk ?? 0), form.stats.def, form.stats.cost + (m?.attr.cost ?? 0)], `${label(f)}: stats`);
|
||||
assert.deepEqual([u.profile.dmgType, u.profile.canHitFly, u.profile.allInRange, u.profile.projectile], ['arts', true, true, 'beam'], `${label(f)}: 轰击术师`);
|
||||
assert.deepEqual(sortN(u.rangeKeys), sortN(OWN.map(([a, b]) => K(a, b))), `${label(f)}: her own 5-1`);
|
||||
assert.deepEqual(u.liveRangeGrid, form.rangeGrid, `${label(f)}: the card shows 5-1`);
|
||||
assert.deepEqual([u.def.bonds, u.def.raw.garrisonIds, u.def.tokens], [BACKUPS.diy.operators[APHRIS].bonds, [], [RELAY]], `${label(f)}: bonds / 特质 / summon`);
|
||||
assert.ok(!u.s.flags.liftoff && !u.s.flags.camou && !u.s.flags.stealth, `${label(f)}: enemies target her`);
|
||||
done(h);
|
||||
}
|
||||
}
|
||||
// E2 Lv1 1261 / 727, E2 Lv60 1526 / 826, cost 34; BLA-Y −8 cost, +120 / +45 → +200 / +70 HP / ATK
|
||||
assert.deepEqual([FORMS['2/1/4/0'].stats.maxHp, FORMS['2/1/4/0'].stats.atk, FORMS['2/60/7/1'].stats.maxHp, FORMS['2/60/7/1'].stats.atk, FORMS['2/60/7/1'].stats.cost], [1261, 727, 1526, 826, 34]);
|
||||
assert.deepEqual([modOf(5, BLAY).attr, modOf(6, BLAY).attr], [{ cost: -8, maxHp: 120, atk: 45 }, { cost: -8, maxHp: 200, atk: 70 }]);
|
||||
});
|
||||
|
||||
test('a 自选 pick: 谬因 is offered at tiers 5 and 6 (she has a kit) and a roster with her passes validateDiyPicks', () => {
|
||||
const data = { chess: CHESS, backups: BACKUPS };
|
||||
assert.ok(KITTED_CHARS.includes(APHRIS));
|
||||
for (const t of [5, 6]) assert.ok(diyPool(t, { data, kitted: KITTED_CHARS }).includes(APHRIS), `tier ${t}`);
|
||||
assert.deepEqual(validateDiyPicks({ [SLOT[6]]: { charId: APHRIS, skillIndex: 1, uniEquipId: BLAY } }, { data, kitted: KITTED_CHARS }),
|
||||
{ ok: true, picks: { [SLOT[6]]: { charId: APHRIS, skillIndex: 1, uniEquipId: BLAY } } });
|
||||
});
|
||||
|
||||
test('链路协议 range: her 中继器 turns the path to its facing and allows 2 more tiles; one attack strikes every enemy of the bent path (air too), none of the straight line past it; the card shows the bent path', () => {
|
||||
for (const f of FORMS_ALL) {
|
||||
const { h, u, r } = field({ tier: f[0], elite: f[1], mod: f[2], skill: 1, relay: UP4 });
|
||||
assert.deepEqual([r.alive, r.dir, r.ownerUnit === u, r.def.id], [true, 'UP', true, RELAY], `${label(f)}: the piece`);
|
||||
assert.deepEqual(sortN(u.rangeKeys), sortN(BENT.map(([a, b]) => K(a, b))), `${label(f)}: bent path`);
|
||||
assert.deepEqual(sortN(u.baseRangeKeys), sortN(BENT.map(([a, b]) => K(a, b))), `${label(f)}: the DEFAULT trigger reads it too`);
|
||||
assert.equal(u.liveRangeGrid.length, BENT.length, `${label(f)}: the card`);
|
||||
const before = h.spawn('enemy_dummy', { pos: [9, 3] }), past = h.spawn('enemy_fly', { pos: [12, 4] }), straight = h.spawn('enemy_dummy', { pos: [9, 6] });
|
||||
h.runUntil(() => atkHits(h, u).length >= 2, 4);
|
||||
const hits = atkHits(h, u);
|
||||
const first = hits.filter((c) => c.dmg.attackId === hits[0].dmg.attackId);
|
||||
assert.deepEqual(first.map((c) => c.target.id).sort(), [before.id, past.id].sort(), `${label(f)}: the bent path`);
|
||||
assert.ok(!hits.some((c) => c.target === straight), `${label(f)}: not the straight line past the piece`);
|
||||
done(h);
|
||||
}
|
||||
});
|
||||
|
||||
test('the 中继器 (T1 链路协议): ATK +25 % (T6 BLA-Y +35 %) while it stands; it withdraws after 25 s (T6 BLA-Y 35 s) and comes back on its tile 30 s (T6 BLA-Y 20 s) later for 3 DP; untargetable, 无敌, 禁疗, 孤立, blocks nothing', () => {
|
||||
for (const f of FORMS_ALL) {
|
||||
const [tier, elite, mod] = f;
|
||||
const { h, u, r } = field({ tier, elite, mod, skill: 1, relay: UP4 });
|
||||
const y3 = elite && tier === 6 && mod === BLAY;
|
||||
const v = TOKEN.variants[`${APHRIS}@${statusKey(tier, elite)}`];
|
||||
const stats = (mod && v.byModule?.[mod]?.stats) || v.stats;
|
||||
const life = y3 ? 35 : 25, back = y3 ? 20 : 30, atk = y3 ? 0.35 : 0.25;
|
||||
assert.deepEqual([stats.respawnTime, stats.cost, r.base.respawnTime, r.base.blockCnt], [back, 3, back, 0], `${label(f)}: token data`);
|
||||
assert.equal(u.def.raw.talents.find((t) => t.index === 0).bb.atk, atk, `${label(f)}: talent`);
|
||||
assert.deepEqual([r.s.flags.untargetable, r.s.flags.invulnerable, r.s.flags.isolated, r.s.flags.noHeal], [true, true, true, true], `${label(f)}: flags`);
|
||||
h.run(0.1);
|
||||
approx(u.s.atk, u.base.atk * (1 + atk), `${label(f)}: ATK +${atk * 100} %`);
|
||||
h.run(life - 0.3);
|
||||
assert.ok(r.alive, `${label(f)}: still there before ${life} s`);
|
||||
const dp0 = h.b.players[0].dp;
|
||||
h.run(0.4);
|
||||
assert.ok(!r.alive && !r.removed, `${label(f)}: withdrawn after ${life} s, waiting`);
|
||||
h.step();
|
||||
approx(u.s.atk, u.base.atk, `${label(f)}: no bonus without it`);
|
||||
assert.deepEqual(sortN(u.rangeKeys), sortN(OWN.map(([a, b]) => K(a, b))), `${label(f)}: the straight line again`);
|
||||
h.run(back - 0.4);
|
||||
assert.ok(!r.alive, `${label(f)}: not before ${back} s`);
|
||||
h.run(0.6);
|
||||
assert.ok(r.alive && r.tileR === 9 && r.tileC === 4 && r.dir === 'UP', `${label(f)}: back on its tile`);
|
||||
approx(dp0 - h.b.players[0].dp, 3, `${label(f)}: 3 DP`);
|
||||
h.step();
|
||||
approx(u.s.atk, u.base.atk * (1 + atk), `${label(f)}: the bonus again`);
|
||||
done(h);
|
||||
}
|
||||
});
|
||||
|
||||
test('T2 取样优化: every allied operator standing on her path — her own tile too — ignores 10 RES (法术穿透); none off it', () => {
|
||||
for (const f of FORMS_ALL) {
|
||||
const others = [{ uid: 3, chessId: 'chess_char_1_02_a', row: 10, col: 4 }, { uid: 4, chessId: 'chess_char_1_02_a', row: 9, col: 6 }];
|
||||
const { h, u } = field({ tier: f[0], elite: f[1], mod: f[2], skill: 1, relay: UP4, others });
|
||||
assert.equal(u.def.raw.talents.find((t) => t.index === 1).bb.magic_resist_penetrate_fixed, 10, label(f));
|
||||
h.run(0.3);
|
||||
assert.deepEqual([u.s.resIgnoreFlat, h.unit(3).s.resIgnoreFlat, h.unit(4).s.resIgnoreFlat], [10, 10, 0], `${label(f)}: herself, the one on the bent path, not the one on the straight line`);
|
||||
done(h);
|
||||
}
|
||||
});
|
||||
|
||||
test('S1 连续映射 (AUTO, 持续时间无限 — the kit\'s SP_FULL: no enemy needed): at full SP (45 / 40); ATK +90 % / +120 %; a 中继器 whose time runs out stays', () => {
|
||||
for (const [tier, elite, mod] of [[5, false, null], [6, true, BLAY]]) {
|
||||
const sk = skillOf(tier, elite, S1);
|
||||
const { h, u, r } = field({ tier, elite, mod, skill: 0, relay: UP4 });
|
||||
assert.deepEqual([u.skill.rule, u.skill.kind, u.skill.spCost, sk.bb.atk], ['SP_FULL', 'toggle', elite ? 40 : 45, elite ? 1.2 : 0.9], `T${tier}`);
|
||||
h.run(sk.spCost - 1);
|
||||
assert.equal(u.skill.activations, 0, `T${tier}: not before full SP`);
|
||||
assert.ok(h.runUntil(() => u.skill.active, 2), `T${tier}: cast at full SP, no enemy on the field`);
|
||||
approx(u.s.atk, u.base.atk * (1 + sk.bb.atk), `T${tier}: ATK (no 中继器 bonus: it withdrew at its time)`);
|
||||
// the piece back (cooldown), then its time runs out while 连续映射 runs: it stays
|
||||
h.runUntil(() => r.alive, 40);
|
||||
h.run((elite && tier === 6 ? 35 : 25) + 5);
|
||||
assert.ok(r.alive, `T${tier}: the 中继器 stays`);
|
||||
approx(u.s.atk, u.base.atk * (1 + sk.bb.atk + (elite && tier === 6 ? 0.35 : 0.25)), `T${tier}: both bonuses`);
|
||||
h.run(60);
|
||||
assert.deepEqual([u.skill.active, u.skill.activations], [true, 1], `T${tier}: infinite`);
|
||||
done(h);
|
||||
}
|
||||
});
|
||||
|
||||
test('S2 临界瞬爆 (MANUAL, data DEFAULT, 8 s): no normal attack; from 0.167 s every 0.5 s the beam hits every enemy along an unbounded path — turned by her 中继器 and by any allied operator it reaches — for 90 % / 120 % ATK arts; 16 hits; her range is back after', () => {
|
||||
for (const [tier, elite] of [[5, false], [6, true]]) {
|
||||
const sk = skillOf(tier, elite, S2);
|
||||
const others = [{ uid: 3, chessId: 'chess_char_1_02_a', row: 11, col: 4, dir: 'RIGHT' }];
|
||||
const { h, u } = field({ tier, elite, skill: 1, relay: UP4, others });
|
||||
assert.deepEqual([u.skill.rule, sk.duration, sk.bb.atk_scale, sk.bb.interval, u.skill.spCost], ['DEFAULT', 8, elite ? 1.2 : 0.9, 0.5, elite ? 20 : 22], `T${tier}`);
|
||||
const inPath = h.spawn('enemy_dummy', { pos: [10, 4] }), afterOp = h.spawn('enemy_fly', { pos: [11, 9] });
|
||||
const pastOp = h.spawn('enemy_dummy', { pos: [12, 4] }), straight = h.spawn('enemy_dummy', { pos: [9, 6] });
|
||||
u.skill.gainSp(999);
|
||||
assert.ok(h.runUntil(() => u.skill.active, 4), `T${tier}: cast`);
|
||||
// the beam: (9,2) → (9,4) 中继器 UP → (11,4) 角峰 RIGHT → the field's edge
|
||||
for (const [a, b] of [[10, 4], [11, 4], [11, 5], [11, 10], [11, 20]]) assert.ok(u.rangeKeySet.has(K(a, b)), `T${tier}: (${a}, ${b}) on the beam`);
|
||||
for (const [a, b] of [[12, 4], [9, 5], [9, 6]]) assert.ok(!u.rangeKeySet.has(K(a, b)), `T${tier}: (${a}, ${b}) off it`);
|
||||
const n0 = atkHits(h, u).length, cast = h.hooksOf('skillStart').at(-1).t;
|
||||
h.runUntil(() => !u.skill.active, 10);
|
||||
const endT = h.hooksOf('skillEnd').at(-1).t;
|
||||
const beam = tagged(h, u, 'aphris:beam');
|
||||
approx(beam[0].t - cast, 0.167, `T${tier}: the first hit after the Begin clip (0.167 s)`, 0.2);
|
||||
approx(beam.filter((c) => c.target === inPath)[1].t - beam[0].t, 0.5, `T${tier}: then every 0.5 s`, 0.07);
|
||||
for (const e of [inPath, afterOp]) {
|
||||
const mine = beam.filter((c) => c.target === e);
|
||||
assert.equal(mine.length, 16, `T${tier}: 16 beam hits on ${e.defId}`);
|
||||
approx(mine[0].amount, u.s.atk * sk.bb.atk_scale, `T${tier}: ${sk.bb.atk_scale * 100} % ATK`);
|
||||
assert.deepEqual([mine[0].type, mine[0].dmg.isAttack], ['arts', false], `T${tier}: arts, no normal attack`);
|
||||
}
|
||||
assert.ok(!beam.some((c) => c.target === pastOp || c.target === straight), `T${tier}: nothing off the beam`);
|
||||
assert.equal(atkHits(h, u).filter((c) => c.t < endT).length, n0, `T${tier}: no normal attack meanwhile`);
|
||||
assert.deepEqual(sortN(u.rangeKeys), sortN(BENT.map(([a, b]) => K(a, b))), `T${tier}: the bent 5-1 path again`);
|
||||
done(h);
|
||||
}
|
||||
});
|
||||
|
||||
test('S3 混沌的本质 (MANUAL, data DEFAULT, 20 bullets): 3 s 强制缴械 from the cast, every 中继器 withdrawn and back at once; interval 2.9 → 1.8 s, ATK +95 % / +115 %, 140 % / 155 % + 停顿 0.2 / 0.4 s; past a 中继器 +25 % / +30 % ATK and 停顿 +0.2 / +0.4 s; no 中继器 withdraws until it ends, all do then and come back at once', () => {
|
||||
for (const [tier, elite, mod] of [[5, false, null], [6, true, BLAY]]) {
|
||||
const sk = skillOf(tier, elite, S3);
|
||||
const { h, u, r } = field({ tier, elite, mod, skill: 2, relay: UP4 });
|
||||
const atk = elite && tier === 6 ? 0.35 : 0.25;
|
||||
assert.deepEqual([u.skill.rule, u.skill.kind, u.skill.ammo, sk.bb.charge_time, sk.bb.base_attack_time, sk.bb.atk, sk.bb['attack@atk_scale'], sk.bb['attack@origin_sluggish'], sk.bb['attack@extra_atk_scale'], sk.bb['attack@extra_sluggish']],
|
||||
['DEFAULT', 'ammo', 20, 3, -1.1, elite ? 1.15 : 0.95, elite ? 1.55 : 1.4, elite ? 0.4 : 0.2, elite ? 0.3 : 0.25, elite ? 0.4 : 0.2], `T${tier}`);
|
||||
const before = h.spawn('enemy_dummy', { pos: [9, 3] }), past = h.spawn('enemy_dummy', { pos: [11, 4] }), off = h.spawn('enemy_dummy', { pos: [9, 6] });
|
||||
u.skill.gainSp(999);
|
||||
assert.ok(h.runUntil(() => u.skill.active, 4), `T${tier}: cast`);
|
||||
const t0 = h.hooksOf('skillStart').at(-1).t, n0 = atkHits(h, u).length;
|
||||
assert.ok(h.hooksOf('death').some((c) => c.unit === r && Math.abs(c.t - t0) < 1e-9), `T${tier}: the 中继器 withdrawn at the cast`);
|
||||
assert.ok(h.runUntil(() => r.alive, 0.5), `T${tier}: and back at once (redeploy time cleared)`);
|
||||
h.run(2.8 - (h.b.time - t0));
|
||||
assert.equal(atkHits(h, u).length, n0, `T${tier}: 强制缴械 3 s`);
|
||||
approx(u.s.interval, 1.8, `T${tier}: 1.8 s`);
|
||||
approx(u.s.atk, u.base.atk * (1 + atk + sk.bb.atk), `T${tier}: ATK`);
|
||||
h.runUntil(() => atkHits(h, u).length > n0, 1);
|
||||
const hits = atkHits(h, u).slice(n0);
|
||||
assert.ok(h.b.time - t0 >= 3 - 1e-6, `T${tier}: the first attack after 3 s`);
|
||||
assert.deepEqual(hits.map((c) => c.target.id).sort(), [before.id, past.id].sort(), `T${tier}: the bent path`);
|
||||
for (const c of hits) { approx(c.amount, u.s.atk * sk.bb['attack@atk_scale'], `T${tier}: ${sk.bb['attack@atk_scale'] * 100} %`); assert.equal(c.type, 'arts'); }
|
||||
assert.deepEqual(sortN(u.rangeKeys), sortN(BENT.map(([a, b]) => K(a, b))), `T${tier}: the bent 5-1 path while it runs`);
|
||||
const extra = tagged(h, u, 'aphris:relay');
|
||||
assert.deepEqual(extra.map((c) => c.target.id), [past.id], `T${tier}: the extra hit past the 中继器 only`);
|
||||
approx(extra[0].amount, u.s.atk * sk.bb['attack@extra_atk_scale'], `T${tier}: +${sk.bb['attack@extra_atk_scale'] * 100} % ATK`);
|
||||
const slow = (e) => h.hooksOf('statusApplied').filter((c) => c.source === u && c.status === 'sluggish' && c.target === e).at(-1)?.duration;
|
||||
approx(slow(before), sk.bb['attack@origin_sluggish'], `T${tier}: 停顿 before it`);
|
||||
approx(slow(past), sk.bb['attack@origin_sluggish'] + sk.bb['attack@extra_sluggish'], `T${tier}: 停顿 past it`);
|
||||
assert.ok(!hits.some((c) => c.target === off));
|
||||
// its time runs out during the skill: it stays; all go when the skill ends — and come back at once (redeploy time
|
||||
// cleared again), with their normal time
|
||||
h.runUntil(() => !u.skill.active, 60);
|
||||
assert.equal(atkHits(h, u).filter((c) => c.dmg.isSkill).length, 2 * 20, `T${tier}: 20 bullets (2 targets each)`);
|
||||
const end = h.hooksOf('skillEnd').at(-1).t;
|
||||
assert.ok(end - t0 > (elite && tier === 6 ? 35 : 25), `T${tier}: it outlasted the piece's time`);
|
||||
assert.ok(h.hooksOf('death').some((c) => c.unit === r && Math.abs(c.t - end) < 1e-9), `T${tier}: withdrawn at the end`);
|
||||
assert.ok(h.runUntil(() => r.alive, 0.5), `T${tier}: back at once`);
|
||||
const back = h.b.time;
|
||||
h.run((elite && tier === 6 ? 35 : 25) + 0.5);
|
||||
assert.ok(h.hooksOf('death').some((c) => c.unit === r && c.t > back), `T${tier}: and withdraws at its time again`);
|
||||
done(h);
|
||||
}
|
||||
});
|
||||
|
||||
test('BLA-Y “第三相态” (stages 1 and 3): the 部署费用 attribute (34 → 26); stage 3 only: 35 s 中继器, its redeploy time 30 → 20 s (再部署时间变短), ATK +35 %', () => {
|
||||
for (const tier of [5, 6]) {
|
||||
for (const mod of [null, BLAY]) {
|
||||
const { h, u, r } = field({ tier, elite: true, mod, relay: UP4 });
|
||||
assert.equal(u.base.cost, mod ? 26 : 34, `T${tier} ${mod}: cost`);
|
||||
const y3 = tier === 6 && mod === BLAY;
|
||||
assert.deepEqual(r.def.talents.map((t) => t.bb.duration), y3 ? [25, 35] : [25], `T${tier} ${mod}: the piece's talents`);
|
||||
assert.equal(r.base.respawnTime, y3 ? 20 : 30, `T${tier} ${mod}: redeploy time`);
|
||||
if (y3) assert.match(u.def.raw.talents.find((t) => t.index === 0).desc, /35秒.*再部署时间变短.*攻击力\+35%/);
|
||||
done(h);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
test('链路协议: her 中继器 leaves the field with her (die_to_kill_token) and is back on its tile as soon as she is (charge_token[born]), not before', () => {
|
||||
const { h, u, r } = field({ tier: 6, elite: true, mod: BLAY, skill: 1, relay: UP4 });
|
||||
h.run(2);
|
||||
assert.ok(r.alive);
|
||||
const e = h.spawn('enemy_dummy', { pos: [9, 3] });
|
||||
h.b.dealDamage(e, u, { amount: 1e7, type: 'true' });
|
||||
assert.equal(u.alive, false, 'knocked out');
|
||||
assert.ok(!r.alive && !r.removed, 'the piece withdrawn with her');
|
||||
h.run(40);
|
||||
assert.ok(!r.alive, 'not while she is down (its redeploy time is long over)');
|
||||
h.runUntil(() => u.alive, 60);
|
||||
assert.ok(h.runUntil(() => r.alive, 0.5), 'back with her');
|
||||
assert.ok(r.tileR === 9 && r.tileC === 4 && r.dir === 'UP', 'on its tile');
|
||||
done(h);
|
||||
});
|
||||
@@ -0,0 +1,294 @@
|
||||
// test/content/op_ifrit.test.js — the 自选 operator kit of 伊芙利特 (char_134_ifrit, 6★ 轰击术师; kit
|
||||
// server/sim/content/kits/ops/op-ifrit.js), fielded the production way (a DIY slot + its `diy` pick, simdata getDiy) in
|
||||
// every form: tiers 5 / 6, normal (E2 Lv1, skill rank 4, no module) and elite (E2 Lv60, rank 7) with no module, BLA-X
|
||||
// “同熔” or BLA-D “热成形记忆” at stage 1 (tier 5) / 3 (tier 6). Every number is read back from data/backups.json (the form of
|
||||
// that slot status); the fidelity checklist of kits/README.md item by item.
|
||||
// Run: node --test test/content/op_ifrit.test.js
|
||||
|
||||
import { test } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { readFileSync } from 'node:fs';
|
||||
import { makeBattle, enemyRec, checkInvariants } from '../helpers/battleHarness.js';
|
||||
import { KITTED_CHARS, OPERATOR_KITS, KITS } from '../../server/sim/content/kits/index.js';
|
||||
import { diyPool, validateDiyPicks } from '../../shared/diy.js';
|
||||
|
||||
const load = (f) => JSON.parse(readFileSync(new URL(`../../data/${f}.json`, import.meta.url), 'utf8'));
|
||||
const CHESS = load('chess');
|
||||
const BACKUPS = load('backups');
|
||||
const IFRIT = 'char_134_ifrit';
|
||||
const FORMS = BACKUPS.units[IFRIT].forms;
|
||||
const SLOT = { 5: 'chess_char_5_diy1_a', 6: 'chess_char_6_diy1_a' };
|
||||
const BLAX = 'uniequip_002_ifrit', BLAD = 'uniequip_003_ifrit';
|
||||
const S1 = 'skchr_ifrit_1', S2 = 'skchr_ifrit_2', S3 = 'skchr_ifrit_3';
|
||||
const formOf = (tier, elite) => FORMS[elite ? (tier === 5 ? '2/60/7/1' : '2/60/7/3') : '2/1/4/0'];
|
||||
const skillOf = (tier, elite, id) => formOf(tier, elite).skills.find((s) => s.skillId === id);
|
||||
const modOf = (tier, mod) => (mod ? formOf(tier, true).modules.find((m) => m.uniEquipId === mod) : null);
|
||||
const approx = (a, b, msg, eps = 1e-6) => assert.ok(Math.abs(a - b) <= eps * Math.max(1, Math.abs(b)), `${msg}: ${a} vs ${b}`);
|
||||
const dummy = (key, o = {}) => enemyRec({ key, hp: 1e9, speed: 0, mass: 0, ...o });
|
||||
const ENEMIES = {
|
||||
enemy_dummy: dummy('enemy_dummy'), enemy_fly: dummy('enemy_fly', { motion: 'FLY' }),
|
||||
enemy_res: dummy('enemy_res', { res: 50 }), enemy_def: dummy('enemy_def', { def: 300 }),
|
||||
enemy_hitter: dummy('enemy_hitter', { atk: 1000, range: 0, bat: 1 }),
|
||||
};
|
||||
/** Every 自选 form: [tier, elite, module]. */
|
||||
const FORMS_ALL = [[5, false, null], [6, false, null], ...[5, 6].flatMap((t) => [null, BLAX, BLAD].map((m) => [t, true, m]))];
|
||||
const label = ([tier, elite, mod]) => `T${tier} ${elite ? 'elite' : 'normal'} ${mod ?? 'none'}`;
|
||||
|
||||
/** A battle with 伊芙利特 as uid 1 at (row, col) facing RIGHT (her line: that row, col … col + 5), plus `others`. */
|
||||
function field({ tier = 5, elite = false, mod = null, skill = 0, row = 10, col = 4, others = [], seed = 5, flags = {} } = {}) {
|
||||
const h = makeBattle({
|
||||
defs: { enemies: ENEMIES }, timeLimit: 900, autoFinish: false, seed,
|
||||
flags: { dpPerSec: 0, dpMax: 999, ...flags }, hooks: ['damaged', 'skillStart', 'skillEnd', 'statusApplied', 'spGain'], captureNoisy: true,
|
||||
units: [{ uid: 1, diy: { slot: SLOT[tier], charId: IFRIT, skillIndex: skill, uniEquipId: mod }, elite, row, col }, ...others],
|
||||
});
|
||||
h.step();
|
||||
return { h, u: h.unit(1) };
|
||||
}
|
||||
const atkHits = (h, u) => h.hooksOf('damaged').filter((c) => c.source === u && c.dmg?.isAttack);
|
||||
const tagged = (h, u, tag) => h.hooksOf('damaged').filter((c) => (c.source === u || c.credit === u) && c.dmg?.tags?.includes(tag));
|
||||
function done(h) {
|
||||
checkInvariants(h.b);
|
||||
assert.equal(h.b.errors.length, 0, JSON.stringify(h.b.errors[0]));
|
||||
}
|
||||
|
||||
test('伊芙利特 in every 自选 form: her operator kit (all three skills authored), the form\'s stats + module attributes, 5-1 line, 轰击术师 (every enemy of the line, air too, arts, instant), no 特质', () => {
|
||||
assert.equal(OPERATOR_KITS[IFRIT], KITS[IFRIT]);
|
||||
for (const f of FORMS_ALL) {
|
||||
const [tier, elite, mod] = f;
|
||||
for (const skill of [0, 1, 2]) {
|
||||
const { h, u } = field({ tier, elite, mod, skill });
|
||||
const form = formOf(tier, elite), m = elite ? modOf(tier, mod) : null;
|
||||
assert.deepEqual([u.def.charId, u.def.diyFor, u.skill.id, !!u.kit.generic, u.kit.skillSource], [IFRIT, SLOT[tier], form.skills[skill].skillId, false, 'skills'], label(f));
|
||||
assert.deepEqual([u.base.maxHp, u.base.atk, u.base.def, u.base.aspd], [form.stats.maxHp + (m?.attr.maxHp ?? 0), form.stats.atk + (m?.attr.atk ?? 0), form.stats.def + (m?.attr.def ?? 0), 100 + (m?.attr.aspd ?? 0)], `${label(f)}: stats`);
|
||||
assert.deepEqual([u.profile.attack, u.profile.dmgType, u.profile.canHitFly, u.profile.allInRange, u.profile.projectile, u.base.bat], ['ranged', 'arts', true, true, 'beam', 2.9], `${label(f)}: 轰击术师`);
|
||||
assert.deepEqual(u.liveRangeGrid, form.rangeGrid, `${label(f)}: 5-1`);
|
||||
assert.deepEqual([u.def.bonds, u.def.raw.garrisonIds], [BACKUPS.diy.operators[IFRIT].bonds, []], `${label(f)}: bonds / 特质`);
|
||||
assert.ok(!u.s.flags.liftoff && !u.s.flags.camou && !u.s.flags.stealth, `${label(f)}: enemies target her`);
|
||||
done(h);
|
||||
}
|
||||
}
|
||||
// E2 Lv1 1276 / 722, E2 Lv60 1544 / 820; BLA-X +50 ATK +5 ASPD → +72 / +7, BLA-D +120 HP +45 ATK → +200 / +70
|
||||
assert.deepEqual([FORMS['2/1/4/0'].stats.maxHp, FORMS['2/1/4/0'].stats.atk, FORMS['2/60/7/1'].stats.maxHp, FORMS['2/60/7/1'].stats.atk], [1276, 722, 1544, 820]);
|
||||
assert.deepEqual([modOf(5, BLAX).attr, modOf(6, BLAX).attr, modOf(5, BLAD).attr, modOf(6, BLAD).attr], [{ atk: 50, aspd: 5 }, { atk: 72, aspd: 7 }, { maxHp: 120, atk: 45 }, { maxHp: 200, atk: 70 }]);
|
||||
});
|
||||
|
||||
test('a 自选 pick: 伊芙利特 is offered at tiers 5 and 6 (she has a kit) and a roster with her passes validateDiyPicks', () => {
|
||||
const data = { chess: CHESS, backups: BACKUPS };
|
||||
assert.ok(KITTED_CHARS.includes(IFRIT));
|
||||
for (const t of [5, 6]) assert.ok(diyPool(t, { data, kitted: KITTED_CHARS }).includes(IFRIT), `tier ${t}`);
|
||||
assert.deepEqual(validateDiyPicks({ [SLOT[6]]: { charId: IFRIT, skillIndex: 2, uniEquipId: BLAD } }, { data, kitted: KITTED_CHARS }),
|
||||
{ ok: true, picks: { [SLOT[6]]: { charId: IFRIT, skillIndex: 2, uniEquipId: BLAD } } });
|
||||
});
|
||||
|
||||
test('trait 轰击术师: one attack strikes every enemy of her 5-1 line at once — ground and air, the same damage near and far (no module) — and nothing off the line', () => {
|
||||
for (const [tier, elite] of [[5, false], [6, true]]) {
|
||||
const { h, u } = field({ tier, elite, skill: 0 });
|
||||
const near = h.spawn('enemy_dummy', { pos: [10, 5] }), far = h.spawn('enemy_dummy', { pos: [10, 9] });
|
||||
const fly = h.spawn('enemy_fly', { pos: [10, 7] }), off = h.spawn('enemy_dummy', { pos: [11, 5] }), behind = h.spawn('enemy_dummy', { pos: [10, 3] });
|
||||
assert.ok(h.runUntil(() => atkHits(h, u).length > 0, 4), `T${tier}: she attacks`);
|
||||
const first = atkHits(h, u);
|
||||
const hit = first.filter((c) => c.dmg.attackId === first[0].dmg.attackId);
|
||||
assert.deepEqual(hit.map((c) => c.target.id).sort(), [near, far, fly].map((e) => e.id).sort(), `T${tier}: her line, air included`);
|
||||
for (const c of hit) { approx(c.amount, u.s.atk, `T${tier}: 100 % ATK at any distance`); assert.equal(c.type, 'arts'); }
|
||||
for (const e of [off, behind]) assert.ok(!hit.some((c) => c.target === e), `T${tier}: off the line`);
|
||||
done(h);
|
||||
}
|
||||
});
|
||||
|
||||
test('S1 狂热 (MANUAL, data DEFAULT, 20 s): ATK +10 % / +20 %, ASPD +58 / +67; all back after', () => {
|
||||
for (const [tier, elite] of [[5, false], [6, true]]) {
|
||||
const sk = skillOf(tier, elite, S1);
|
||||
const { h, u } = field({ tier, elite, skill: 0 });
|
||||
assert.deepEqual([u.skill.rule, sk.duration, sk.bb.atk, sk.bb.attack_speed, u.skill.spCost], ['DEFAULT', 20, elite ? 0.2 : 0.1, elite ? 67 : 58, elite ? 44 : 47], `T${tier}`);
|
||||
u.skill.gainSp(999);
|
||||
h.run(1);
|
||||
assert.equal(u.skill.activations, 0, `T${tier}: no enemy, no cast`);
|
||||
h.spawn('enemy_dummy', { pos: [10, 6] });
|
||||
assert.ok(h.runUntil(() => u.skill.active, 2), `T${tier}: cast on her attack`);
|
||||
approx(u.s.atk, u.base.atk * (1 + sk.bb.atk), `T${tier}: ATK`);
|
||||
assert.equal(u.s.aspd, 100 + sk.bb.attack_speed, `T${tier}: ASPD`);
|
||||
approx(u.skill.timeLeft, 20, `T${tier}: 20 s`, 0.01);
|
||||
assert.deepEqual(u.liveRangeGrid, formOf(tier, elite).rangeGrid, `T${tier}: 5-1 while it runs`);
|
||||
h.runUntil(() => !u.skill.active, 25);
|
||||
approx(u.s.atk, u.base.atk, `T${tier}: ATK back`);
|
||||
assert.equal(u.s.aspd, 100, `T${tier}: ASPD back`);
|
||||
done(h);
|
||||
}
|
||||
});
|
||||
|
||||
test('S2 炎爆 (AUTO, 2 / 3 charges, data DEFAULT): the next attack hits her whole line for 160 % / 190 %, DEF −100 / −200 for 3 s and the 灼伤 (33 % of her current ATK per s, 3 ticks, no dodge) on every enemy hit — the burn ticks on after she leaves', () => {
|
||||
for (const [tier, elite] of [[5, false], [6, true]]) {
|
||||
const sk = skillOf(tier, elite, S2);
|
||||
const { h, u } = field({ tier, elite, skill: 1 });
|
||||
assert.deepEqual([u.skill.rule, u.skill.kind, u.skill.maxCharges, u.skill.spCost, sk.bb.atk_scale, sk.bb.def, sk.bb['burn.atk_scale'], sk.bb.duration],
|
||||
['DEFAULT', 'charges', elite ? 3 : 2, 8, elite ? 1.9 : 1.6, elite ? -200 : -100, 0.33, 3.01], `T${tier}`);
|
||||
const a = h.spawn('enemy_def', { pos: [10, 6] }), b = h.spawn('enemy_fly', { pos: [10, 8] }), off = h.spawn('enemy_dummy', { pos: [11, 6] });
|
||||
u.skill.gainSp(999);
|
||||
const n0 = atkHits(h, u).length;
|
||||
assert.ok(h.runUntil(() => u.skill.activations === 1 && atkHits(h, u).length > n0, 4), `T${tier}: cast on her next attack`);
|
||||
const hits = atkHits(h, u).slice(n0);
|
||||
const t0 = h.b.time;
|
||||
for (const c of hits) assert.equal(c.dmg.isSkill, true);
|
||||
approx(hits.find((c) => c.target === b).amount, u.s.atk * sk.bb.atk_scale, `T${tier}: ${sk.bb.atk_scale * 100} % on the flyer`);
|
||||
approx(a.s.def, 300 + sk.bb.def < 0 ? 0 : 300 + sk.bb.def, `T${tier}: DEF cut`);
|
||||
assert.equal(off.findBuff('ifrit:pyroDef'), null, `T${tier}: off the line`);
|
||||
assert.ok(a.findBuff('ifrit:pyroBurn') && b.findBuff('ifrit:pyroBurn'), `T${tier}: both burn`);
|
||||
// the burn: 3 ticks of 33 % of her current ATK; she leaves the field after the first one
|
||||
h.runUntil(() => tagged(h, u, 'ifrit:burn').filter((c) => c.target === b).length >= 1, 2);
|
||||
const atkNow = u.s.atk;
|
||||
h.b.retreat(u);
|
||||
h.run(3);
|
||||
const burns = tagged(h, u, 'ifrit:burn').filter((c) => c.target === b);
|
||||
assert.equal(burns.length, 3, `T${tier}: 3 ticks`);
|
||||
approx(burns[0].amount, atkNow * 0.33, `T${tier}: 33 % ATK arts`);
|
||||
for (const c of burns) { assert.deepEqual([c.type, c.dmg.canDodge], ['arts', false]); assert.ok(c.t - t0 <= 3.05, `T${tier}: within 3 s`); }
|
||||
assert.equal(a.findBuff('ifrit:pyroDef'), null, `T${tier}: DEF cut over after 3 s`);
|
||||
done(h);
|
||||
}
|
||||
});
|
||||
|
||||
test('S3 灼地 (MANUAL, data DEFAULT, 20 s, 维持技能状态): no normal attack; from the Begin clip\'s event (0.4 s) every second each ground enemy of her line takes 90 % / 110 % ATK arts and RES −7 / −10 for 1 s; she loses 2 % max HP per s; 20 ticks; a stun ends it at once', () => {
|
||||
for (const [tier, elite] of [[5, false], [6, true]]) {
|
||||
const sk = skillOf(tier, elite, S3);
|
||||
const { h, u } = field({ tier, elite, skill: 2 });
|
||||
assert.deepEqual([u.skill.rule, sk.duration, sk.bb.atk_scale, sk.bb.magic_resistance, sk.bb.hp_ratio], ['DEFAULT', 20, elite ? 1.1 : 0.9, elite ? -10 : -7, 0.02], `T${tier}`);
|
||||
const g = h.spawn('enemy_res', { pos: [10, 6] }), fly = h.spawn('enemy_fly', { pos: [10, 7] }), off = h.spawn('enemy_res', { pos: [11, 6] });
|
||||
u.skill.gainSp(999);
|
||||
assert.ok(h.runUntil(() => u.skill.active, 4), `T${tier}: cast`);
|
||||
const n0 = atkHits(h, u).length, hp0 = u.hp, cast = h.hooksOf('skillStart').at(-1).t;
|
||||
h.run(1.02);
|
||||
// RES 50 × 0.6 (精神融解) − 7 / −10: (50 − cut) × 0.6
|
||||
approx(g.s.res, (50 + sk.bb.magic_resistance) * 0.6, `T${tier}: RES cut + 精神融解`, 1e-9);
|
||||
approx(off.s.res, 50, `T${tier}: off the line`);
|
||||
assert.deepEqual(u.liveRangeGrid, formOf(tier, elite).rangeGrid, `T${tier}: 5-1 while it runs`);
|
||||
const ticks = () => tagged(h, u, 'ifrit:scorch').filter((c) => c.type === 'arts');
|
||||
assert.equal(ticks().length, 1, `T${tier}: one tick after 1 s`);
|
||||
approx(ticks()[0].t - cast, 0.4, `T${tier}: the first tick at the Begin clip's attack event`, 0.05);
|
||||
approx(ticks()[0].amount, u.s.atk * sk.bb.atk_scale * (1 - (50 + sk.bb.magic_resistance) * 0.6 / 100), `T${tier}: ${sk.bb.atk_scale * 100} % ATK arts`);
|
||||
assert.ok(!ticks().some((c) => c.target === fly || c.target === off), `T${tier}: ground enemies of her line only`);
|
||||
approx(hp0 - u.hp, u.s.maxHp * 0.02, `T${tier}: 2 % max HP`);
|
||||
h.runUntil(() => !u.skill.active, 25);
|
||||
assert.equal(ticks().length, 20, `T${tier}: 20 ticks`);
|
||||
const endT = h.hooksOf('skillEnd').at(-1).t;
|
||||
assert.equal(atkHits(h, u).filter((c) => c.t < endT).length, n0, `T${tier}: no normal attack meanwhile`);
|
||||
// a second cast, cut short by a stun
|
||||
u.hp = u.s.maxHp;
|
||||
u.skill.gainSp(999);
|
||||
assert.ok(h.runUntil(() => u.skill.active, 6), `T${tier}: cast again`);
|
||||
h.run(2.5);
|
||||
h.b.applyStatus(u, 'stun', { duration: 1, force: true });
|
||||
h.step();
|
||||
assert.equal(u.skill.active, false, `T${tier}: the stun ends 灼地`);
|
||||
assert.equal(h.hooksOf('skillEnd').at(-1).reason, 'interrupted');
|
||||
done(h);
|
||||
}
|
||||
});
|
||||
|
||||
test('T1 精神融解: RES ×0.6 on every enemy of her line (gone once it leaves), none off it; BLA-D stage 3: her attacks and 灼地 ticks on an enemy in its 灼燃 burst add 50 % ATK 元素伤害 (a 持续伤害)', () => {
|
||||
for (const f of FORMS_ALL) {
|
||||
const [tier, elite, mod] = f;
|
||||
const { h, u } = field({ tier, elite, mod, skill: 0 });
|
||||
const t0 = u.def.raw.talents.find((t) => t.index === 0);
|
||||
assert.equal(t0.bb.magic_resistance, -0.4, label(f));
|
||||
const on = h.spawn('enemy_res', { pos: [10, 7] }), off = h.spawn('enemy_res', { pos: [11, 7] });
|
||||
h.run(0.3);
|
||||
approx(on.s.res, 30, `${label(f)}: 50 → 30`);
|
||||
approx(off.s.res, 50, `${label(f)}: off the line`);
|
||||
h.b.retreat(u);
|
||||
h.run(0.6);
|
||||
approx(on.s.res, 50, `${label(f)}: gone with her`);
|
||||
done(h);
|
||||
}
|
||||
for (const [tier, mod, extra] of [[6, BLAD, 0.5], [5, BLAD, 0], [6, BLAX, 0], [6, null, 0]]) {
|
||||
const { h, u } = field({ tier, elite: true, mod, skill: 2 });
|
||||
const e = h.spawn('enemy_dummy', { pos: [10, 6] });
|
||||
const calm = h.spawn('enemy_dummy', { pos: [10, 7] });
|
||||
h.b.addBuff(e, { key: 'burnBurst', duration: 60, flags: { burstLock: true } });
|
||||
const n0 = atkHits(h, u).length;
|
||||
h.runUntil(() => atkHits(h, u).length > n0, 4);
|
||||
h.step();
|
||||
const el = () => tagged(h, u, 'ifrit:meltdown');
|
||||
assert.equal(el().length, extra ? 1 : 0, `T${tier} ${mod}: the extra hit on her attack`);
|
||||
if (extra) {
|
||||
approx(el()[0].amount, u.s.atk * extra, 'T6 BLA-D: 50 % ATK');
|
||||
assert.deepEqual([el()[0].type, el()[0].dmg.element, el()[0].dmg.tags.includes('dot'), el()[0].target], ['elemental', 'burn', true, e]);
|
||||
assert.match(u.def.raw.talents.find((t) => t.index === 0).desc, /灼燃损伤.*爆发期间.*50%的元素伤害/);
|
||||
}
|
||||
// the 灼地 ticks are attacks of hers too (the equip adds it to every ability family)
|
||||
u.skill.gainSp(999);
|
||||
h.runUntil(() => u.skill.active, 4);
|
||||
h.run(2.5);
|
||||
const onTicks = el().filter((c) => c.t > h.hooksOf('skillStart').at(-1).t);
|
||||
assert.equal(onTicks.length, extra ? 3 : 0, `T${tier} ${mod}: one per 灼地 tick (0.4 / 1.4 / 2.4 s)`);
|
||||
assert.ok(!el().some((c) => c.target === calm), `T${tier} ${mod}: none on an enemy outside a burst`);
|
||||
done(h);
|
||||
}
|
||||
});
|
||||
|
||||
test('T2 莱茵回路: +2 SP every 6 s of a deployment; BLA-X stage 3: a 30 % roll for +5 SP more each 6 s (none in any other form)', () => {
|
||||
for (const f of FORMS_ALL) {
|
||||
const [tier, elite, mod] = f;
|
||||
const { h, u } = field({ tier, elite, mod, skill: 0, seed: 21 });
|
||||
const dice = elite && tier === 6 && mod === BLAX;
|
||||
const t1 = u.def.raw.talents.find((t) => t.index === 1).bb;
|
||||
assert.deepEqual([t1.sp, t1.interval, t1['ifrit_e_002[dice_sp].prob'] ?? 0, t1['ifrit_e_002[dice_sp].sp'] ?? 0], [2, 6, dice ? 0.3 : 0, dice ? 5 : 0], label(f));
|
||||
const gains = () => h.hooksOf('spGain').filter((c) => c.unit === u && c.reason === 'talent');
|
||||
for (let i = 0; i < 60; i++) { u.skill.sp = 0; h.run(6); }
|
||||
const g = gains();
|
||||
const twos = g.filter((c) => c.amount === 2).length, fives = g.filter((c) => c.amount === 5).length;
|
||||
assert.ok(twos >= 59 && twos <= 60, `${label(f)}: ${twos} gifts of 2 SP in 360 s`);
|
||||
if (dice) assert.ok(fives >= 9 && fives <= 30, `${label(f)}: ${fives} / 60 rolls of +5 ≈ 30 %`);
|
||||
else assert.equal(fives, 0, `${label(f)}: no roll`);
|
||||
done(h);
|
||||
}
|
||||
});
|
||||
|
||||
test('BLA-X “同熔” (stages 1 and 3): ×(1 + 0.1 × d / 4) by the distance to the target, capped at 4 tiles — on her attacks, the 灼伤 while she stands and the 灼地 ticks; none without it', () => {
|
||||
for (const f of FORMS_ALL) {
|
||||
const [tier, elite, mod] = f;
|
||||
const { h, u } = field({ tier, elite, mod, skill: 0 });
|
||||
const blax = elite && mod === BLAX;
|
||||
if (blax) assert.deepEqual(u.def.raw.trait.bb, { min_dist: 0, max_dist: 4, damage_scale: 0.1 }, label(f));
|
||||
const at = [5, 6, 8, 9].map((c) => h.spawn('enemy_dummy', { pos: [10, c] }));
|
||||
const n0 = atkHits(h, u).length;
|
||||
h.runUntil(() => atkHits(h, u).length >= n0 + 4, 4);
|
||||
const hits = atkHits(h, u).slice(n0, n0 + 4);
|
||||
for (const [i, d] of [[0, 1], [1, 2], [2, 4], [3, 5]]) {
|
||||
const c = hits.find((x) => x.target === at[i]);
|
||||
approx(c.amount, u.s.atk * (blax ? 1 + 0.1 * Math.min(1, d / 4) : 1), `${label(f)}: d = ${d}`);
|
||||
}
|
||||
done(h);
|
||||
}
|
||||
// the 灼伤 while she stands and after she left; the 灼地 tick
|
||||
for (const [skill, tag] of [[1, 'ifrit:burn'], [2, 'ifrit:scorch']]) {
|
||||
const { h, u } = field({ tier: 6, elite: true, mod: BLAX, skill });
|
||||
const e = h.spawn('enemy_dummy', { pos: [10, 8] }); // 4 tiles: ×1.1
|
||||
u.skill.gainSp(999);
|
||||
h.runUntil(() => tagged(h, u, tag).filter((c) => c.type === 'arts').length >= 1, 6);
|
||||
const c = tagged(h, u, tag).find((x) => x.type === 'arts' && x.target === e);
|
||||
const scale = skill === 1 ? 0.33 : skillOf(6, true, S3).bb.atk_scale;
|
||||
approx(c.amount, u.s.atk * scale * 1.1, `${tag}: ×1.1 at 4 tiles`);
|
||||
if (skill === 1) {
|
||||
h.b.retreat(u);
|
||||
h.run(2.1);
|
||||
const after = tagged(h, u, tag).filter((x) => x.target === e).at(-1);
|
||||
approx(after.amount, u.s.atk * scale, '灼伤 after she left: no module effect');
|
||||
}
|
||||
done(h);
|
||||
}
|
||||
});
|
||||
|
||||
test('BLA-D “热成形记忆” (stages 1 and 3): every arts damage she deals while on the field attaches 8 % of it as 灼燃损伤 — her attacks and the 灼伤 — and no 元素损伤 without it', () => {
|
||||
for (const f of FORMS_ALL) {
|
||||
const [tier, elite, mod] = f;
|
||||
const { h, u } = field({ tier, elite, mod, skill: 1 });
|
||||
const blad = elite && mod === BLAD;
|
||||
if (blad) assert.equal(u.def.raw.trait.bb.ep_damage_ratio, 0.08, label(f));
|
||||
const e = h.spawn('enemy_dummy', { pos: [10, 7] });
|
||||
u.skill.gainSp(999);
|
||||
h.runUntil(() => tagged(h, u, 'ifrit:burn').length >= 2, 6);
|
||||
const arts = h.hooksOf('damaged').filter((c) => c.source === u && c.target === e && c.type === 'arts').reduce((s, c) => s + c.amount, 0);
|
||||
approx(e.elem.burn, blad ? arts * 0.08 : 0, `${label(f)}: 8 % of ${Math.round(arts)} arts damage as 灼燃损伤`);
|
||||
done(h);
|
||||
}
|
||||
});
|
||||
@@ -0,0 +1,292 @@
|
||||
// test/content/op_lin.test.js — the 自选 operator kit of 林 (char_4080_lin, 6★ 阵法术师; kit
|
||||
// server/sim/content/kits/ops/op-lin.js), fielded the production way (a DIY slot + its `diy` pick, simdata getDiy) in
|
||||
// every form: tiers 5 / 6, normal (E2 Lv1, skill rank 4, no module) and elite (E2 Lv60, rank 7) with no module, PLX-X
|
||||
// “七窍玲珑” or PLX-Y “情与义” at stage 1 (tier 5) / 3 (tier 6). Every number is read back from data/backups.json (the form
|
||||
// of that slot status); the fidelity checklist of kits/README.md item by item.
|
||||
// Run: node --test test/content/op_lin.test.js
|
||||
|
||||
import { test } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { readFileSync } from 'node:fs';
|
||||
import { makeBattle, enemyRec, checkInvariants } from '../helpers/battleHarness.js';
|
||||
import { KITTED_CHARS, OPERATOR_KITS, KITS } from '../../server/sim/content/kits/index.js';
|
||||
import { diyPool, validateDiyPicks } from '../../shared/diy.js';
|
||||
|
||||
const load = (f) => JSON.parse(readFileSync(new URL(`../../data/${f}.json`, import.meta.url), 'utf8'));
|
||||
const CHESS = load('chess');
|
||||
const BACKUPS = load('backups');
|
||||
const LIN = 'char_4080_lin';
|
||||
const FORMS = BACKUPS.units[LIN].forms;
|
||||
const SLOT = { 5: 'chess_char_5_diy1_a', 6: 'chess_char_6_diy1_a' };
|
||||
const PLXX = 'uniequip_002_lin', PLXY = 'uniequip_003_lin';
|
||||
const S1 = 'skchr_lin_1', S2 = 'skchr_lin_2', S3 = 'skchr_lin_3';
|
||||
const formOf = (tier, elite) => FORMS[elite ? (tier === 5 ? '2/60/7/1' : '2/60/7/3') : '2/1/4/0'];
|
||||
const skillOf = (tier, elite, id) => formOf(tier, elite).skills.find((s) => s.skillId === id);
|
||||
const modOf = (tier, mod) => (mod ? formOf(tier, true).modules.find((m) => m.uniEquipId === mod) : null);
|
||||
const approx = (a, b, msg, eps = 1e-6) => assert.ok(Math.abs(a - b) <= eps * Math.max(1, Math.abs(b)), `${msg}: ${a} vs ${b}`);
|
||||
const dummy = (key, o = {}) => enemyRec({ key, hp: 1e9, speed: 0, mass: 0, ...o });
|
||||
const ENEMIES = { enemy_dummy: dummy('enemy_dummy'), enemy_fly: dummy('enemy_fly', { motion: 'FLY' }), enemy_weak: dummy('enemy_weak', { hp: 10 }) };
|
||||
const FORMS_ALL = [[5, false, null], [6, false, null], ...[5, 6].flatMap((t) => [null, PLXX, PLXY].map((m) => [t, true, m]))];
|
||||
const label = ([tier, elite, mod]) => `T${tier} ${elite ? 'elite' : 'normal'} ${mod ?? 'none'}`;
|
||||
/** Her x-1 (and x-2) range from (10, 5) facing RIGHT, as [row, col]. */
|
||||
const X1 = [[12, 5], [11, 4], [11, 5], [11, 6], [10, 3], [10, 4], [10, 5], [10, 6], [10, 7], [9, 4], [9, 5], [9, 6], [8, 5]];
|
||||
|
||||
/** A battle with 林 as uid 1 at (10, 5) facing RIGHT, plus `others`. */
|
||||
function field({ tier = 5, elite = false, mod = null, skill = 0, others = [], seed = 5, setup = null } = {}) {
|
||||
const h = makeBattle({
|
||||
defs: { enemies: ENEMIES }, timeLimit: 900, autoFinish: false, seed, setup,
|
||||
flags: { dpPerSec: 0, dpMax: 999 }, hooks: ['damaged', 'skillStart', 'skillEnd', 'statusApplied', 'spGain'], captureNoisy: true,
|
||||
units: [{ uid: 1, diy: { slot: SLOT[tier], charId: LIN, skillIndex: skill, uniEquipId: mod }, elite, row: 10, col: 5 }, ...others],
|
||||
});
|
||||
h.step();
|
||||
return { h, u: h.unit(1) };
|
||||
}
|
||||
const atkHits = (h, u) => h.hooksOf('damaged').filter((c) => c.source === u && c.dmg?.isAttack);
|
||||
const glassHits = (h, u) => h.hooksOf('damaged').filter((c) => c.source === u && c.dmg?.tags?.includes('lin:glass'));
|
||||
const glassOf = (a) => a.findBuff('lin:glass');
|
||||
/** True damage straight to `t` from `src` (no DEF / RES: the exact amount meets the 琉璃璧). */
|
||||
const hurt = (h, src, t, n) => h.b.dealDamage(src, t, { amount: n, type: 'true' });
|
||||
function done(h) {
|
||||
checkInvariants(h.b);
|
||||
assert.equal(h.b.errors.length, 0, JSON.stringify(h.b.errors[0]));
|
||||
}
|
||||
|
||||
test('林 in every 自选 form: her operator kit (all three skills authored), the form\'s stats + module attributes, x-1 range, 阵法术师 (no attack and the guard while no skill runs; every enemy of her range, air too, while one does)', () => {
|
||||
assert.equal(OPERATOR_KITS[LIN], KITS[LIN]);
|
||||
for (const f of FORMS_ALL) {
|
||||
const [tier, elite, mod] = f;
|
||||
for (const skill of [0, 1, 2]) {
|
||||
const { h, u } = field({ tier, elite, mod, skill });
|
||||
const form = formOf(tier, elite), m = elite ? modOf(tier, mod) : null;
|
||||
assert.deepEqual([u.def.charId, u.def.diyFor, u.skill.id, !!u.kit.generic, u.kit.skillSource], [LIN, SLOT[tier], form.skills[skill].skillId, false, 'skills'], label(f));
|
||||
assert.deepEqual([u.base.maxHp, u.base.atk, u.base.def, u.base.res, u.base.bat], [form.stats.maxHp + (m?.attr.maxHp ?? 0), form.stats.atk + (m?.attr.atk ?? 0), form.stats.def + (m?.attr.def ?? 0), 15, 2], `${label(f)}: stats`);
|
||||
assert.deepEqual([u.profile.noAttackUnlessSkill, u.profile.allInRange, u.profile.canHitFly, u.profile.dmgType, u.profile.projectile], [true, true, true, 'arts', 'beam'], `${label(f)}: 阵法术师`);
|
||||
const plxx = elite && mod === PLXX;
|
||||
assert.deepEqual([u.profile.guardDef, u.profile.guardRes], plxx ? [2.15, 25] : [2, 20], `${label(f)}: trait tunables`);
|
||||
assert.deepEqual(u.liveRangeGrid, form.rangeGrid, `${label(f)}: x-1`);
|
||||
assert.deepEqual([u.def.bonds, u.def.raw.garrisonIds], [BACKUPS.diy.operators[LIN].bonds, []], `${label(f)}: bonds / 特质`);
|
||||
assert.ok(!u.s.flags.liftoff && !u.s.flags.camou && !u.s.flags.stealth, `${label(f)}: enemies target her`);
|
||||
done(h);
|
||||
}
|
||||
}
|
||||
// E2 Lv1 1679 / 730 / 212, E2 Lv60 1924 / 809 / 232; PLX-X +62 / +45 → +77 / +53 ATK / DEF, PLX-Y +50 / +20 → +73 / +40
|
||||
assert.deepEqual([FORMS['2/1/4/0'].stats.maxHp, FORMS['2/1/4/0'].stats.atk, FORMS['2/60/7/1'].stats.maxHp, FORMS['2/60/7/1'].stats.atk], [1679, 730, 1924, 809]);
|
||||
assert.deepEqual([modOf(5, PLXX).attr, modOf(6, PLXX).attr, modOf(5, PLXY).attr, modOf(6, PLXY).attr], [{ atk: 62, def: 45 }, { atk: 77, def: 53 }, { atk: 50, def: 20 }, { atk: 73, def: 40 }]);
|
||||
});
|
||||
|
||||
test('a 自选 pick: 林 is offered at tiers 5 and 6 (she has a kit) and a roster with her passes validateDiyPicks', () => {
|
||||
const data = { chess: CHESS, backups: BACKUPS };
|
||||
assert.ok(KITTED_CHARS.includes(LIN));
|
||||
for (const t of [5, 6]) assert.ok(diyPool(t, { data, kitted: KITTED_CHARS }).includes(LIN), `tier ${t}`);
|
||||
assert.deepEqual(validateDiyPicks({ [SLOT[5]]: { charId: LIN, skillIndex: 0, uniEquipId: PLXX } }, { data, kitted: KITTED_CHARS }),
|
||||
{ ok: true, picks: { [SLOT[5]]: { charId: LIN, skillIndex: 0, uniEquipId: PLXX } } });
|
||||
});
|
||||
|
||||
test('trait + PLX-X: DEF ×3 / RES +20 while no skill runs (PLX-X ×3.15 / +25); while one runs the guard is off — PLX-X keeps DEF +100 % / RES +10 (stages 1 and 3)', () => {
|
||||
for (const f of FORMS_ALL) {
|
||||
const [tier, elite, mod] = f;
|
||||
const { h, u } = field({ tier, elite, mod, skill: 1 });
|
||||
const plxx = elite && mod === PLXX;
|
||||
if (plxx) assert.deepEqual(u.def.raw.trait.bb, { def: 2.15, magic_resistance: 25, 'lin_e_002[buff].def': 1, 'lin_e_002[buff].magic_resistance': 10 }, label(f));
|
||||
approx(u.s.def, u.base.def * (1 + (plxx ? 2.15 : 2)), `${label(f)}: guard DEF`);
|
||||
approx(u.s.res, 15 + (plxx ? 25 : 20), `${label(f)}: guard RES`);
|
||||
h.run(1);
|
||||
assert.equal(atkHits(h, u).length, 0, `${label(f)}: no attack while no skill runs`);
|
||||
u.skill.gainSp(999);
|
||||
h.spawn('enemy_dummy', { pos: [10, 6] });
|
||||
assert.ok(h.runUntil(() => u.skill.active, 1), `${label(f)}: 荫庇`);
|
||||
approx(u.s.def, u.base.def * (1 + (plxx ? 1 : 0)), `${label(f)}: skill DEF`);
|
||||
approx(u.s.res, 15 + (plxx ? 10 : 0), `${label(f)}: skill RES`);
|
||||
h.runUntil(() => !u.skill.active, 30);
|
||||
approx(u.s.def, u.base.def * (1 + (plxx ? 2.15 : 2)), `${label(f)}: the guard is back`);
|
||||
done(h);
|
||||
}
|
||||
});
|
||||
|
||||
test('S1 玲珑 (MANUAL, data SEARCH, a 状态切换类 skill: switched on once and kept): cast as soon as an enemy is in her range; ATK +25 % / +40 %, interval 2 → 3 s, every enemy of her range (air too) 停顿 0.8 / 0.9 s per attack', () => {
|
||||
for (const [tier, elite] of [[5, false], [6, true]]) {
|
||||
const sk = skillOf(tier, elite, S1);
|
||||
const { h, u } = field({ tier, elite, skill: 0 });
|
||||
assert.deepEqual([u.skill.rule, u.skill.kind, sk.bb.atk, sk.bb['attack@sluggish'], sk.bb.base_attack_time, u.skill.spCost], ['SEARCH', 'toggle', elite ? 0.4 : 0.25, elite ? 0.9 : 0.8, 1, elite ? 6 : 8], `T${tier}`);
|
||||
u.skill.gainSp(999);
|
||||
h.run(1);
|
||||
assert.equal(u.skill.activations, 0, `T${tier}: nobody in range`);
|
||||
const a = h.spawn('enemy_dummy', { pos: [10, 7] }), b = h.spawn('enemy_fly', { pos: [11, 5] }), off = h.spawn('enemy_dummy', { pos: [10, 8] });
|
||||
assert.ok(h.runUntil(() => u.skill.active, 0.2), `T${tier}: cast at once (SEARCH)`);
|
||||
approx(u.s.atk, u.base.atk * (1 + sk.bb.atk), `T${tier}: ATK`);
|
||||
approx(u.s.interval, 3, `T${tier}: 3 s`);
|
||||
h.runUntil(() => atkHits(h, u).length >= 2, 4);
|
||||
const hits = atkHits(h, u);
|
||||
assert.deepEqual(hits.map((c) => c.target.id).sort(), [a.id, b.id].sort(), `T${tier}: both in range, air too`);
|
||||
for (const c of hits) { approx(c.amount, u.s.atk, `T${tier}: 100 % ATK`); assert.equal(c.type, 'arts', `T${tier}: arts`); }
|
||||
assert.deepEqual(u.liveRangeGrid, formOf(tier, elite).rangeGrid, `T${tier}: x-1 while it runs`);
|
||||
const slow = h.hooksOf('statusApplied').filter((c) => c.source === u && c.status === 'sluggish');
|
||||
assert.deepEqual(slow.map((c) => c.target.id).sort(), [a.id, b.id].sort(), `T${tier}: 停顿 on each`);
|
||||
for (const c of slow) approx(c.duration, sk.bb['attack@sluggish'], `T${tier}: 停顿 ${sk.bb['attack@sluggish']} s`);
|
||||
assert.ok(!hits.some((c) => c.target === off), `T${tier}: outside x-1`);
|
||||
h.run(120);
|
||||
assert.deepEqual([u.skill.active, u.skill.activations], [true, 1], `T${tier}: kept on`);
|
||||
done(h);
|
||||
}
|
||||
});
|
||||
|
||||
test('S2 荫庇 (MANUAL, data SEARCH, 25 s): ASPD +50 / +90, taunt −1; every allied unit of her range gets its own 琉璃璧 (threshold 200, Lin\'s ATK, centred on it, its own regrowth), lost at the end; none outside', () => {
|
||||
for (const [tier, elite, mod] of [[5, false, null], [6, true, PLXY]]) {
|
||||
const sk = skillOf(tier, elite, S2);
|
||||
const t0 = formOf(tier, elite).modules?.find((m) => m.uniEquipId === mod)?.talentChanges.find((t) => t.talentIndex === 0)?.bb ?? formOf(tier, elite).talents[0].bb;
|
||||
const others = [{ uid: 2, chessId: 'chess_char_1_02_a', row: 10, col: 6 }, { uid: 3, chessId: 'chess_char_1_02_a', row: 12, col: 9 }];
|
||||
const { h, u } = field({ tier, elite, mod, skill: 1, others });
|
||||
const near = h.unit(2), far = h.unit(3);
|
||||
assert.deepEqual([u.skill.rule, sk.duration, sk.bb.attack_speed, sk.bb.taunt_level], ['SEARCH', 25, elite ? 90 : 50, -1], `T${tier}`);
|
||||
assert.equal(glassOf(near), null, `T${tier}: no copy before the skill`);
|
||||
u.skill.gainSp(999);
|
||||
const e0 = h.spawn('enemy_dummy', { pos: [11, 5] });
|
||||
assert.ok(h.runUntil(() => u.skill.active, 0.5), `T${tier}: cast`);
|
||||
h.run(0.2);
|
||||
assert.deepEqual([u.s.aspd, u.s.taunt], [100 + sk.bb.attack_speed, -1], `T${tier}: ASPD / taunt`);
|
||||
assert.deepEqual([glassOf(near)?.shield, glassOf(near)?.source === u, glassOf(far)], [200, true, null], `T${tier}: a copy in range only`);
|
||||
// the copy breaks on a hit over 200: burst on Lin's range centred on the ally, Lin's ATK, source Lin
|
||||
const inBurst = h.spawn('enemy_dummy', { pos: [10, 8] }), outBurst = h.spawn('enemy_dummy', { pos: [10, 9] });
|
||||
h.step();
|
||||
const hp0 = near.hp;
|
||||
hurt(h, e0, near, 300);
|
||||
approx(hp0 - near.hp, 100, `T${tier}: 300 − 200 through`);
|
||||
assert.equal(glassOf(near), null, `T${tier}: broken`);
|
||||
const gh = glassHits(h, u);
|
||||
assert.ok(gh.some((c) => c.target === inBurst) && !gh.some((c) => c.target === outBurst), `T${tier}: centred on the ally`);
|
||||
approx(gh.find((c) => c.target === inBurst).amount, u.s.atk * t0.atk_scale * (mod === PLXY ? 1 + 0.03 : 1), `T${tier}: ${t0.atk_scale * 100} % Lin ATK`);
|
||||
assert.ok(h.hooksOf('statusApplied').some((c) => c.source === u && c.status === 'stun' && c.target === inBurst), `T${tier}: stunned`);
|
||||
h.run(t0.interval - 0.2);
|
||||
assert.equal(glassOf(near), null, `T${tier}: not before ${t0.interval} s`);
|
||||
h.run(0.4);
|
||||
assert.equal(glassOf(near)?.shield, 200, `T${tier}: back after ${t0.interval} s`);
|
||||
h.runUntil(() => !u.skill.active, 30);
|
||||
assert.equal(glassOf(near), null, `T${tier}: gone with the skill`);
|
||||
assert.ok(glassOf(u), `T${tier}: hers stays`);
|
||||
done(h);
|
||||
}
|
||||
});
|
||||
|
||||
test('S3 流光乍裂 (MANUAL, data CUSTOM_RANGE x-2, 26 / 28 s): cast with an enemy in x-2; range x-2 while on (bursts too), back after; ATK +125 % / +160 %; her 琉璃璧 threshold ×2 / ×2.5; a knock-out by her attack breaks it (burst) and raises it at once', () => {
|
||||
for (const [tier, elite] of [[5, false], [6, true]]) {
|
||||
const sk = skillOf(tier, elite, S3);
|
||||
const { h, u } = field({ tier, elite, skill: 2 });
|
||||
assert.deepEqual([u.skill.rule, sk.duration, sk.bb.atk, sk.bb.talent_scale, sk.rangeId], ['CUSTOM_RANGE', elite ? 28 : 26, elite ? 1.6 : 1.25, elite ? 2.5 : 2, 'x-2'], `T${tier}`);
|
||||
assert.deepEqual(sk.trigger.customRangeGrid, sk.rangeGrid);
|
||||
u.skill.gainSp(999);
|
||||
const e = h.spawn('enemy_dummy', { pos: [11, 7] }); // x-2 [1, 2], not x-1
|
||||
assert.ok(h.runUntil(() => u.skill.active, 0.5), `T${tier}: cast with an enemy in x-2`);
|
||||
assert.deepEqual(u.liveRangeGrid, sk.rangeGrid, `T${tier}: x-2`);
|
||||
approx(u.s.atk, u.base.atk * (1 + sk.bb.atk), `T${tier}: ATK`);
|
||||
const thr = 200 * sk.bb.talent_scale;
|
||||
assert.equal(glassOf(u).shield, thr, `T${tier}: threshold ${thr}`);
|
||||
const hp0 = u.hp;
|
||||
hurt(h, e, u, 450);
|
||||
if (thr > 450) { assert.equal(u.hp, hp0, `T${tier}: 450 absorbed`); assert.ok(glassOf(u)); } else { approx(hp0 - u.hp, 450 - thr, `T${tier}: 450 − ${thr}`); assert.equal(glassOf(u), null); }
|
||||
// a knock-out by her attack: burst (x-2 around her) and the 琉璃璧 standing again at once
|
||||
if (!glassOf(u)) { h.run(9); assert.ok(glassOf(u), `T${tier}: regrown`); }
|
||||
const witness = h.spawn('enemy_dummy', { pos: [9, 3] }); // x-2 [−1, −2]
|
||||
const weak = h.spawn('enemy_weak', { pos: [10, 6] });
|
||||
h.step();
|
||||
const g0 = glassHits(h, u).length;
|
||||
h.runUntil(() => !weak.alive, 4);
|
||||
h.step();
|
||||
assert.ok(glassHits(h, u).slice(g0).some((c) => c.target === witness), `T${tier}: the kill's burst reaches x-2`);
|
||||
assert.equal(glassOf(u)?.shield, thr, `T${tier}: raised again at once`);
|
||||
h.runUntil(() => !u.skill.active, 40);
|
||||
assert.deepEqual(u.liveRangeGrid, formOf(tier, elite).rangeGrid, `T${tier}: x-1 again`);
|
||||
assert.equal(glassOf(u)?.shield, 200, `T${tier}: plain threshold again`);
|
||||
done(h);
|
||||
}
|
||||
});
|
||||
|
||||
test('T1 计出万全 (every form): a 琉璃璧 from deployment — a hit ≤ 200 absorbed whole, a hit over 200 goes through less 200 and breaks it: stun 1 s first, then 100 % / 110 % ATK arts on her range, regrowing after 8 s / 6 s (PLX-Y stage 3); a lethal hit still breaks it', () => {
|
||||
for (const f of FORMS_ALL) {
|
||||
const [tier, elite, mod] = f;
|
||||
const order = [];
|
||||
const { h, u } = field({ tier, elite, mod, skill: 2, setup: (b) => {
|
||||
b.on('statusApplied', (c) => { if (c.status === 'stun' && c.source?.uid === 1) order.push('stun'); });
|
||||
b.on('damaged', (c) => { if (c.dmg?.tags?.includes('lin:glass')) order.push(c.target.s.flags.stun ? 'hit-stunned' : 'hit'); });
|
||||
} });
|
||||
const t0 = u.def.raw.talents.find((t) => t.index === 0).bb;
|
||||
const y3 = elite && tier === 6 && mod === PLXY;
|
||||
assert.deepEqual([t0.value, t0.atk_scale, t0.stun, t0.interval], [200, y3 ? 1.1 : 1, 1, y3 ? 6 : 8], label(f));
|
||||
assert.equal(glassOf(u)?.shield, 200, `${label(f)}: up from deployment`);
|
||||
const e = h.spawn('enemy_dummy', { pos: [10, 7] }), out = h.spawn('enemy_dummy', { pos: [10, 9] });
|
||||
h.step();
|
||||
const hp0 = u.hp;
|
||||
hurt(h, e, u, 150);
|
||||
hurt(h, e, u, 200);
|
||||
assert.deepEqual([u.hp, glassOf(u)?.shield], [hp0, 200], `${label(f)}: 150 and 200 absorbed, full again`);
|
||||
hurt(h, e, u, 300);
|
||||
approx(hp0 - u.hp, 100, `${label(f)}: 300 − 200`);
|
||||
assert.equal(glassOf(u), null, `${label(f)}: broken`);
|
||||
const gh = glassHits(h, u);
|
||||
assert.deepEqual(gh.map((c) => c.target.id), [e.id], `${label(f)}: her range only`);
|
||||
const plxy = elite && mod === PLXY ? 1 + 0.03 * 1 : 1;
|
||||
approx(gh[0].amount, u.s.atk * t0.atk_scale * plxy, `${label(f)}: ${t0.atk_scale * 100} % ATK`);
|
||||
assert.deepEqual(order, ['stun', 'hit-stunned'], `${label(f)}: stun first`);
|
||||
assert.ok(!h.hooksOf('statusApplied').some((c) => c.target === out && c.status === 'stun'), `${label(f)}: none outside`);
|
||||
h.run(t0.interval - 0.1);
|
||||
assert.equal(glassOf(u), null, `${label(f)}: not yet`);
|
||||
h.run(0.2);
|
||||
assert.equal(glassOf(u)?.shield, 200, `${label(f)}: back after ${t0.interval} s`);
|
||||
// a lethal hit: the burst still comes
|
||||
const n0 = glassHits(h, u).length;
|
||||
hurt(h, e, u, u.hp + 1000);
|
||||
assert.equal(u.alive, false, `${label(f)}: knocked out`);
|
||||
assert.equal(glassHits(h, u).length, n0 + 1, `${label(f)}: the lethal hit broke it`);
|
||||
done(h);
|
||||
}
|
||||
});
|
||||
|
||||
test('T2 韬光: each damage instance she takes rolls 50 % for +1 SP (PLX-X stage 3: 75 %, +2) — one the 琉璃璧 absorbs whole too; a 流失 never', () => {
|
||||
for (const f of FORMS_ALL) {
|
||||
const [tier, elite, mod] = f;
|
||||
const { h, u } = field({ tier, elite, mod, skill: 2, seed: 33 });
|
||||
const x3 = elite && tier === 6 && mod === PLXX;
|
||||
const t1 = u.def.raw.talents.find((t) => t.index === 1).bb;
|
||||
assert.deepEqual([t1.prob, t1.sp], x3 ? [0.75, 2] : [0.5, 1], label(f));
|
||||
const e = h.spawn('enemy_dummy', { pos: [10, 9] });
|
||||
h.step();
|
||||
const gains = () => h.hooksOf('spGain').filter((c) => c.unit === u && c.reason === 'talent');
|
||||
const hp0 = u.hp;
|
||||
for (let i = 0; i < 200; i++) { if (i % 10 === 0) u.skill.sp = 0; hurt(h, e, u, 50); }
|
||||
assert.equal(u.hp, hp0, `${label(f)}: all absorbed`);
|
||||
const absorbed = gains();
|
||||
assert.ok(Math.abs(absorbed.length / 200 - t1.prob) < 0.12, `${label(f)}: absorbed hits roll too: ${absorbed.length} / 200 ≈ ${t1.prob * 100} %`);
|
||||
assert.ok(absorbed.every((c) => c.amount === t1.sp), `${label(f)}: +${t1.sp} SP`);
|
||||
hurt(h, e, u, 400); // breaks it: 200 through
|
||||
const n0 = gains().length;
|
||||
for (let i = 0; i < 200; i++) { if (i % 10 === 0) u.skill.sp = 0; hurt(h, e, u, 1); }
|
||||
const g = gains().slice(n0);
|
||||
assert.ok(Math.abs(g.length / 200 - t1.prob) < 0.12, `${label(f)}: ${g.length} / 200 ≈ ${t1.prob * 100} %`);
|
||||
const n1 = gains().length;
|
||||
for (let i = 0; i < 50; i++) { u.skill.sp = 0; h.b.loseHp(u, 1, { source: e }); }
|
||||
assert.equal(gains().length, n1, `${label(f)}: a 流失 rolls nothing`);
|
||||
done(h);
|
||||
}
|
||||
});
|
||||
|
||||
test('PLX-Y “情与义” (stages 1 and 3): +3 % damage per enemy on her range, at most 5 (+15 %); none without it', () => {
|
||||
for (const f of FORMS_ALL.filter(([, elite]) => elite)) {
|
||||
const [tier, , mod] = f;
|
||||
const plxy = mod === PLXY;
|
||||
for (const n of [2, 7]) {
|
||||
const { h, u } = field({ tier, elite: true, mod, skill: 0 });
|
||||
if (plxy) assert.deepEqual(u.def.raw.talents.filter((t) => t.index === -1).map((t) => t.bb), [{ damage_scale: 0.03, max_valid_stack_cnt: 5 }], label(f));
|
||||
const tiles = [[10, 6], [10, 7], [11, 5], [9, 5], [11, 4], [9, 4], [11, 6]].slice(0, n);
|
||||
for (const p of tiles) h.spawn('enemy_dummy', { pos: p });
|
||||
u.skill.gainSp(999);
|
||||
h.runUntil(() => atkHits(h, u).length >= n, 5);
|
||||
for (const c of atkHits(h, u).slice(0, n)) approx(c.amount, u.s.atk * (plxy ? 1 + 0.03 * Math.min(5, n) : 1), `${label(f)}: ${n} enemies`);
|
||||
done(h);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
test('the x-1 grid of the tests is her data range (from (10, 5) facing RIGHT)', () => {
|
||||
const { h, u } = field({});
|
||||
assert.deepEqual([...u.rangeKeys].sort((a, b) => a - b), X1.map(([r, c]) => r * 21 + c).sort((a, b) => a - b));
|
||||
done(h);
|
||||
});
|
||||
Reference in new issue
Block a user