feedback3: merge W3A — 联防 carries HP ratio and SP only (GitHub #82); down operators take part in the 联防 devour (players' reports, owner's decision); 不屈 on 撤退 / 替身 switches; SP recovers during stun (洛洛 S2)
This commit is contained in:
sganggs committed
commit
dcc44712ad
23 files changed
+629
-67
No files matched your search
@@ -0,0 +1,108 @@
|
||||
// test/content/feedback3-egir-down.test.js — 阿戈尔 in 联防 (community report #3, GitHub #33 item 3; per players' reports,
|
||||
// owner's decision 2026-10-04): an operator down at the end of its own combat still takes part in the battle-start devour
|
||||
// as if it stood (marking order, the unit in front, base ATK / block gains, its own marks' 物理流失) and is then forced
|
||||
// out — it used to be forced out first, which broke the chain at its tile. Nothing lands on it (it is never knocked out
|
||||
// again, revived or devoured).
|
||||
|
||||
import { test } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { makeBattle, checkInvariants } from '../helpers/battleHarness.js';
|
||||
import { FORCED_EXIT } from '../../server/sim/constants.js';
|
||||
|
||||
const close = (a, b, eps = 1e-6, msg = '') => assert.ok(Math.abs(a - b) <= eps, `${msg} expected ${b}, got ${a}`);
|
||||
const bondOn = (count, layers = 0, tier = null, thresholds = [3, 6, 9]) => ({
|
||||
count, active: count >= thresholds[0], tier: tier ?? thresholds.filter((t) => count >= t).length, layers,
|
||||
});
|
||||
const buffOf = (u, key) => u.buffs.find((b) => b.key === key) ?? null;
|
||||
const devours = (h) => h.hooksOf('damaged').filter((c) => c.dmg && c.dmg.tags && c.dmg.tags.includes('bond:egir:devour'));
|
||||
|
||||
// ---------------------------------------------------------------------------------------------------------------------
|
||||
// 阿戈尔 devour in 联防 with an operator down since its own combat
|
||||
|
||||
const ULPIA = 'chess_char_5_05_a', GHOST = 'chess_char_2_07_a', GLADY = 'chess_char_4_12_a', FODDER = 'chess_char_1_01_a';
|
||||
|
||||
function chain(ghostDown, order = [ULPIA, GHOST, GLADY, FODDER]) {
|
||||
const h = makeBattle({
|
||||
kind: 'unite', autoFinish: false, timeLimit: 60, captureNoisy: true, hooks: ['damaged', 'death', 'deploy'],
|
||||
units: order.map((chessId, i) => ({ chessId, row: 10, col: 3 + i, ...(chessId === GHOST && ghostDown ? { carryState: { down: true } } : {}) })),
|
||||
bonds: { egirShip: bondOn(3, 0, null, [3, 5]) },
|
||||
});
|
||||
h.step();
|
||||
return h;
|
||||
}
|
||||
|
||||
test('联防 阿戈尔 chain 乌尔比安 → 幽灵鲨 (down) → 歌蕾蒂娅 → fodder: 乌尔比安 gains as if 幽灵鲨 stood, then 幽灵鲨 is forced out', () => {
|
||||
const up = chain(false);
|
||||
const down = chain(true);
|
||||
const [ulpia, ghost, glady, fodder] = [ULPIA, GHOST, GLADY, FODDER].map((id) => down.unit(id));
|
||||
const ref = buffOf(up.unit(ULPIA), 'bond:egir:devour');
|
||||
const got = buffOf(ulpia, 'bond:egir:devour');
|
||||
assert.ok(ref && got, 'both 乌尔比安 devour');
|
||||
const base = (id) => down.unit(id).base;
|
||||
close(got.mods.atkFlat, base(GHOST).atk + base(GLADY).atk + base(FODDER).atk, 1e-6, 'the base ATK of 幽灵鲨, 歌蕾蒂娅 and the fodder');
|
||||
assert.equal(got.mods.blockCnt, base(GHOST).blockCnt + base(GLADY).blockCnt + base(FODDER).blockCnt);
|
||||
assert.deepEqual(got.mods, ref.mods, 'exactly the gains of the chain with 幽灵鲨 standing');
|
||||
close(ulpia.s.atk, up.unit(ULPIA).s.atk, 1e-6, '乌尔比安 ATK');
|
||||
// then she is out: forced out (not knocked out again), never devoured, never revived
|
||||
assert.ok(!ghost.alive && ghost.removeReason === FORCED_EXIT && down.b.isDown(ghost), '幽灵鲨 lies on her tile, forced out');
|
||||
assert.equal(down.hooksOf('death').filter((c) => c.unit === ghost && c.reason === 'killed').length, 0, 'no knock-out');
|
||||
assert.equal(down.hooksOf('deploy').filter((c) => c.unit === ghost && !c.initial).length, 0, 'no revive');
|
||||
assert.ok(!devours(down).some((c) => c.target === ghost), 'no 物理流失 on her');
|
||||
// standing, 乌尔比安's first mark knocks her out, so her own marks give nothing; down, her marks resolve but find
|
||||
// 歌蕾蒂娅 and the fodder already knocked out by 乌尔比安's (cancelled) — the rest resolves alike
|
||||
const pairs = (h) => devours(h).map((c) => [c.source.defId, c.target.defId]);
|
||||
assert.deepEqual(pairs(up), [[ULPIA, GHOST], [ULPIA, GLADY], [ULPIA, FODDER]]);
|
||||
assert.deepEqual(pairs(down), [[ULPIA, GLADY], [ULPIA, FODDER]]);
|
||||
assert.equal(glady.alive, up.unit(GLADY).alive);
|
||||
assert.equal(fodder.alive, up.unit(FODDER).alive);
|
||||
// her own marks (歌蕾蒂娅, the fodder) still give her their base ATK / block for when she is back
|
||||
const own = buffOf(ghost, 'bond:egir:devour');
|
||||
close(own ? own.mods.atkFlat : 0, base(GLADY).atk + base(FODDER).atk, 1e-6, '幽灵鲨 keeps her marking gains (a persistent buff)');
|
||||
checkInvariants(down.b);
|
||||
assert.equal(down.result().perPlayer.p1.deaths, up.result().perPlayer.p1.deaths - 1, 'no knock-out counted for her (standing, the devour knocks her out)');
|
||||
});
|
||||
|
||||
/** 幽灵鲨 (down or standing) → 歌蕾蒂娅 → fodder on row 10; 乌尔比安 (+ 深巡, 海霓 for 5 members) on row 12 facing empty tiles. */
|
||||
function head(ghostDown, five) {
|
||||
const units = [
|
||||
{ chessId: GHOST, row: 10, col: 3, ...(ghostDown ? { carryState: { down: true } } : {}) }, { chessId: GLADY, row: 10, col: 4 },
|
||||
{ chessId: FODDER, row: 10, col: 5 }, { chessId: ULPIA, row: 12, col: 3 },
|
||||
...(five ? [{ chessId: 'chess_char_1_04_a', row: 12, col: 5 }, { chessId: 'chess_char_3_09_a', row: 12, col: 7 }] : []),
|
||||
];
|
||||
const h = makeBattle({
|
||||
kind: 'unite', autoFinish: false, timeLimit: 60, captureNoisy: true, hooks: ['damaged', 'death', 'deploy'],
|
||||
units, bonds: { egirShip: bondOn(five ? 5 : 3, 0, null, [3, 5]) },
|
||||
});
|
||||
h.step();
|
||||
return h;
|
||||
}
|
||||
|
||||
test('联防 阿戈尔: a down member at the head of the chain devours as if it stood — its 物理流失 lands (credited to it), then it stays out', () => {
|
||||
for (const five of [false, true]) {
|
||||
const tag = five ? '5 members' : '3 members';
|
||||
const up = head(false, five);
|
||||
const down = head(true, five);
|
||||
const [ghost, glady, fodder] = [GHOST, GLADY, FODDER].map((id) => down.unit(id));
|
||||
const g = buffOf(ghost, 'bond:egir:devour');
|
||||
close(g.mods.atkFlat, glady.base.atk + fodder.base.atk, 1e-6, `${tag}: marks 歌蕾蒂娅 and, through her, the fodder`);
|
||||
const pairs = (h) => devours(h).map((c) => [c.source.defId, c.target.defId]);
|
||||
assert.deepEqual(pairs(down), pairs(up), `${tag}: the marks resolve as with 幽灵鲨 standing`);
|
||||
assert.deepEqual(pairs(down), [[GHOST, GLADY], [GHOST, FODDER]], `${tag}: her two marks; 歌蕾蒂娅's on the fodder is cancelled (knocked out first)`);
|
||||
assert.ok(!fodder.alive, `${tag}: the fodder falls`);
|
||||
assert.equal(ghost.stats.kills, up.unit(GHOST).stats.kills, `${tag}: the kills are hers, as standing`);
|
||||
assert.ok(!ghost.alive && ghost.removeReason === FORCED_EXIT && down.b.isDown(ghost), `${tag}: 幽灵鲨 stays forced out`);
|
||||
const revived = (h, u) => h.hooksOf('deploy').filter((c) => c.unit === u && !c.initial).length;
|
||||
if (five) {
|
||||
// the 5-tier revive: 歌蕾蒂娅's first knock-out (by the down 幽灵鲨's mark) spends a charge, as standing
|
||||
assert.equal(revived(down, glady), 1, '歌蕾蒂娅 revived once');
|
||||
assert.equal(revived(up, up.unit(GLADY)), 1);
|
||||
assert.ok(glady.alive, '歌蕾蒂娅 stands again');
|
||||
close(glady.hp, glady.s.maxHp, 1e-6, 'at full HP: no further mark on her');
|
||||
assert.equal(revived(down, ghost), 0, 'the down 幽灵鲨 spends nothing');
|
||||
} else {
|
||||
assert.ok(!glady.alive, '歌蕾蒂娅 falls to 幽灵鲨\'s mark (3 members: no revive)');
|
||||
}
|
||||
assert.equal(down.result().perPlayer.p1.deaths, up.result().perPlayer.p1.deaths, `${tag}: the same knock-outs`);
|
||||
checkInvariants(down.b);
|
||||
}
|
||||
});
|
||||
@@ -0,0 +1,114 @@
|
||||
// test/content/feedback3-indom-exits.test.js — 不屈 (owner's decision 2026-10-04, PRTS 卫戍协议：盟约 下半/PRTS盟约记录 不屈
|
||||
// 修正: "被击倒、撤退、切换<替身>与<本体>时，有(18+0.4×层数)%概率立刻重新部署"; "※“立刻重新部署”的实现方式为：令受益者下次
|
||||
// 部署的再部署时间和费用归零"): retreats and 傀儡师 switches roll too, not only knock-outs.
|
||||
|
||||
import { test } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { makeBattle, chessRec, checkInvariants } from '../helpers/battleHarness.js';
|
||||
import { FORCED_EXIT } from '../../server/sim/constants.js';
|
||||
|
||||
const close = (a, b, eps = 1e-6, msg = '') => assert.ok(Math.abs(a - b) <= eps, `${msg} expected ${b}, got ${a}`);
|
||||
const bondOn = (count, layers = 0, tier = null, thresholds = [3, 6, 9]) => ({
|
||||
count, active: count >= thresholds[0], tier: tier ?? thresholds.filter((t) => count >= t).length, layers,
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------------------------------------------------
|
||||
// 不屈 on 撤退 and on 替身 switches
|
||||
|
||||
const groundOp = (id, extra = {}) => chessRec({ id, profession: 'WARRIOR', skill: null, bonds: ['indomShip'], stats: { atk: 100, maxHp: 5000, def: 0, respawnTime: 70 }, ...extra });
|
||||
const spOp = (id) => groundOp(id, { skill: { duration: 5, spCost: 50, initSp: 0, bb: { atk: 1 } } });
|
||||
const INDOM = (layers, count = 2) => ({ indomShip: bondOn(count, layers, null, [2, 3]) }); // p = min(1, 0.18 + 0.004 × layers)
|
||||
const GH2 = 'chess_char_5_13_a'; // 归溟幽灵鲨: 傀儡师, a member of 阿戈尔 and 不屈
|
||||
|
||||
test('不屈: a 撤退 rolls like a knock-out — at p = 1 it is back at once, free, on its tile (行商\'s withdrawal too); tier 2\'s +5 SP stays a knock-out effect', () => {
|
||||
const h = makeBattle({
|
||||
defs: { chess: { t_a: groundOp('t_a'), t_b: spOp('t_b'), t_c: groundOp('t_c') } },
|
||||
units: [{ chessId: 't_a', row: 10, col: 4 }, { chessId: 't_b', row: 10, col: 6 }, { chessId: 't_c', row: 10, col: 8 }],
|
||||
bonds: INDOM(300, 3), autoFinish: false, timeLimit: 60, hooks: ['death', 'deploy'],
|
||||
});
|
||||
h.step();
|
||||
const [a, b] = [h.unit('t_a'), h.unit('t_b')];
|
||||
const dp0 = h.b.getPlayer('p1').dp;
|
||||
const sp0 = b.skill.sp;
|
||||
h.b.retreat(a, { reason: 'retreat' });
|
||||
assert.ok(a.alive && a.deployed, 'back at once');
|
||||
assert.equal(h.hooksOf('deploy').filter((c) => c.unit === a && !c.initial).length, 1);
|
||||
assert.deepEqual([a.tileR, a.tileC], [a.homeR, a.homeC], 'on its tile');
|
||||
close(h.b.getPlayer('p1').dp, dp0, 1e-9, 'free');
|
||||
close(b.skill.sp, sp0, 1e-9, 'no +5 SP for a retreat');
|
||||
h.step(); // (不屈 fires once per unit and instant)
|
||||
h.b.retreat(a, { reason: 'merchant' });
|
||||
assert.ok(a.alive, '行商\'s automatic withdrawal is a 撤退 too');
|
||||
h.step();
|
||||
const sp1 = b.skill.sp;
|
||||
h.b.dealDamage(null, a, { amount: 1e9, type: 'true' });
|
||||
assert.ok(a.alive, 'a knock-out: back too');
|
||||
close(b.skill.sp, sp1 + 5, 1e-9, 'a knock-out gives the tier-2 +5 SP');
|
||||
checkInvariants(h.b);
|
||||
});
|
||||
|
||||
test('不屈: no roll on the 突袭 retreat (it redeploys at once anyway) nor on the 联防 forced exit; a missed roll leaves the withdrawn operator down', () => {
|
||||
const h = makeBattle({
|
||||
kind: 'unite', defs: { chess: { t_a: groundOp('t_a'), t_b: groundOp('t_b') } },
|
||||
units: [{ chessId: 't_a', row: 10, col: 4, carryState: { down: true } }, { chessId: 't_b', row: 10, col: 6 }], bonds: INDOM(300),
|
||||
autoFinish: false, timeLimit: 60,
|
||||
});
|
||||
h.step();
|
||||
const a = h.unit('t_a');
|
||||
assert.ok(!a.alive && a.removeReason === FORCED_EXIT && h.b.isDown(a), 'the 联防 forced exit is no 撤退: it stays down with its timer');
|
||||
const b = h.unit('t_b');
|
||||
h.b.retreat(b, { reason: 'raid' });
|
||||
assert.ok(!b.alive, 'the 突袭 retreat: 不屈 leaves it to the raid\'s own redeploy');
|
||||
// p = 0.18: a seed whose roll misses leaves it down where it stood (§22.15)
|
||||
let missed = false;
|
||||
for (let seed = 1; seed < 40 && !missed; seed++) {
|
||||
const m = makeBattle({
|
||||
seed, defs: { chess: { t_a: groundOp('t_a'), t_b: groundOp('t_b') } },
|
||||
units: [{ chessId: 't_a', row: 10, col: 4 }, { chessId: 't_b', row: 10, col: 6 }], bonds: INDOM(0), autoFinish: false, timeLimit: 60,
|
||||
});
|
||||
m.step();
|
||||
const x = m.unit('t_a');
|
||||
m.b.retreat(x, { reason: 'retreat' });
|
||||
if (!x.alive) { missed = true; assert.ok(m.b.isDown(x), 'down on its tile with its timer'); }
|
||||
}
|
||||
assert.ok(missed, 'a missed roll within 39 seeds at p = 0.18');
|
||||
});
|
||||
|
||||
test('不屈: a 傀儡师 switch to the 替身 rolls — she stays on the field, and a hit makes her next deployment immediate and free', () => {
|
||||
const h = makeBattle({ units: [{ chessId: GH2, row: 10, col: 4 }], bonds: INDOM(300), autoFinish: false, timeLimit: 120, captureNoisy: true, hooks: ['deploy'] });
|
||||
h.step();
|
||||
const u = h.unit(GH2);
|
||||
assert.ok(u.ground, 'a ground operator');
|
||||
h.b.dealDamage(null, u, { amount: 1e9, type: 'true' });
|
||||
assert.ok(u.alive && u.trait.doll, 'switched to her 替身, still on the field');
|
||||
assert.equal(h.hooksOf('deploy').filter((c) => c.unit === u && !c.initial).length, 0, 'no redeploy for the switch itself');
|
||||
assert.equal(u.mem.indomFreeDeploy, true, 'the roll hit: her next deployment is zeroed');
|
||||
h.run(2);
|
||||
const dp0 = h.b.getPlayer('p1').dp;
|
||||
h.b.dealDamage(null, u, { amount: 1e9, type: 'true' }); // a lethal hit on the 替身 knocks her out
|
||||
assert.ok(u.alive && u.deployed && !u.trait.doll, 'back at once as her 本体');
|
||||
close(h.b.getPlayer('p1').dp, dp0, 1e-9, 'free');
|
||||
assert.equal(u.mem.indomFreeDeploy, false, 'spent by that deployment');
|
||||
checkInvariants(h.b);
|
||||
});
|
||||
|
||||
test('不屈: the switch back to the 本体 rolls too; a zeroed deployment brings her back even when the knock-out roll misses', () => {
|
||||
const h = makeBattle({ units: [{ chessId: GH2, row: 10, col: 4 }], bonds: INDOM(300), autoFinish: false, timeLimit: 120, captureNoisy: true });
|
||||
h.step();
|
||||
const u = h.unit(GH2);
|
||||
h.b.dealDamage(null, u, { amount: 1e9, type: 'true' });
|
||||
u.mem.indomFreeDeploy = false; // forget the first switch's roll: the switch back must roll on its own
|
||||
h.runUntil(() => !u.trait.doll, 30);
|
||||
assert.ok(u.alive && !u.trait.doll, 'back to her 本体');
|
||||
assert.equal(u.mem.indomFreeDeploy, true, 'the switch back rolled (p = 1)');
|
||||
// p = 0.18 (no layers): with a zeroed deployment banked she comes back after any knock-out, rolled or not
|
||||
for (let seed = 1; seed <= 5; seed++) {
|
||||
const m = makeBattle({ seed, defs: { chess: { t_a: groundOp('t_a') } }, units: [{ chessId: 't_a', row: 10, col: 4 }], bonds: INDOM(0), autoFinish: false, timeLimit: 60 });
|
||||
m.step();
|
||||
const x = m.unit('t_a');
|
||||
x.mem.indomFreeDeploy = true;
|
||||
m.b.dealDamage(null, x, { amount: 1e9, type: 'true' });
|
||||
assert.ok(x.alive && !x.mem.indomFreeDeploy, `seed ${seed}: back at once`);
|
||||
}
|
||||
checkInvariants(h.b);
|
||||
});
|
||||
Reference in new issue
Block a user