Winner stays (Doozer Games' 1-on-1 house rule), Four in a Row and Reversi

systems/winner-stays.md · System · doozer-games, winner-stays, four-in-a-row, reversi, framework, tv, phones, rematch

status: stable · written by claude-opus-5-5 on 2026-10-26 · stale after 2027-04-01

The reusable rule for any 1-on-1 game on a Doozer Games TV (champion, challenger, a line, rematch), kept apart from the game so the next 1-on-1 game is only its rules and its board. Four in a Row and Reversi are built on it.

Winner stays: Four in a Row and Reversi

v2.2.691 (Oct 26 2026); Reversi v2.2.692 (Oct 27). Jon: "a 1-on-1 game that lets the winner stay while a new challenger can join. If no challengers exist, the winner still stays and the loser may ask for a rematch. This model can apply to many games." The room and relay under it: Doozer Games rooms and relay; the menu and how a new game plugs in: Town Trivia and the Doozer Games menu.

The rule (assets/js/doozer-winner-stays.js, DZWinnerStays.start)

• Seat 0 is the champion, seat 1 the challenger, who moves first. Everyone else waits in a line

in the order they scanned in. The first person in takes the seat; the second challenges.

• The result stays on screen as it was played (seats, colors, the winning line) for a few

seconds; only then does the winner hold seat 0. GOTCHA (found by looking): swapping seats and colors the moment a challenger won repainted the winning stone in the loser's color on the TV and every phone. settle() now runs when the result clears, or first if someone leaves during it.

• After a game: the loser goes to the back of the line. With nobody waiting, the loser gets a

minute to ask for a rematch (Rematch / Not now). Someone new scanning in during that minute plays first and the loser waits behind them. When the minute runs out the loser is watching, and "Get in line" brings them back.

• A draw keeps the champion. Leaving mid-game forfeits (both names are kept from the start of

the game, since a player who leaves is gone from the room before the result is written). Out of time (20 seconds) the game's autoMove plays for you; nobody is ever stuck.

• The streak lives only in the room. Who plays is decided only by who joined with the code (the

house rules: the code on the screen is the only way in, nicknames, nothing kept).

Building the next 1-on-1 game

A game gives the rule four functions and draws what it is told:

var ws = DZWinnerStays.start({room, rules: {name, newState(), legal(s, move, side), autoMove(s, side),
  moves(s, side) /* optional: the phone on turn gets its legal moves */,
  apply(s, move, side) -> null                       // the other side moves next
                        | {next: 0|1, note}           // that side moves next: a pass, an extra turn
                        | {winner: 0|1|null, line, score}},   // over; null is a draw
  turnSecs, onView});
// DZRoom.start({welcome: p => { ws.enlist(p); return ws.phoneView(p); },
//               onJoin: ws.joined, onPart: ws.parted, onMsg: (p, m) => ws.msg(p, m)})

• A move is one small number (the relay's move allows 0 to 255). The phone sends

{t: 'move', v}, {t: 'rematch'}, {t: 'line', on}; all three are already in both relay allowlists. GOTCHA: the game's name IS a relay change: pick (a phone choosing a game on the menu) only passes names on its list, in includes/games-relay.php and in the Worker (cloudflare/games-relay/src/index.js). A game left off it opens from the remote but not from a phone. That list is deliberate: a phone must not be able to send the TV to any URL.

• Every change sends each phone {t: 'ws', ...phoneView}: its role (champ, chal, line, rematch,

out), place in line, whose turn, the state, the colors as played, and its own result.

• Call ws.enlist(p) in the welcome. GOTCHA: the room sends the welcome before onJoin, so a

new phone opened on "You are watching" for a moment while it was really next in line.

• The phone page renders winner-stays screens in renderWS (includes/doozer-pad.php) for every

1-on-1 game; what differs lives in WSG[game]: the name, the board function, the words for "your turn" and "out of time", and whether to show a count (score). A new game adds one entry and a board function, plus its slug in the phone's GAMES names.

• The menu (includes/doozer-tv-home.php) fits four tiles across, the stick's 960x540

included. A fifth needs a second row or a scrolling shelf. A tile's art is inline SVG.

Four in a Row (includes/doozer-four-tv.php, /tv/four)

Seven columns, six rows; four across, down or diagonally wins. The TV draws an SVG board (wood frame, stones that drop, the winning four pulsing), champion and challenger cards with a turn timer bar, a banner for the matchup and the result, "Next up" with the line, and plays itself (an attract loop) until two people are in. The code card is a small corner chip during a game and stands in the challenger's place when the seat is open, so it never covers the board. The rematch screen keeps the finished board. autoMove wins if it can, blocks if it must, else leans to the middle. The move is a column: the stone it dropped is the top one in that column (topCell), which the drop animation and the phone's last-move ring use.

The remote plays too: the first press gets it in line, arrows choose a column, OK drops (or asks for the rematch). Up to eight people in the room.

Reversi (includes/doozer-reversi-tv.php, /tv/reversi)

Chosen for a bar or living-room TV (Jon asked for one that suits the room): two colors and a big count beside each name tell anyone across the room who is ahead; one move can flip a whole row, so the lead swings in front of everyone; the phone lights up the squares you can play, so nobody needs the rules. It is the 1880s game, public domain; never call it Othello (a trademark).

8x8; the challenger (seat 1) has the classic opening squares and moves first. A move is a square (0 to 63). The stones a move traps turn over in a ripple out from it (a CSS scaleX flip; the color changes on edge); faint dots on the TV show where the player on turn can go, so the room can follow. A player with no move passes: apply returns {next: side, note: 'pass'}, the TV says "Wren has no move / Heron goes again", the phones say it too. When neither can move, the most stones wins and the result carries score ("Heron wins, 42 to 22"); 32 to 32 is a draw (the champion stays). autoMove picks by a corners-first weight table. The remote moves a cursor in two dimensions; it starts each turn on the legal square nearest where it was, and OK on an illegal square shakes it. About 1 game in 3 has a pass; 6 in 200 random games were draws.

GOTCHA (found on the Fire TV stick, v2.2.694): a stone keeps its pop-in class (put) after it lands, and when the flip class came off at the end of a flip, the pop-in started over: every stone placed during the game blinked out and popped back after flipping (41 of 41 measured). A flip now removes put too. With CSS animations, taking a class off can restart another one still on.

Looked at and dropped: dimming the loser's stones at the end turned gold into a muddy olive that read as a third player. The glowing winner card and the banner say who won; the board stays as played.

Testing

ws.test.mjs (24 checks, the rule with Four's rules, fake room), rev.test.mjs (13 checks and 200 whole Reversi games: counts always add up, passes only when the other side truly has no move) and headless-Chrome runs: three phones through the menu into a match, a new champion and the next challenger; two phones through a rematch, a mid-game leave and the remote as challenger; a whole Reversi game of 60 moves by tapping glowing squares; a replayed game that forces a pass; the remote's cursor. GOTCHAS:

• Read a phone after its screen changes, not right after the TV's; the relay delivers within about

a second, and a probe that reads too early reports a stale screen that is not a bug.

• A background tab does not run CSS animations, so stones placed while the test's TV tab was

behind the phones were missing from its screenshot. Bring the TV tab to the front (Page.bringToFront) before shooting it. On a real TV the page is always in front.

• The relay allows 12 new rooms per address per UTC clock hour (grRateOk('new', 12)); a TV that

reloads or changes game reuses its room first and is not counted. Tests that clear the stored room to start fresh do count, including local runs (the local router uses the live relay), so a busy test hour runs out and the TV sits on "Making a room" until the hour turns.

On the Fire TV stick (Oct 27 2026, app 0.3.1, web 2.2.694): real remote presses over adb, the stick's own page read over DevTools, two or three headless phones on the live relay. Both games from the menu with the remote and the room code kept; Reversi flips at 58 to 59 fps (worst frame gap 34 ms) with the ripple timed as written; the remote cursor moves in two dimensions, starts on a legal square, shakes on an occupied one, places on a legal one; Four's hover column moves and OK drops; Back from either game lands on the menu, stays there, and the phones follow. That run found two bugs, both fixed: the backlog replay (the relay, v2.2.693) and the flip blink above. How: the release build hides the page from DevTools, so swap in the debug build (same source; uninstall first, the signatures differ) and put the release back after; adb shell input keyevent takes about 1.3 s a press, so a remote turn of ten presses uses half its 20 seconds; adb shell screenrecord plus ffmpeg frames shows an animation as the stick drew it.

Related: Doozer Games and Doozer Shop.