Pass the button to the next player, not the next chair

The button moved one seat per hand regardless of whether anyone was sitting
there. At a ten-seat table with four players — an ordinary home game — it spent
five hands out of eight on an empty chair.

That reads as untidy, but the real problem is fairness. Position and the blinds
are meant to come round to each player at the same rate. Rotating past empty
chairs breaks that: a player with three empty seats to their right takes the
button far less often than one sitting in a cluster, while both pay blinds every
time the rotation reaches them.

The button now skips to the next seat that's actually dealt in, so with four
players it visits those four in turn and each takes it once every four hands.

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,19 +184,9 @@ const Betting = {
 
         const nextStreetIndex = this.STREETS.indexOf(state.street || "preflop") + 1;
         state.street = this.STREETS[nextStreetIndex] || "river";
-
-        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);
+        state.actingSeatIndex = this.liveSeats(state).length > 1
+            ? this.nextLiveIndex(state, state.dealerSeatIndex)
+            : null;
     },
 
     isHandOver(state) {
@@ -217,23 +207,15 @@ const Betting = {
 
         const sb = Number(state.smallBlind) || 0;
         const bb = Number(state.bigBlind) || 0;
-        const { sbIndex, bbIndex, headsUp } = HoldemState.getBlindSeats(state);
+        const sbIndex = this.seatAt(state, state.dealerSeatIndex, 1);
+        const bbIndex = this.seatAt(state, state.dealerSeatIndex, 2);
 
-        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);
+        if (sb > 0 && state.seats[sbIndex].inHand) this.putIn(state, sbIndex, sb);
+        if (bb > 0 && state.seats[bbIndex].inHand) 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;
-
-        // 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);
+        state.actingSeatIndex = this.nextLiveIndex(state, bbIndex);
     },
 
     // Winners get their share put back in front of them.

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

@@ -159,40 +159,27 @@ const HoldemState = {
         return ((fromIndex + delta) % count + count) % count;
     },
 
+    // The button passes to the next player, not the next chair. Moving it one seat at
+    // a time parks it on empty chairs — with four players spread around ten seats it
+    // sits on nobody most hands — and that isn't only untidy: position and blinds are
+    // supposed to come round to each player at the same rate, and they don't if the
+    // button is rotating past chairs nobody is sitting in.
     advanceButton(state) {
+        for (let step = 1; step <= state.seatCount; step++) {
+            const index = this.nextSeatIndex(state, state.dealerSeatIndex, step);
+            if (state.seats[index].inHand) {
+                state.dealerSeatIndex = index;
+                return;
+            }
+        }
+        // Nobody is dealt in; move it along anyway so it doesn't look stuck.
         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 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 };
+        const sbIndex = this.nextSeatIndex(state, state.dealerSeatIndex, 1);
+        const bbIndex = this.nextSeatIndex(state, state.dealerSeatIndex, 2);
+        return { dealerIndex: state.dealerSeatIndex, sbIndex, bbIndex };
     },
 
     startNextHand(state) {