feat(game): Sudden Death mode — last-place player eliminated per round (#827)

[mholzi]

What & why

Implements Sudden Death mode (#827): an opt-in mode where the lowest round-scoring player is eliminated each round (from round 2 on) until one player is left standing. Adds the tension arc and clear finale the open-ended scoring lacked.

Design directions came from a /design-shotgun pass (7 screen elements × variants); picks: wizard in-row toggle, player "Stark Blackout" eliminated view, hard cut-line leaderboard, full-bleed "OUT" TV takeover, arena FINAL, "Last One Standing" trophy hero, admin control-bar live toggle.

Two changes vs. the issue as filed

1. Wizard toggle defaults ON (issue said False) when ≥3 players; auto-disabled + tooltip below that. The dataclass default stays False; the wizard checkbox is what defaults on.
2. NEW: live toggle on the reveal screen — the host can flip Sudden Death on/off mid-game from the Stop/Skip/End control bar, not only in the wizard.
   • ON → eliminations arm starting next round; current round's results stand.
   • OFF → no further cuts; already-eliminated players stay out.

Mechanics

• Eliminate the lowest round delta (not cumulative) among survivors. Tie-break: slowest submitter is out; a non-submitter counts as slowest. Round 1 never eliminates. Never cuts the last survivor — start_round auto-ends the game when one remains.
• all_submitted / early-reveal ignore eliminated players. Eliminated state persists across rounds + pause/resume, resets on a new game/rematch.
• New "Last One Standing" superlative for the survivor.

Surfaces

• Backend (game/, server/): sudden_death_mode config + create_game, PlayerSession.eliminated/eliminated_round, elimination in _end_round_unlocked, set_sudden_death() + POST /beatify/api/sudden-death, WS state (sudden_death_mode, players[].eliminated, REVEAL eliminated_this_round, leaderboards).
• Frontend (www/): wizard mode card, player eliminated view + leaderboard cut-line (submit gated), admin live toggle + elimination/FINAL chips, dashboard TV "OUT"/FINAL/Last-One-Standing, i18n en/de/es/fr/nl, regenerated .min bundles.

Tests / gates

• 17 new unit tests in test_state.py (elimination, round-delta, tie-break, round-1 skip, auto-end, all-submitted, persistence, live toggle, superlative).
• ✅ Python unit suite (1116 passed) · ✅ JS suite (325 passed) · ✅ ruff · ✅ mypy · ✅ build:check (no .min drift).

Scope notes / follow-ups

• Server does not hard-reject Sudden Death with <3 players at game-create time (players join the lobby after create_game clears sessions). Guarding is done in the wizard (disabled <3) and the elimination/auto-end logic self-guards. Worth a confirm.
• Cheer/reaction buttons on the eliminated view were cut from v1 (no existing reaction system to reuse), per the issue's flags.
• The END winner/podium still ranks by cumulative score; the survivor is marked via the "Last One Standing" superlative + hero. Crowning the survivor as Guess artist functionality #1 regardless of score is a possible follow-up.

Closes #827

🤖 Generated with Claude Code

[gemini-code-assist]

Code Review

This pull request implements a new "Sudden Death" game mode where the lowest-scoring player is eliminated each round. The implementation spans backend state management, lifecycle hooks, API endpoints, and comprehensive frontend updates for the player, admin, and dashboard views, along with unit tests. The review feedback identifies several important issues: a bug where the elimination takeover key is not reset on rounds without eliminations (preventing it from firing in rematches), an incorrect winner assignment if multiple survivors remain, a potential server crash if a non-dictionary JSON payload is sent to the sudden-death API, an overly restrictive disable threshold for the live toggle when two players remain, and incorrect argument ordering in translation helper calls.

Important

The consumer version of Gemini Code Assist on GitHub is being sunset. Starting June 18, 2026, new organization installations will be blocked, and all code review activity will officially cease on July 17, 2026.
For more details on the timeline and next steps, please review the Help Documentation.

[gemini-code-assist]

The comment states that the key should be reset when there is no elimination this round, but the code simply returns without resetting sdLastOutKey.

Without resetting sdLastOutKey, if a game is rematched and the same player is eliminated in the same round of the new game (e.g., round 2), the key will match the cached sdLastOutKey from the previous game, and the "OUT" takeover will fail to fire.

Set sdLastOutKey = null; before returning to ensure the key is properly reset.

Suggested change

	if (!names.length) {
	// No elimination this round — make sure the key resets so a future
	// elimination with the same names (different round) still fires.
	return;
	}
	if (!names.length) {
	// No elimination this round — make sure the key resets so a future
	// elimination with the same names (different round) still fires.
	sdLastOutKey = null;
	return;
	}

[gemini-code-assist]

If a Sudden Death game ends by reaching the maximum number of rounds rather than by 1v1 elimination, there can be multiple survivors left (e.g., survivors.length > 1).

Currently, winner is set to survivors[0].name as long as survivors.length is non-zero. This means the highest-scoring survivor will be crowned as the "Last One Standing" even though other players also survived.

To prevent this incorrect display, winner should only be extracted from the leaderboard if there is exactly one survivor (survivors.length === 1). Otherwise, it should remain null (or fall back to the superlative, which also correctly guards for exactly one survivor).

Suggested change

	var leaderboard = data.leaderboard || [];
	var survivors = leaderboard.filter(function(e) { return !e.eliminated; });
	var winner = survivors.length ? survivors[0].name : null;
	var leaderboard = data.leaderboard || [];
	var survivors = leaderboard.filter(function(e) { return !e.eliminated; });
	var winner = survivors.length === 1 ? survivors[0].name : null;

[gemini-code-assist]

If the request contains a valid JSON payload that is not an object (e.g., a list [] or a string "enabled"), await request.json() will succeed but return a non-dict object. Calling body.get(...) on it will then raise an AttributeError, resulting in an unhandled 500 Internal Server Error.

Add a type check to ensure body is a dictionary before accessing its keys.

Suggested change

	try:
	body = await request.json()
	except (ValueError, UnicodeDecodeError):
	return _json_error("Invalid JSON", 400, code="INVALID_REQUEST")
	enabled = bool(body.get("enabled", False))
	try:
	body = await request.json()
	except (ValueError, UnicodeDecodeError):
	return _json_error("Invalid JSON", 400, code="INVALID_REQUEST")
	if not isinstance(body, dict):
	return _json_error("Invalid request body", 400, code="INVALID_REQUEST")
	enabled = bool(body.get("enabled", False))

[gemini-code-assist]

The live toggle is disabled when there are fewer than 3 survivors (remaining < 3). However, if there are exactly 2 survivors left, toggling Sudden Death is still highly relevant:

1. If it is currently ON, the host might want to turn it OFF to prevent the game from ending on the next round and allow the remaining 2 players to continue playing.
2. If it is currently OFF, the host might want to turn it ON to make the next round a decisive "winner-takes-all" final round.

Disabling the toggle at 2 players unnecessarily restricts these valid host choices. Consider changing the disable threshold to remaining < 2 instead.

Suggested change

	// Arming below 3 survivors is pointless (2 left = final already / 1 = winner).
	btn.disabled = remaining < 3;
	// Only disable the toggle if there are fewer than 2 survivors left.
	btn.disabled = remaining < 2;

[gemini-code-assist]

The current call to utils.t passes the variables object { round: round } as the second argument. If the translation system's signature is t(key, fallback, variables), this treats the variables object as the fallback string, which could result in [object Object] being displayed if the translation key is missing.

Additionally, if utils.t returns the key name (e.g., 'game.eliminatedRound') when a translation is missing, the || fallback will never be reached because the returned key is truthy.

To be safe and idiomatic, pass the fallback string as the second argument and the variables as the third argument.

            subEl.textContent = utils.t('game.eliminatedRound', 'Eliminated · Round {round}', { round: round });

[gemini-code-assist]

Similar to the game.eliminatedRound translation call, pass the fallback string as the second argument and the variables as the third argument to ensure robust translation fallback and interpolation.

Suggested change

	var outText = utils.t('game.outRound', { round: round }) || ('Out · R' + round);
	var outText = utils.t('game.outRound', 'Out · R{round}', { round: round });

[mholzi]

Follow-ups addressed (commit 73d9c8d)

All three flagged items are now fixed:

1. Survivor is the winner — compute_winners() returns the last player standing regardless of cumulative score once the game resolves (≥1 elimination, one survivor), and get_final_leaderboard() now orders by survival (survivor 1st, then reverse elimination order, score breaking ties). Podium Guess artist functionality #1, the winner field, and the "Last One Standing" hero all agree. Falls back to score-based when Sudden Death is off or the game ended early.
2. Server-side <3-player floor — start-gameplay auto-disables Sudden Death (returning a warnings[] + sudden_death_disabled flag) when fewer than 3 players are connected. This is the right enforcement point since players join the lobby after create_game clears sessions; the wizard still disables the toggle client-side.
3. Eliminated players can cheer — instead of adding bespoke buttons to the minimal Stark-Blackout view, eliminated spectators now get the existing #reaction-bar during PLAYING (it normally only shows in REVEAL), piggybacking the live-reaction system.

+4 new tests. Gates: ✅ 1120 Python tests · ✅ 325 JS · ✅ ruff · ✅ mypy · ✅ build:check.