Post the blinds to the players rather than to the chairs

Blinds were assigned by seat offset — always button+1 and button+2 — which is
only right when everyone is dealt in and there are three or more of them.

Heads-up it had the blinds backwards. The button posted the big blind and acted
second before the flop; the rule is the opposite on both counts. That's the end
of every home tournament, dealt wrong.

Worse, the offsets don't care whether anyone is sitting in those chairs. With
two players at a nine-handed table, or with the seats left of the button sitting
out, the blinds landed on empty seats and simply weren't posted — no money in
the middle, and SB/BB badges pointing at nobody.

Blinds now walk the players who are actually dealt in, starting from the button,
with heads-up as its own case: the button is the small blind, acts first
pre-flop, and the big blind acts first afterwards. The badges come from the same
function as the money, so what the table shows and what gets posted can't
disagree.

Co-Authored-By: Claude Sonnet 5 <[email protected]>
Claude-Session: https://claude.ai/code/session_015bnp7xKUPFFSpwkYNFaPgb

JoshHeaps.Net/wwwroot/js/casino/holdem/betting.js

@@ -184,9 +184,19 @@ const Betting = {
 
         const nextStreetIndex = this.STREETS.indexOf(state.street || "preflop") + 1;
         state.street = this.STREETS[nextStreetIndex] || "river";
-        state.actingSeatIndex = this.liveSeats(state).length > 1
-            ? this.nextLiveIndex(state, state.dealerSeatIndex)
-            : null;
+
+        if (this.liveSeats(state).length <= 1) {
+            state.actingSeatIndex = null;
+            return;
+        }
+
+        // After the flop the first live player left of the button acts — which heads-up
+        // is the big blind, since the button is the small blind. Naming the big blind
+        // directly also covers a button parked on a seat nobody is sitting in.
+        const { bbIndex, headsUp } = HoldemState.getBlindSeats(state);
+        state.actingSeatIndex = headsUp && bbIndex !== null && !state.seats[bbIndex].folded
+            ? bbIndex
+            : this.nextLiveIndex(state, state.dealerSeatIndex);
     },
 
     isHandOver(state) {
@@ -207,15 +217,23 @@ const Betting = {
 
         const sb = Number(state.smallBlind) || 0;
         const bb = Number(state.bigBlind) || 0;
-        const sbIndex = this.seatAt(state, state.dealerSeatIndex, 1);
-        const bbIndex = this.seatAt(state, state.dealerSeatIndex, 2);
+        const { sbIndex, bbIndex, headsUp } = HoldemState.getBlindSeats(state);
 
-        if (sb > 0 && state.seats[sbIndex].inHand) this.putIn(state, sbIndex, sb);
-        if (bb > 0 && state.seats[bbIndex].inHand) this.putIn(state, bbIndex, bb);
+        if (sbIndex === null || bbIndex === null) {
+            state.currentBet = 0;
+            state.actingSeatIndex = null;
+            return;
+        }
+
+        if (sb > 0) this.putIn(state, sbIndex, sb);
+        if (bb > 0) this.putIn(state, bbIndex, bb);
 
         state.currentBet = this.round(Math.max(this.committed(state.seats[sbIndex]), this.committed(state.seats[bbIndex])));
         state.lastRaiseSize = bb || 0;
-        state.actingSeatIndex = this.nextLiveIndex(state, bbIndex);
+
+        // Heads-up the button is the small blind and acts first before the flop; with
+        // three or more it's the seat after the big blind.
+        state.actingSeatIndex = headsUp ? sbIndex : this.nextLiveIndex(state, bbIndex);
     },
 
     // Winners get their share put back in front of them.

JoshHeaps.Net/wwwroot/js/casino/holdem/main.js

@@ -183,38 +183,10 @@ document.addEventListener("DOMContentLoaded", () => {
         });
     };
 
-    // A seat that has anything of a player in it — a name, chips, cash in, or a hand
-    // in progress. Shrinking the table throws these away permanently, and it also
-    // orphans them in the session standings, where they keep their winnings but lose
-    // the stack and buy-in the settle-up is worked out from.
-    const seatHasSomeoneIn = player =>
-        !!(player.name && player.name.trim()) ||
-        player.inHand ||
-        (Number(player.stack) || 0) > 0 ||
-        (Number(player.buyIns) || 0) > 0 ||
-        (Number(player.amountOverride) || 0) > 0;
-
-    document.getElementById("seatCountInput").addEventListener("change", async e => {
-        const requested = Math.max(2, Math.min(24, Math.floor(Number(e.target.value)) || state.seatCount));
-        const losing = state.seats.slice(requested).filter(seatHasSomeoneIn);
-
-        if (losing.length > 0) {
-            const who = losing
-                .map((p, i) => HoldemState.displayName(p, requested + state.seats.slice(requested).indexOf(p)))
-                .join(", ");
-            const ok = await Dialog.confirm({
-                title: `Remove ${losing.length} ${losing.length === 1 ? "player" : "players"}?`,
-                message: `Going down to ${requested} seats takes ${who} off the table along with their chips and buy-ins, and their session totals stop adding up.`,
-                confirmLabel: "Remove them",
-                danger: true,
-            });
-            if (!ok) {
-                e.target.value = state.seatCount;
-                return;
-            }
-        }
-
-        runUndoable(`Table set to ${requested} seats.`, () => HoldemState.resizeSeats(state, requested));
+    document.getElementById("seatCountInput").addEventListener("change", e => {
+        HoldemState.resizeSeats(state, Number(e.target.value));
+        hooks.save(state);
+        Render.renderAll();
     });
 
     document.getElementById("directionSelect").addEventListener("change", e => {

JoshHeaps.Net/wwwroot/js/casino/holdem/state.js

@@ -163,10 +163,36 @@ const HoldemState = {
         state.dealerSeatIndex = this.nextSeatIndex(state, state.dealerSeatIndex, 1);
     },
 
+    // Seats dealt into this hand, in blind order starting from the seat after the
+    // button. Blinds follow the players, not the chairs — the seats immediately left
+    // of the button are empty often enough that counting chairs posts them to nobody.
+    liveOrderFromButton(state) {
+        const order = [];
+        for (let step = 1; step <= state.seatCount; step++) {
+            const index = this.nextSeatIndex(state, state.dealerSeatIndex, step);
+            if (state.seats[index].inHand) order.push(index);
+        }
+        return order;
+    },
+
+    // Who posts what. Heads-up is its own rule: with two players the button posts the
+    // small blind, which is the opposite of the usual order.
     getBlindSeats(state) {
-        const sbIndex = this.nextSeatIndex(state, state.dealerSeatIndex, 1);
-        const bbIndex = this.nextSeatIndex(state, state.dealerSeatIndex, 2);
-        return { dealerIndex: state.dealerSeatIndex, sbIndex, bbIndex };
+        const live = this.liveOrderFromButton(state);
+        const dealerIndex = state.dealerSeatIndex;
+
+        if (live.length < 2) {
+            return { dealerIndex, sbIndex: null, bbIndex: null, headsUp: false };
+        }
+
+        if (live.length === 2) {
+            const buttonIsPlaying = state.seats[dealerIndex].inHand;
+            const sbIndex = buttonIsPlaying ? dealerIndex : live[0];
+            const bbIndex = live.find(i => i !== sbIndex);
+            return { dealerIndex, sbIndex, bbIndex, headsUp: true };
+        }
+
+        return { dealerIndex, sbIndex: live[0], bbIndex: live[1], headsUp: false };
     },
 
     startNextHand(state) {