feedback5 O7: 自选 operator kits for 早露, 提丰 and 娜仁图亚 — every skill, talent, trait and module at every form
- kits/ops/op-poca.js 早露 (攻城手): heaviest first; 深入骨髓 60 % DEF ignore vs 重量等级 ≥ 3; 学生楷模 ATK on every 【乌萨斯学生自治团】 operator of her team (teamId student); S1 ATK, S2 ATK + 2 targets, S3 雪崩击 links the 3 heaviest, binds them and strikes each every second (6 / 7 attacks, PRTS link-break rules); SIE-X ×1.15 vs heavy + Lv3 60 % ATK extra hit; SIE-Y distance bonus ≤ 12 % + Lv3 学生楷模 +12 % and +15 % per student in skill (≤ 45 %). - kits/ops/op-typhon.js 提丰 (攻城手): 锐如兽牙 stacking DEF ignore; 重如沼泥 first hit per enemy per cast ×1.6 + 停顿 3 s; S1 ATK / ASPD; S2 two arrows (both at a lone enemy), 40 % stun, 20 s on the first cast of a deployment then endless; S3 永恒狩猎 mark (radius 1.3, follows its enemy), whole-field range, 4-arrow rain per bullet with 0.4 s stuns; SIE-X ×1.15, Lv3 12 % / 10 s; SIE-Y distance bonus, Lv3 two marks ×2.2; ISW-A attributes only (集成战略 parts N/A). - kits/ops/op-narant.js 娜仁图亚 (回环射手): 偷取 25 ATK / 20 DEF per landing attack hit (caps 250 / 200; LPS-X Lv3 300 / 240, twice within one tile; the largest thief wins; given back when she leaves); 婀娜虚影 35 % dodge and −20 % 命中率 for enemies within one tile (LPS-Y Lv3 −30 % and ATK +15 % after 6 s unhurt); S1 旋刃 toggle, range −1, up to 3 bounces; S2 恶魇 dash and the sweep on its way back; S3 吞日 3 boomerangs and the recall blast; LPS-X ×1.1 within one tile; LPS-Y 1 SP per 5 boomerangs caught. - Data triggers unchanged (all nine skills MANUAL / DEFAULT). Registered in OPERATOR_KIT_FILES (one line per file). - Tests: test/content/op_poca.test.js (11), op_typhon.test.js (12), op_narant.test.js (11, two on the engine hooks). - Golden: test/golden/diy.json only — diy-003 … diy-009 now field the three kits in every form × module × skill, the prototypes / 预备干员 re-packed into diy-009 … diy-013; diy-001 / diy-002 (推进之王) and every other family unchanged.
This commit is contained in:
sganggs committed
1 parent
12fa92d9f6
commit
5643dab2cb
8 files changed
+2104
-100
No files matched your search
@@ -0,0 +1,376 @@
|
||||
// test/content/op_narant.test.js — the 自选 operator kit of 娜仁图亚 (char_4138_narant, 6★ 回环射手; kit
|
||||
// server/sim/content/kits/ops/op-narant.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, LPS-X
|
||||
// “吹尽狂沙” or LPS-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. Also the two engine hooks of the
|
||||
// boomerang flight it relies on (ai.js throwBoomerang: `boomerangCaught`, a profile's `boomerangOnward`).
|
||||
// Run: node --test test/content/op_narant.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';
|
||||
import { PROJECTILE_SPEEDS, BOOMERANG_RETURN_SPEED } from '../../server/sim/constants.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 NARANT = 'char_4138_narant';
|
||||
const FORMS = BACKUPS.units[NARANT].forms;
|
||||
const SLOT = { 5: 'chess_char_5_diy1_a', 6: 'chess_char_6_diy1_a' };
|
||||
const LPSX = 'uniequip_002_narant', LPSY = 'uniequip_003_narant';
|
||||
const S1 = 'skchr_narant_1', S2 = 'skchr_narant_2', S3 = 'skchr_narant_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_brute: dummy('enemy_brute', { atk: 400, def: 300 }),
|
||||
enemy_fly: dummy('enemy_fly', { motion: 'FLY' }),
|
||||
// a ranged attacker that shoots twice a second at whatever ally its 2.5-tile radius holds (an ATK her steals cannot drain)
|
||||
enemy_shooter: dummy('enemy_shooter', { atk: 5000, bat: 0.5, range: 2.5 }),
|
||||
};
|
||||
/** Every 自选 form: [tier, elite, module]. */
|
||||
const FORMS_ALL = [[5, false, null], [6, false, null], ...[5, 6].flatMap((t) => [null, LPSX, LPSY].map((m) => [t, true, m]))];
|
||||
/** LPS-Y stage 3 婀娜虚影: ATK +15 % while unhurt — she starts unhurt. */
|
||||
const calmAtk = (tier, elite, mod) => (elite && mod === LPSY && tier === 6 ? 0.15 : 0);
|
||||
|
||||
/** A battle with 娜仁图亚 as uid 1 at (row, col) facing RIGHT, plus `others`. */
|
||||
function field({ tier = 5, elite = false, mod = null, skill = 0, row = 10, col = 3, others = [], seed = 5, hooks = [] } = {}) {
|
||||
const h = makeBattle({
|
||||
defs: { enemies: ENEMIES }, timeLimit: 900, autoFinish: false, seed,
|
||||
flags: { dpPerSec: 0, dpMax: 999 }, hooks: ['damaged', 'skillStart', 'skillEnd', 'statusApplied', 'boomerangCaught', 'spGain', 'attack', ...hooks], captureNoisy: true,
|
||||
units: [{ uid: 1, diy: { slot: SLOT[tier], charId: NARANT, skillIndex: skill, uniEquipId: mod }, elite, row, col }, ...others],
|
||||
});
|
||||
h.step();
|
||||
return { h, u: h.unit(1) };
|
||||
}
|
||||
const hitsBy = (h, u) => h.hooksOf('damaged').filter((c) => c.source === u);
|
||||
const atkHits = (h, u) => hitsBy(h, u).filter((c) => c.dmg?.isAttack);
|
||||
function done(h) {
|
||||
checkInvariants(h.b);
|
||||
assert.equal(h.b.errors.length, 0, JSON.stringify(h.b.errors[0]));
|
||||
}
|
||||
const label = ([tier, elite, mod]) => `T${tier} ${elite ? 'elite' : 'normal'} ${mod ?? 'none'}`;
|
||||
const TICK = 1 / 30;
|
||||
|
||||
test('娜仁图亚 in every 自选 form: her operator kit (all three skills authored), the form\'s stats + module attributes, y-7 range, ranged physical boomerangs that hit air, block 1, 35 % dodge, no 特质', () => {
|
||||
assert.equal(OPERATOR_KITS[NARANT], KITS[NARANT]);
|
||||
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], [NARANT, SLOT[tier], form.skills[skill].skillId, false, 'skills'], label(f));
|
||||
assert.deepEqual([u.base.maxHp, u.base.atk, u.base.def], [form.stats.maxHp + (m?.attr.maxHp ?? 0), form.stats.atk + (m?.attr.atk ?? 0), form.stats.def + (m?.attr.def ?? 0)], `${label(f)}: stats`);
|
||||
assert.deepEqual([u.s.blockCnt, u.profile.attack, u.profile.dmgType, u.profile.projectile, u.profile.canHitFly, u.base.bat, typeof u.profile.canAttack],
|
||||
[1, 'ranged', 'phys', 'boomerang', true, 1, 'function'], `${label(f)}: 回环射手`);
|
||||
assert.deepEqual(u.liveRangeGrid, form.rangeGrid, `${label(f)}: y-7`);
|
||||
assert.deepEqual([u.s.dodgePhys, u.s.dodgeArts], [0.35, 0.35], `${label(f)}: 婀娜虚影 dodge`);
|
||||
assert.deepEqual([u.def.bonds, u.def.raw.garrisonIds], [BACKUPS.diy.operators[NARANT].bonds, []], `${label(f)}: bonds / 特质`);
|
||||
assert.ok(!u.s.flags.liftoff && !u.s.flags.camou && !u.s.flags.stealth, `${label(f)}: ground enemies target her`);
|
||||
done(h);
|
||||
}
|
||||
}
|
||||
// E2 Lv1 2000 / 546 / 144, E2 Lv60 2331 / 632 / 161; LPS-X +25 / +25 → +45 / +45 ATK / DEF, LPS-Y +210 / +20 → +300 / +40 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], [2000, 546, 2331, 632]);
|
||||
assert.deepEqual([modOf(5, LPSX).attr, modOf(6, LPSX).attr, modOf(5, LPSY).attr, modOf(6, LPSY).attr], [{ atk: 25, def: 25 }, { atk: 45, def: 45 }, { maxHp: 210, atk: 20 }, { maxHp: 300, atk: 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(NARANT));
|
||||
for (const t of [5, 6]) assert.ok(diyPool(t, { data, kitted: KITTED_CHARS }).includes(NARANT), `tier ${t}`);
|
||||
assert.deepEqual(validateDiyPicks({ [SLOT[5]]: { charId: NARANT, skillIndex: 0, uniEquipId: LPSX } }, { data, kitted: KITTED_CHARS }),
|
||||
{ ok: true, picks: { [SLOT[5]]: { charId: NARANT, skillIndex: 0, uniEquipId: LPSX } } });
|
||||
});
|
||||
|
||||
test('trait 回环射手 (engine): one boomerang out at 15 and back at 3.75 tiles/s, the next throw once it is caught — each catch fires boomerangCaught { unit, attackId, isSkill }; a flyer is hit', () => {
|
||||
const { h, u } = field({ tier: 6, elite: true, skill: 2 });
|
||||
const fly = h.spawn('enemy_fly', { pos: [10, 6] });
|
||||
h.run(6);
|
||||
const hits = atkHits(h, u), caught = h.hooksOf('boomerangCaught').filter((c) => c.unit === u);
|
||||
assert.ok(hits.length >= 2 && hits.every((c) => c.target === fly), '可对空');
|
||||
assert.ok(caught.length >= 2);
|
||||
for (const c of caught) assert.ok(hits.some((x) => x.dmg.attackId === c.attackId) && c.isSkill === false, 'the catch names its attack');
|
||||
const d = 3;
|
||||
const flight = d / PROJECTILE_SPEEDS.boomerang + d / BOOMERANG_RETURN_SPEED;
|
||||
approx(caught[0].t - hits[0].t, d / BOOMERANG_RETURN_SPEED, 'back at 3.75 tiles/s', 0.1);
|
||||
approx(hits[1].t - hits[0].t, flight, 'she waits for it (longer than her 1 s interval)', 0.1);
|
||||
assert.ok(h.eventsOf('atk').filter((e) => e[1] === u.id).every((e) => e[3] === 'boomerang'));
|
||||
done(h);
|
||||
});
|
||||
|
||||
test('S1 旋刃 (切换: on until she leaves; data DEFAULT): range −1 (the far column of y-7), 140 % / 160 % ATK, then up to 3 bounces (radius 1.7, an enemy this attack has not hit first, then the nearest; 6 tiles/s), then back; a lone enemy: no bounce', () => {
|
||||
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, u.skill.spCost, u.skill.initSp, sk.bb['attack@times'], sk.bb['attack@atk_scale'], sk.bb.ability_range_forward_extend],
|
||||
['DEFAULT', 'toggle', elite ? 8 : 9, 0, 3, elite ? 1.6 : 1.4, -1], `T${tier}`);
|
||||
const lone = h.spawn('enemy_dummy', { pos: [10, 5] });
|
||||
assert.ok(h.runUntil(() => u.skill.active, 12), `T${tier}: on once its SP is full and an enemy is in range`);
|
||||
const short = formOf(tier, elite).rangeGrid.filter(([, c]) => c < 3);
|
||||
assert.deepEqual(u.liveRangeGrid, short, `T${tier}: 攻击距离-1`);
|
||||
h.run(3);
|
||||
const one = atkHits(h, u).filter((c) => c.dmg.isSkill);
|
||||
assert.ok(one.length >= 1 && one.every((c) => c.target === lone), `T${tier}: one hit per attack on a lone enemy`);
|
||||
assert.equal(new Set(one.map((c) => c.dmg.attackId)).size, one.length, `T${tier}: no bounce`);
|
||||
const before = atkHits(h, u).filter((c) => c.t < one[0].t - 1e-9).length; // her normal attacks' steals so far
|
||||
approx(one[0].amount, (u.base.atk + Math.min(250, 25 * before)) * sk.bb['attack@atk_scale'], `T${tier}: ${sk.bb['attack@atk_scale'] * 100} % (+ the ATK stolen before)`);
|
||||
// A (lone) at 10,5; B at 11,5 (1 from A); C at 9,6 (1.41 from A, 2.24 from B)
|
||||
const b = h.spawn('enemy_dummy', { pos: [11, 5] }), c = h.spawn('enemy_dummy', { pos: [9, 6] });
|
||||
const far = h.spawn('enemy_dummy', { pos: [12, 5] }); // 2 from A, 1 from B: reachable from B only
|
||||
h.run(0.1);
|
||||
const n0 = atkHits(h, u).length;
|
||||
h.run(4);
|
||||
const after = atkHits(h, u).slice(n0);
|
||||
const id = after[0].dmg.attackId;
|
||||
const chain = after.filter((x) => x.dmg.attackId === id);
|
||||
assert.equal(chain.length, 4, `T${tier}: the hit + 3 bounces`);
|
||||
assert.equal(chain[0].target, lone, `T${tier}: her target`);
|
||||
assert.equal(chain[1].target, b, `T${tier}: nearest not yet hit (B, 1 tile)`);
|
||||
assert.equal(chain[2].target, far, `T${tier}: from B the one not yet hit (12,5), before A`);
|
||||
approx(chain[1].t - chain[0].t, 1 / 6 + TICK, `T${tier}: bounce at 6 tiles/s`, 0.07);
|
||||
assert.ok(chain.every((x) => x.dmg.isAttack && x.dmg.isSkill && x.type === 'phys'), `T${tier}: hits of the attack`);
|
||||
assert.ok(!chain.some((x) => x.target === c) || chain[3].target === c, `T${tier}: C (2.24 from B) only from A`);
|
||||
// on until she leaves; redeployed: off, own range
|
||||
h.run(30);
|
||||
assert.ok(u.skill.active, `T${tier}: still on`);
|
||||
h.b.retreat(u);
|
||||
h.b.redeploy(u);
|
||||
assert.ok(!u.skill.active, `T${tier}: off after a redeploy`);
|
||||
assert.deepEqual(u.liveRangeGrid, formOf(tier, elite).rangeGrid, `T${tier}: y-7 again`);
|
||||
done(h);
|
||||
}
|
||||
});
|
||||
|
||||
test('S2 恶魇 (30 s, attack SP 18 from 5 / 8): 210 % / 225 % ATK + 停顿 1 s; the boomerang flies on 0.5 s, then hits every enemy within 1.0 of its way back once for 155 % / 170 %; farther ones untouched', () => {
|
||||
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.spType, u.skill.spCost, u.skill.initSp, sk.duration, sk.bb['attack@atk_scale'], sk.bb['attack@atk_scale_comeback'], sk.bb['attack@sluggish'], sk.bb['attack@move_ahead_time'], sk.bb['attack@projectile_range']],
|
||||
['DEFAULT', 'attack', 18, elite ? 8 : 5, 30, elite ? 2.25 : 2.1, elite ? 1.7 : 1.55, 1, 0.5, 1], `T${tier}`);
|
||||
const target = h.spawn('enemy_dummy', { pos: [10, 6] });
|
||||
const side = h.spawn('enemy_dummy', { pos: [11, 5] }); // 1.0 from the return line (row 10): hit on the way back
|
||||
const off = h.spawn('enemy_dummy', { pos: [12, 4] }); // 2 rows off: never
|
||||
h.b.addBuff(target, { key: 'test:taunt', mods: { taunt: 5 } }); // her target
|
||||
// attack SP: one per normal attack
|
||||
const sp0 = u.skill.sp;
|
||||
h.run(3.5);
|
||||
const normal = atkHits(h, u).filter((c) => !c.dmg.isSkill).length;
|
||||
approx(u.skill.sp, Math.min(18, sp0 + normal), `T${tier}: +1 SP an attack`);
|
||||
u.skill.gainSp(999);
|
||||
assert.ok(h.runUntil(() => u.skill.active, 4), `T${tier}: cast`);
|
||||
approx(u.skill.timeLeft, 30, `T${tier}: 30 s`, 0.1);
|
||||
h.run(3);
|
||||
const sk2 = atkHits(h, u).filter((c) => c.dmg.isSkill);
|
||||
const id = sk2[0].dmg.attackId;
|
||||
const main = sk2.find((c) => c.dmg.attackId === id && !c.dmg.tags?.includes('narant:comeback'));
|
||||
const back = sk2.filter((c) => c.dmg.attackId === id && c.dmg.tags?.includes('narant:comeback'));
|
||||
assert.equal(main.target, target, `T${tier}: her target`);
|
||||
assert.deepEqual(back.map((c) => c.target).sort((a, b) => a.id - b.id), [target, side].sort((a, b) => a.id - b.id), `T${tier}: once each within 1.0 of the way back`);
|
||||
assert.ok(back.every((c) => c.t - main.t >= 0.5), `T${tier}: after the 0.5 s dash`);
|
||||
assert.ok(!sk2.some((c) => c.target === off), `T${tier}: 2 tiles off the line`);
|
||||
assert.ok(back.every((c) => c.dmg.isAttack && c.type === 'phys'), `T${tier}: hits of the attack`);
|
||||
const slows = h.hooksOf('statusApplied').filter((c) => c.source === u && c.status === 'sluggish');
|
||||
assert.ok(slows.length && slows.every((c) => c.target === target && Math.abs(c.duration - 1) < 1e-9), `T${tier}: 停顿 1 s on the hit target only`);
|
||||
// the hit's ATK scale: her ATK at that hit (base + the steals before it) × 225 %
|
||||
const before = atkHits(h, u).filter((c) => c.t < main.t - 1e-9).length;
|
||||
const sa = formOf(tier, elite).talents.find((t) => t.index === 0).bb['attack@steal_atk'];
|
||||
approx(main.amount, (u.base.atk + Math.min(250, sa * before)) * sk.bb['attack@atk_scale'], `T${tier}: ${sk.bb['attack@atk_scale'] * 100} %`);
|
||||
done(h);
|
||||
}
|
||||
});
|
||||
|
||||
test('S3 吞日 (20 s): 3 boomerangs per attack (3 hits of 145 % / 160 %, flying together); once they are caught she strikes at most 3 enemies within one tile for 130 % / 140 % and 停顿 1 s (no attack)', () => {
|
||||
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, u.skill.spCost, u.skill.initSp, sk.duration, sk.bb.cnt, sk.bb['attack@atk_scale'], sk.bb.atk_scale_aoe, sk.bb['attack@aoe.max_target'], sk.bb.sluggish],
|
||||
['DEFAULT', elite ? 36 : 39, elite ? 17 : 14, 20, 3, elite ? 1.6 : 1.45, elite ? 1.4 : 1.3, 3, 1], `T${tier}`);
|
||||
const target = h.spawn('enemy_dummy', { pos: [10, 6] });
|
||||
const around = [[9, 3], [11, 3], [9, 4], [11, 4]].map((pos) => h.spawn('enemy_dummy', { pos }));
|
||||
h.b.addBuff(target, { key: 'test:taunt', mods: { taunt: 5 } }); // her target: the far one
|
||||
u.skill.gainSp(999);
|
||||
assert.ok(h.runUntil(() => u.skill.active, 4), `T${tier}: cast`);
|
||||
approx(u.skill.timeLeft, 20, `T${tier}: 20 s`, 0.1);
|
||||
h.run(2.5);
|
||||
const sk3 = atkHits(h, u).filter((c) => c.dmg.isSkill);
|
||||
const id = sk3[0].dmg.attackId;
|
||||
const three = sk3.filter((c) => c.dmg.attackId === id);
|
||||
assert.equal(three.length, 3, `T${tier}: 3 boomerangs`);
|
||||
assert.ok(three.every((c) => c.target === target && c.t === three[0].t), `T${tier}: together, at the target`);
|
||||
const caught = h.hooksOf('boomerangCaught').find((c) => c.unit === u && c.attackId === id);
|
||||
assert.ok(caught?.isSkill, `T${tier}: caught`);
|
||||
const blast = hitsBy(h, u).filter((c) => c.dmg.tags?.includes('narant:blast') && Math.abs(c.t - caught.t) < 1e-9);
|
||||
assert.equal(blast.length, 3, `T${tier}: at most 3 of the 4 around her`);
|
||||
assert.ok(blast.every((c) => around.includes(c.target) && !c.dmg.isAttack && c.dmg.isSkill && c.type === 'phys'), `T${tier}: skill hits within one tile`);
|
||||
const slows = h.hooksOf('statusApplied').filter((c) => c.source === u && c.status === 'sluggish' && Math.abs(c.t - caught.t) < 1e-9);
|
||||
assert.equal(slows.length, 3, `T${tier}: 停顿 on each`);
|
||||
for (const c of slows) approx(c.duration, 1, '1 s');
|
||||
done(h);
|
||||
}
|
||||
});
|
||||
|
||||
test('T1 “我见，我得”: every landing attack hit steals 25 ATK / 20 DEF — the enemy loses, she gains, each capped at 250 / 200 (LPS-X stage 3: 300 / 240, twice within one tile); two of her: the larger loss, not the sum; a dodged hit steals nothing; all given back when she leaves', () => {
|
||||
for (const f of [[5, false, null], [6, true, null], [5, true, LPSX], [6, true, LPSX], [6, true, LPSY]]) {
|
||||
const [tier, elite, mod] = f;
|
||||
const t0 = formOf(tier, elite).talents.find((t) => t.index === 0).bb;
|
||||
const tc = mod === LPSX && tier === 6 ? modOf(6, LPSX).talentChanges.find((t) => t.talentIndex === 0) : null;
|
||||
const capA = tc?.bb['attack@steal_atk_max'] ?? t0['attack@steal_atk_max'], capD = tc?.bb['attack@steal_def_max'] ?? t0['attack@steal_def_max'];
|
||||
assert.deepEqual([t0['attack@steal_atk'], t0['attack@steal_def'], capA, capD], [25, 20, ...(tc ? [300, 240] : [250, 200])], label(f));
|
||||
const twice = !!tc;
|
||||
if (twice) assert.match(tc.desc, /攻击到周围8格的敌人时偷取触发2次/);
|
||||
// one hit at two tiles, then one at one tile
|
||||
{
|
||||
const { h, u } = field({ tier, elite, mod, skill: 2 });
|
||||
const e = h.spawn('enemy_brute', { pos: [10, 5] });
|
||||
assert.ok(h.runUntil(() => atkHits(h, u).length === 1, 3));
|
||||
assert.deepEqual(u.findBuff('talent:narant:loot')?.mods, { atkFlat: 25, defFlat: 20 }, `${label(f)}: she gains`);
|
||||
assert.deepEqual(e.findBuff('narant:stolen')?.mods, { atkFlat: -25, defFlat: -20 }, `${label(f)}: the enemy loses`);
|
||||
assert.deepEqual([e.s.atk, e.s.def], [375, 280], `${label(f)}: its stats`);
|
||||
h.b.kill(e, null);
|
||||
const near = h.spawn('enemy_brute', { pos: [10, 4] });
|
||||
assert.ok(h.runUntil(() => atkHits(h, u).length === 2, 4));
|
||||
const k = twice ? 2 : 1;
|
||||
assert.deepEqual(near.findBuff('narant:stolen')?.mods, { atkFlat: -25 * k, defFlat: -20 * k }, `${label(f)}: within one tile ×${k}`);
|
||||
assert.deepEqual(u.findBuff('talent:narant:loot')?.mods, { atkFlat: 25 * (1 + k), defFlat: 20 * (1 + k) }, `${label(f)}: hers`);
|
||||
// the caps
|
||||
h.run(40);
|
||||
assert.deepEqual(u.findBuff('talent:narant:loot')?.mods, { atkFlat: capA, defFlat: capD }, `${label(f)}: her cap`);
|
||||
assert.deepEqual(near.findBuff('narant:stolen')?.mods, { atkFlat: -capA, defFlat: -capD }, `${label(f)}: its cap`);
|
||||
approx(u.s.atk, (u.base.atk + capA) * (1 + calmAtk(tier, elite, mod)), `${label(f)}: her ATK`);
|
||||
// she leaves: nothing kept, everything given back
|
||||
h.b.retreat(u);
|
||||
h.step();
|
||||
assert.equal(u.findBuff('talent:narant:loot'), null, `${label(f)}: her gains go`);
|
||||
assert.equal(near.findBuff('narant:stolen'), null, `${label(f)}: its losses come back`);
|
||||
assert.deepEqual([near.s.atk, near.s.def], [400, 300]);
|
||||
done(h);
|
||||
}
|
||||
}
|
||||
// two of her (a T5 and a T6 piece) hitting one enemy: the larger loss, never the sum; a dodged hit steals nothing
|
||||
const { h, u } = field({ tier: 5, skill: 2, others: [{ uid: 2, diy: { slot: SLOT[6], charId: NARANT, skillIndex: 2 }, row: 12, col: 3 }] });
|
||||
const v = h.unit(2);
|
||||
const e = h.spawn('enemy_brute', { pos: [11, 5] });
|
||||
h.run(8);
|
||||
const n1 = atkHits(h, u).filter((c) => c.target === e).length, n2 = atkHits(h, v).filter((c) => c.target === e).length;
|
||||
assert.ok(n1 >= 3 && n2 >= 3, `both hit it (${n1}, ${n2})`);
|
||||
assert.deepEqual(e.findBuff('narant:stolen')?.mods.atkFlat, -Math.min(250, 25 * Math.max(n1, n2)), 'the larger loss');
|
||||
const ghost = h.spawn('enemy_brute', { pos: [11, 4] });
|
||||
h.b.kill(e, null);
|
||||
h.b.addBuff(ghost, { key: 'test:dodge', mods: { dodgePhys: 1 } });
|
||||
h.run(4);
|
||||
assert.ok(h.hooksOf('damaged').every((c) => c.target !== ghost), 'every hit dodged');
|
||||
assert.equal(ghost.findBuff('narant:stolen'), null, 'a dodged hit steals nothing');
|
||||
done(h);
|
||||
});
|
||||
|
||||
test('T2 婀娜虚影: enemies within one tile of her miss 20 % (LPS-Y stage 3: 30 %) of their physical / arts attacks — one roll per attack —, farther ones never; LPS-Y stage 3: ATK +15 % after 6 s without damage', () => {
|
||||
for (const f of [[5, false, null], [6, true, LPSY], [5, true, LPSY]]) {
|
||||
const [tier, elite, mod] = f;
|
||||
const t1 = formOf(tier, elite).talents.find((t) => t.index === 1).bb;
|
||||
const cut = mod === LPSY && tier === 6 ? -modOf(6, LPSY).talentChanges.find((t) => t.talentIndex === 1).bb.damage_hitrate_physical : -t1.damage_hitrate_physical;
|
||||
assert.equal(cut, mod === LPSY && tier === 6 ? 0.3 : 0.2, label(f));
|
||||
for (const [pos, inside] of [[[10, 4], true], [[11, 5], false]]) {
|
||||
const { h, u } = field({ tier, elite, mod, skill: 2, seed: 13 });
|
||||
h.b.removeBuff(u, 'talent:narant:dodge'); // her own 闪避 aside: every lost shot is a miss
|
||||
h.b.addBuff(u, { key: 'test:tank', mods: { hpFlat: 1e9 } });
|
||||
const shooter = h.spawn('enemy_shooter', { pos });
|
||||
h.run(150);
|
||||
const shots = h.hooksOf('attack').filter((c) => c.attacker === shooter).length;
|
||||
const landed = h.hooksOf('damaged').filter((c) => c.source === shooter).length;
|
||||
assert.ok(shots > 200, `${label(f)}: ${shots} shots`);
|
||||
const rate = 1 - landed / shots;
|
||||
if (inside) assert.ok(Math.abs(rate - cut) < 0.07, `${label(f)}: ${(rate * 100).toFixed(1)} % missed ≈ ${cut * 100} %`);
|
||||
else assert.ok(landed >= shots - 1, `${label(f)}: two tiles away: no miss (${landed} / ${shots}, the last one may still fly)`);
|
||||
done(h);
|
||||
}
|
||||
}
|
||||
// the calm ATK
|
||||
const { h, u } = field({ tier: 6, elite: true, mod: LPSY, skill: 2 });
|
||||
assert.deepEqual(modOf(6, LPSY).talentChanges.find((t) => t.talentIndex === -1).bb, { atk: 0.15, interval: 6 });
|
||||
h.step();
|
||||
assert.deepEqual(u.findBuff('talent:narant:calm')?.mods, { atkPct: 0.15 }, 'unhurt since her deployment');
|
||||
h.b.dealDamage(null, u, { amount: 10, type: 'true' });
|
||||
h.step();
|
||||
assert.equal(u.findBuff('talent:narant:calm'), null, 'hurt: gone');
|
||||
h.run(5.5);
|
||||
assert.equal(u.findBuff('talent:narant:calm'), null, 'not yet');
|
||||
h.run(0.6);
|
||||
assert.ok(u.findBuff('talent:narant:calm'), '6 s later: back');
|
||||
h.b.loseHp(u, 10, {});
|
||||
h.step();
|
||||
assert.ok(u.findBuff('talent:narant:calm'), 'a 流失 is no damage');
|
||||
done(h);
|
||||
});
|
||||
|
||||
test('LPS-X “吹尽狂沙”: ×1.1 on her attack hits within one tile (stages 1 and 3), not beyond; none without it', () => {
|
||||
for (const [tier, mod] of [[5, LPSX], [6, LPSX], [6, LPSY], [5, null]]) {
|
||||
const near = mod === LPSX ? 1.1 : 1;
|
||||
if (mod === LPSX) assert.deepEqual(modOf(tier, LPSX).traitOverride.bb, { atk_scale: 1.1 });
|
||||
for (const [pos, d1] of [[[10, 4], true], [[10, 5], false], [[11, 4], true]]) {
|
||||
const { h, u } = field({ tier, elite: true, mod, skill: 2 });
|
||||
const e = h.spawn('enemy_dummy', { pos });
|
||||
assert.ok(h.runUntil(() => atkHits(h, u).length === 1, 3));
|
||||
approx(atkHits(h, u)[0].amount, u.base.atk * (1 + calmAtk(tier, true, mod)) * (d1 ? near : 1), `T${tier} ${mod}: ${pos}`);
|
||||
assert.equal(atkHits(h, u)[0].target, e);
|
||||
done(h);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
test('LPS-Y “致我们的老大”: 1 SP every 5 boomerangs caught (an S3 throw carries 3), none while her skill runs; none without it', () => {
|
||||
for (const [tier, mod] of [[5, LPSY], [6, LPSY], [6, LPSX]]) {
|
||||
if (mod === LPSY) assert.deepEqual(modOf(tier, LPSY).traitOverride.bb, { come_back_cnt: 5, sp: 1 });
|
||||
const { h, u } = field({ tier, elite: true, mod, skill: 1 }); // S2: attack SP — the time SP stays out of it
|
||||
h.spawn('enemy_dummy', { pos: [10, 6] });
|
||||
h.run(9);
|
||||
const caught = h.hooksOf('boomerangCaught').filter((c) => c.unit === u && !c.isSkill).length;
|
||||
const gains = h.hooksOf('spGain').filter((c) => c.unit === u && c.reason === 'module').length;
|
||||
assert.ok(caught >= 5, `T${tier} ${mod}: ${caught} caught`);
|
||||
assert.equal(gains, mod === LPSY ? Math.floor(caught / 5) : 0, `T${tier} ${mod}: ${gains} module SP`);
|
||||
done(h);
|
||||
}
|
||||
// S3: each throw is 3 boomerangs; while S3 runs no SP is gained (the catches still count)
|
||||
const { h, u } = field({ tier: 6, elite: true, mod: LPSY, skill: 2 });
|
||||
h.spawn('enemy_dummy', { pos: [10, 6] });
|
||||
u.skill.gainSp(999);
|
||||
assert.ok(h.runUntil(() => u.skill.active, 4));
|
||||
h.run(6);
|
||||
const during = h.hooksOf('boomerangCaught').filter((c) => c.unit === u && c.isSkill).length;
|
||||
assert.ok(during >= 3, `${during} S3 throws caught`);
|
||||
assert.equal(u.mem.narantCaught, (3 * during) % 5, 'the S3 catches count 3 each');
|
||||
assert.equal(h.hooksOf('spGain').filter((c) => c.unit === u && c.reason === 'module' && c.amount > 0 && u.skill.active).length, 0, 'no SP during S3');
|
||||
done(h);
|
||||
});
|
||||
|
||||
test('engine: a profile `boomerangOnward` takes the flight over after the first hit — ctx.hit / ctx.comeBack once — and a content error there still brings the boomerang back', () => {
|
||||
const calls = [];
|
||||
const kits = {
|
||||
[NARANT]: () => ({
|
||||
skills: Object.fromEntries([S1, S2, S3].map((id) => [id, { kind: 'duration' }])),
|
||||
trait: {
|
||||
boomerangOnward(ctx) {
|
||||
calls.push(ctx.attackId);
|
||||
if (calls.length === 2) throw new Error('kit bug');
|
||||
ctx.battle.after(0.5, () => { assert.equal(typeof ctx.comeBack(ctx.x, ctx.y), 'object'); assert.equal(ctx.comeBack(ctx.x, ctx.y), null, 'once'); });
|
||||
},
|
||||
},
|
||||
}),
|
||||
};
|
||||
const h = makeBattle({ defs: { enemies: ENEMIES }, timeLimit: 120, autoFinish: false, seed: 1, kits, verbose: false, hooks: ['boomerangCaught'],
|
||||
units: [{ uid: 1, diy: { slot: SLOT[6], charId: NARANT, skillIndex: 2 }, elite: true, row: 10, col: 3 }] });
|
||||
h.step();
|
||||
const u = h.unit(1);
|
||||
h.spawn('enemy_dummy', { pos: [10, 6] });
|
||||
h.run(6);
|
||||
assert.ok(calls.length >= 3, `${calls.length} flights taken over`);
|
||||
assert.ok(h.hooksOf('boomerangCaught').length >= 2, 'caught every time (the error one too)');
|
||||
assert.ok(h.b.errors.some((e) => /boomerang\.onward/.test(e.label ?? e.where ?? JSON.stringify(e))), 'the error is logged');
|
||||
assert.equal(u.trait.boomerangsOut <= 1, true);
|
||||
checkInvariants(h.b);
|
||||
});
|
||||
@@ -0,0 +1,343 @@
|
||||
// test/content/op_poca.test.js — the 自选 operator kit of 早露 (char_197_poca, 6★ 攻城手; kit
|
||||
// server/sim/content/kits/ops/op-poca.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, SIE-X
|
||||
// 攻城器械训练装置 or SIE-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_poca.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 POCA = 'char_197_poca';
|
||||
const FORMS = BACKUPS.units[POCA].forms;
|
||||
const SLOT = { 5: 'chess_char_5_diy1_a', 6: 'chess_char_6_diy1_a' };
|
||||
const SIEX = 'uniequip_002_poca', SIEY = 'uniequip_003_poca';
|
||||
const S1 = 'skcom_atk_up[3]', S2 = 'skchr_poca_2', S3 = 'skchr_poca_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_light: dummy('enemy_light', { mass: 1 }), enemy_mid: dummy('enemy_mid', { mass: 2 }), enemy_heavy: dummy('enemy_heavy', { mass: 3 }),
|
||||
enemy_armor: dummy('enemy_armor', { mass: 3, def: 600 }), enemy_plate: dummy('enemy_plate', { mass: 2, def: 600 }),
|
||||
enemy_fly: dummy('enemy_fly', { mass: 1, motion: 'FLY' }), enemy_hfly: dummy('enemy_hfly', { mass: 4, motion: 'FLY' }),
|
||||
};
|
||||
/** Every 自选 form: [tier, elite, module]. */
|
||||
const FORMS_ALL = [[5, false, null], [6, false, null], ...[5, 6].flatMap((t) => [null, SIEX, SIEY].map((m) => [t, true, m]))];
|
||||
/** 学生楷模: she is a 【乌萨斯学生自治团】 operator herself — her ATK always carries the talent's +atk. */
|
||||
const studentAtk = (tier, elite, mod) => (elite && mod === SIEY && tier === 6 ? 0.12 : 0.08);
|
||||
|
||||
/** A battle with 早露 as uid 1 at (row, col) facing RIGHT, plus `others`. */
|
||||
function field({ tier = 5, elite = false, mod = null, skill = 0, row = 10, col = 3, others = [], seed = 5 } = {}) {
|
||||
const h = makeBattle({
|
||||
defs: { enemies: ENEMIES }, timeLimit: 600, autoFinish: false, seed,
|
||||
flags: { dpPerSec: 0, dpMax: 999 }, hooks: ['damaged', 'skillStart', 'skillEnd', 'statusApplied'], captureNoisy: true,
|
||||
units: [{ uid: 1, diy: { slot: SLOT[tier], charId: POCA, skillIndex: skill, uniEquipId: mod }, elite, row, col }, ...others],
|
||||
});
|
||||
h.step();
|
||||
return { h, u: h.unit(1) };
|
||||
}
|
||||
const hitsBy = (h, u) => h.hooksOf('damaged').filter((c) => c.source === u);
|
||||
const atkHits = (h, u) => hitsBy(h, u).filter((c) => c.dmg?.isAttack);
|
||||
function done(h) {
|
||||
checkInvariants(h.b);
|
||||
assert.equal(h.b.errors.length, 0, JSON.stringify(h.b.errors[0]));
|
||||
}
|
||||
const label = ([tier, elite, mod]) => `T${tier} ${elite ? 'elite' : 'normal'} ${mod ?? 'none'}`;
|
||||
|
||||
test('早露 in every 自选 form: her operator kit (all three skills authored), the form\'s stats + module attributes, 4-3 range without her tile, ranged physical arrows that hit air, heaviest first, block 1, no 特质', () => {
|
||||
assert.equal(OPERATOR_KITS[POCA], KITS[POCA]);
|
||||
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], [POCA, SLOT[tier], form.skills[skill].skillId, false, 'skills'], label(f));
|
||||
assert.deepEqual([u.base.maxHp, u.base.atk, u.base.def], [form.stats.maxHp + (m?.attr.maxHp ?? 0), form.stats.atk + (m?.attr.atk ?? 0), form.stats.def + (m?.attr.def ?? 0)], `${label(f)}: stats`);
|
||||
assert.deepEqual([u.s.blockCnt, u.profile.attack, u.profile.dmgType, u.profile.canHitFly, u.profile.groundOnly, u.profile.priority, u.base.bat],
|
||||
[1, 'ranged', 'phys', true, false, 'heaviest', 2.4], `${label(f)}: 攻城手`);
|
||||
assert.deepEqual(u.liveRangeGrid, form.rangeGrid, `${label(f)}: 4-3`);
|
||||
assert.ok(!u.liveRangeGrid.some(([r, c]) => r === 0 && c === 0), `${label(f)}: PRTS 攻城手 "攻击范围不包含自身所在地块"`);
|
||||
assert.deepEqual([u.def.bonds, u.def.raw.garrisonIds], [BACKUPS.diy.operators[POCA].bonds, []], `${label(f)}: bonds / 特质`);
|
||||
assert.ok(!u.s.flags.liftoff && !u.s.flags.camou && !u.s.flags.stealth, `${label(f)}: ground enemies target her`);
|
||||
done(h);
|
||||
}
|
||||
}
|
||||
// the numbers of the forms (zh_CN): E2 Lv1 1351 / 856 / 100, E2 Lv60 1619 / 973 / 115; SIE-X +60 / +30 → +90 / +45,
|
||||
// SIE-Y +70 / +20 → +100 / +30 ATK / DEF
|
||||
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], [1351, 856, 1619, 973]);
|
||||
assert.deepEqual([modOf(5, SIEX).attr, modOf(6, SIEX).attr, modOf(5, SIEY).attr, modOf(6, SIEY).attr], [{ atk: 60, def: 30 }, { atk: 90, def: 45 }, { atk: 70, def: 20 }, { atk: 100, def: 30 }]);
|
||||
});
|
||||
|
||||
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(POCA));
|
||||
for (const t of [5, 6]) assert.ok(diyPool(t, { data, kitted: KITTED_CHARS }).includes(POCA), `tier ${t}`);
|
||||
assert.deepEqual(validateDiyPicks({ [SLOT[5]]: { charId: POCA, skillIndex: 2, uniEquipId: SIEY } }, { data, kitted: KITTED_CHARS }),
|
||||
{ ok: true, picks: { [SLOT[5]]: { charId: POCA, skillIndex: 2, uniEquipId: SIEY } } });
|
||||
});
|
||||
|
||||
test('trait 攻城手 "优先攻击重量最重的敌人": the heaviest enemy of her range first, wherever it stands; a lighter one only once it is heavier (失重 moves it down); flyers are targets too', () => {
|
||||
for (const [tier, elite] of [[5, false], [6, true]]) {
|
||||
const { h, u } = field({ tier, elite, skill: 0 });
|
||||
const light = h.spawn('enemy_light', { pos: [10, 5] }), heavy = h.spawn('enemy_heavy', { pos: [11, 7] });
|
||||
const n0 = atkHits(h, u).length;
|
||||
assert.ok(h.runUntil(() => atkHits(h, u).length > n0, 4), `T${tier}: an attack`);
|
||||
assert.equal(atkHits(h, u).at(-1).target, heavy, `T${tier}: weight 3 before weight 1 (the nearer one)`);
|
||||
h.b.addBuff(heavy, { key: 'test:weightless', mods: { massFlat: -3 } });
|
||||
const n1 = atkHits(h, u).length;
|
||||
assert.ok(h.runUntil(() => atkHits(h, u).length > n1, 4));
|
||||
assert.equal(atkHits(h, u).at(-1).target, light, `T${tier}: 失重 to 0 — now the light one first`);
|
||||
const fly = h.spawn('enemy_hfly', { pos: [9, 6] });
|
||||
const n2 = atkHits(h, u).length;
|
||||
assert.ok(h.runUntil(() => atkHits(h, u).length > n2, 4));
|
||||
assert.equal(atkHits(h, u).at(-1).target, fly, `T${tier}: a weight-4 flyer first (可对空)`);
|
||||
done(h);
|
||||
}
|
||||
});
|
||||
|
||||
test('S1 攻击力强化·γ型 (MANUAL, data DEFAULT): ATK +45 % / +60 % for 30 s, SP 37 / 35 from 5 / 10; cast with an enemy in her range at her 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, u.skill.spType, u.skill.spCost, u.skill.initSp, sk.duration, sk.bb.atk],
|
||||
['DEFAULT', 'duration', 'time', elite ? 35 : 37, elite ? 10 : 5, 30, elite ? 0.6 : 0.45], `T${tier}`);
|
||||
const st = studentAtk(tier, elite, null);
|
||||
approx(u.s.atk, u.base.atk * (1 + st), `T${tier}: 学生楷模 only`);
|
||||
u.skill.gainSp(999);
|
||||
h.run(2);
|
||||
assert.equal(u.skill.activations, 0, `T${tier}: no enemy, no cast`);
|
||||
h.spawn('enemy_light', { pos: [10, 6] });
|
||||
assert.ok(h.runUntil(() => u.skill.active, 4), `T${tier}: cast`);
|
||||
approx(u.skill.timeLeft, 30, `T${tier}: 30 s`, 0.01);
|
||||
approx(u.s.atk, u.base.atk * (1 + st + sk.bb.atk), `T${tier}: ATK +${sk.bb.atk * 100} %`);
|
||||
h.runUntil(() => !u.skill.active, 31);
|
||||
approx(u.s.atk, u.base.atk * (1 + st), `T${tier}: back`);
|
||||
done(h);
|
||||
}
|
||||
});
|
||||
|
||||
test('S2 分裂射击 (60 s): ATK +45 % / +60 % and two targets per attack (attack@max_target 2) — the two heaviest; a lone enemy gets one arrow', () => {
|
||||
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, sk.duration, sk.bb.atk, sk.bb['attack@max_target'], u.skill.spCost, u.skill.initSp], ['DEFAULT', 60, elite ? 0.6 : 0.45, 2, 80, elite ? 45 : 42], `T${tier}`);
|
||||
const lone = h.spawn('enemy_light', { pos: [10, 6] });
|
||||
u.skill.gainSp(999);
|
||||
assert.ok(h.runUntil(() => u.skill.active, 4));
|
||||
approx(u.skill.timeLeft, 60, `T${tier}: 60 s`, 0.05);
|
||||
approx(u.s.atk, u.base.atk * (1 + studentAtk(tier, elite, null) + sk.bb.atk), `T${tier}: ATK`);
|
||||
h.run(0.6);
|
||||
const n0 = atkHits(h, u).length;
|
||||
h.run(2.5);
|
||||
const one = atkHits(h, u).slice(n0);
|
||||
assert.ok(one.length >= 1 && one.every((c) => c.target === lone), `T${tier}: one target, one arrow per attack`);
|
||||
const mid = h.spawn('enemy_mid', { pos: [11, 6] }), heavy = h.spawn('enemy_heavy', { pos: [9, 5] });
|
||||
h.run(0.5);
|
||||
const n1 = atkHits(h, u).length;
|
||||
h.run(2.5);
|
||||
const ids = atkHits(h, u).slice(n1).map((c) => c.dmg.attackId);
|
||||
const first = atkHits(h, u).slice(n1).filter((c) => c.dmg.attackId === ids[0]);
|
||||
assert.deepEqual(first.map((c) => c.target).sort((a, b) => a.id - b.id), [mid, heavy].sort((a, b) => a.id - b.id), `T${tier}: the two heaviest (weights 3, 2), not the light one`);
|
||||
done(h);
|
||||
}
|
||||
});
|
||||
|
||||
test('S3 雪崩击 (6 / 7 s): harpoons link the 3 heaviest enemies of her range (a flyer too), 束缚 them, and strike each every second — 6 / 7 strikes at ATK +10 % (attacks), no other attack; the binds end with it', () => {
|
||||
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.max_target, sk.bb.hit_interval, sk.bb.hit_duration, sk.bb.atk, u.skill.spCost, u.skill.initSp],
|
||||
['DEFAULT', elite ? 7 : 6, 3, 1, elite ? 7 : 6, 0.1, elite ? 34 : 37, elite ? 12 : 11], `T${tier}`);
|
||||
const light = h.spawn('enemy_light', { pos: [10, 5] }), mid = h.spawn('enemy_mid', { pos: [10, 6] });
|
||||
const heavy = h.spawn('enemy_heavy', { pos: [11, 6] }), hfly = h.spawn('enemy_hfly', { pos: [9, 6] });
|
||||
const outside = h.spawn('enemy_heavy', { pos: [10, 9] });
|
||||
u.skill.gainSp(999);
|
||||
assert.ok(h.runUntil(() => u.skill.active, 4), `T${tier}: cast`);
|
||||
const t0 = h.b.time;
|
||||
const linked = [mid, heavy, hfly];
|
||||
for (const e of linked) assert.equal(e.findBuff('bind')?.source, u, `T${tier}: ${e.defId} bound`);
|
||||
assert.equal(light.findBuff('bind'), null, `T${tier}: the 4th heaviest is not linked`);
|
||||
assert.equal(outside.findBuff('bind'), null, `T${tier}: out of range`);
|
||||
approx(u.s.atk, u.base.atk * (1 + studentAtk(tier, elite, null) + 0.1), `T${tier}: ATK +10 %`);
|
||||
assert.ok(h.runUntil(() => !u.skill.active, 10), `T${tier}: ends`);
|
||||
approx(h.b.time - t0, sk.duration, `T${tier}: ${sk.duration} s`, 0.02);
|
||||
const hits = hitsBy(h, u);
|
||||
for (const e of linked) {
|
||||
const on = hits.filter((c) => c.target === e);
|
||||
assert.equal(on.length, sk.duration, `T${tier}: ${on.length} strikes on ${e.defId}`);
|
||||
assert.ok(on.every((c) => c.dmg.isAttack && c.dmg.isSkill && c.type === 'phys'), `T${tier}: physical skill attacks`);
|
||||
on.forEach((c, i) => i && approx(c.t - on[i - 1].t, 1, `T${tier}: one a second`, 0.02));
|
||||
}
|
||||
assert.ok(!hits.some((c) => c.target === light || c.target === outside), `T${tier}: nobody else is hit`);
|
||||
for (const e of linked) assert.equal(e.findBuff('bind'), null, `T${tier}: unbound at the end`);
|
||||
// the strikes are instant along the links
|
||||
assert.ok(h.eventsOf('atk').filter((ev) => ev[1] === u.id).some((ev) => ev[3] === 'beam'));
|
||||
done(h);
|
||||
}
|
||||
});
|
||||
|
||||
test('S3 雪崩击 (PRTS 备注): a link breaks when its enemy is knocked out or vanishes, the skill ends at once when none is left; a stun / silence on her breaks every link', () => {
|
||||
for (const [tier, elite] of [[5, false], [6, true]]) {
|
||||
// all links lost ⇒ the skill ends early
|
||||
{
|
||||
const { h, u } = field({ tier, elite, skill: 2 });
|
||||
const a = h.spawn('enemy_heavy', { pos: [10, 6] }), b = h.spawn('enemy_mid', { pos: [11, 6] });
|
||||
u.skill.gainSp(999);
|
||||
assert.ok(h.runUntil(() => u.skill.active, 4));
|
||||
h.run(1.2);
|
||||
h.b.kill(a, null);
|
||||
h.step();
|
||||
assert.ok(u.skill.active, `T${tier}: one link left`);
|
||||
b.hidden = true; // 消失
|
||||
h.step();
|
||||
assert.ok(!u.skill.active, `T${tier}: no link left ⇒ ends at once`);
|
||||
b.hidden = false;
|
||||
assert.equal(b.findBuff('bind'), null, `T${tier}: its bind went with the link`);
|
||||
done(h);
|
||||
}
|
||||
for (const status of ['stun', 'silence']) {
|
||||
const { h, u } = field({ tier, elite, skill: 2 });
|
||||
const a = h.spawn('enemy_heavy', { pos: [10, 6] });
|
||||
u.skill.gainSp(999);
|
||||
assert.ok(h.runUntil(() => u.skill.active, 4));
|
||||
h.run(1.5);
|
||||
h.b.applyStatus(u, status, { duration: 2, source: null });
|
||||
h.step();
|
||||
assert.ok(!u.skill.active, `T${tier}: ${status} breaks the links`);
|
||||
assert.equal(a.findBuff('bind'), null, `T${tier}: ${status}: unbound`);
|
||||
done(h);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
test('T1 深入骨髓: her damage ignores 60 % of the DEF of an enemy of 重量等级 ≥ 3 (exact numbers), none below; the S3 strikes too', () => {
|
||||
for (const [tier, elite] of [[5, false], [6, true]]) {
|
||||
const t0 = formOf(tier, elite).talents.find((t) => t.index === 0);
|
||||
assert.deepEqual([t0.bb.value, t0.bb.def_penetrate], [3, 0.6], `T${tier}: data`);
|
||||
for (const skill of [0, 2]) {
|
||||
const { h, u } = field({ tier, elite, skill });
|
||||
const armor = h.spawn('enemy_armor', { pos: [10, 6] }), plate = h.spawn('enemy_plate', { pos: [11, 6] });
|
||||
if (skill === 2) { u.skill.gainSp(999); assert.ok(h.runUntil(() => u.skill.active, 4)); h.run(2.2); } else h.run(12);
|
||||
const on = (e) => atkHits(h, u).filter((c) => c.target === e);
|
||||
assert.ok(on(armor).length, `T${tier} S${skill + 1}: hit the weight-3 one`);
|
||||
for (const c of on(armor)) approx(c.amount, u.s.atk - 600 * (1 - 0.6), `T${tier} S${skill + 1}: weight 3, DEF 600 × 40 %`);
|
||||
if (skill === 2) {
|
||||
assert.ok(on(plate).length, `T${tier}: S3 links the weight-2 one too`);
|
||||
for (const c of on(plate)) approx(c.amount, u.s.atk - 600, `T${tier} S3: weight 2, full DEF`);
|
||||
}
|
||||
done(h);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
test('T2 学生楷模: every 【乌萨斯学生自治团】 operator of her team — her and 古米, deployed or not — ATK +8 %, nobody else; SIE-Y stage 3: +12 % and +15 % per student in skill (≤ +45 %), re-read every 0.3 s', () => {
|
||||
for (const f of FORMS_ALL) {
|
||||
const [tier, elite, mod] = f;
|
||||
const others = [{ uid: 2, chessId: 'chess_char_1_10_a', row: 12, col: 3 }, { uid: 3, chessId: 'chess_char_1_02_a', row: 12, col: 6 }];
|
||||
const { h, u } = field({ tier, elite, mod, skill: 0, others });
|
||||
const gummy = h.unit(2), yak = h.unit(3);
|
||||
const v = studentAtk(tier, elite, mod);
|
||||
for (const a of [u, gummy]) assert.deepEqual(a.findBuff('talent:poca:students')?.mods, { atkPct: v }, `${label(f)}: ${a.def.charId}`);
|
||||
assert.equal(yak.findBuff('talent:poca:students'), null, `${label(f)}: 角峰 is no student`);
|
||||
h.b.retreat(u);
|
||||
h.run(0.5);
|
||||
assert.ok(gummy.findBuff('talent:poca:students'), `${label(f)}: 编入队伍时 — still there with her off the field`);
|
||||
assert.ok(u.findBuff('talent:poca:students'), `${label(f)}: kept through her retreat`);
|
||||
assert.equal(!!gummy.findBuff('talent:poca:studentSkills'), false, `${label(f)}: nobody in skill`);
|
||||
done(h);
|
||||
}
|
||||
// SIE-Y stage 3: the extra +15 % per student operator on the field whose skill runs, at most +45 %
|
||||
const t6 = formOf(6, true).modules.find((m) => m.uniEquipId === SIEY).talentChanges;
|
||||
assert.deepEqual([t6.find((t) => t.talentIndex === 1).bb.atk, t6.find((t) => t.talentIndex === -1).bb], [0.12, { init_atk: 0.15, max_atk: 0.45 }]);
|
||||
const others = [
|
||||
{ uid: 2, chessId: 'chess_char_1_10_a', row: 12, col: 3, skillIndex: 1 }, { uid: 3, chessId: 'chess_char_1_10_b', row: 12, col: 5, skillIndex: 1 },
|
||||
{ uid: 4, diy: { slot: 'chess_char_6_diy2_a', charId: 'char_1051_headb2', skillIndex: 0 }, row: 11, col: 8 },
|
||||
{ uid: 5, chessId: 'chess_char_1_02_a', row: 12, col: 7 },
|
||||
];
|
||||
const { h, u } = field({ tier: 6, elite: true, mod: SIEY, skill: 0, others });
|
||||
const team = [u, h.unit(2), h.unit(3), h.unit(4)];
|
||||
assert.ok(team.every((a) => a && a.deployed), 'four students on the field');
|
||||
const drive = (a) => a.findBuff('talent:poca:studentSkills')?.mods.atkPct ?? 0;
|
||||
const cast = (a) => { a.skill.gainSp(999); a.skill.activate('test'); assert.ok(a.skill.active, `${a.def.charId} in skill`); };
|
||||
cast(u);
|
||||
h.step(); // at once: 每次开启技能时
|
||||
for (const a of team) approx(drive(a), 0.15, `one in skill: ${a.def.charId}`);
|
||||
assert.equal(drive(h.unit(5)), 0, '角峰 gets nothing');
|
||||
approx(u.s.atk, u.base.atk * (1 + 0.12 + 0.15 + skillOf(6, true, S1).bb.atk), 'her ATK: +12 % +15 % (and her S1)');
|
||||
cast(h.unit(2));
|
||||
h.step();
|
||||
approx(drive(h.unit(4)), 0.3, 'two in skill');
|
||||
cast(h.unit(3));
|
||||
cast(h.unit(4));
|
||||
h.step();
|
||||
approx(drive(u), 0.45, 'four in skill: capped at +45 %');
|
||||
u.skill.end('test');
|
||||
h.run(0.35); // the 0.3 s re-read
|
||||
approx(drive(h.unit(2)), 0.45, 'three in skill');
|
||||
for (const a of team.slice(1)) a.skill.end('test');
|
||||
h.run(0.35);
|
||||
assert.equal(drive(u), 0, 'nobody in skill');
|
||||
done(h);
|
||||
});
|
||||
|
||||
test('SIE-X 攻城器械训练装置: ×1.15 on her attacks against 重量等级 ≥ 3 (normal attacks, S3 strikes), nothing below; stage 3 深入骨髓 adds a 60 % ATK physical hit on such enemies (with the DEF ignore)', () => {
|
||||
for (const [tier, mod] of [[5, null], [5, SIEX], [6, SIEX], [6, SIEY], [6, null]]) {
|
||||
const xs = mod === SIEX ? 1.15 : 1;
|
||||
const extra = mod === SIEX && tier === 6 ? 0.6 : 0;
|
||||
if (mod === SIEX) assert.deepEqual(modOf(tier, SIEX).talentChanges.find((t) => t.hidden).bb, { atk_scale: 1.15, value: 3 }, `T${tier}: data`);
|
||||
for (const skill of [0, 2]) {
|
||||
const { h, u } = field({ tier, elite: true, mod, skill });
|
||||
const heavy = h.spawn('enemy_heavy', { pos: [10, 5] }), mid = h.spawn('enemy_mid', { pos: [10, 6] });
|
||||
if (skill === 2) { u.skill.gainSp(999); assert.ok(h.runUntil(() => u.skill.active, 4)); h.run(2.2); } else h.run(12);
|
||||
const main = atkHits(h, u);
|
||||
const onH = main.filter((c) => c.target === heavy), onM = main.filter((c) => c.target === mid);
|
||||
// (SIE-Y's own distance factor: 2 / 3 tiles)
|
||||
const far = (d) => (mod === SIEY ? 1 + 0.12 * (d - 1) / 3.5 : 1);
|
||||
assert.ok(onH.length, `T${tier} ${mod} S${skill + 1}: hits the heavy one`);
|
||||
for (const c of onH) approx(c.amount, u.s.atk * xs * far(2), `T${tier} ${mod} S${skill + 1}: ×${xs} on weight 3`);
|
||||
for (const c of onM) approx(c.amount, u.s.atk * far(3), `T${tier} ${mod} S${skill + 1}: ×1 on weight 2`);
|
||||
const ex = hitsBy(h, u).filter((c) => c.dmg.tags?.includes('poca:extra'));
|
||||
if (extra) {
|
||||
assert.equal(ex.length, onH.length, `T${tier}: one extra hit per attack hit on the heavy one`);
|
||||
assert.ok(ex.every((c) => c.target === heavy && c.type === 'phys' && !c.dmg.isAttack), `T${tier}: physical, not an attack`);
|
||||
for (const c of ex) approx(c.amount, u.s.atk * extra, `T${tier}: 60 % ATK`);
|
||||
} else assert.equal(ex.length, 0, `T${tier} ${mod}: no extra hit`);
|
||||
done(h);
|
||||
}
|
||||
}
|
||||
// the extra hit gets 深入骨髓's 物理穿透 too: weight 3, DEF 600
|
||||
const { h, u } = field({ tier: 6, elite: true, mod: SIEX, skill: 0 });
|
||||
const armor = h.spawn('enemy_armor', { pos: [10, 6] });
|
||||
h.run(6);
|
||||
const ex = hitsBy(h, u).filter((c) => c.target === armor && c.dmg.tags?.includes('poca:extra'));
|
||||
assert.ok(ex.length);
|
||||
for (const c of ex) approx(c.amount, u.s.atk * 0.6 - 600 * 0.4, 'extra hit: DEF 600 × 40 %');
|
||||
done(h);
|
||||
});
|
||||
|
||||
test('SIE-Y “心”: her attack damage rises with the distance, linearly from 1 tile to 4.5 (at most +12 %), stages 1 and 3; nothing without it', () => {
|
||||
for (const [tier, mod] of [[5, SIEY], [6, SIEY], [6, SIEX], [5, null]]) {
|
||||
const tb = mod === SIEY ? modOf(tier, SIEY).traitOverride.bb : {};
|
||||
if (mod === SIEY) assert.deepEqual(tb, { max_dist: 4.5, min_dist: 1, damage_scale: 0.12 }, `T${tier}: data`);
|
||||
for (const [r, c] of [[10, 5], [10, 6], [10, 7], [11, 6], [12, 5]]) {
|
||||
const { h, u } = field({ tier, elite: true, mod, skill: 0 });
|
||||
const e = h.spawn('enemy_light', { pos: [r, c] });
|
||||
h.run(3);
|
||||
const hit = atkHits(h, u).find((x) => x.target === e);
|
||||
assert.ok(hit, `T${tier} ${mod}: hit at ${r},${c}`);
|
||||
const d = Math.hypot(c - 3, r - 10);
|
||||
const want = mod === SIEY ? 1 + 0.12 * Math.max(0, Math.min(1, (d - 1) / 3.5)) : 1;
|
||||
approx(hit.amount, u.s.atk * want, `T${tier} ${mod}: ${d.toFixed(2)} tiles ×${want.toFixed(4)}`);
|
||||
done(h);
|
||||
}
|
||||
}
|
||||
});
|
||||
@@ -0,0 +1,343 @@
|
||||
// test/content/op_typhon.test.js — the 自选 operator kit of 提丰 (char_2012_typhon, 6★ 攻城手; kit
|
||||
// server/sim/content/kits/ops/op-typhon.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, SIE-X
|
||||
// 自然的包容, SIE-Y 冰原的影子 or ISW-A 提丰特限证章 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_typhon.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 TYPHON = 'char_2012_typhon';
|
||||
const FORMS = BACKUPS.units[TYPHON].forms;
|
||||
const SLOT = { 5: 'chess_char_5_diy1_a', 6: 'chess_char_6_diy1_a' };
|
||||
const SIEX = 'uniequip_002_typhon', SIEY = 'uniequip_003_typhon', ISWA = 'uniequip_004_typhon';
|
||||
const S1 = 'skcom_quickattack[3]', S2 = 'skchr_typhon_2', S3 = 'skchr_typhon_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_light: dummy('enemy_light', { mass: 1 }), enemy_mid: dummy('enemy_mid', { mass: 2 }), enemy_heavy: dummy('enemy_heavy', { mass: 3 }),
|
||||
enemy_plate: dummy('enemy_plate', { mass: 1, def: 600 }), enemy_fly: dummy('enemy_fly', { mass: 1, motion: 'FLY' }),
|
||||
enemy_walk: enemyRec({ key: 'enemy_walk', hp: 1e9, speed: 0.8, mass: 3 }),
|
||||
};
|
||||
/** Every 自选 form: [tier, elite, module]. */
|
||||
const FORMS_ALL = [[5, false, null], [6, false, null], ...[5, 6].flatMap((t) => [null, SIEX, SIEY, ISWA].map((m) => [t, true, m]))];
|
||||
|
||||
/** A battle with 提丰 as uid 1 at (row, col) facing RIGHT, plus `others`. */
|
||||
function field({ tier = 5, elite = false, mod = null, skill = 0, row = 10, col = 3, others = [], seed = 5 } = {}) {
|
||||
const h = makeBattle({
|
||||
defs: { enemies: ENEMIES }, timeLimit: 900, autoFinish: false, seed,
|
||||
flags: { dpPerSec: 0, dpMax: 999 }, hooks: ['damaged', 'skillStart', 'skillEnd', 'statusApplied'], captureNoisy: true,
|
||||
units: [{ uid: 1, diy: { slot: SLOT[tier], charId: TYPHON, skillIndex: skill, uniEquipId: mod }, elite, row, col }, ...others],
|
||||
});
|
||||
h.step();
|
||||
return { h, u: h.unit(1) };
|
||||
}
|
||||
const hitsBy = (h, u) => h.hooksOf('damaged').filter((c) => c.source === u);
|
||||
const atkHits = (h, u) => hitsBy(h, u).filter((c) => c.dmg?.isAttack);
|
||||
const rainHits = (h, u) => hitsBy(h, u).filter((c) => c.dmg?.tags?.includes('typhon:rain'));
|
||||
function done(h) {
|
||||
checkInvariants(h.b);
|
||||
assert.equal(h.b.errors.length, 0, JSON.stringify(h.b.errors[0]));
|
||||
}
|
||||
const label = ([tier, elite, mod]) => `T${tier} ${elite ? 'elite' : 'normal'} ${mod ?? 'none'}`;
|
||||
|
||||
test('提丰 in every 自选 form: her operator kit (all three skills authored), the form\'s stats + module attributes (SIE-Y ASPD), 4-3 range, ranged physical arrows that hit air, heaviest first, no 特质', () => {
|
||||
assert.equal(OPERATOR_KITS[TYPHON], KITS[TYPHON]);
|
||||
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], [TYPHON, 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.s.blockCnt, u.profile.attack, u.profile.dmgType, u.profile.canHitFly, u.profile.priority, u.base.bat], [1, 'ranged', 'phys', true, 'heaviest', 2.4], `${label(f)}: 攻城手`);
|
||||
assert.deepEqual(u.liveRangeGrid, form.rangeGrid, `${label(f)}: 4-3`);
|
||||
assert.deepEqual([u.def.bonds, u.def.raw.garrisonIds], [BACKUPS.diy.operators[TYPHON].bonds, []], `${label(f)}: bonds / 特质`);
|
||||
assert.ok(!u.s.flags.liftoff && !u.s.flags.camou && !u.s.flags.stealth, `${label(f)}: ground enemies target her`);
|
||||
done(h);
|
||||
}
|
||||
}
|
||||
// E2 Lv1 1310 / 867 / 92, E2 Lv60 1570 / 985 / 106; SIE-X +120 HP / +60 ATK → +210 / +90, SIE-Y +70 ATK / +5 ASPD → +94 / +7,
|
||||
// ISW-A +100 / +70 → +150 / +90
|
||||
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], [1310, 867, 1570, 985]);
|
||||
assert.deepEqual([modOf(5, SIEX).attr, modOf(6, SIEX).attr, modOf(5, SIEY).attr, modOf(6, SIEY).attr, modOf(5, ISWA).attr, modOf(6, ISWA).attr],
|
||||
[{ maxHp: 120, atk: 60 }, { maxHp: 210, atk: 90 }, { atk: 70, aspd: 5 }, { atk: 94, aspd: 7 }, { maxHp: 100, atk: 70 }, { maxHp: 150, atk: 90 }]);
|
||||
});
|
||||
|
||||
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(TYPHON));
|
||||
for (const t of [5, 6]) assert.ok(diyPool(t, { data, kitted: KITTED_CHARS }).includes(TYPHON), `tier ${t}`);
|
||||
assert.deepEqual(validateDiyPicks({ [SLOT[6]]: { charId: TYPHON, skillIndex: 1, uniEquipId: ISWA } }, { data, kitted: KITTED_CHARS }),
|
||||
{ ok: true, picks: { [SLOT[6]]: { charId: TYPHON, skillIndex: 1, uniEquipId: ISWA } } });
|
||||
});
|
||||
|
||||
test('trait 攻城手: the heaviest enemy of her range first; a flyer is a target', () => {
|
||||
const { h, u } = field({ tier: 6, elite: true });
|
||||
const light = h.spawn('enemy_light', { pos: [10, 5] }), heavy = h.spawn('enemy_heavy', { pos: [9, 6] });
|
||||
h.run(3);
|
||||
assert.equal(atkHits(h, u)[0].target, heavy);
|
||||
h.b.kill(heavy, null);
|
||||
h.b.kill(light, null);
|
||||
const fly = h.spawn('enemy_fly', { pos: [11, 5] });
|
||||
h.run(3);
|
||||
assert.ok(atkHits(h, u).some((c) => c.target === fly), '可对空');
|
||||
done(h);
|
||||
});
|
||||
|
||||
test('S1 迅捷打击·γ型 (MANUAL, data DEFAULT): ATK +27 % / +34 %, ASPD +25 / +35 for 35 s; SP 42 / 39 from 5 / 10', () => {
|
||||
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, u.skill.spCost, u.skill.initSp, sk.duration, sk.bb.atk, sk.bb.attack_speed],
|
||||
['DEFAULT', 'duration', elite ? 39 : 42, elite ? 10 : 5, 35, elite ? 0.34 : 0.27, elite ? 35 : 25], `T${tier}`);
|
||||
u.skill.gainSp(999);
|
||||
h.run(2);
|
||||
assert.equal(u.skill.activations, 0, `T${tier}: no enemy, no cast`);
|
||||
h.spawn('enemy_light', { pos: [10, 6] });
|
||||
assert.ok(h.runUntil(() => u.skill.active, 4));
|
||||
approx(u.skill.timeLeft, 35, `T${tier}: 35 s`, 0.01);
|
||||
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`);
|
||||
h.runUntil(() => !u.skill.active, 36);
|
||||
assert.deepEqual([u.s.atk, u.s.aspd], [u.base.atk, 100], `T${tier}: back`);
|
||||
done(h);
|
||||
}
|
||||
});
|
||||
|
||||
test('S2 冰原秩序: ATK +26 % / +35 %, two arrows per attack — two enemies when there are two, both at a lone one — each with 40 % to stun 1 s; 20 s on the first cast of a deployment, then 持续时间无限 until she leaves (a redeploy counts again)', () => {
|
||||
for (const [tier, elite] of [[5, false], [6, true]]) {
|
||||
const sk = skillOf(tier, elite, S2);
|
||||
const { h, u } = field({ tier, elite, skill: 1, seed: 9 });
|
||||
assert.deepEqual([u.skill.rule, u.skill.kind, sk.duration, sk.bb.first_duration, sk.bb.atk, sk.bb['attack@prob'], sk.bb['attack@stun'], u.skill.spCost, u.skill.initSp],
|
||||
['DEFAULT', 'toggle', 20, 20, elite ? 0.35 : 0.26, 0.4, 1, elite ? 51 : 53, elite ? 40 : 37], `T${tier}`);
|
||||
const lone = h.spawn('enemy_light', { pos: [10, 6] });
|
||||
u.skill.gainSp(999);
|
||||
assert.ok(h.runUntil(() => u.skill.active, 4), `T${tier}: cast`);
|
||||
const t0 = h.b.time;
|
||||
approx(u.skill.timeLeft, 20, `T${tier}: first cast 20 s`, 0.05);
|
||||
approx(u.s.atk, u.base.atk * (1 + sk.bb.atk), `T${tier}: ATK`);
|
||||
h.run(5);
|
||||
const s2 = atkHits(h, u).filter((c) => c.dmg.isSkill);
|
||||
const byAttack = Map.groupBy(s2, (c) => c.dmg.attackId);
|
||||
assert.ok(byAttack.size >= 2, `T${tier}: attacks`);
|
||||
for (const list of byAttack.values()) assert.deepEqual(list.map((c) => c.target), [lone, lone], `T${tier}: both arrows at the lone enemy`);
|
||||
const other = h.spawn('enemy_mid', { pos: [11, 6] });
|
||||
h.run(5);
|
||||
const later = atkHits(h, u).filter((c) => c.dmg.isSkill && c.t > h.b.time - 4.5);
|
||||
for (const list of Map.groupBy(later, (c) => c.dmg.attackId).values()) {
|
||||
assert.deepEqual(list.map((c) => c.target).sort((a, b) => a.id - b.id), [lone, other].sort((a, b) => a.id - b.id), `T${tier}: two different enemies`);
|
||||
}
|
||||
assert.ok(h.runUntil(() => !u.skill.active, 15), `T${tier}: the first cast ends`);
|
||||
approx(h.b.time - t0, 20, `T${tier}: after 20 s`, 0.05);
|
||||
// the second cast never ends
|
||||
u.skill.gainSp(999);
|
||||
assert.ok(h.runUntil(() => u.skill.active, 4), `T${tier}: second cast`);
|
||||
assert.equal(u.skill.timeLeft, Infinity, `T${tier}: 持续时间无限`);
|
||||
h.run(120);
|
||||
assert.ok(u.skill.active, `T${tier}: still on after 120 s`);
|
||||
// the stun: 40 % of the arrows, 1 s
|
||||
const all = atkHits(h, u).filter((c) => c.dmg.isSkill);
|
||||
const stuns = h.hooksOf('statusApplied').filter((c) => c.source === u && c.status === 'stun');
|
||||
assert.ok(all.length > 100, `T${tier}: ${all.length} arrows`);
|
||||
assert.ok(stuns.length / all.length > 0.32 && stuns.length / all.length < 0.48, `T${tier}: ${stuns.length} / ${all.length} stuns ≈ 40 %`);
|
||||
for (const c of stuns) approx(c.duration, 1, `T${tier}: 1 s`);
|
||||
// a redeploy counts its casts again
|
||||
h.b.retreat(u);
|
||||
h.b.redeploy(u);
|
||||
assert.ok(!u.skill.active && u.deployed, `T${tier}: back on the field, skill off`);
|
||||
u.skill.gainSp(999);
|
||||
assert.ok(h.runUntil(() => u.skill.active, 4), `T${tier}: cast after the redeploy`);
|
||||
approx(u.skill.timeLeft, 20, `T${tier}: the first cast of this deployment — 20 s again`, 0.05);
|
||||
done(h);
|
||||
}
|
||||
});
|
||||
|
||||
test('S3 “永恒狩猎”: 7 / 8 rounds, attack interval 2.4 + 3.1 s; the mark on the heaviest enemy of her own range; range 全场 but attacks only with an enemy in the mark area (radius 1.3); each round 4 arrows 0.1 s apart on random enemies of the area, 145 % / 160 % ATK physical skill hits (no attack), 0.4 s stun once they land', () => {
|
||||
for (const [tier, elite] of [[5, false], [6, true]]) {
|
||||
const sk = skillOf(tier, elite, S3);
|
||||
const { h, u } = field({ tier, elite, skill: 2, seed: 7 });
|
||||
assert.deepEqual([u.skill.rule, u.skill.kind, sk.durationType, sk.bb['attack@s3_trigger_time'], sk.bb.base_attack_time, sk.bb['attack@s3_atk_scale'], sk.bb['attack@s3_max_hit_num'], sk.bb['attack@s3_stun'], u.skill.spCost, u.skill.initSp],
|
||||
['DEFAULT', 'ammo', 'AMMO', elite ? 8 : 7, 3.1, elite ? 1.6 : 1.45, 4, 0.4, elite ? 43 : 47, 25], `T${tier}`);
|
||||
const marked = h.spawn('enemy_heavy', { pos: [10, 6] }), near = h.spawn('enemy_light', { pos: [11, 6] });
|
||||
const away = h.spawn('enemy_mid', { pos: [9, 5] }); // in her range, 1.4+ tiles from the mark: never hit
|
||||
u.skill.gainSp(999);
|
||||
assert.ok(h.runUntil(() => u.skill.active, 4), `T${tier}: cast`);
|
||||
const t0 = h.b.time;
|
||||
assert.equal(u.mem.typhonMark.target, marked, `T${tier}: the heaviest of her range is marked`);
|
||||
assert.ok(u.liveRangeGrid.length >= 400, `T${tier}: the card shows 全场`);
|
||||
approx(u.s.interval, 2.4 + 3.1, `T${tier}: interval 5.5 s`);
|
||||
assert.ok(h.runUntil(() => !u.skill.active, 60), `T${tier}: ammo spent`);
|
||||
h.run(0.5);
|
||||
const rain = rainHits(h, u);
|
||||
assert.equal(atkHits(h, u).filter((c) => c.t >= t0 - 0.05).length, 0, `T${tier}: the round itself deals nothing`);
|
||||
assert.equal(rain.length, sk.bb['attack@s3_trigger_time'] * 4, `T${tier}: ${rain.length} arrows (rounds × 4)`);
|
||||
assert.ok(rain.every((c) => c.target === marked || c.target === near), `T${tier}: the area only`);
|
||||
assert.ok(rain.some((c) => c.target === near) && rain.some((c) => c.target === marked), `T${tier}: random among the area`);
|
||||
assert.ok(rain.every((c) => c.type === 'phys' && c.dmg.isSkill && !c.dmg.isAttack), `T${tier}: physical skill hits, no attack`);
|
||||
const rounds = Map.groupBy(rain, (c) => Math.round((c.t - t0) / 5.5));
|
||||
assert.equal(rounds.size, sk.bb['attack@s3_trigger_time'], `T${tier}: one round per bullet`);
|
||||
for (const list of rounds.values()) list.forEach((c, i) => i && approx(c.t - list[i - 1].t, 0.1, `T${tier}: 0.1 s apart`, 0.05));
|
||||
// amounts: ATK × s3_atk_scale (DEF 0), the first hit on each enemy ×1.6 (重如沼泥)
|
||||
const firsts = new Set([marked, near].map((e) => rain.find((c) => c.target === e)));
|
||||
for (const c of rain) approx(c.amount, u.s.atk * sk.bb['attack@s3_atk_scale'] * (firsts.has(c) ? 1.6 : 1), `T${tier}: s3_atk_scale`);
|
||||
const stuns = h.hooksOf('statusApplied').filter((c) => c.source === u && c.status === 'stun');
|
||||
assert.equal(stuns.length, rain.length, `T${tier}: a stun per landed arrow`);
|
||||
for (const c of stuns) approx(c.duration, 0.4, `T${tier}: 0.4 s`);
|
||||
assert.ok(!hitsBy(h, u).some((c) => c.target === away), `T${tier}: outside the mark area`);
|
||||
assert.ok(u.liveRangeGrid.length < 20, `T${tier}: own range back`);
|
||||
done(h);
|
||||
}
|
||||
});
|
||||
|
||||
test('S3 “永恒狩猎”: no enemy in the mark area ⇒ no attack and no bullet spent; the mark follows its enemy and stays where it left the field', () => {
|
||||
const { h, u } = field({ tier: 6, elite: true, skill: 2, seed: 3 });
|
||||
const walker = h.spawn('enemy_walk', { routeIndex: 0 });
|
||||
u.skill.gainSp(999);
|
||||
assert.ok(h.runUntil(() => u.skill.active, 30), 'cast once the walker is in her range');
|
||||
assert.equal(u.mem.typhonMark.target, walker);
|
||||
const x0 = u.mem.typhonMark.x;
|
||||
h.run(1);
|
||||
assert.notEqual(u.mem.typhonMark.x, x0, 'the mark moves with its enemy');
|
||||
const ammo = u.skill.ammoLeft;
|
||||
h.b.kill(walker, null);
|
||||
const spot = [u.mem.typhonMark.x, u.mem.typhonMark.y];
|
||||
h.run(12);
|
||||
assert.equal(u.skill.ammoLeft, ammo, 'nothing in the area: no round');
|
||||
assert.deepEqual([u.mem.typhonMark.x, u.mem.typhonMark.y], spot, 'the mark stays');
|
||||
const later = h.spawn('enemy_light', { pos: [Math.round(spot[1]), Math.round(spot[0])] });
|
||||
assert.ok(h.runUntil(() => rainHits(h, u).some((c) => c.target === later), 12), 'an enemy at the old spot is hit');
|
||||
assert.equal(u.skill.ammoLeft, ammo - 1);
|
||||
done(h);
|
||||
});
|
||||
|
||||
test('T1 锐如兽牙: each attack adds 10 % (SIE-X stage 3: 12 %) DEF ignore up to 5 stacks, applied to that attack already; all gone 8 s (10 s) after her last attack', () => {
|
||||
for (const [tier, elite, mod] of [[5, false, null], [6, true, null], [5, true, SIEX], [6, true, SIEX]]) {
|
||||
const t0 = formOf(tier, elite).talents.find((t) => t.index === 0).bb;
|
||||
const tc = mod ? modOf(tier, mod).talentChanges.find((t) => t.talentIndex === 0 && !t.hidden)?.bb : null;
|
||||
const per = tc?.def_penetrate ?? t0.def_penetrate, dur = tc?.duration ?? t0.duration;
|
||||
assert.deepEqual([per, dur, tc?.max_stack_cnt ?? t0.max_stack_cnt], tier === 6 && mod === SIEX ? [0.12, 10, 5] : [0.1, 8, 5], label([tier, elite, mod]));
|
||||
const { h, u } = field({ tier, elite, mod, skill: 0 });
|
||||
const e = h.spawn('enemy_plate', { pos: [10, 6] });
|
||||
h.run(16);
|
||||
const list = atkHits(h, u).filter((c) => c.target === e);
|
||||
assert.ok(list.length >= 6, `${label([tier, elite, mod])}: ${list.length} attacks`);
|
||||
list.forEach((c, i) => approx(c.amount, u.s.atk - 600 * (1 - per * Math.min(5, i + 1)), `${label([tier, elite, mod])}: attack ${i + 1}`));
|
||||
h.b.kill(e, null);
|
||||
const last = list.at(-1).t;
|
||||
h.run(last + dur - 1 - h.b.time);
|
||||
assert.equal(u.findBuff('talent:typhon:fang')?.stacks, 5, `${label([tier, elite, mod])}: still there ${dur - 1} s after the last attack`);
|
||||
h.run(1.5);
|
||||
assert.equal(u.findBuff('talent:typhon:fang'), null, `${label([tier, elite, mod])}: lost after ${dur} s without an attack`);
|
||||
done(h);
|
||||
}
|
||||
});
|
||||
|
||||
test('T2 重如沼泥: while her skill runs, the first damage on each enemy deals ×1.6 and 停顿 3 s (SIE-Y stage 3: the first two, ×2.2); not outside a skill; a new cast clears the marks', () => {
|
||||
for (const [tier, elite, mod] of [[5, false, null], [6, true, null], [5, true, SIEY], [6, true, SIEY], [6, true, ISWA]]) {
|
||||
const t1 = formOf(tier, elite).talents.find((t) => t.index === 1).bb;
|
||||
const tc = mod === SIEY && tier === 6 ? modOf(tier, SIEY).talentChanges.find((t) => t.talentIndex === 1).bb : null;
|
||||
const n = tc?.max_stack_cnt ?? 1, scale = tc?.atk_scale ?? t1.atk_scale;
|
||||
assert.deepEqual([scale, tc?.sluggish ?? t1.sluggish], [tier === 6 && mod === SIEY ? 2.2 : 1.6, 3], label([tier, elite, mod]));
|
||||
const { h, u } = field({ tier, elite, mod, skill: 0 });
|
||||
const a = h.spawn('enemy_light', { pos: [10, 5] });
|
||||
const far = (d) => (mod === SIEY ? 1 + 0.12 * (d - 1) / 3.5 : 1);
|
||||
h.run(5);
|
||||
assert.ok(atkHits(h, u).length && atkHits(h, u).every((c) => c.target === a), `${label([tier, elite, mod])}: attacks`);
|
||||
for (const c of atkHits(h, u)) approx(c.amount, u.s.atk * far(2), `${label([tier, elite, mod])}: no skill, no bonus`);
|
||||
assert.equal(h.hooksOf('statusApplied').filter((c) => c.source === u && c.status === 'sluggish').length, 0);
|
||||
u.skill.gainSp(999);
|
||||
assert.ok(h.runUntil(() => u.skill.active, 4));
|
||||
const t0 = h.b.time;
|
||||
h.run(8);
|
||||
const during = atkHits(h, u).filter((c) => c.t >= t0 - 0.05);
|
||||
assert.ok(during.length > n + 1, `${label([tier, elite, mod])}: attacks during S1`);
|
||||
during.forEach((c, i) => approx(c.amount, u.s.atk * far(2) * (i < n ? scale : 1), `${label([tier, elite, mod])}: hit ${i + 1}`));
|
||||
const slows = h.hooksOf('statusApplied').filter((c) => c.source === u && c.status === 'sluggish');
|
||||
assert.equal(slows.length, n, `${label([tier, elite, mod])}: 停顿 with the marked hits`);
|
||||
for (const c of slows) approx(c.duration, 3, '3 s');
|
||||
// a second enemy gets its own first hit; a new cast clears the marks
|
||||
u.skill.end('test');
|
||||
u.skill.gainSp(999);
|
||||
assert.ok(h.runUntil(() => u.skill.active, 5));
|
||||
const t1s = h.b.time;
|
||||
h.run(3);
|
||||
const again = atkHits(h, u).filter((c) => c.t >= t1s - 0.05);
|
||||
approx(again[0].amount, u.s.atk * far(2) * scale, `${label([tier, elite, mod])}: marks cleared by the new cast`);
|
||||
done(h);
|
||||
}
|
||||
});
|
||||
|
||||
test('SIE-X 自然的包容: ×1.15 on her attacks against 重量等级 ≥ 3, nothing below; the S3 arrow rain (no attack) is not raised', () => {
|
||||
for (const [tier, mod] of [[5, SIEX], [6, SIEX], [6, null], [6, ISWA]]) {
|
||||
const xs = mod === SIEX ? 1.15 : 1;
|
||||
if (mod === SIEX) assert.deepEqual(modOf(tier, SIEX).talentChanges.find((t) => t.hidden).bb, { atk_scale: 1.15, value: 3 });
|
||||
const { h, u } = field({ tier, elite: true, mod, skill: 0 });
|
||||
const heavy = h.spawn('enemy_heavy', { pos: [10, 5] });
|
||||
h.run(4);
|
||||
const mid = h.spawn('enemy_mid', { pos: [10, 6] });
|
||||
h.b.kill(heavy, null);
|
||||
h.run(4);
|
||||
for (const c of atkHits(h, u)) approx(c.amount, u.s.atk * (c.target.weight >= 3 ? xs : 1), `T${tier} ${mod}: ${c.target.defId}`);
|
||||
assert.ok(atkHits(h, u).some((c) => c.target === mid) && atkHits(h, u).some((c) => c.target.weight >= 3));
|
||||
done(h);
|
||||
}
|
||||
// S3: rain hits on a weight-3 enemy are s3_atk_scale × ATK (× 1.6 the first)
|
||||
const { h, u } = field({ tier: 6, elite: true, mod: SIEX, skill: 2 });
|
||||
h.spawn('enemy_heavy', { pos: [10, 6] });
|
||||
u.skill.gainSp(999);
|
||||
assert.ok(h.runUntil(() => u.skill.active, 4));
|
||||
h.run(7);
|
||||
const rain = rainHits(h, u);
|
||||
rain.forEach((c, i) => approx(c.amount, u.s.atk * 1.6 * (i === 0 ? 1.6 : 1), `rain ${i + 1}: no ×1.15`));
|
||||
done(h);
|
||||
});
|
||||
|
||||
test('SIE-Y 冰原的影子: her attack damage rises with the distance, linearly 1 → 4.5 tiles, at most +12 % (stages 1 and 3); the S3 rain is not raised', () => {
|
||||
for (const tier of [5, 6]) {
|
||||
assert.deepEqual(modOf(tier, SIEY).traitOverride.bb, { max_dist: 4.5, min_dist: 1, damage_scale: 0.12 });
|
||||
for (const [r, c] of [[10, 5], [10, 7], [11, 6]]) {
|
||||
const { h, u } = field({ tier, elite: true, mod: SIEY, skill: 0 });
|
||||
const e = h.spawn('enemy_light', { pos: [r, c] });
|
||||
h.run(3);
|
||||
const d = Math.hypot(c - 3, r - 10);
|
||||
approx(atkHits(h, u).find((x) => x.target === e).amount, u.s.atk * (1 + 0.12 * (d - 1) / 3.5), `T${tier}: ${d.toFixed(2)} tiles`);
|
||||
done(h);
|
||||
}
|
||||
}
|
||||
const { h, u } = field({ tier: 6, elite: true, mod: SIEY, skill: 2 });
|
||||
h.spawn('enemy_light', { pos: [10, 7] });
|
||||
u.skill.gainSp(999);
|
||||
assert.ok(h.runUntil(() => u.skill.active, 4));
|
||||
h.run(7);
|
||||
const n = modOf(6, SIEY).talentChanges.find((t) => t.talentIndex === 1).bb.max_stack_cnt;
|
||||
rainHits(h, u).forEach((c, i) => approx(c.amount, u.s.atk * 1.6 * (i < n ? 2.2 : 1), `rain ${i + 1}: no distance bonus`));
|
||||
done(h);
|
||||
});
|
||||
|
||||
test('ISW-A 提丰特限证章: only its HP / ATK — the 集成战略 trait (damage_scale 1.4 on heavy enemies) and arrow-rain mark do nothing here', () => {
|
||||
for (const tier of [5, 6]) {
|
||||
const m = modOf(tier, ISWA);
|
||||
assert.match(m.traitOverride.moduleDesc, /^在集成战略中/);
|
||||
assert.ok(m.talentChanges.some((t) => t.bb.damage_scale === 1.4), 'the data carries the IS part');
|
||||
const { h, u } = field({ tier, elite: true, mod: ISWA, skill: 0 });
|
||||
const heavy = h.spawn('enemy_heavy', { pos: [10, 5] });
|
||||
h.run(8);
|
||||
for (const c of atkHits(h, u).filter((x) => x.target === heavy)) approx(c.amount, u.s.atk, `T${tier}: ×1 on a weight-3 enemy`);
|
||||
h.run(30);
|
||||
assert.equal(h.hooksOf('damaged').filter((c) => c.source === u && !c.dmg.isAttack).length, 0, `T${tier}: no arrow rain of its own`);
|
||||
done(h);
|
||||
}
|
||||
});
|
||||
Reference in new issue
Block a user