395 lines
25 KiB
JavaScript
395 lines
25 KiB
JavaScript
// test/sim/playtest5-targeting.test.js — user playtest #5 items 1 and 5 (DESIGN §19).
|
||
// #1 "有近地悬浮的敌人会被只能攻击地面单位的干员打到": a hovering enemy (近地悬浮, PRTS 术语释义 ba.float) is an air unit for
|
||
// every targeting rule (Unit.isFlying) while it keeps the ground path; it cannot be blocked or displaced (失衡免疫);
|
||
// 掠海漂移体 / 吉兆飞鳞 lose the float when stunned (their PRTS pages); 浮空 (levitate) is an air unit too.
|
||
// #5 "敌人优先锁定的干员顺序": PRTS 作战机制 索敌 — 敌方 "阻挡→特殊优先级→仇恨值（更容易被攻击→…→最后部署的目标→不容易被
|
||
// 攻击）→最早出现"; PRTS 卫戍协议/帮助 — "按从上到下>从左到右的顺序部署。优先部署干员，随后为召唤物"; a stealthed ally
|
||
// is attacked only by the enemy it blocks (PRTS 作战机制 §隐匿); an enemy's own rule (只攻击地面单位) filters its
|
||
// candidates before the order; a special priority (优先攻击防御力最高的…) breaks ties by taunt, then latest deployed.
|
||
|
||
import { test } from 'node:test';
|
||
import assert from 'node:assert/strict';
|
||
import fs from 'node:fs';
|
||
import { makeBattle, chessRec, enemyRec, checkInvariants } from '../helpers/battleHarness.js';
|
||
import * as enemiesMod from '../../server/sim/content/enemies.js';
|
||
import * as bossesMod from '../../server/sim/content/bosses.js';
|
||
import { canTargetEnemy } from '../../server/sim/targeting.js';
|
||
|
||
const FLOATER = 'enemy_2025_syufo'; // 掠海漂移体 (海嗣, ELEMENT faction)
|
||
const PARROT = 'enemy_10045_parrot'; // 吉兆飞鳞 (悬赏·飞行II)
|
||
const approx = (a, b, eps = 1e-6, msg = '') => assert.ok(Math.abs(a - b) <= eps * Math.max(1, Math.abs(b)), `${msg} ${a} ≈ ${b}`);
|
||
/** Damage `src` dealt to `target` (recorded `damaged` hooks; needs captureNoisy). */
|
||
const dealt = (h, src, target) => h.hooksOf('damaged').filter((c) => c.source === src && c.target === target).reduce((a, c) => a + c.amount, 0);
|
||
/** A pinned enemy (speed ×0) on a tile; `o.mods` merged. */
|
||
const put = (h, key, pos, o = {}) => h.spawn(key, { pos, routeIndex: 0, mods: { speedMul: o.move ? 1 : 0, ...(o.mods || {}) } });
|
||
|
||
// synthetic allies: a wall that never attacks, a melee blade, a long-range gun
|
||
const WALL = chessRec({ id: 't_wall', profession: 'TANK', stats: { atk: 0, maxHp: 1e7, blockCnt: 3 }, rangeGrid: [[0, 0]], skill: null });
|
||
const BLADE = chessRec({ id: 't_blade', profession: 'WARRIOR', stats: { atk: 300, maxHp: 1e7, bat: 1, blockCnt: 2 }, rangeGrid: [[0, 0], [0, 1]], skill: null });
|
||
const BIG = [];
|
||
for (let dr = -4; dr <= 4; dr++) for (let dc = -12; dc <= 12; dc++) BIG.push([dr, dc]);
|
||
const GUN = chessRec({ id: 't_gun', profession: 'SNIPER', projectile: 'none', stats: { atk: 300, maxHp: 1e7, bat: 1, blockCnt: 0 }, rangeGrid: BIG, skill: null });
|
||
const SHOOTER = enemyRec({ key: 'enemy_t_shooter', hp: 1e7, atk: 10, range: 9, bat: 1, speed: 0 });
|
||
const SLIME = enemyRec({ key: 'enemy_t_slime', hp: 1e7, atk: 0, speed: 0 });
|
||
const BAT = enemyRec({ key: 'enemy_t_bat', hp: 1e7, atk: 0, speed: 0, motion: 'FLY' });
|
||
const SYN = { chess: { t_wall: WALL, t_blade: BLADE, t_gun: GUN }, enemies: { enemy_t_shooter: SHOOTER, enemy_t_slime: SLIME, enemy_t_bat: BAT } };
|
||
const NOATK = () => ({ trait: { noAttack: true } });
|
||
|
||
/** Synthetic arena: generic kits + the enemies module only (other content never interferes). */
|
||
function arena(o = {}) {
|
||
return makeBattle({ content: 'generic', extraContent: [enemiesMod], seed: 7, autoFinish: false, timeLimit: 300, defs: SYN,
|
||
kits: { t_wall: NOATK }, captureNoisy: true, ...o });
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------------------------------------------
|
||
// #1 近地悬浮
|
||
|
||
test('#1 the user\'s case: ground-only operators never hit a 近地悬浮 enemy (melee 山 / 泡泡, 迷迭香\'s ground-only shots); ranged 能天使 and the lord 银灰 do', () => {
|
||
const cases = [
|
||
['chess_char_5_17_a', 10, 5, false], // 山 (fighter, melee)
|
||
['chess_char_2_08_a', 10, 6, false], // 泡泡 (protector, melee — standing on the floater's tile)
|
||
['chess_char_6_12_a', 10, 4, false], // 迷迭香 (bombarder: "攻击对小范围的地面敌人造成…" — ranged but ground only)
|
||
['chess_char_3_01_a', 10, 4, true], // 能天使 (fastshot, ranged)
|
||
['chess_char_4_22_a', 10, 5, true], // 银灰 (lord: ranged reach, can hit air)
|
||
];
|
||
for (const [chessId, row, col, hits] of cases) {
|
||
const h = makeBattle({ units: [{ chessId, row, col }], seed: 3, autoFinish: false, timeLimit: 120, captureNoisy: true });
|
||
h.step();
|
||
const e = put(h, FLOATER, [10, 6], { mods: { hpMul: 100, atkMul: 0 } });
|
||
assert.ok(e.isFlying && e.motion === 'WALK', 'an air unit on the ground path');
|
||
h.run(20);
|
||
const op = h.b.allyUnits.find((u) => u.kind === 'op');
|
||
const d = dealt(h, op, e);
|
||
assert.equal(d > 0, hits, `${op.name}: ${d}`);
|
||
assert.ok(!e.blockedBy, `${op.name}: never blocks it`);
|
||
checkInvariants(h.b);
|
||
}
|
||
});
|
||
|
||
test('#1 ground-only splash spares a hovering enemy next to its ground target (迷迭香 + aftershocks)', () => {
|
||
const h = makeBattle({ units: [{ chessId: 'chess_char_6_12_a', row: 10, col: 3 }], seed: 3, autoFinish: false, timeLimit: 120, captureNoisy: true, defs: SYN });
|
||
h.step();
|
||
const g = put(h, 'enemy_t_slime', [10, 6]);
|
||
const e = put(h, FLOATER, [10, 6], { mods: { hpMul: 100, atkMul: 0 } });
|
||
h.run(15);
|
||
const op = h.b.allyUnits.find((u) => u.kind === 'op');
|
||
assert.ok(dealt(h, op, g) > 0, 'the ground enemy is shot');
|
||
assert.equal(dealt(h, op, e), 0, 'the floater on the same tile takes no splash');
|
||
});
|
||
|
||
test('#1 a 近地悬浮 enemy walks the ground path through blockers, cannot be displaced (失衡免疫) and ignores deep water', () => {
|
||
const h = arena({ units: [{ chessId: 't_wall', row: 9, col: 6 }] });
|
||
h.step();
|
||
const e = h.spawn(FLOATER, { routeIndex: 0, mods: { atkMul: 0 } });
|
||
const ys = new Set();
|
||
h.b.on('tick', () => { if (e.alive) ys.add(Math.round(e.y)); });
|
||
h.runUntil(() => e.x < 5.5, 60);
|
||
assert.ok(e.x < 5.5 && !e.blockedBy, 'passed the wall on (9,6)');
|
||
assert.deepEqual([...ys], [9], 'stayed on its ground lane');
|
||
const x0 = e.x;
|
||
assert.equal(h.b.displace(e, { x: 1, y: 0 }, 2, { force: 3 }), 0);
|
||
assert.equal(e.x, x0);
|
||
// 深水 (act2 m04): the floater hovers over the water — no drowning damage or slow
|
||
const w = makeBattle({ stageId: 'act2autochess_m04', autoFinish: false, timeLimit: 30,
|
||
routes: [{ motion: 'WALK', start: [11, 6], end: [9, 2], checkpoints: [{ type: 'WAIT', time: 99 }] }],
|
||
enemies: [{ key: FLOATER, route: { motion: 'WALK', start: [11, 6], end: [9, 2], checkpoints: [{ type: 'WAIT', time: 99 }] } }] });
|
||
w.run(3);
|
||
const f = w.enemy(FLOATER);
|
||
assert.equal(f.hp, f.s.maxHp, 'not in the water');
|
||
assert.equal(f.findBuff('terrain:deepsea'), null);
|
||
});
|
||
|
||
test('#1 掠海漂移体 stunned ⇒ 爬行模式 for good (PRTS): a ground unit — blocked, hit by melee — that only attacks its blocker', () => {
|
||
const h = arena({ units: [{ chessId: 't_blade', row: 10, col: 5 }, { chessId: 't_gun', row: 12, col: 3 }] });
|
||
h.step();
|
||
const e = put(h, FLOATER, [10, 6], { mods: { hpMul: 100 } });
|
||
const blade = h.unit('t_blade'), gun = h.unit('t_gun');
|
||
h.run(3);
|
||
assert.equal(dealt(h, blade, e), 0, 'floating: the blade cannot hit it');
|
||
assert.ok(e.stats.attacks > 0, 'floating: attacks at range');
|
||
assert.ok(h.b.applyStatus(e, 'stun', { duration: 0.2, source: gun }));
|
||
assert.ok(!e.isFlying && !e.s.flags.unblockable && !e.s.flags.noDisplace, 'crawling: a ground unit');
|
||
approx(e.findBuff('stun').timeLeft, 0.5, 1e-9, 'the 0.5 s drop stun (the longer one)');
|
||
assert.ok(e.profile.melee, '仅进行阻挡攻击');
|
||
h.run(3);
|
||
assert.ok(dealt(h, blade, e) > 0, 'the blade hits it now');
|
||
// walking again it is blocked by a ground operator on its way
|
||
const h2 = arena({ units: [{ chessId: 't_wall', row: 9, col: 6 }] });
|
||
h2.step();
|
||
const e2 = h2.spawn(FLOATER, { routeIndex: 0, mods: { atkMul: 0 } });
|
||
h2.b.applyStatus(e2, 'freeze', { duration: 0.5 });
|
||
h2.runUntil(() => !!e2.blockedBy || e2.x < 5.5, 60);
|
||
assert.equal(e2.blockedBy, h2.unit('t_wall'), '冻结 drops it too; then the wall blocks it');
|
||
});
|
||
|
||
test('#1 吉兆飞鳞: a stun grounds it for Stun.duration s (unblockable), then it floats again; a freeze grounds it when it ends', () => {
|
||
const h = arena();
|
||
h.step();
|
||
const e = put(h, PARROT, [10, 7]);
|
||
const down = e.mem.ab.t['Stun.duration'];
|
||
assert.ok(down > 0 && e.isFlying);
|
||
h.b.applyStatus(e, 'stun', { duration: 0.5 });
|
||
assert.ok(!e.isFlying && e.s.flags.unblockable, '晕眩模式: no float, still unblockable');
|
||
approx(e.findBuff('stun').timeLeft, down, 1e-9);
|
||
h.run(down - 0.2);
|
||
assert.ok(!e.isFlying);
|
||
h.run(0.4);
|
||
assert.ok(e.isFlying && e.s.flags.noDisplace, 'floats again (初始模式)');
|
||
h.b.applyStatus(e, 'freeze', { duration: 1 });
|
||
h.run(0.5);
|
||
assert.ok(e.isFlying, 'frozen: still floating');
|
||
h.run(0.6);
|
||
assert.ok(!e.isFlying && e.findBuff('stun'), '【失温坠落】: grounded when the freeze ends');
|
||
// "离开上述异常效果影响后进入初始模式": a sleep that outlasts the mode stun keeps it down until the sleep ends
|
||
const z = put(h, PARROT, [11, 7]);
|
||
assert.ok(h.b.applyStatus(z, 'sleep', { duration: down + 3 }));
|
||
h.run(down + 0.5);
|
||
assert.ok(!z.isFlying && z.s.flags.sleep && !z.findBuff('stun'), 'asleep after the 8 s stun: still grounded');
|
||
h.run(3);
|
||
assert.ok(z.isFlying && !z.s.flags.sleep, 'awake: floats again');
|
||
});
|
||
|
||
test('#1 浮空 (levitate) makes a ground enemy an air unit (melee cannot hit it); data flyers and levitated units refuse it, a 近地悬浮 enemy does not', () => {
|
||
const h = arena({ units: [{ chessId: 't_blade', row: 10, col: 5 }] });
|
||
h.step();
|
||
const g = put(h, 'enemy_t_slime', [10, 6]);
|
||
const blade = h.unit('t_blade');
|
||
assert.ok(canTargetEnemy(blade, g, blade.profile));
|
||
assert.ok(h.b.applyStatus(g, 'levitate', { duration: 3 }));
|
||
assert.ok(g.isFlying && !canTargetEnemy(blade, g, blade.profile) && canTargetEnemy(blade, g, { canHitFly: true }));
|
||
// PRTS 行动方式: "行动类型（数据）为飞行的单位、以及已持有浮空异常的单位无法被施加浮空Buff"
|
||
assert.equal(h.b.applyStatus(g, 'levitate', { duration: 3 }), false, 'already levitated');
|
||
assert.equal(h.b.applyStatus(put(h, 'enemy_t_bat', [9, 6]), 'levitate', { duration: 3 }), false, 'a data flyer');
|
||
// 近地悬浮 is WALK in the data: it can be levitated; 浮空 is none of 掠海漂移体's drop triggers (晕眩/无法行动/沉睡/冻结/缚地)
|
||
const f = put(h, FLOATER, [11, 6]);
|
||
assert.ok(h.b.applyStatus(f, 'levitate', { duration: 3 }), 'a hovering enemy can be levitated');
|
||
assert.ok(f.isFlying && f.s.flags.stun && f.findBuff('ab:float'), 'levitated: helpless, still an air unit, still hovering');
|
||
assert.ok(!f.profile.melee, 'not in 爬行模式');
|
||
h.run(3.1);
|
||
assert.ok(!g.isFlying && canTargetEnemy(blade, g, blade.profile), 'back on the ground');
|
||
assert.ok(f.isFlying && f.findBuff('ab:float') && !f.s.flags.levitate && !f.profile.melee, 'the floater keeps hovering');
|
||
});
|
||
|
||
/**
|
||
* Chess `id` with skill `skillIndex` at (10, col) next to a pinned floating 掠海漂移体 and a ground bait on (10, 6); the
|
||
* skill is refilled every second for `secs` s. Returns the damage its side (the operator, its summons) dealt to the bait
|
||
* and — only while it still hovered — to the floater, per damage tag.
|
||
*/
|
||
function floaterDuel(id, skillIndex, { col = 5, secs = 30 } = {}) {
|
||
const BAIT = enemyRec({ key: 'enemy_t_bait', hp: 1e9, atk: 0, speed: 0 });
|
||
const h = makeBattle({ units: [{ chessId: id, row: 10, col, skillIndex }], seed: 3, autoFinish: false, timeLimit: 200, captureNoisy: true, defs: { enemies: { enemy_t_bait: BAIT } } });
|
||
h.step();
|
||
const f = put(h, FLOATER, [10, 6], { mods: { hpMul: 1e5, atkMul: 0 } });
|
||
const g = put(h, 'enemy_t_bait', [10, 6]);
|
||
const out = { floater: 0, bait: 0, floaterTags: new Map() };
|
||
h.b.on('damaged', (c) => {
|
||
if (!c.source || c.source.side !== 'ally' || !(c.amount > 0)) return;
|
||
if (c.target === g) out.bait += c.amount;
|
||
if (c.target !== f || !f.findBuff('ab:float')) return;
|
||
out.floater += c.amount;
|
||
for (const t of c.dmg?.tags || ['-']) out.floaterTags.set(t, (out.floaterTags.get(t) || 0) + c.amount);
|
||
});
|
||
const op = h.b.allyUnits.find((u) => u.kind === 'op');
|
||
for (let t = 0; t < secs; t++) {
|
||
if (op.skill && !op.skill.active) op.skill.gainSp(op.skill.spCost * (op.skill.maxCharges || 1) + 1, 'test');
|
||
h.run(1);
|
||
}
|
||
assert.deepEqual(h.b.errors.map((e) => `${e.label} ${e.message}`), []);
|
||
return out;
|
||
}
|
||
|
||
test('#1 ground-only skills and talents spare a hovering enemy (the worst 731a01c offenders + the PRTS "不可对空" notes)', () => {
|
||
const cases = [
|
||
['chess_char_6_19_a', 1, 5, '锏 S2 无声的嘲笑'],
|
||
['chess_char_6_07_a', 0, 5, '维娜·维多利亚 S1 重铸晖光'],
|
||
['chess_char_5_06_a', 2, 5, '隐德来希 S3 灵与欲的惜别'],
|
||
['chess_char_6_12_a', 2, 4, '迷迭香 S3 “如你所愿”'],
|
||
['chess_char_5_06_a', 1, 5, '隐德来希 S2 绯红壁合 (PRTS 备注: 血镰 可对空 only on a 起飞 carrier)'],
|
||
['chess_char_5_13_a', 1, 5, '归溟幽灵鲨 拥抱自我 (PRTS 备注: "伤害与减速不可对空")'],
|
||
['chess_char_3_04_a', 2, 5, '琳琅诗怀雅 S3 千金一掷 (PRTS 备注: 地面敌方单位, 弹道不可对空)'],
|
||
['chess_char_5_05_a', 0, 5, '乌尔比安 S1 必须促成的接触 (捕网, like 雪雉\'s "不对空" net)'],
|
||
];
|
||
for (const [id, idx, col, name] of cases) for (const cid of [id, id.replace(/_a$/, '_b')]) {
|
||
const r = floaterDuel(cid, idx, { col });
|
||
assert.ok(r.bait > 0, `${name} (${cid}): the ground bait is hit`);
|
||
assert.equal(r.floater, 0, `${name} (${cid}): ${JSON.stringify([...r.floaterTags])}`);
|
||
}
|
||
});
|
||
|
||
test('#1 skills PRTS marks "可对空" still hit a hovering enemy (德克萨斯 S2 剑雨, 焰尾 S2 “红松林”, 锏 S3 归于宁静)', () => {
|
||
// 锏 S3: PRTS 备注 "※可对空。不会拖拽自身中心半径0.6708范围内的敌人" (user playtest #6, WF audit — it used to sit in the
|
||
// ground-only list above)
|
||
for (const [id, idx, tag, name] of [['chess_char_1_08_a', 1, 'skill', '德克萨斯 S2'], ['chess_char_4_19_a', 1, 'redPine', '焰尾 S2'], ['chess_char_6_19_a', 2, 'slash', '锏 S3']]) {
|
||
const r = floaterDuel(id, idx);
|
||
assert.ok((r.floaterTags.get(tag) || 0) > 0, `${name}: ${JSON.stringify([...r.floaterTags])}`);
|
||
}
|
||
});
|
||
|
||
test('#1 阿罗玛\'s bubble levitates a hovering 掠海漂移体 (WALK in its data) without dropping it to 爬行模式', () => {
|
||
const h = makeBattle({ units: [{ chessId: 'chess_char_4_10_a', row: 10, col: 3 }], seed: 3, autoFinish: false, timeLimit: 60 });
|
||
h.step();
|
||
const f = put(h, FLOATER, [10, 6], { mods: { hpMul: 100, atkMul: 0 } });
|
||
h.runUntil(() => h.hooksOf('statusApplied').some((c) => c.target === f && c.status === 'levitate'), 10);
|
||
const lev = h.hooksOf('statusApplied').find((c) => c.target === f && c.status === 'levitate');
|
||
assert.ok(lev, 'levitated by her first hit');
|
||
assert.ok(f.isFlying && f.findBuff('ab:float') && !f.profile.melee, 'still hovering, not crawling');
|
||
});
|
||
|
||
test('#1 HOVER_KEYS lists exactly the enemies that spawn hovering (the match\'s bot counts them as air units)', () => {
|
||
const E = JSON.parse(fs.readFileSync(new URL('../../data/enemies.json', import.meta.url), 'utf8'));
|
||
const h = arena();
|
||
h.step();
|
||
const hov = [];
|
||
for (const key of Object.keys(E)) {
|
||
const e = put(h, key, [10, 6]);
|
||
if (e && e.findBuff('ab:float')) hov.push(key);
|
||
}
|
||
assert.deepEqual(hov.sort(), [...enemiesMod.HOVER_KEYS].sort());
|
||
});
|
||
|
||
// ---------------------------------------------------------------------------------------------------------------
|
||
// #5 enemy target order
|
||
|
||
/** The ally the latest attack of `enemy` targeted. */
|
||
function lastTarget(h, enemy) {
|
||
const ev = h.eventsOf('atk').filter((x) => x[1] === enemy.id).pop();
|
||
return ev ? h.b.unitById(ev[2]) : null;
|
||
}
|
||
|
||
test('#5 unblocked ranged enemies: highest taunt, then the latest deployed — the rightmost column, its bottom (从上到下 > 从左到右: down each column, the columns left to right)', () => {
|
||
const units = [[12, 5], [11, 3], [9, 4], [9, 7], [10, 8], [12, 8]].map(([row, col], i) => ({ chessId: 't_wall', row, col, uid: i + 1 }));
|
||
const h = arena({ units, enemies: [{ key: 'enemy_t_shooter', pos: [10.5, 6] }] });
|
||
h.step();
|
||
const order = h.hooksOf('deploy').filter((c) => c.initial).map((c) => [c.unit.tileR, c.unit.tileC]);
|
||
assert.deepEqual(order, [[11, 3], [9, 4], [12, 5], [9, 7], [12, 8], [10, 8]]);
|
||
h.run(1.2);
|
||
const e = h.enemy('enemy_t_shooter');
|
||
const t = lastTarget(h, e);
|
||
assert.deepEqual([t.tileR, t.tileC], [10, 8], 'the last deployed');
|
||
// a taunt level beats deployment order
|
||
const h2 = arena({ units, enemies: [{ key: 'enemy_t_shooter', pos: [10.5, 6] }] });
|
||
h2.step();
|
||
h2.b.addBuff(h2.unit(1), { key: 'test:taunt', mods: { taunt: 1 }, persist: true });
|
||
h2.run(1.2);
|
||
assert.equal(lastTarget(h2, h2.enemy('enemy_t_shooter')), h2.unit(1));
|
||
});
|
||
|
||
test('#5 the initial deployment puts every operator before the summons (PRTS 卫戍协议/帮助) — a summon piece draws the fire', () => {
|
||
const tok = { kind: 'token', tokenId: 'token_10028_vigil_wolf', ownerUid: 1, row: 12, col: 4, uid: 3, def: { name: 'tok', stats: { maxHp: 1e7, atk: 0, blockCnt: 0 } } };
|
||
const h = arena({ units: [{ chessId: 't_wall', row: 12, col: 3, uid: 1 }, { chessId: 't_wall', row: 9, col: 8, uid: 2 }, tok], enemies: [{ key: 'enemy_t_shooter', pos: [10.5, 6] }] });
|
||
h.step();
|
||
const order = h.hooksOf('deploy').filter((c) => c.initial).map((c) => c.unit.uid);
|
||
assert.deepEqual(order, [1, 2, 3], 'the operators (by column from the left), then the summon');
|
||
const t = h.unit(3);
|
||
assert.ok(t.aggroSeq > h.unit(1).aggroSeq && t.aggroSeq > h.unit(2).aggroSeq);
|
||
h.run(1.2);
|
||
assert.equal(lastTarget(h, h.enemy('enemy_t_shooter')), t);
|
||
// a summon an operator brings along at the start ranks after every operator too
|
||
const h2 = arena({ units: [{ chessId: 't_wall', row: 12, col: 3, uid: 1 }, { chessId: 't_wall', row: 9, col: 8, uid: 2 }], enemies: [{ key: 'enemy_t_shooter', pos: [10.5, 6] }],
|
||
setup: (b) => b.on('deploy', (c) => { if (c.initial && c.unit.uid === 1) b.spawnToken(c.unit, 'token_10028_vigil_wolf', 12, 4, { def: { name: 'tok', stats: { maxHp: 1e7, atk: 0, blockCnt: 0 } } }); }) });
|
||
h2.step();
|
||
const s = h2.b.allyUnits.find((u) => u.kind === 'token');
|
||
assert.ok(s.deploySeq < h2.unit(2).deploySeq, 'it came in during the first operator\'s deployment');
|
||
assert.ok(s.aggroSeq > h2.unit(2).aggroSeq, '…but ranks after every operator');
|
||
h2.run(1.2);
|
||
assert.equal(lastTarget(h2, h2.enemy('enemy_t_shooter')), s);
|
||
// a redeployed operator is the latest deployed again
|
||
h2.b.retreat(h2.unit(1), { reason: 'retreat' });
|
||
h2.b.redeploy(h2.unit(1), { free: true });
|
||
assert.ok(h2.unit(1).aggroSeq > s.aggroSeq);
|
||
});
|
||
|
||
test('#5 a blocked ranged enemy attacks its blocker first', () => {
|
||
const h = arena({ units: [{ chessId: 't_wall', row: 10, col: 6, uid: 1 }, { chessId: 't_wall', row: 9, col: 7, uid: 2 }], enemies: [{ key: 'enemy_t_shooter', pos: [10, 6] }] });
|
||
h.step();
|
||
h.run(1.2);
|
||
const e = h.enemy('enemy_t_shooter');
|
||
assert.equal(e.blockedBy, h.unit(1));
|
||
assert.equal(lastTarget(h, e), h.unit(1), 'not the later-deployed one beside it');
|
||
});
|
||
|
||
test('#5 隐匿 / 迷彩 allies: only the enemy they block attacks them — blocking does not expose them to other ranged enemies (PRTS 作战机制 §隐匿, 索敌的概念)', () => {
|
||
const units = [{ chessId: 't_wall', row: 12, col: 5, uid: 1 }, { chessId: 't_wall', row: 9, col: 7, uid: 2 }];
|
||
const mk = (stealth) => {
|
||
const h = arena({ units, enemies: [{ key: 'enemy_t_shooter', pos: [10.5, 5] }, { key: 'enemy_t_shooter', pos: [9, 7] }] });
|
||
h.step();
|
||
if (stealth) h.b.applyStatus(h.unit(2), 'stealth', { duration: 99 });
|
||
h.run(1.2);
|
||
const held = h.b.enemies.find((e) => e.blockedBy === h.unit(2));
|
||
const free = h.b.enemies.find((e) => e !== held);
|
||
assert.ok(held && free && !free.blockedBy);
|
||
return { h, held, free };
|
||
};
|
||
const a = mk(true);
|
||
assert.equal(lastTarget(a.h, a.held), a.h.unit(2), 'the enemy it blocks attacks it ("强行无视对方可选性")');
|
||
assert.equal(lastTarget(a.h, a.free), a.h.unit(1), 'an unblocked ranged enemy skips it although it blocks ("我方干员并不会因为阻挡而解除隐匿")');
|
||
const b = mk(false);
|
||
assert.equal(lastTarget(b.h, b.free), b.h.unit(2), 'control: without stealth the latest deployed is shot');
|
||
// 排气格栅 (烟雾) uses the same stealth flag: test/content/tokens_devices.test.js
|
||
});
|
||
|
||
test('#5 an enemy\'s own rule filters its candidates first: 萨卡兹枯朽战车 (只攻击地面单位) shoots the ground operator, never idles', () => {
|
||
// (10,2) is high ground: that operator deploys last (row 10 after row 11) and would be the preferred target
|
||
const h = arena({ units: [{ chessId: 't_wall', row: 11, col: 5, uid: 1 }, { chessId: 't_wall', row: 10, col: 2, uid: 2 }] });
|
||
h.step();
|
||
assert.equal(h.unit(2).ground, false);
|
||
const e = put(h, 'enemy_1272_nhtank', [10, 4], { mods: { atkMul: 0.01 } });
|
||
h.runUntil(() => e.stats.attacks >= 2, 20);
|
||
assert.ok(e.stats.attacks >= 2, 'it attacks');
|
||
const targets = h.eventsOf('atk').filter((x) => x[1] === e.id).map((x) => x[2]);
|
||
assert.ok(targets.every((id) => id === h.unit(1).id), 'only the ground operator');
|
||
// PRTS 天赋 "普通攻击只攻击位于低地的我方单位，且不会攻击飞行单位": a flying ally on a low tile (the 炎佑 dragon) is no target
|
||
const h2 = arena({ units: [{ chessId: 't_wall', row: 11, col: 5, uid: 1 }, { chessId: 't_wall', row: 10, col: 5, uid: 2 }] });
|
||
h2.step();
|
||
h2.unit(2).motion = 'FLY';
|
||
assert.ok(h2.unit(2).ground && h2.unit(2).isFlying);
|
||
const e2 = put(h2, 'enemy_1272_nhtank', [10, 4], { mods: { atkMul: 0.01 } });
|
||
h2.runUntil(() => e2.stats.attacks >= 2, 20);
|
||
assert.ok(e2.stats.attacks >= 2);
|
||
assert.ok(h2.eventsOf('atk').filter((x) => x[1] === e2.id).every((x) => x[2] === h2.unit(1).id), 'never the flyer');
|
||
});
|
||
|
||
test('#5 “萨科塔之眼” (不会攻击飞行单位) filters its candidates: it shoots the ground ally, never the later-deployed flyer', () => {
|
||
const h = arena({ units: [{ chessId: 't_wall', row: 11, col: 5, uid: 1 }, { chessId: 't_wall', row: 10, col: 5, uid: 2 }] });
|
||
h.step();
|
||
h.unit(2).motion = 'FLY';
|
||
const e = put(h, 'enemy_10084_hlegle', [10.5, 5.5], { mods: { atkMul: 0.01 } });
|
||
h.runUntil(() => e.stats.attacks >= 2, 20);
|
||
assert.ok(e.stats.attacks >= 2, 'it attacks');
|
||
assert.ok(h.eventsOf('atk').filter((x) => x[1] === e.id).every((x) => x[2] === h.unit(1).id), 'only the ground ally');
|
||
});
|
||
|
||
test('#5 a shared field (boss / 联防) deploys the players side by side — the i-th operators together, then the summons [ASSUMED]', () => {
|
||
const W = chessRec({ id: 't_w', profession: 'TANK', stats: { atk: 0, maxHp: 1e7, blockCnt: 3 }, rangeGrid: [[0, 0]], skill: null });
|
||
const tok = { kind: 'token', tokenId: 'token_10028_vigil_wolf', ownerUid: 1, row: 12, col: 6, uid: 5, def: { name: 'tok', stats: { maxHp: 1e7, atk: 0, blockCnt: 0 } } };
|
||
const h = makeBattle({ kind: 'boss', content: 'none', autoFinish: false, defs: { chess: { t_w: W } },
|
||
players: [
|
||
{ playerId: 'L1', side: 'L', colOffset: 0, units: [{ uid: 1, chessId: 't_w', row: 12, col: 4 }, { uid: 2, chessId: 't_w', row: 11, col: 4 }, { uid: 3, chessId: 't_w', row: 10, col: 4 }, tok] },
|
||
{ playerId: 'R1', side: 'R', colOffset: 8, units: [{ uid: 4, chessId: 't_w', row: 12, col: 4 }] },
|
||
] });
|
||
h.step();
|
||
assert.deepEqual(h.hooksOf('deploy').filter((c) => c.initial).map((c) => c.unit.uid), [1, 4, 2, 3, 5],
|
||
'not every left operator before the right one: at equal taunt the leader does not always prefer one player');
|
||
const seq = (uid) => h.b.allyUnits.find((u) => u.uid === uid).aggroSeq;
|
||
assert.ok(seq(5) > Math.max(seq(1), seq(2), seq(3), seq(4)), 'the summon ranks after every operator');
|
||
});
|
||
|
||
test('#5 a special priority breaks ties by taunt, then the latest deployed (假想敌：铳 "优先攻击防御力最高的单位"; PRTS 索敌: 特殊优先级 → 仇恨值)', () => {
|
||
const pool = { hp: 1e7, maxHp: 1e7, damage(pid, a) { this.hp = Math.max(0, this.hp - a); } };
|
||
const duel = (taunt) => {
|
||
const h = makeBattle({ kind: 'boss', sharedBoss: pool, content: 'generic', extraContent: [enemiesMod, bossesMod], seed: 7, autoFinish: false, timeLimit: 600,
|
||
defs: SYN, kits: { t_wall: NOATK }, units: [{ chessId: 't_wall', row: 10, col: 9, uid: 1 }, { chessId: 't_wall', row: 10, col: 11, uid: 2 }] });
|
||
h.step();
|
||
if (taunt) h.b.addBuff(h.unit(1), { key: 'test:taunt', mods: { taunt: 1 }, persist: true });
|
||
const e = h.spawn('enemy_9017_achunt', { pos: [3, 10], routeIndex: 0, mods: { speedMul: 0 }, tag: 'boss' });
|
||
h.runUntil(() => e.stats.attacks >= 1, 60);
|
||
assert.ok(e.stats.attacks >= 1);
|
||
assert.equal(h.unit(1).s.def, h.unit(2).s.def, 'equal DEF');
|
||
return { h, t: lastTarget(h, e) };
|
||
};
|
||
const a = duel(false);
|
||
assert.equal(a.t, a.h.unit(2), 'equal DEF: the latest deployed');
|
||
const b = duel(true);
|
||
assert.equal(b.t, b.h.unit(1), 'equal DEF: the higher taunt level first');
|
||
});
|