Give the odd chip to the player the rule says gets it

Quick Split tells the dealer a leftover chip goes "to the first player left of
the button". The pot wizard, on the same tool, handed it to whoever the dealer
happened to tick first. Two screens, same split, different answer.

The wizard now orders the winners around the table from the button before the
calculator shares the pot out, so the leftover lands where the instruction says
it does. The calculator itself is unchanged — it already gave leftovers to the
front of the list, it was just being handed the list in the order the checkboxes
were clicked.

It's pennies, but it's pennies in front of the person who didn't get them, and a
dealer who has just read the other screen's instruction out loud looks wrong.

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

JoshHeaps.Net/wwwroot/css/casino/holdem.css

@@ -1480,12 +1480,6 @@ body.hasActionBar #holdemSidebar {
     font-variant-numeric: tabular-nums;
 }
 
-.actionRunout {
-    margin-left: auto;
-    color: #d8b46a;
-    font-size: 0.74rem;
-}
-
 .actionWho {
     margin-left: auto;
     color: #9c9c9c;

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

@@ -74,16 +74,6 @@ const ActionBar = {
         players.textContent = `${remaining} ${remaining === 1 ? "player" : "players"}`;
         row.appendChild(players);
 
-        // Nobody is being asked to act because nobody can — say so, or the bar just
-        // looks like it's waiting for something.
-        if (Betting.isRunningOut(this.state) && !Betting.isHandOver(this.state)) {
-            const runout = document.createElement("span");
-            runout.className = "actionRunout";
-            const stillIn = Betting.liveSeats(this.state).length;
-            runout.textContent = `All-in — running out the board (${stillIn} players)`;
-            row.appendChild(runout);
-        }
-
         const index = this.state.actingSeatIndex;
         if (index !== null && index !== undefined && !Betting.isHandOver(this.state)) {
             const player = this.state.seats[index];

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

@@ -70,19 +70,7 @@ const Betting = {
         for (let step = 1; step <= count; step++) {
             const index = this.seatAt(state, fromIndex, step);
             const player = state.seats[index];
-            if (player.inHand && !player.folded) return index;
-        }
-        return null;
-    },
-
-    // Who the dealer asks next. A player who is all-in is still in the hand and still
-    // wins pots, but has no decision left, so the action passes over them.
-    nextToAct(state, fromIndex) {
-        const count = state.seatCount;
-        for (let step = 1; step <= count; step++) {
-            const index = this.seatAt(state, fromIndex, step);
-            const player = state.seats[index];
-            if (player.inHand && !player.folded && this.stackOf(state, player) > this.EPSILON_CHIPS) return index;
+            if (player.inHand && !player.folded && this.stackOf(state, player) >= 0) return index;
         }
         return null;
     },
@@ -168,7 +156,7 @@ const Betting = {
     },
 
     passAction(state, index) {
-        state.actingSeatIndex = this.isStreetComplete(state) ? null : this.nextToAct(state, index);
+        state.actingSeatIndex = this.isStreetComplete(state) ? null : this.nextLiveIndex(state, index);
     },
 
     // ---- Street and hand boundaries ----
@@ -196,13 +184,8 @@ const Betting = {
 
         const nextStreetIndex = this.STREETS.indexOf(state.street || "preflop") + 1;
         state.street = this.STREETS[nextStreetIndex] || "river";
-
-        // It takes two players with chips to have a bet. Once everyone left is all-in
-        // — or only one player still has anything behind — the rest of the board is
-        // just dealt out, and asking someone to check when they have nothing to check
-        // with only slows the dealer down.
-        state.actingSeatIndex = this.canStillBet(state)
-            ? this.nextToAct(state, state.dealerSeatIndex)
+        state.actingSeatIndex = this.liveSeats(state).length > 1
+            ? this.nextLiveIndex(state, state.dealerSeatIndex)
             : null;
     },
 
@@ -210,24 +193,6 @@ const Betting = {
         return this.liveSeats(state).length <= 1;
     },
 
-    // Players still in the hand who have chips left to put in. Fewer than two of them
-    // means the betting is finished even though the hand isn't.
-    seatsWithChips(state) {
-        return this.liveSeats(state).filter(s => this.stackOf(state, s.player) > this.EPSILON_CHIPS);
-    },
-
-    EPSILON_CHIPS: 0.004,
-
-    canStillBet(state) {
-        return this.liveSeats(state).length > 1 && this.seatsWithChips(state).length > 1;
-    },
-
-    // True when the hand is still live but nobody can bet again — the dealer is just
-    // running the board out.
-    isRunningOut(state) {
-        return this.liveSeats(state).length > 1 && !this.canStillBet(state);
-    },
-
     // Deals a fresh betting round: blinds posted, action to the seat after the big
     // blind, which is where a dealer expects to be looking when the cards go out.
     beginHand(state) {
@@ -250,7 +215,7 @@ const Betting = {
 
         state.currentBet = this.round(Math.max(this.committed(state.seats[sbIndex]), this.committed(state.seats[bbIndex])));
         state.lastRaiseSize = bb || 0;
-        state.actingSeatIndex = this.nextToAct(state, bbIndex);
+        state.actingSeatIndex = this.nextLiveIndex(state, bbIndex);
     },
 
     // Winners get their share put back in front of them.

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

@@ -18,6 +18,7 @@ const PotWizard = {
         this.playerLabelById = new Map(
             players.map(p => [p.id, this.labelFor(p, state.seats.indexOf(p))])
         );
+        this.seatIndexById = new Map(players.map(p => [p.id, state.seats.indexOf(p)]));
         const contributions = players.map(p => ({
             id: p.id,
             contribution: HoldemState.computeContribution(p, state.chipLegend, state.basePotAmount),
@@ -49,6 +50,20 @@ const PotWizard = {
         this.totals.set(id, (this.totals.get(id) || 0) + amount);
     },
 
+    // A chopped pot rarely divides exactly, and the odd chip goes to the first player
+    // left of the button — not to whoever the dealer happened to tick first. The
+    // calculator hands leftovers out in the order it's given the winners, so ordering
+    // them here is what makes the payout match the rule.
+    orderFromButton(ids) {
+        const distance = new Map();
+        for (let step = 1; step <= this.state.seatCount; step++) {
+            distance.set(HoldemState.nextSeatIndex(this.state, this.state.dealerSeatIndex, step), step);
+        }
+        return [...ids].sort((a, b) =>
+            (distance.get(this.seatIndexById.get(a)) ?? 0) - (distance.get(this.seatIndexById.get(b)) ?? 0)
+        );
+    },
+
     renderStep() {
         // Auto-resolve any round where only one player is left standing — nothing to ask.
         let contenders = PotCalculator.getContenders(this.entries);
@@ -127,7 +142,7 @@ const PotWizard = {
         confirmBtn.addEventListener("click", () => {
             const selected = Array.from(choices.querySelectorAll("input:checked")).map(i => i.value);
             if (selected.length === 0) return;
-            const result = PotCalculator.resolveRound(this.entries, selected);
+            const result = PotCalculator.resolveRound(this.entries, this.orderFromButton(selected));
             this.recordRound(result);
             this.entries = result.updatedEntries;
             this.renderStep();