Support Harkonnen special Karama truth commitments
Verify and publish checkpoint container / container (push) Successful in 10m17s
Verify and publish checkpoint container / container (push) Successful in 10m17s
This commit is contained in:
1 parent
15a4f3038a
commit
b448144c52
15 files changed
+449
-35
No files matched your search
@@ -0,0 +1,155 @@
|
||||
import assert from 'node:assert/strict';
|
||||
import test from 'node:test';
|
||||
import { viewGame, type Action, type Game } from '../game/engine';
|
||||
import { windowCardOpportunity } from '../game/window-card-play';
|
||||
import { botActions } from '../game/bots';
|
||||
import { DIFFICULTIES } from '../game/bot-profiles';
|
||||
import { actTruthBid as act, createTruthBidFixture, truthBidInventory as inventory,
|
||||
truthBidPlayer as player } from './fixture-truth-bid';
|
||||
|
||||
/** Genuine Advanced setup and native Bidding; swap one original Truthtrance
|
||||
* and one original Karama between dealt hands as a controlled custody fixture. */
|
||||
function fixture() {
|
||||
const f = createTruthBidFixture({ advanced: true, targetKarama: true });
|
||||
const game = structuredClone(f.game), harkonnen = player(game, f.asker), emperor = player(game, f.target);
|
||||
const truth = harkonnen.hand.findIndex(card => card.effect === 'truthtrance');
|
||||
const karama = emperor.hand.findIndex(card => card.effect === 'karama');
|
||||
assert.ok(truth >= 0 && karama >= 0);
|
||||
const truthCard = harkonnen.hand[truth], karamaCard = emperor.hand[karama];
|
||||
harkonnen.hand[truth] = karamaCard; emperor.hand[karama] = truthCard;
|
||||
assert.deepEqual(inventory(game), f.originalCards);
|
||||
const window = windowCardOpportunity(game, 'karamaHarkonnenSpecial'); assert.ok(window);
|
||||
return { game, asker: emperor.id, owner: harkonnen.id, opponent: f.opponent,
|
||||
truth: truthCard.id, karama: karamaCard.id, source: window.source, cards: f.originalCards };
|
||||
}
|
||||
function reject(game: Game, id: string, action: Action) {
|
||||
const before = structuredClone(game); assert.throws(() => act(game, id, action)); assert.deepEqual(game, before);
|
||||
}
|
||||
function declare(f: ReturnType<typeof fixture>) {
|
||||
let game = act(f.game, f.asker, { type: 'card', card: f.truth });
|
||||
while (game.truthtrance?.stage === 'priority') {
|
||||
const seat = game.players.find(p => !game.truthtrance!.passed.includes(p.id)); assert.ok(seat);
|
||||
game = act(game, seat.id, { type: 'truthPass' });
|
||||
}
|
||||
assert.equal(game.truthtrance?.stage, 'ask');
|
||||
return game;
|
||||
}
|
||||
function question(f: ReturnType<typeof fixture>, target = f.owner) {
|
||||
return { kind: 'turnActions', target, turn: f.game.turn, mixed: { kind: 'action', action: {
|
||||
kind: 'windowCardPlay', effect: 'karamaHarkonnenSpecial', source: f.source,
|
||||
} } };
|
||||
}
|
||||
function ask(f: ReturnType<typeof fixture>, game = declare(f)) {
|
||||
return act(game, f.asker, { type: 'truthAsk', question: question(f) });
|
||||
}
|
||||
function special(f: ReturnType<typeof fixture>): Action {
|
||||
return { type: 'card', card: f.karama, mode: 'special', target: f.opponent, amount: 1 };
|
||||
}
|
||||
|
||||
void test('Advanced Harkonnen special Yes records the physical special role and retains private hand exchange', () => {
|
||||
const f = fixture(), asked = ask(f);
|
||||
assert.ok(viewGame(asked, f.owner).truthTurnActionAnswers?.includes('yes'));
|
||||
assert.equal(viewGame(asked, f.opponent).truthTurnActionAnswers, null);
|
||||
let game = act(asked, f.owner, { type: 'truthAnswer', answer: 'yes' });
|
||||
const guide = viewGame(game, f.owner).turnActionGuide; assert.ok(guide);
|
||||
assert.equal(guide.action.type, 'card');
|
||||
assert.equal(guide.action.mode, 'special');
|
||||
assert.equal(guide.action.card, f.karama);
|
||||
for (const difficulty of DIFFICULTIES) {
|
||||
const bot = viewGame(game, f.owner);
|
||||
bot.players.find(p => p.id === f.owner)!.bot = difficulty;
|
||||
assert.deepEqual(botActions(bot)[0], guide.action);
|
||||
}
|
||||
// A normal free-purchase use of the sole Karama cannot evade this Yes.
|
||||
reject(game, f.owner, { type: 'card', card: f.karama, mode: 'purchase' });
|
||||
const bound = game, before = structuredClone(game), lot = structuredClone(game.auction);
|
||||
game = act(game, f.owner, special(f));
|
||||
assert.deepEqual(bound, before, 'Native action works on an immutable input');
|
||||
assert.equal(player(game, f.owner).specialKaramaUsed, true);
|
||||
assert.equal(game.turnActionPromises!.find(p => p.player === f.owner)!.fulfilled, true);
|
||||
assert.equal(game.turnActionPromises!.find(p => p.player === f.owner)!.windowCards!.karamaHarkonnenSpecial!.played, true);
|
||||
assert.equal(game.decision?.kind, 'handExchange');
|
||||
assert.equal(game.discard.filter(card => card.id === f.karama).length, 1);
|
||||
const observer = viewGame(game, f.asker);
|
||||
assert.equal(observer.players.find(p => p.id === f.owner)!.hand, undefined);
|
||||
assert.equal(observer.players.find(p => p.id === f.opponent)!.hand, undefined);
|
||||
assert.deepEqual(observer.turnActionPromises, []);
|
||||
const returned = player(game, f.owner).hand[0]; assert.ok(returned);
|
||||
game = act(game, f.owner, { type: 'decision', returnCards: [returned.id] });
|
||||
assert.deepEqual(game.auction, lot);
|
||||
assert.deepEqual(inventory(game), f.cards);
|
||||
});
|
||||
|
||||
void test('Advanced Harkonnen special No rejects that role and leaves the original Karama held', () => {
|
||||
const f = fixture(), asked = ask(f);
|
||||
assert.ok(viewGame(asked, f.owner).truthTurnActionAnswers?.includes('no'));
|
||||
const game = act(asked, f.owner, { type: 'truthAnswer', answer: 'no' });
|
||||
reject(game, f.owner, special(f));
|
||||
assert.ok(player(game, f.owner).hand.some(card => card.id === f.karama));
|
||||
assert.notEqual(player(game, f.owner).specialKaramaUsed, true);
|
||||
assert.deepEqual(inventory(game), f.cards);
|
||||
});
|
||||
|
||||
void test('a Harkonnen special source cannot bind another respondent or a forged turn', () => {
|
||||
const f = fixture(), game = declare(f);
|
||||
reject(game, f.asker, { type: 'truthAsk', question: question(f, f.opponent) });
|
||||
const malformed = question(f);
|
||||
malformed.mixed.action.source = JSON.stringify(['karamaHarkonnenSpecial', game.turn + 1, f.owner]);
|
||||
reject(game, f.asker, { type: 'truthAsk', question: malformed });
|
||||
});
|
||||
|
||||
/** Stage an existing Hajr into the other player's private hand without adding
|
||||
* or duplicating a physical card. The Harkonnen respondent does not know that
|
||||
* face and cannot treat it as an owned future Movement play. */
|
||||
function withOpponentHajr() {
|
||||
const f = fixture(), game = structuredClone(f.game), other = player(game, f.opponent);
|
||||
const index = game.deck.findIndex(card => card.effect === 'hajr');
|
||||
assert.ok(index >= 0, 'The original undealt Hajr must be available to stage');
|
||||
const prior = other.hand.findIndex(card => card.effect !== 'hajr'); assert.ok(prior >= 0);
|
||||
[game.deck[index], other.hand[prior]] = [other.hand[prior], game.deck[index]];
|
||||
assert.ok(!player(game, f.owner).hand.some(card => card.effect === 'hajr'));
|
||||
assert.deepEqual(inventory(game), f.cards);
|
||||
return { ...f, game };
|
||||
}
|
||||
function compound(f: ReturnType<typeof fixture>, kind: 'and' | 'or') {
|
||||
const simple = question(f);
|
||||
return { ...simple, mixed: { kind, terms: [simple.mixed,
|
||||
{ kind: 'action', action: { kind: 'cardPlay', effect: 'hajr' } },
|
||||
] } };
|
||||
}
|
||||
|
||||
void test('a hidden opponent Hajr cannot fund special-Karama AND Hajr Yes', () => {
|
||||
const f = withOpponentHajr(), declared = declare(f);
|
||||
const asked = act(declared, f.asker, { type: 'truthAsk', question: compound(f, 'and') });
|
||||
assert.ok(!viewGame(asked, f.owner).truthTurnActionAnswers?.includes('yes'));
|
||||
assert.equal(viewGame(asked, f.owner).players.find(p => p.id === f.opponent)!.hand, undefined);
|
||||
// The same Hajr in the undealt deck rather than that opponent's hidden hand
|
||||
// must not change the respondent's available answers.
|
||||
const alternate = structuredClone(f.game), other = player(alternate, f.opponent);
|
||||
const held = other.hand.findIndex(card => card.effect === 'hajr');
|
||||
const spare = alternate.deck.findIndex(card => card.name === 'Baliset');
|
||||
assert.ok(held >= 0 && spare >= 0);
|
||||
[other.hand[held], alternate.deck[spare]] = [alternate.deck[spare], other.hand[held]];
|
||||
const f2 = { ...f, game: alternate };
|
||||
const asked2 = act(declare(f2), f2.asker, { type: 'truthAsk', question: compound(f2, 'and') });
|
||||
assert.deepEqual(viewGame(asked2, f2.owner).truthTurnActionAnswers,
|
||||
viewGame(asked, f.owner).truthTurnActionAnswers);
|
||||
assert.deepEqual(inventory(alternate), f.cards);
|
||||
reject(asked, f.owner, { type: 'truthAnswer', answer: 'yes' });
|
||||
const game = act(asked, f.owner, { type: 'truthAnswer', answer: 'no' });
|
||||
assert.deepEqual(inventory(game), f.cards);
|
||||
});
|
||||
|
||||
void test('special-Karama OR Hajr preserves either alternative and No forbids the actual special', () => {
|
||||
const f = withOpponentHajr(), declared = declare(f);
|
||||
const asked = act(declared, f.asker, { type: 'truthAsk', question: compound(f, 'or') });
|
||||
assert.ok(viewGame(asked, f.owner).truthTurnActionAnswers?.includes('yes'));
|
||||
assert.ok(viewGame(asked, f.owner).truthTurnActionAnswers?.includes('no'));
|
||||
const yes = act(asked, f.owner, { type: 'truthAnswer', answer: 'yes' });
|
||||
const after = act(yes, f.owner, special(f));
|
||||
assert.equal(after.turnActionPromises!.find(row => row.player === f.owner)!.fulfilled, true);
|
||||
const no = act(asked, f.owner, { type: 'truthAnswer', answer: 'no' });
|
||||
reject(no, f.owner, special(f));
|
||||
assert.ok(player(no, f.owner).hand.some(card => card.id === f.karama));
|
||||
assert.deepEqual(inventory(no), f.cards);
|
||||
});
|
||||
Reference in new issue
Block a user