diff --git a/components/elite-count.tsx b/components/elite-count.tsx
index 1a12dc10..da345f4d 100644
--- a/components/elite-count.tsx
+++ b/components/elite-count.tsx
@@ -5,11 +5,13 @@ export function EliteCount({
value,
onChange,
max,
+ min = 0,
label = 'Elite forces included',
}: {
value: number;
onChange: (value: number) => void;
max: number;
+ min?: number;
label?: string;
}) {
const id = useId();
@@ -19,7 +21,7 @@ export function EliteCount({
Once per game: revive up to three forces or one
- leader for free.
+ leader for free. These returns do not use your
+ ordinary revival allowances, including the normal
+ one-Sardaukar limit.
Forces to revive
@@ -6346,12 +6348,8 @@ export function GameTable({
]*>)/)?.[1];
+ assert.ok(input, 'The actual Sardaukar selector is visible');
+ return input;
+}
+
+void test('Emperor special UI includes available Sardaukar despite an already used ordinary starred allowance', () => {
+ const html = specialControls(markup(game(3, 3, 1)));
+ assert.match(html, /ordinary revival allowances, including the normal\s*one-Sardaukar limit/);
+ assert.match(html, /Forces to revive\s*]*max="3"/);
+ const input = eliteInput(html);
+ assert.match(input, /\bmin="1"/);
+ assert.match(input, /\bmax="1"/);
+ assert.match(input, /\bvalue="0"/);
+ assert.match(html, /disabled=""[^>]*>Use special Karama · forces/,
+ 'The initial zero-elite selection is invalid when only Sardaukar are available');
+});
+
+void test('special UI respects physical stocks and does not expose another player’s hand controls', () => {
+ const mixed = specialControls(markup(game(3, 2, 1)));
+ const mixedInput = eliteInput(mixed);
+ assert.match(mixedInput, /\bmin="0"/);
+ assert.match(mixedInput, /\bmax="1"/);
+ assert.doesNotMatch(mixed, /disabled=""[^>]*>Use special Karama · forces/);
+ const noElites = eliteInput(specialControls(markup(game(2, 0, 1))));
+ assert.match(noElites, /\bmax="0"/);
+ assert.doesNotMatch(markup(game(3, 3, 1), 'atreides'), /Use special Karama · forces/);
+});
diff --git a/tests/emperor-special-revival-exemption-runtime.test.ts b/tests/emperor-special-revival-exemption-runtime.test.ts
new file mode 100644
index 00000000..b7ca7fd6
--- /dev/null
+++ b/tests/emperor-special-revival-exemption-runtime.test.ts
@@ -0,0 +1,121 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { createGame, joinGame, newPlayer, viewGame, type Action, type Game } from '../game/engine';
+import { botActions } from '../game/bots';
+import {
+ actAdvancedRevivalOrder as act,
+ advanceAdvancedRevivalOrder as advance,
+ advancedRevivalOrderClean as clean,
+ advancedRevivalOrderInventory as inventory,
+ advancedRevivalOrderPlayer as player,
+ type AdvancedRevivalOrderStep,
+} from './fixture-advanced-revival-order';
+
+/** A genuine Advanced lobby, native setup, paid shipment and Storm deaths.
+ * Only original unopened starting-deal and Spice card positions are selected;
+ * no played hand, force, Tank, revival counter or clock is assigned. */
+function source() {
+ let game = createGame('EMPERORSPECIAL', newPlayer('emperor', 'Emperor', 'emperor'), true, ['ix']);
+ joinGame(game, newPlayer('atreides', 'Atreides', 'atreides'));
+ joinGame(game, newPlayer('tleilaxu', 'Tleilaxu', 'tleilaxu'));
+ const actions: AdvancedRevivalOrderStep[] = [];
+ const send = (actor: string, action: Action) => { game = act(game, actor, action, actions); };
+ const reach = (until: (state: Game) => boolean) => { game = advance(game, until, actions); };
+ for (const seat of game.players) send(seat.id, { type: 'ready' });
+ send('emperor', { type: 'start', advancedPreview: true });
+ assert.equal(game.status, 'setup');
+ assert.ok(game.players.every(seat => seat.hand.length === 0));
+ const originalCards = inventory(game);
+ const index = game.deck.findIndex(card => card.effect === 'karama');
+ assert.ok(index >= 0);
+ [game.deck[0], game.deck[index]] = [game.deck[index], game.deck[0]];
+ const karama = game.deck[0].id;
+ reach(state => state.status === 'playing');
+ assert.ok(player(game, 'emperor').hand.some(card => card.id === karama));
+ for (let position = 0; position < 4; position++) {
+ const from = game.spiceDeck.findIndex((card, index) => index >= position && 'territory' in card && !card.discovery);
+ assert.ok(from >= position);
+ game.spiceDeck.splice(position, 0, game.spiceDeck.splice(from, 1)[0]);
+ }
+ reach(state => state.turn === 1 && state.phase === 5 && state.active === 'emperor' && clean(state));
+ const beforeShipment = structuredClone(game);
+ send('emperor', { type: 'ship', territory: 'hagga_basin', sector: 13, amount: 3, elite: 3, allyPayment: 0 });
+ reach(clean);
+ assert.equal(player(game, 'emperor').elites?.forces['hagga_basin:13'], 3);
+ assert.equal(player(beforeShipment, 'emperor').spice - player(game, 'emperor').spice, 6);
+ reach(state => state.turn === 2 && state.phase === 1);
+ assert.equal(player(game, 'emperor').tanks, 3);
+ assert.equal(player(game, 'emperor').elites?.tanks, 3);
+ assert.equal(player(game, 'emperor').elites?.revived, 0);
+ reach(state => state.turn === 2 && state.phase === 4 && clean(state) &&
+ (!state.revivalOrder || state.revivalOrder.remaining[0] === 'emperor'));
+ assert.deepEqual(inventory(game), originalCards);
+ return { game, karama, originalCards, actions };
+}
+
+function special(game: Game, card: string, amount: number, elite: number): Game {
+ return act(game, 'emperor', { type: 'card', mode: 'special', card, amount, elite });
+}
+function ordinary(game: Game): Game {
+ return advance(act(game, 'emperor', { type: 'revive', amount: 1, elite: 1 }), clean);
+}
+function reject(game: Game, action: Action) {
+ const before = structuredClone(game);
+ assert.throws(() => act(game, 'emperor', action));
+ assert.deepEqual(game, before);
+}
+
+void test('Advanced Emperor may revive two extra Sardaukar after an ordinary elite revival', () => {
+ const f = source();
+ let game = ordinary(f.game);
+ assert.equal(player(game, 'emperor').elites?.revived, 1);
+ assert.equal(player(game, 'emperor').elites?.tanks, 2);
+ const before = structuredClone(player(game, 'emperor'));
+ game = advance(special(game, f.karama, 2, 2), clean);
+ assert.equal(player(game, 'emperor').elites?.tanks, 0);
+ assert.equal(player(game, 'emperor').elites?.reserves, before.elites!.reserves + 2);
+ assert.equal(player(game, 'emperor').elites?.revived, 1);
+ assert.equal(player(game, 'emperor').revived, before.revived);
+ assert.equal(player(game, 'emperor').spice, before.spice);
+ assert.equal(player(game, 'emperor').specialKaramaUsed, true);
+ assert.equal(game.discard.filter(card => card.id === f.karama).length, 1);
+ assert.deepEqual(inventory(game), f.originalCards);
+});
+
+void test('Advanced Emperor retains ordinary elite allowance after special two-Sardaukar revival', () => {
+ const f = source();
+ let game = advance(special(f.game, f.karama, 2, 2), clean);
+ assert.equal(player(game, 'emperor').elites?.tanks, 1);
+ assert.equal(player(game, 'emperor').elites?.revived, 0);
+ assert.equal(player(game, 'emperor').revived, 0);
+ game = ordinary(game);
+ assert.equal(player(game, 'emperor').elites?.tanks, 0);
+ assert.equal(player(game, 'emperor').elites?.revived, 1);
+ assert.equal(player(game, 'emperor').revived, 1);
+ assert.deepEqual(inventory(game), f.originalCards);
+});
+
+void test('Advanced Emperor may use all three special slots for Sardaukar without exceeding real Tanks', () => {
+ const f = source();
+ reject(f.game, { type: 'card', mode: 'special', card: f.karama, amount: 4, elite: 4 });
+ const game = advance(special(f.game, f.karama, 3, 3), clean);
+ assert.equal(player(game, 'emperor').tanks, 0);
+ assert.equal(player(game, 'emperor').elites?.tanks, 0);
+ assert.equal(player(game, 'emperor').elites?.reserves, 5);
+ assert.equal(player(game, 'emperor').elites?.revived, 0);
+ assert.equal(player(game, 'emperor').revived, 0);
+ assert.deepEqual(inventory(game), f.originalCards);
+});
+
+void test('the minimal bot can use the special revival with three actual Sardaukar', () => {
+ const f = source(), view = viewGame(f.game, 'emperor');
+ view.players.find(seat => seat.id === 'emperor')!.bot = 'Easy';
+ const action = botActions(view).find(candidate => candidate.type === 'card' && candidate.mode === 'special');
+ assert.ok(action);
+ assert.equal(action.amount, 3);
+ assert.equal(action.elite, 3);
+ const game = advance(act(f.game, 'emperor', action), clean);
+ assert.equal(player(game, 'emperor').elites?.tanks, 0);
+ assert.equal(player(game, 'emperor').elites?.revived, 0);
+ assert.deepEqual(inventory(game), f.originalCards);
+});
diff --git a/tests/karama-intents.test.ts b/tests/karama-intents.test.ts
index a9494038..568a7667 100644
--- a/tests/karama-intents.test.ts
+++ b/tests/karama-intents.test.ts
@@ -195,7 +195,7 @@ void test('Emperor force revival commits once after serialization and never duri
executeSpecialKaramaIntent(g, JSON.parse(JSON.stringify(intent)));
assert.equal(g.players[0].tanks, 2);
assert.equal(g.players[0].reserves, 18);
- assert.equal(g.players[0].elites!.revived, 1);
+ assert.equal(g.players[0].elites!.revived, 0);
assert.equal(g.players[0].specialKaramaUsed, true);
assert.equal(g.discard.filter((c) => c.id === intent.card).length, 1);
const after = structuredClone(g);
diff --git a/tests/special-karama.test.ts b/tests/special-karama.test.ts
index 9a75a2de..0036b909 100644
--- a/tests/special-karama.test.ts
+++ b/tests/special-karama.test.ts
@@ -267,7 +267,7 @@ void test('special power usage persists across turns and does not disable ordina
card: karmas[1].id,
});
});
-void test('Emperor special revival is free, separate from normal quota and preserves the one-elite-per-turn limit', () => {
+void test('Emperor special revival is free and separate from the ordinary force and elite quotas', () => {
const before = stock(fixture());
before.players[1].revived = 3;
const spice = before.players[1].spice;
@@ -276,14 +276,16 @@ void test('Emperor special revival is free, separate from normal quota and prese
assert.equal(g.players[1].reserves, 18);
assert.equal(g.players[1].elites!.tanks, 1);
assert.equal(g.players[1].elites!.reserves, 4);
- assert.equal(g.players[1].elites!.revived, 1);
+ assert.equal(g.players[1].elites!.revived, 0);
assert.equal(g.players[1].revived, 3);
assert.equal(g.players[1].spice, spice);
assert.equal(g.response, null);
const already = stock(fixture());
already.players[1].elites!.revived = 1;
- assert.throws(() => revive(already), /one elite/);
- assert.equal(already.players[1].specialKaramaUsed, undefined);
+ assert.equal(revive(already).players[1].elites!.revived, 1);
+ const two = revive(already, { amount: 2, elite: 2 });
+ assert.equal(two.players[1].elites!.tanks, 0);
+ assert.equal(two.players[1].elites!.revived, 1);
assert.equal(
revive(already, { amount: 3, elite: 0 }).players[1].elites!.revived,
1,
@@ -313,7 +315,7 @@ void test('Emperor invalid special revivals preserve the card and usage and cann
for (const extra of [
{ amount: 4 },
{ amount: 0 },
- { amount: 2, elite: 2 },
+ { amount: 2, elite: 3 },
{ amount: 1, target: 'g' },
]) {
assert.throws(() => revive(g, extra));
diff --git a/tests/tleilaxu-special-karama-window.test.ts b/tests/tleilaxu-special-karama-window.test.ts
index ab8be6c3..ffd5f0bc 100644
--- a/tests/tleilaxu-special-karama-window.test.ts
+++ b/tests/tleilaxu-special-karama-window.test.ts
@@ -48,13 +48,20 @@ void test('native quiet Revival permits any player before a request and spends t
void test('ready, self and empty-Tanks targets do not narrow quiet declaration permission', () => {
const f = fixture();
- const ready = act(f.game, f.observer, { type: 'ready' });
- for (const target of [f.owner, f.observer]) {
- assert.equal(player(ready, target).tanks, 0);
+ // Advanced Revival is ordered. Finish the actual current seat instead of
+ // assuming that Emperor may finish ahead of the public queue.
+ const first = f.game.revivalOrder?.remaining[0];
+ assert.ok(first);
+ assert.ok(f.game.revivalOrder!.remaining.length > 1);
+ const ready = act(f.game, first, { type: 'ready' });
+ assert.ok(ready.ready.includes(first));
+ for (const target of [f.owner, f.observer]) assert.equal(player(ready, target).tanks, 0);
+ for (const target of new Set([first, f.owner, f.observer])) {
+ const tanks = player(ready, target).tanks;
const chosen = act(ready, f.owner, { ...f.special, target });
assert.equal(chosen.revivalPrevention?.player, target);
assert.deepEqual(chosen.ready, ready.ready);
- assert.equal(player(chosen, target).tanks, 0);
+ assert.equal(player(chosen, target).tanks, tanks);
}
});