152 lines
8.5 KiB
JavaScript
152 lines
8.5 KiB
JavaScript
// GitHub #82 (second part): the hand rules of PRTS 卫戍协议/帮助 §手牌区 — "手牌区域分为10个常规手牌区和5个临时手牌区。当
|
||
// 常规手牌区全满无空位时，玩家将无法执行使手牌溢出的操作" ("例如招募/购入等通常情况下会增加手牌的操作") and "溢出单位会自动
|
||
// 进入临时手牌区，常规手牌区出现空位时自动移入".
|
||
// * a full regular hand refuses every purchase and reward pick — also one whose copy would complete a merge at once
|
||
// (the reporter's first-hand check in the official game; BWIKI 盟约 "无法进行涉及到整备区的操作（购买、撤回等）")
|
||
// * a free regular slot pulls a temp piece in at once (PlayerState._fillHandFromTemp, run by every recompute): after a
|
||
// sale, a deployment from the hand, a merge that consumed hand copies, an item destroyed / equipped from the hand, a
|
||
// summon stack removed with its owner. The temp row empties right → left (the order it fills) [ASSUMED]; each piece
|
||
// takes the hand's next free slot right → left.
|
||
import { test } from 'node:test';
|
||
import assert from 'node:assert/strict';
|
||
import { ERR } from '../../shared/constants.js';
|
||
import { DATA, makeMatch, give, giveItem, checkInvariants, chessOfTier, legalTileFor } from './harness.js';
|
||
|
||
/** Plain equipment (no equip / merge side effects), all different: hand fillers that never merge with each other. */
|
||
const PLAIN = Object.values(DATA.items)
|
||
.filter((i) => i.itemType === 'EQUIP' && !i.isGolden && i.kind === 'passive')
|
||
.map((i) => i.itemId ?? i.id).filter(Boolean);
|
||
|
||
/** Solo 标准 (untimed) PREP R1 with an empty board and hand, 100 funds, a known stage. */
|
||
function prep(seed) {
|
||
const h = makeMatch({ mode: 'solo', difficulty: 'NORMAL', seed }).start();
|
||
h.toPrep(1);
|
||
h.setStage('act2autochess_m04');
|
||
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();
|
||
ps.funds = 100;
|
||
return { h, m: h.m, ps };
|
||
}
|
||
|
||
/** Fill every free hand slot with plain equipment (skipping `skip` ids). */
|
||
function fillHand(ps, skip = []) {
|
||
const ids = PLAIN.filter((id) => !skip.includes(id));
|
||
let k = 0;
|
||
while (ps.hand.some((x) => x == null)) giveItem(ps.m, ps, ids[k++]);
|
||
}
|
||
|
||
const mergeable = (m) => chessOfTier(1, (c) => c.position === 'MELEE').find((id) => m.pool.has(id) && m.gd.mergeCount(id) === 3);
|
||
|
||
test('a full hand refuses a purchase / pick that would complete a merge (chess, item, reward); nothing is spent', () => {
|
||
const { m, ps } = prep(8201);
|
||
const id = mergeable(m);
|
||
give(m, ps, id, 'hand', 0);
|
||
give(m, ps, id, 'hand', 1);
|
||
const twin = PLAIN[0];
|
||
giveItem(m, ps, twin, 'hand', 2);
|
||
fillHand(ps, [twin]);
|
||
assert.ok(ps.completesChessMerge(id) && ps.completesItemMerge(twin));
|
||
ps.shop.slots[0] = { kind: 'chess', id, basePrice: m.gd.chessPrice(id), frozen: false, sold: false };
|
||
const itemSlot = ps.shop.slots.findIndex((s, i) => i > 0 && s && s.kind === 'item');
|
||
ps.shop.slots[itemSlot] = { kind: 'item', id: twin, basePrice: 2, frozen: false, sold: false };
|
||
const left = m.pool.left(id);
|
||
assert.deepEqual(m.handle('p_0', { t: 'g.buy', slot: 0 }), { error: ERR.HAND_FULL }, 'the third copy of a held pair');
|
||
assert.deepEqual(m.handle('p_0', { t: 'g.buy', slot: itemSlot }), { error: ERR.HAND_FULL }, 'an item whose twin is in the hand');
|
||
ps.pushRewardOffer('merge', { ids: [id] });
|
||
assert.deepEqual(m.handle('p_0', { t: 'g.reward', idx: 0 }), { error: ERR.HAND_FULL }, 'a merge-completing reward pick');
|
||
assert.equal(ps.funds, 100, 'nothing spent');
|
||
assert.equal(m.pool.left(id), left, 'no copy taken');
|
||
assert.ok(!ps.shop.slots[0].sold && !ps.shop.slots[itemSlot].sold);
|
||
assert.equal(ps.countCopies(m.gd.baseIdOf(id)), 2, 'no merge');
|
||
// a free slot (an item destroyed) lets the purchase through: it completes the merge, the elite goes to the hand
|
||
assert.deepEqual(m.handle('p_0', { t: 'g.destroy', uid: ps.hand[9].uid }), { ok: true });
|
||
assert.deepEqual(m.handle('p_0', { t: 'g.buy', slot: 0 }), { ok: true });
|
||
assert.ok(ps.hand.some((p) => p && p.id === m.gd.goldenIdOf(id)), 'the elite in the hand');
|
||
assert.equal(ps.hand.filter(Boolean).length, 8, '10 − the destroyed item − 2 copies + the elite');
|
||
checkInvariants(m);
|
||
m.dispose();
|
||
});
|
||
|
||
test('selling / destroying from a full hand pulls the temp pieces in, rightmost first, into the freed slot; Ready follows', () => {
|
||
const { m, ps } = prep(8202);
|
||
const sold = give(m, ps, chessOfTier(2).find((x) => m.pool.has(x)), 'hand', 4);
|
||
fillHand(ps);
|
||
const ids = chessOfTier(3).filter((x) => m.pool.has(x));
|
||
const first = give(m, ps, ids[0], 'temp', 4); // the first overflow takes the rightmost temp slot (stow → freeSlot)
|
||
const second = give(m, ps, ids[1], 'temp', 3);
|
||
assert.ok(ps.temp.includes(first) && ps.temp.includes(second), 'a full hand: both wait in temp');
|
||
assert.equal(ps.privateView().canReady, false);
|
||
checkInvariants(m);
|
||
assert.deepEqual(m.handle('p_0', { t: 'g.sell', uid: sold.uid }), { ok: true });
|
||
assert.equal(ps.hand[4], first, 'the rightmost temp piece moves into the freed slot');
|
||
assert.ok(ps.temp.includes(second) && !ps.temp.includes(first));
|
||
assert.equal(ps._tempDue.has(first.uid), false, 'no longer due at the prep deadline');
|
||
assert.equal(ps.privateView().canReady, false, 'one left in temp');
|
||
checkInvariants(m);
|
||
const item = ps.hand[7];
|
||
assert.equal(item.kind, 'item');
|
||
assert.deepEqual(m.handle('p_0', { t: 'g.destroy', uid: item.uid }), { ok: true });
|
||
assert.equal(ps.hand[7], second);
|
||
assert.ok(ps.tempEmpty);
|
||
assert.equal(ps.privateView().canReady, true);
|
||
assert.deepEqual(m.handle('p_0', { t: 'g.ready', ready: true }), { ok: true });
|
||
checkInvariants(m);
|
||
m.dispose();
|
||
});
|
||
|
||
test('deploying a card from a full hand, or equipping an item from it, pulls a temp piece into the freed slot', () => {
|
||
const { m, ps } = prep(8203);
|
||
const id = chessOfTier(1, (c) => c.position === 'MELEE' && !m.gd.placeableTokens(c.chessId).length).find((x) => m.pool.has(x));
|
||
const card = give(m, ps, id, 'hand', 9);
|
||
fillHand(ps);
|
||
const t1 = give(m, ps, chessOfTier(2).find((x) => m.pool.has(x)), 'temp', 4);
|
||
const t2 = giveItem(m, ps, PLAIN[PLAIN.length - 1], 'temp', 3);
|
||
const [r, c] = legalTileFor(m, ps, id);
|
||
assert.deepEqual(m.handle('p_0', { t: 'g.move', uid: card.uid, to: { area: 'board', row: r, col: c } }), { ok: true });
|
||
assert.equal(ps.hand[9], t1, 'the deployed card\'s slot took the temp piece');
|
||
checkInvariants(m);
|
||
const it = ps.hand[0];
|
||
assert.deepEqual(m.handle('p_0', { t: 'g.equip', itemUid: it.uid, targetUid: card.uid }), { ok: true });
|
||
assert.equal(ps.hand[0], t2, 'the equipped item\'s slot took the temp piece');
|
||
assert.ok(ps.tempEmpty);
|
||
checkInvariants(m);
|
||
m.dispose();
|
||
});
|
||
|
||
test('a gain that merges two hand copies: the elite takes one freed slot, the other pulls a temp piece in', () => {
|
||
const { m, ps } = prep(8204);
|
||
const id = mergeable(m);
|
||
give(m, ps, id, 'hand', 0);
|
||
give(m, ps, id, 'hand', 1);
|
||
fillHand(ps);
|
||
const ids = chessOfTier(3).filter((x) => m.pool.has(x));
|
||
const t1 = give(m, ps, ids[0], 'temp', 4);
|
||
const t2 = give(m, ps, ids[1], 'temp', 3);
|
||
const elite = ps.acquireChess(id, { source: 'grant' });
|
||
assert.ok(elite && m.gd.isGolden(elite.id));
|
||
assert.equal(ps.hand[1], elite, 'the elite: the hand\'s next free slot (right → left)');
|
||
assert.equal(ps.hand[0], t1, 'the other freed slot: the rightmost temp piece');
|
||
assert.deepEqual(ps.temp.filter(Boolean), [t2], 'the hand is full again: the other waits');
|
||
checkInvariants(m);
|
||
m.dispose();
|
||
});
|
||
|
||
test('selling a deployed summoner removes its summon stack from the hand: that slot pulls a temp piece in', () => {
|
||
const { m, ps } = prep(8205);
|
||
const owner = Object.values(DATA.chess).find((c) => c.visible && !c.isGolden && m.pool.has(c.chessId) && m.gd.placeableTokens(c.chessId).length && legalTileFor(m, ps, c.chessId));
|
||
assert.ok(owner, 'a chess with a manually deployable summon');
|
||
const op = give(m, ps, owner.chessId, 'board', legalTileFor(m, ps, owner.chessId));
|
||
const stackAt = ps.hand.findIndex((p) => p && p.kind === 'token' && p.ownerUid === op.uid);
|
||
assert.ok(stackAt >= 0, 'its summon stack joined the hand');
|
||
fillHand(ps);
|
||
const t = give(m, ps, chessOfTier(2).find((x) => m.pool.has(x)), 'temp', 4);
|
||
assert.deepEqual(m.handle('p_0', { t: 'g.sell', uid: op.uid }), { ok: true });
|
||
assert.equal(ps.hand[stackAt], t, 'the stack\'s slot took the temp piece');
|
||
assert.ok(ps.tempEmpty);
|
||
checkInvariants(m);
|
||
m.dispose();
|
||
});
|