177 lines
12 KiB
JavaScript
177 lines
12 KiB
JavaScript
// User playtest #6 follow-up, client side of "合成精锐时，如果消耗了场上的干员，精锐会出现在场上那个位置" (PRTS 卫戍协议/帮助
|
|
// "若消耗已部署至作战区的干员，则发送至作战区对应位置"; server PlayerState._mergeChess / board.js mergeTile):
|
|
// * gameLogic.mergeTarget mirrors the server: the tile of the deployed copy that deploys first (row desc, col asc)
|
|
// when gaining one more copy completes a merge, null when it completes none or no copy is deployed (the hand)
|
|
// * the shop card's 可晋升 tag says where the elite goes; ShopBar reports the armed card (armedSlotOf → onArm) so the
|
|
// game screen lights that tile (screens/game.js MERGE_HL)
|
|
// * the server and client agree on the target for real merges (the engine's elite lands on mergeTarget's tile)
|
|
// * an elite card never merges (server completesChessMerge): mergeProgress reports 0 copies, so no pips / tag / tile
|
|
|
|
import { test, describe } from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import { readFileSync } from 'node:fs';
|
|
import path from 'node:path';
|
|
import { fileURLToPath } from 'node:url';
|
|
|
|
const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
|
|
const read = (p) => readFileSync(path.join(ROOT, p), 'utf8');
|
|
|
|
globalThis.fetch = async (url) => {
|
|
const name = String(url).split('/').pop();
|
|
try {
|
|
const body = readFileSync(path.join(ROOT, 'data', name), 'utf8');
|
|
return { ok: true, status: 200, json: async () => JSON.parse(body) };
|
|
} catch {
|
|
return { ok: false, status: 404, json: async () => ({}) };
|
|
}
|
|
};
|
|
|
|
const { mergeTarget, mergeProgress } = await import('../../public/js/ui/gameLogic.js');
|
|
const { ChessCard, armedSlotOf, armKey, mergeHint } = await import('../../public/js/ui/shopBar.js');
|
|
const { ChessDetail, resolveDetail } = await import('../../public/js/ui/detailPanel.js');
|
|
const { data } = await import('../../public/js/data.js');
|
|
const { DATA, makeMatch, give } = await import('../match/harness.js');
|
|
|
|
await data.loadAll('chess', 'bonds', 'assets');
|
|
|
|
const getChess = (id) => (Object.hasOwn(DATA.chess, id) ? DATA.chess[id] : null);
|
|
const A = 'chess_char_1_01_a';
|
|
const KAZE = 'chess_char_2_11_a';
|
|
const golden = (id) => DATA.chess[id].goldenId;
|
|
const onBoard = (id, row, col, dir = 'RIGHT', uid = row * 100 + col) => ({ uid, kind: 'chess', id, golden: false, row, col, dir });
|
|
const inHand = (id, uid) => ({ uid, kind: 'chess', id, golden: false });
|
|
|
|
function* walk(v) {
|
|
if (Array.isArray(v)) { for (const x of v) yield* walk(x); return; }
|
|
if (!v || typeof v !== 'object') return;
|
|
yield v;
|
|
yield* walk(v.props?.children);
|
|
}
|
|
const hasClass = (v, c) => typeof v?.props?.class === 'string' && v.props.class.split(/\s+/).includes(c);
|
|
|
|
describe('gameLogic.mergeTarget (mirror of server board.js mergeTile)', () => {
|
|
test('no merge yet / hand copies only → null; a deployed copy → its tile and facing', () => {
|
|
assert.equal(mergeTarget({ board: [], hand: [inHand(A, 1)] }, A, getChess), null, 'one copy: no merge');
|
|
assert.equal(mergeTarget({ board: [], hand: [inHand(A, 1), inHand(A, 2)] }, A, getChess), null, 'hand copies: the elite goes to the hand');
|
|
assert.deepEqual(mergeTarget({ board: [onBoard(A, 10, 4, 'UP')], hand: [inHand(A, 2)] }, A, getChess), { row: 10, col: 4, dir: 'UP' });
|
|
assert.deepEqual(mergeTarget({ board: [onBoard(A, 10, 4)], temp: [inHand(A, 2)] }, A, getChess), { row: 10, col: 4, dir: 'RIGHT' }, 'temp copies count');
|
|
});
|
|
test('two deployed copies → the one that deploys first: col asc, then row desc (by column from the left, Battle.start)', () => {
|
|
const priv = { board: [onBoard(A, 9, 2, 'DOWN'), onBoard(A, 11, 7, 'LEFT')], hand: [] };
|
|
assert.deepEqual(mergeTarget(priv, A, getChess), { row: 9, col: 2, dir: 'DOWN' }, 'the left column, though lower (row-major until 0.1.3)');
|
|
const same = { board: [onBoard(A, 10, 8, 'UP'), onBoard(A, 10, 3, 'DOWN')], hand: [] };
|
|
assert.deepEqual(mergeTarget(same, A, getChess), { row: 10, col: 3, dir: 'DOWN' });
|
|
const column = { board: [onBoard(A, 9, 4, 'UP'), onBoard(A, 12, 4, 'LEFT')], hand: [] };
|
|
assert.deepEqual(mergeTarget(column, A, getChess), { row: 12, col: 4, dir: 'LEFT' }, 'one column: the top first');
|
|
});
|
|
test('elites and other operators are ignored; 风丸 merges with one deployed copy', () => {
|
|
const priv = { board: [{ ...onBoard(golden(A), 12, 2), golden: true }, onBoard('chess_char_1_02_a', 12, 3), onBoard(A, 9, 9)], hand: [inHand(A, 5)] };
|
|
assert.deepEqual(mergeTarget(priv, A, getChess), { row: 9, col: 9, dir: 'RIGHT' });
|
|
assert.equal(mergeProgress({ board: [onBoard(KAZE, 10, 5)] }, KAZE, getChess).need, 2);
|
|
assert.deepEqual(mergeTarget({ board: [onBoard(KAZE, 10, 5, 'UP')] }, KAZE, getChess), { row: 10, col: 5, dir: 'UP' });
|
|
assert.equal(mergeTarget({ board: [onBoard(A, 10, 5)] }, A, getChess), null, 'two of three: no merge yet');
|
|
});
|
|
test('the engine agrees: a real merge puts the elite on mergeTarget\'s tile', () => {
|
|
for (const seed of [61, 62, 63]) {
|
|
const h = makeMatch({ mode: 'solo', difficulty: 'NORMAL', seed }).start();
|
|
h.toPrep(1);
|
|
h.setStage('act2autochess_m04');
|
|
const m = h.m;
|
|
const ps = h.ps('p_0');
|
|
for (const p of [...ps.board.values(), ...ps.hand.filter(Boolean)]) if (p.kind === 'chess') ps.returnCopies(p);
|
|
ps.board.clear();
|
|
ps.hand.fill(null);
|
|
ps.recompute();
|
|
const id = Object.values(DATA.chess).find((c) => !c.isGolden && c.tier === 1 && c.position === 'MELEE' && m.pool.has(c.chessId) && m.gd.mergeCount(c.chessId) === 3 && !m.gd.placeableTokens(c.chessId).length).chessId;
|
|
const tiles = [];
|
|
const map = ps.deployMap();
|
|
for (const [k, cls] of map) if (cls === 'melee') tiles.push(k.split(',').map(Number));
|
|
// two copies on two seed-dependent melee tiles
|
|
const pick = [tiles[seed % tiles.length], tiles[(seed * 7 + 3) % tiles.length]];
|
|
if (pick[0].join() === pick[1].join()) pick[1] = tiles[(seed + 1) % tiles.length];
|
|
give(m, ps, id, 'board', pick[0]).dir = 'UP';
|
|
give(m, ps, id, 'board', pick[1]).dir = 'DOWN';
|
|
const want = mergeTarget(ps.privateView(), id, getChess);
|
|
ps.funds = 10;
|
|
ps.shop.slots[0] = { kind: 'chess', id, basePrice: m.gd.chessPrice(id), frozen: false, sold: false };
|
|
assert.deepEqual(m.handle('p_0', { t: 'g.buy', slot: 0 }), { ok: true });
|
|
const view = ps.privateView().board.find((v) => v.golden);
|
|
assert.deepEqual([view.row, view.col, view.dir], [want.row, want.col, want.dir], `seed ${seed}: server and client agree`);
|
|
m.dispose();
|
|
}
|
|
});
|
|
});
|
|
|
|
describe('shop bar: the merge tag and the armed card', () => {
|
|
test('the 可晋升 tag says where the elite goes (the board copy\'s place / the hand)', () => {
|
|
const slot = { kind: 'chess', id: A, price: 1, basePrice: 1 };
|
|
const tagOf = (priv) => [...walk(ChessCard({ slot, idx: 0, priv, onBuy() {}, onDetail() {} }))].find((v) => hasClass(v, 'scard__mergetag'));
|
|
assert.equal(tagOf({ board: [onBoard(A, 10, 4)], hand: [inHand(A, 2)] })?.props.title, '精锐干员将出现在作战区原位置');
|
|
assert.equal(tagOf({ board: [], hand: [inHand(A, 1), inHand(A, 2)] })?.props.title, '精锐干员将进入整备区');
|
|
assert.equal(tagOf({ board: [], hand: [inHand(A, 1)] }), undefined, 'no tag before the merge');
|
|
});
|
|
test('touch shows no title: the detail card the first tap opens says where the elite goes (QA 6b)', async () => {
|
|
await data.loadAll('chess', 'garrisons', 'assets', 'bonds', 'items');
|
|
const board = { board: [onBoard(A, 10, 4)], hand: [inHand(A, 2)] };
|
|
const hand = { board: [], hand: [inHand(A, 1), inHand(A, 2)] };
|
|
assert.equal(mergeHint(board, A), '精锐干员将出现在作战区原位置');
|
|
assert.equal(mergeHint(hand, A), '精锐干员将进入整备区');
|
|
assert.equal(mergeHint({ board: [], hand: [inHand(A, 1)] }, A), null, 'no merge yet');
|
|
assert.equal(mergeHint(board, golden(A)), null, 'an elite card never merges');
|
|
// the first tap: ShopBar tapCard → onDetail(id, 'chess', mergeHint) → game.js setDetail({ …, hint }) → resolveDetail
|
|
assert.match(read('public/js/ui/shopBar.js'), /setArmed\(key\); onDetail\(slot\.id, detailKind, detailKind === 'chess' \? mergeHint\(priv, slot\.id\) : null\)/);
|
|
assert.match(read('public/js/screens/game.js'), /onDetail=\$\{\(id, kind, hint\) => setDetail\(\{ kind: kind === 'item' \? 'item' : 'chess', id, hint: hint \|\| null \}\)\}/);
|
|
const r = resolveDetail({ kind: 'chess', id: A, hint: mergeHint(board, A) }, new Map());
|
|
assert.equal(r.hint, '精锐干员将出现在作战区原位置');
|
|
const blocks = ChessDetail({ chess: r.chess, piece: null, editable: false, bonds: [], loadout: null, hint: r.hint });
|
|
assert.equal(blocks[0].key, 'head');
|
|
assert.equal(blocks[1].key, 'merge', 'right under the header');
|
|
assert.ok(hasClass(blocks[1], 'dhint'));
|
|
const text = JSON.stringify(blocks[1].props.children);
|
|
assert.ok(text.includes('可晋升：') && text.includes('精锐干员将出现在作战区原位置'), text);
|
|
assert.ok(!ChessDetail({ chess: r.chess, piece: null, editable: false, bonds: [], loadout: null }).some((b) => b.key === 'merge'), 'no hint, no line');
|
|
});
|
|
test('an elite card never merges (server completesChessMerge refuses isGolden): no pips, no tag, no target tile', () => {
|
|
const E = golden(A);
|
|
const priv = { board: [onBoard(A, 10, 4, 'UP')], hand: [inHand(A, 2)] };
|
|
assert.equal(mergeProgress(priv, A, getChess).copies, 2);
|
|
assert.equal(mergeProgress(priv, E, getChess).copies, 0);
|
|
assert.equal(mergeTarget(priv, E, getChess), null);
|
|
const card = ChessCard({ slot: { kind: 'chess', id: E, price: 3, basePrice: 3 }, idx: 0, priv, onBuy() {}, onDetail() {} });
|
|
const nodes = [...walk(card)];
|
|
assert.equal(nodes.find((v) => hasClass(v, 'scard__mergetag')), undefined, 'no 可晋升 tag');
|
|
assert.equal(nodes.find((v) => hasClass(v, 'scard__pips')), undefined, 'no 已拥有 pips');
|
|
assert.ok(!hasClass(card, 'is-merge'));
|
|
// the normal card in the same state still merges onto the deployed copy's tile
|
|
assert.deepEqual(mergeTarget(priv, A, getChess), { row: 10, col: 4, dir: 'UP' });
|
|
// and the server agrees: gaining the elite completes no merge
|
|
const h = makeMatch({ mode: 'solo', difficulty: 'NORMAL', seed: 64 }).start();
|
|
h.toPrep(1);
|
|
const ps = h.ps('p_0');
|
|
const id = Object.values(DATA.chess).find((c) => !c.isGolden && c.tier === 1 && h.m.pool.has(c.chessId) && h.m.gd.mergeCount(c.chessId) === 3).chessId;
|
|
give(h.m, ps, id);
|
|
give(h.m, ps, id);
|
|
assert.equal(ps.completesChessMerge(id), true);
|
|
assert.equal(ps.completesChessMerge(golden(id)), false);
|
|
h.m.dispose();
|
|
});
|
|
test('armedSlotOf: shop / reward slots by key; level card, stale and sold keys → null', () => {
|
|
const slots = [{ kind: 'chess', id: A }, { kind: 'chess', id: KAZE, sold: true }, { kind: 'item', id: 'chess_item_1_01_e_a' }];
|
|
const reward = [{ kind: 'chess', id: 'chess_char_1_02_a' }];
|
|
assert.equal(armedSlotOf(armKey('c', 0, slots[0]), slots), slots[0]);
|
|
assert.equal(armedSlotOf(armKey('i', 2, slots[2]), slots), slots[2]);
|
|
assert.equal(armedSlotOf(armKey('r', 0, reward[0]), slots, reward), reward[0]);
|
|
assert.equal(armedSlotOf(armKey('c', 1, slots[1]), slots), null, 'sold');
|
|
assert.equal(armedSlotOf('c:0:other', slots), null, 'rerolled');
|
|
assert.equal(armedSlotOf('lv', slots), null);
|
|
assert.equal(armedSlotOf(null, slots), null);
|
|
});
|
|
test('the game screen lights the target tile while a merge-completing card is armed', () => {
|
|
const src = read('public/js/screens/game.js');
|
|
assert.match(src, /onArm=\$\{setArmedCard\}/, 'ShopBar reports the armed card');
|
|
assert.match(src, /mergeTarget\(priv, armedCard\.id, gd\.chess\)/, 'the target comes from gameLogic.mergeTarget');
|
|
assert.match(src, /view\.highlightTiles\(mergeAt \? \[\[mergeAt\.row, mergeAt\.col\]\] : \[\], MERGE_HL\)/, 'its own highlight group (cleared with [])');
|
|
assert.match(src, /const MERGE_HL = Object\.freeze\(\{ group: 'mergeTile'/);
|
|
});
|
|
});
|