Make the pot button offer a pot-sized raise

The raise pad worked its quick amounts out as "the current bet plus the pot as it stands". That leaves out the raiser's own call, which is in the pot before the raise is measured off it, so every amount came out short. Measured pre-flop at 1/2: offered: Min $4 ½ pot $4 Pot $5 correct: Min $4 ½ pot $4.50 Pot $7 A pot raise there is: call the $2, which makes the pot $5, then raise $5. And the half-pot was so short it clamped up to the minimum and sat next to the Min button showing the same $4 twice, which is how it went unnoticed — it looked like a table where those two happened to coincide. "Pot" is not a suggestion. It is a definite number players say out loud, and a dealer tapping the button that claims to be it should be recording what was actually said. The rule moves into Betting.potRaiseTo, next to the other rules and testable on its own, rather than living as arithmetic inside a DOM renderer: raise to = the current bet + (pot + what they owe) × fraction Facing no bet it comes out as a plain pot-sized bet, because both the bet and the amount owed are zero. Facing a bet it comes out as three times the bet plus the dead money, which is the shape a player checks it against. Co-Authored-By: Claude Opus 5 <[email protected]> Claude-Session: https://claude.ai/code/session_015bnp7xKUPFFSpwkYNFaPgb
2026-09-01 23:51:41 -06:00
parent 8efc14f61f
commit 09eac536b5
3 changed files with 142 additions and 3 deletions
@@ -430,7 +430,6 @@ const ActionBar = {
        const player = this.state.seats[index];
        const stack = Betting.stackOf(this.state, player);
        const maxTo = Betting.round(Betting.committed(player) + stack);
-        const pot = Betting.potSoFar(this.state);
        // Two different minimums, and conflating them was a bug. `minTo` is clamped to
        // what this player can actually put in, which is what the Min button should
        // offer. `legalMin` is what the rules require — for a short stack the two are
@@ -446,10 +445,16 @@ const ActionBar = {
        const quick = document.createElement("div");
        quick.className = "raiseQuick";

+        // The pot amounts come from Betting, which knows that a pot raise is measured
+        // off the pot as it stands *after* the caller's own call goes in. The pad used
+        // to work it out here as "the bet plus the pot", which left the call out and
+        // made both amounts short: pre-flop at 1/2 it offered "Pot $5" where a pot
+        // raise is $7, and a half-pot that clamped up to the minimum and sat next to
+        // the Min button showing the same $4 twice.
        const options = [
            { label: "Min", value: minTo },
-            { label: "½ pot", value: Betting.round(this.state.currentBet + pot / 2) },
-            { label: "Pot", value: Betting.round(this.state.currentBet + pot) },
+            { label: "½ pot", value: Betting.potRaiseTo(this.state, index, 0.5) },
+            { label: "Pot", value: Betting.potRaiseTo(this.state, index, 1) },
            { label: "All-in", value: maxTo },
        ];
        options.forEach(option => {
@@ -518,6 +518,27 @@ const Betting = {
            : this.nextToAct(state, bbIndex);
    },

+    // What a pot-sized raise actually is, as a "raise to" total.
+    //
+    // Not "the bet plus the pot as it stands". The raiser calls first, and their call
+    // is in the pot before the raise is measured off it, so the pot being matched is
+    // the one that exists after the call:
+    //
+    //     raise to = the current bet + (pot + what they owe) × fraction
+    //
+    // Pre-flop at 1/2 that gives $7, not $5: call the $2, which makes the pot $5, then
+    // raise $5. Leaving the call out understates every one of these, and players say
+    // "pot" out loud meaning a definite number.
+    //
+    // Facing no bet this is a plain pot-sized bet — toCall is zero and currentBet is
+    // zero, so it comes out as the pot, which is the right answer there too.
+    potRaiseTo(state, index, fraction = 1) {
+        const player = state.seats[index];
+        if (!player) return 0;
+        const potAfterCall = this.round(this.potSoFar(state) + this.toCall(state, player));
+        return this.round((state.currentBet || 0) + potAfterCall * fraction);
+    },
+
    // Who turns their hand over first.
    //
    // A call the dealer makes at every showdown that isn't a fold, and one nobody at