Timeline placement mode — the gap the README already admits to

[mholzi]

Beatify's own README names this as the biggest gap between it and the boxed game people compare it to:

Timeline placement | ✅ The core mechanic | ❌ Not implemented. Rounds score a year guess instead

— README.md:658, and README.md:662 calls it out again in prose.

What it is

A third game mode. Instead of typing a year, each player slots the playing song into their own timeline between songs they have already won: "is this before 1987, between 1987 and 1994, or after?" Placed correctly, they keep the card. First to ten cards wins.

It is a different question from "what year is this", and a much easier one for a guest who knows the song but not the date — which is most guests.

What it builds on

• year is populated on all 7142 songs, which is the only data the mode needs
• mode selection already exists for the Title & Artist mode (game/state_setup.py, game/challenges.py)
• the reveal and scoring pipeline is in game/state_scoring.py

Size and risk

Large. The risk is the scoring model: cards are not points, so streaks, power-ups and superlatives all assume something this mode does not have. It should be a separate, encapsulated mode rather than a flag threaded through the existing scorer — the sudden-death round of regressions (#1747–#1752) came from exactly that kind of entanglement.

[mholzi]

Not planned.

The README gap is real and stays documented at README.md:658 — this closes the ticket, not the honesty about the gap.

Recorded for whoever opens this again: the data is ready. year is populated on 7142 of 7142 songs across 58 playlists, so the mode needs no new song data at all.

What is not ready is the seam the issue assumed. It says mode selection already exists; what exists is title_artist_mode, a boolean spread across 48 sites in 15 Python modules and roughly a dozen JS files. A third mode does not fit into a boolean, and threading it through as another flag is the entanglement that produced the sudden-death regressions in #1747-#1752.

So the shape was never in doubt — an encapsulated mode with its own state and its own reveal, sitting beside the scorer rather than inside it. The cost is.

[mholzi]

Reopened at Markus' request — the mode is back on the table.

The closing comment above stays as the current state of knowledge and does not need re-deriving:

• year is populated on 7142 of 7142 songs across 58 playlists. The mode needs no new song data.
• The seam is the problem, not the data. title_artist_mode is a boolean spread across 48 sites in 15 Python modules plus roughly a dozen JS files — not a mode selector a third mode can join.
• Therefore: an encapsulated mode with its own state and its own reveal, beside the scorer rather than inside it. Threading another flag through is what produced the sudden-death regressions in Sudden Death elimination uses stale round_score when title/artist scoring is deferred #1747-Late joiners can be eliminated in the very round they join a Sudden Death game #1752.

[mholzi]

Five shapes this mode could take, measured against 9eaf37c9.

The cost is not where this issue puts it

The issue names title_artist_mode — "48 sites across 15 Python modules" — as the reason a third mode is expensive. The 48 are real, but they are not 48 branches. Categorised:

kind	count
actual if branches on the flag	12
pass-through, properties, parameters	30
comments and docstrings	6

The expensive seam is a different one. player.score is touched at 45 sites across 13 modules, and they are the modules that make a party visible: state_leaderboard.py (11), state_tts.py (8 — the spoken announcement reads scores aloud), scoring.py (7), state_serialization.py (6), plus sensor.py (the Home Assistant entity) and share.py (the result card).

So: swapping the question is cheap, swapping the currency is expensive. Every option below sorts on that one axis.

What hangs off points

Thirteen superlatives run at game end. Four belong to Title & Artist mode and would be off in a third mode anyway. Of the nine that remain, seven lose their basis without points — risk_taker (bets), last_one_standing (Sudden Death), clutch_player and comeback_king (both read round_scores), close_calls (±1-year guesses), film_buff and intro_master (point bonuses). Two survive: speed_demon reads submission_times, lucky_streak reads streak.

Add Steal and Sabotage (both pick their target by score), Sudden Death (eliminates by smallest round delta, _sudden_death_round_delta) and Finale ×2 (doubles a round score). Cards instead of points is not "a different field" — it is a decision, per mechanic, to redefine or disable.

What is ready

year is populated on 7142 of 7142 songs across 58 playlists — no new song data at all. And since #2347 the client knows the playing playlist's year span (applyYearRange), since #2358 it draws decade marks on it (renderYearScale). That is exactly the geometry a timeline needs.

The five shapes

	name	the question the player answers	currency	price
D	Nudge	"before or after Billie Jean?" — a bonus beside the year guess	points	1/5
E	Collection	year guess unchanged; a hit inside close_range pins the song to a visible row	points + row	2/5
B	Gap	placement replaces the slider; anchors are your own won songs	points	3/5
C	Board	one shared timeline on the TV, everyone places into the same gaps	points	3/5
A	Card	the boxed game, faithfully: own timeline, cards, first to ten wins	cards	5/5

Only A actually turns the README row from ❌ to ✅ — and only A swaps the currency.

D is the shape the codebase already has three times. ArtistChallenge, MovieChallenge and TitleArtistChallenge all live in ChallengeManager with the same form — one dataclass, one to_dict, all three called side by side in init_round. A TimelineChallenge joins that row without a single existing caller needing to know it exists.

The trick that makes B cheap: a years_off can be derived from the chosen gap (distance to the correct gap, counted in anchors). The 50 sites that read years_off then keep working unchanged — one number is fed instead of 50 sites rewritten.

Why A forces its own engine: once the currency changes, encapsulation inside the manager does not help. The points are not in the manager, they are everywhere. Leaderboard, TTS, HA sensor and share card each need a second path.

The silent omission in A

In the box the game is turn-based: one player is asked, the others may challenge. Beatify asks everyone at once. A faithful port therefore produces twenty parallel solitaires — half of the original, the challenge, drops out silently. Anyone choosing A should know they are not getting it.

My view: keep simultaneous and drop the challenge. It is the one place where contradicting the box is right, and the reason is the guest count Beatify is built for.

Recommendation

E, then C.

E first, because it delivers the one thing the box has emotionally that Beatify has none of: the row that grows in front of you and gets photographed at the end. A score disappears the moment the game is over. E costs a derived list and two views, and touches the scorer nowhere.

C after, because it does ask the placement question, and it solves what a faithful port runs into at a party: twenty private timelines cannot be shown on a TV, one shared board can. It is the only shape where the living-room screen becomes the table.

D is the cheap measurement of the assumption this whole issue rests on — that guests would rather answer "before or after" than "which year". Two evenings of work to find out before spending six weeks on it.

A stays right if the goal is the comparison table rather than the play. Only A turns that row into a ✅, and that row is the first thing a comparison shopper reads. That is a legitimate reason — it just has to be said out loud, because it has to justify a price of 5 instead of 2.

Three decisions that are not in the code

1. The box's mechanism, or the box's feeling? A gives both, E only the second, B and C only the first. This decides whether the price is 2 or 5.
2. Cards or points on the TV? Points means streaks, bets, steal, sabotage, Sudden Death, Finale ×2 and every superlative keep running untouched. Cards means six mechanics and seven superlatives each need a decision.
3. Simultaneous or turn-based? Turn-based brings the challenge back and costs nineteen waiting guests per round.