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

// Live betting: who's to act, what it costs them, and where the money goes.
//
// This is bookkeeping, not a game — the dealer taps what the humans at the table
// actually did, and the tool keeps the arithmetic straight. It deliberately never
// blocks an action it thinks is "illegal"; a dealer overruling the maths is right
// more often than the maths is.
//
// Money model: `player.committed` is what a seat has put in on the current street.
// When a street closes it sweeps into `player.amountOverride`, which is the seat's
// total for the hand — the same field the pot badge, the pot wizard, the standings
// and the CSV already read. So the betting bar is a fast way to fill in a field
// that already existed, and nothing downstream had to change.
const Betting = {
    STREETS: ["preflop", "flop", "turn", "river"],

    streetLabel(street) {
        return { preflop: "Pre-flop", flop: "Flop", turn: "Turn", river: "River" }[street] || "Pre-flop";
    },

    round(amount) {
        return Money.round(amount);
    },

    // ---- Reading the table ----

    liveSeats(state) {
        return state.seats
            .map((player, index) => ({ player, index }))
            .filter(s => s.player.inHand && !s.player.folded);
    },

    // Who would post if the hand were dealt right now. Used to preview the blinds
    // while the table is still being set, so a dealer can see where they'll land
    // before any money moves.
    blindPreview(state) {
        // Dealing relocates a button parked on an empty chair before it works out who
        // posts, so the preview has to answer for the button where it *will* be. Asking
        // from where it currently sits gave a different pair of blinds than the deal
        // produced — the preview promising one thing and doing another is exactly the
        // guessing this whole step exists to remove.
        const buttonIndex = HoldemState.buttonSeatForDeal(state);
        const asDealt = buttonIndex === state.dealerSeatIndex
            ? state
            : { ...state, dealerSeatIndex: buttonIndex };

        const { sbIndex, bbIndex, headsUp, manual } = HoldemState.getBlindSeats(asDealt);
        if (sbIndex === null || bbIndex === null) return null;
        return {
            sbIndex, bbIndex, headsUp, manual: !!manual,
            buttonIndex,
            buttonMoves: buttonIndex !== state.dealerSeatIndex,
            smallBlind: this.round(state.smallBlind || 0),
            bigBlind: this.round(state.bigBlind || 0),
        };
    },

    committed(player) {
        return this.round(player.committed || 0);
    },

    // Everything this seat has put in across the whole hand, including the street
    // still in progress.
    handTotal(player) {
        return this.round((Number(player.amountOverride) || 0) + this.committed(player));
    },

    // Never below zero. A seat can't have negative chips in front of it, and a typo in
    // the stack field used to come back as-is — which then flowed into putIn(), where
    // `Math.min(amount, -50)` moves a negative amount and *adds* chips to the table.
    stackOf(state, player) {
        const own = player.stack;
        if (own !== null && own !== undefined && String(own).trim() !== "") {
            return Math.max(0, this.round(own));
        }
        const fallback = Number(state.defaultStack);
        return Number.isNaN(fallback) ? 0 : Math.max(0, this.round(fallback));
    },

    toCall(state, player) {
        return Math.max(0, this.round((state.currentBet || 0) - this.committed(player)));
    },

    // A raise has to at least match the last one; before any raise, the big blind
    // is the yardstick.
    minRaiseTo(state) {
        const increment = this.round(state.lastRaiseSize || state.bigBlind || 0);
        return this.round((state.currentBet || 0) + (increment || 1));
    },

    potSoFar(state) {
        return this.round(
            state.seats.reduce((sum, p) => sum + this.handTotal(p), 0)
        );
    },

    // ---- Moving the action ----

    nextLiveIndex(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) 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;
        }
        return null;
    },

    // Which chair sits `step` places along in the direction of play. The table owns
    // this — walking the seats is exactly where the button, the blinds and the action
    // used to drift apart from each other, so there is one implementation of it.
    seatAt(state, fromIndex, step) {
        return HoldemState.nextSeatIndex(state, fromIndex, step);
    },

    // A street is done when everyone still live has either matched the bet or has
    // no chips left to argue with, and everyone has had a turn since the last raise.
    isStreetComplete(state) {
        const live = this.liveSeats(state);
        if (live.length <= 1) return true;

        const unsettled = live.filter(s => {
            const allIn = this.stackOf(state, s.player) <= 0;
            const matched = this.toCall(state, s.player) <= 0;
            return !allIn && (!matched || !s.player.hasActed);
        });
        return unsettled.length === 0;
    },

    // ---- Actions ----

    // Moves `amount` from a seat's stack into the middle for this street. Returns
    // what actually moved, which is less than asked for if it puts them all-in.
    putIn(state, index, amount) {
        const player = state.seats[index];
        const stack = this.stackOf(state, player);
        const moved = this.round(Math.min(Math.max(0, amount), stack));

        player.stack = this.round(stack - moved);
        player.committed = this.round(this.committed(player) + moved);
        return moved;
    },

    fold(state, index) {
        state.seats[index].folded = true;
        state.seats[index].hasActed = true;
        this.passAction(state, index);
    },

    check(state, index) {
        state.seats[index].hasActed = true;
        this.passAction(state, index);
    },

    call(state, index) {
        const player = state.seats[index];
        this.putIn(state, index, this.toCall(state, player));
        player.hasActed = true;
        this.passAction(state, index);
    },

    // `total` is what the seat's street commitment becomes — "raise to", the way a
    // dealer says it out loud, not "raise by".
    raiseTo(state, index, total) {
        const player = state.seats[index];
        const target = this.round(total);
        const delta = this.round(target - this.committed(player));
        const moved = this.putIn(state, index, delta);
        const newBet = this.committed(player);
        const previousBet = state.currentBet || 0;

        if (newBet > previousBet) {
            const increase = this.round(newBet - previousBet);
            // What a full raise would have had to be: at least as much again as the
            // last one, or the big blind if there hasn't been a raise yet.
            const fullRaise = this.round(state.lastRaiseSize || state.bigBlind || 0);
            const isFullRaise = increase >= fullRaise - this.EPSILON_CHIPS;

            state.currentBet = newBet;

            if (isFullRaise) {
                state.lastRaiseSize = increase;
                // A real raise reopens the action: everyone else owes a response again.
                state.seats.forEach((p, i) => {
                    if (i !== index && p.inHand && !p.folded) p.hasActed = false;
                });
            }
            // Otherwise this is a short all-in — somebody with less than a full raise
            // left shoving it in. The most misread rule in poker: it does *not* reopen
            // the betting to anyone who has already acted. They owe the difference or
            // they fold; they don't get to raise again because a short stack happened
            // to be between them. Players yet to act keep their full rights, which
            // they do here because their hasActed is already false.
            //
            // lastRaiseSize deliberately isn't lowered either, or the next legal raise
            // would be computed off the short amount and come out too small.
        }

        player.hasActed = true;
        this.passAction(state, index);
        return moved;
    },

    allIn(state, index) {
        const player = state.seats[index];
        return this.raiseTo(state, index, this.round(this.committed(player) + this.stackOf(state, player)));
    },

    passAction(state, index) {
        state.actingSeatIndex = this.isStreetComplete(state) ? null : this.nextToAct(state, index);
    },

    // ---- Street and hand boundaries ----

    // Pulls whatever is in front of the players into their hand totals. Anything that
    // reads a seat's contribution — the pot wizard above all — has to run after this,
    // or it will price the pot without the chips sitting on the current street.
    sweepToHandTotals(state) {
        state.seats.forEach(player => {
            const moved = this.committed(player);
            if (moved > 0) {
                player.amountOverride = this.round((Number(player.amountOverride) || 0) + moved);
            }
            player.committed = 0;
            player.hasActed = false;
        });
    },

    // Sweeps the street's chips into each seat's hand total and opens the next one.
    closeStreet(state) {
        this.sweepToHandTotals(state);

        state.currentBet = 0;
        state.lastRaiseSize = 0;

        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
        // the rest of the board is just dealt out.
        if (!this.canStillBet(state)) {
            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, and it
        // still has to be someone with chips left to bet.
        const { bbIndex, headsUp } = HoldemState.getBlindSeats(state);
        const bigBlindCanAct =
            headsUp &&
            bbIndex !== null &&
            !state.seats[bbIndex].folded &&
            this.stackOf(state, state.seats[bbIndex]) > this.EPSILON_CHIPS;

        state.actingSeatIndex = bigBlindCanAct
            ? bbIndex
            : this.nextToAct(state, state.dealerSeatIndex);
    },

    isHandOver(state) {
        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: Money.EPSILON,

    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);
    },

    // True while nothing has happened in this hand except the blinds going in. Up to
    // that point the dealer can still move the button or rename the blinds and have
    // it cost nothing — which is the state a home game spends a lot of time in,
    // arguing about whose turn it is before the cards come out.
    onlyBlindsIn(state) {
        return (state.street || "preflop") === "preflop" && state.seats.every(p => !p.hasActed);
    },

    // Pulls the blinds back off the table and posts them again from wherever the
    // button and the blind assignment now say they belong. Refunding first is what
    // keeps the chip count straight when the button gets passed round three or four
    // times before anybody is happy with it.
    repostBlinds(state) {
        state.seats.forEach(player => {
            const back = this.committed(player);
            if (back > 0) player.stack = this.round(this.stackOf(state, player) + back);
            player.committed = 0;
            player.hasActed = false;
        });
        this.beginHand(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.
    //
    // Called when the dealer says the table is ready, not automatically when the
    // previous hand ends — everything before this point is setup, where seats and the
    // button can move freely because no money has been committed.
    beginHand(state) {
        state.bettingOpen = true;
        state.street = "preflop";
        state.currentBet = 0;
        state.lastRaiseSize = 0;

        // Position is read off the button all through the hand, so it has to be on
        // somebody before the blinds are worked out — not on the empty seat 1 a
        // brand-new table starts on.
        HoldemState.ensureButtonOnPlayer(state);

        state.seats.forEach(player => {
            player.committed = 0;
            player.hasActed = false;
        });

        const sb = Number(state.smallBlind) || 0;
        const bb = Number(state.bigBlind) || 0;
        const { sbIndex, bbIndex, headsUp } = HoldemState.getBlindSeats(state);

        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;

        // 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. Either way, a blind big
        // enough to put that player all-in leaves them nothing to decide.
        state.actingSeatIndex = headsUp
            ? (this.stackOf(state, state.seats[sbIndex]) > this.EPSILON_CHIPS ? sbIndex : this.nextToAct(state, sbIndex))
            : this.nextToAct(state, bbIndex);
    },

    // Winners get their share put back in front of them.
    creditWinnings(state, payouts) {
        payouts.forEach(payout => {
            const player = state.seats.find(p => p.id === payout.id);
            if (!player) return;
            player.stack = this.round(this.stackOf(state, player) + payout.amount);
        });
    },
};

if (typeof module !== "undefined" && module.exports) {
    module.exports = Betting;
}