jheapsandClaude Opus 5
42b9e83e8f
The seat menu's "Make small blind" / "Make big blind" / "Blinds follow the button again" all re-posted the blinds whenever `Betting.onlyBlindsIn(state)` was true. That condition means "nothing has happened in this hand except the blinds" — which is true of a hand one second old and equally true of a table sitting in setup with no cards out and nothing committed. So naming a blind before the deal ran repostBlinds -> beginHand: betting opened, two stacks docked, the action bar up and waiting on the seat after the big blind. The dealer had said where the blinds go and the tool heard "deal". Betting.blindsArePosted() is the question these three actually wanted — the blinds are down only once a hand is open — and it's the guard makeDealer was already using by hand. Before the deal, naming a blind now moves a badge and nothing else; the toast says "Dee has the small blind next hand." rather than claiming she posted it. Mid-hand behaviour is unchanged: chips come back and go in again from the new positions, and the chip count stays straight. Co-Authored-By: Claude Opus 5 <[email protected]> Claude-Session: https://claude.ai/code/session_015bnp7xKUPFFSpwkYNFaPgb
788 lines
37 KiB
JavaScript
788 lines
37 KiB
JavaScript
// 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.
|
||
// A seat that is dealt in, has nothing in the pot, and has no chips behind.
|
||
//
|
||
// Not the same as all-in: an all-in player has money riding on the hand. This is
|
||
// somebody who busted and hasn't bought back in yet, which a home game produces
|
||
// about once an hour. A seat with no stack *recorded* isn't broke either —
|
||
// stackOf falls back to the table's starting stack for those — only an explicit
|
||
// zero counts.
|
||
brokeSeats(state) {
|
||
const broke = [];
|
||
state.seats.forEach((player, index) => {
|
||
if (!player.inHand) return;
|
||
if (this.handTotal(player) > this.EPSILON_CHIPS) return;
|
||
if (this.stackOf(state, player) > this.EPSILON_CHIPS) return;
|
||
broke.push(index);
|
||
});
|
||
return broke;
|
||
},
|
||
|
||
// The table as it will be once the seats that can't post are dealt around. A view,
|
||
// not a change: the preview has to ask the same question the deal will answer, and
|
||
// asking it of a different shape of table is how the two came apart last time.
|
||
tableAsDealt(state) {
|
||
const broke = this.brokeSeats(state);
|
||
if (broke.length === 0) return state;
|
||
const skip = new Set(broke);
|
||
return {
|
||
...state,
|
||
seats: state.seats.map((player, index) =>
|
||
skip.has(index) ? { ...player, inHand: false, folded: false } : player),
|
||
};
|
||
},
|
||
|
||
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. Same reason the broke seats come
|
||
// out first: the preview once promised a small blind from a seat with no chips.
|
||
const dealt = this.tableAsDealt(state);
|
||
const buttonIndex = HoldemState.buttonSeatForDeal(dealt);
|
||
const asDealt = buttonIndex === dealt.dealerSeatIndex
|
||
? dealt
|
||
: { ...dealt, dealerSeatIndex: buttonIndex };
|
||
|
||
const satOut = this.brokeSeats(state);
|
||
const { sbIndex, bbIndex, headsUp, manual, deadSmallBlind } = HoldemState.getBlindSeats(asDealt);
|
||
if (bbIndex === null) return null;
|
||
return {
|
||
sbIndex, bbIndex, headsUp, manual: !!manual, deadSmallBlind: !!deadSmallBlind,
|
||
deadButton: !!asDealt.deadButton && !asDealt.seats[buttonIndex].inHand,
|
||
// Asked of the table as it will be dealt, for the same reason the blinds
|
||
// are: someone sitting out for having no chips isn't owed a blind, and the
|
||
// big blind of the hand about to go out isn't either.
|
||
debtors: HoldemState.blindDebtors(asDealt, bbIndex),
|
||
posting: (state.postingIn || []).slice(),
|
||
buttonIndex,
|
||
buttonMoves: buttonIndex !== state.dealerSeatIndex,
|
||
satOut,
|
||
smallBlind: this.round(state.smallBlind || 0),
|
||
bigBlind: this.round(state.bigBlind || 0),
|
||
// What the straddles will be if the hand is dealt as it stands, and how
|
||
// many more this table could take.
|
||
straddles: this.straddleSeats(state),
|
||
maxStraddles: this.maxStraddles(state),
|
||
};
|
||
},
|
||
|
||
// ---- Straddles ----
|
||
//
|
||
// A straddle is a blind raise put out before the cards, by the player left of the
|
||
// big blind, for twice it. It buys the last word before the flop: everyone else
|
||
// acts first, and the straddler still has the option when it comes back round even
|
||
// if nobody raised. Re-straddles carry on left, each doubling again.
|
||
//
|
||
// Home games run them constantly and a dealer has to get three things right at
|
||
// once — the amount, who is first to act, and what the minimum raise becomes. The
|
||
// tool used to do none of them, so a dealer's only way through was to deal, have
|
||
// the straddler "raise" to $4, and hand the action to the wrong player.
|
||
|
||
// How many straddles this table could take. Everyone but the two blinds can put
|
||
// one out; heads-up that is nobody, which is the right answer — the button is
|
||
// already the small blind and there is no seat left of the big blind to straddle
|
||
// from.
|
||
maxStraddles(state) {
|
||
return Math.max(0, this.liveSeats(this.tableAsDealt(state)).length - 2);
|
||
},
|
||
|
||
// Who straddles and for how much, walking left from the big blind and doubling.
|
||
// Asked of the table as it will be dealt, so a seat about to be sat out for having
|
||
// no chips is never handed a straddle it can't post.
|
||
straddleSeats(state, count = state.straddleCount) {
|
||
const wanted = Math.min(Math.max(0, Number(count) || 0), this.maxStraddles(state));
|
||
if (wanted <= 0) return [];
|
||
|
||
const dealt = this.tableAsDealt(state);
|
||
const buttonIndex = HoldemState.buttonSeatForDeal(dealt);
|
||
const asDealt = buttonIndex === dealt.dealerSeatIndex
|
||
? dealt
|
||
: { ...dealt, dealerSeatIndex: buttonIndex };
|
||
const { bbIndex } = HoldemState.getBlindSeats(asDealt);
|
||
if (bbIndex === null) return [];
|
||
|
||
const straddles = [];
|
||
let index = bbIndex;
|
||
let amount = this.round((Number(state.bigBlind) || 0) * 2);
|
||
for (let n = 0; n < wanted; n++) {
|
||
index = this.nextToAct(asDealt, index);
|
||
if (index === null || index === bbIndex) break;
|
||
straddles.push({ index, amount });
|
||
amount = this.round(amount * 2);
|
||
}
|
||
return straddles;
|
||
},
|
||
|
||
// Does handing this seat chips also put them back in the game?
|
||
//
|
||
// At a real table those are one event, and here they were two: a busted player got
|
||
// their chips and stayed sat out, silently skipped hand after hand until somebody
|
||
// noticed and found "Deal in" in the seat menu. Nothing said so — the toast just
|
||
// read "Ben added $100".
|
||
//
|
||
// Not for a seat that was sat out while *holding* chips. That's a dealer who sat
|
||
// somebody out on purpose and is topping them up, and dealing them back in would be
|
||
// the tool guessing at something it wasn't told. Only a seat with no stack of its
|
||
// own: busted at zero, or a chair being bought into for the first time.
|
||
//
|
||
// Deliberately reads player.stack rather than stackOf(), which substitutes the
|
||
// table's starting stack for a seat that has none — the question here is what this
|
||
// seat was actually recorded as holding.
|
||
buyInDealsThemIn(player) {
|
||
if (!player || player.inHand) return false;
|
||
const own = player.stack;
|
||
const recorded = own !== null && own !== undefined && String(own).trim() !== "";
|
||
return !recorded || Number(own) <= this.EPSILON_CHIPS;
|
||
},
|
||
|
||
// "bet" or "raise" — what putting more in is actually called right now.
|
||
//
|
||
// A wager into a pot nobody has wagered into is a bet; everything after that is a
|
||
// raise. The bar decided this from what the acting player still owes, which gets
|
||
// the big blind's option backwards: they owe nothing, so it offered "Bet", but
|
||
// their own blind is a live bet and putting more in is a raise. It gets the other
|
||
// half wrong too — the raise pad said "Raise to" for an opening bet on the flop,
|
||
// and wrote "Ann's raise to $10" into the undo control for it.
|
||
//
|
||
// The arithmetic was always right (minRaiseTo returns two big blinds for the big
|
||
// blind's option and one for an opening bet). This is only what it's called, which
|
||
// for a tool a dealer announces the action from is not a small thing.
|
||
wagerVerb(state) {
|
||
return (state.currentBet || 0) > this.EPSILON_CHIPS ? "raise" : "bet";
|
||
},
|
||
|
||
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;
|
||
},
|
||
|
||
// A player still in the hand with chips in the pot and nothing left behind. This is
|
||
// the same stack test nextToAct uses to pass over them, which is the point: the
|
||
// seat the felt marks all-in is exactly the seat the dealer will never be asked to
|
||
// act on again.
|
||
//
|
||
// The "chips in the pot" half matters. A seat with an empty stack who hasn't put
|
||
// anything in is a busted player who shouldn't have been dealt in, not a player
|
||
// who moved all-in, and calling them all-in on the felt would be a lie.
|
||
isAllIn(state, player) {
|
||
if (!player || !player.inHand || player.folded) return false;
|
||
return this.handTotal(player) > this.EPSILON_CHIPS &&
|
||
this.stackOf(state, player) <= this.EPSILON_CHIPS;
|
||
},
|
||
|
||
// 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);
|
||
// Aggression, whether or not it was a full raise — a short all-in doesn't
|
||
// reopen the betting, but the player who made it is still the last one who
|
||
// put money in, and at the showdown they are still the one who shows first.
|
||
state.streetAggressorIndex = index;
|
||
state.handAggressorIndex = index;
|
||
// 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;
|
||
// Whoever led this street stops being the answer the moment the next one opens.
|
||
// The hand's aggressor is deliberately left alone: it's the fallback for a
|
||
// river nobody could bet on.
|
||
state.streetAggressorIndex = null;
|
||
|
||
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) {
|
||
// Only while a hand is actually being played. Before the deal, a table of
|
||
// busted players who haven't rebought looks exactly like a table of all-ins to
|
||
// this test, and the bar was announcing a run-out over a felt with no cards and
|
||
// no chips on it.
|
||
if (!state.bettingOpen) return false;
|
||
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);
|
||
},
|
||
|
||
// Are the blinds actually down? Moving the button or naming a blind means two
|
||
// completely different things depending on the answer, and `onlyBlindsIn` alone
|
||
// cannot tell them apart: a table sitting in setup, with no cards out and nothing
|
||
// committed, satisfies it just as well as a hand that has only just been dealt.
|
||
//
|
||
// With a hand open, the blinds are chips on the felt. Re-aiming them has to take
|
||
// those chips back and post them again from the new positions, or the badges and
|
||
// the money disagree.
|
||
//
|
||
// Before the deal it is a marker being slid round a table with nothing in the
|
||
// middle. Re-posting there would *deal the hand* — betting opened, blinds taken off
|
||
// two stacks, action on the seat after the big blind — which is not what a dealer
|
||
// means by "she's the big blind this one". Setting the positions is how a dealer
|
||
// gets ready to deal; the cards come out when they press the button, and not a
|
||
// moment before.
|
||
blindsArePosted(state) {
|
||
return !!state.bettingOpen && this.onlyBlindsIn(state);
|
||
},
|
||
|
||
// Chips the pot has been priced with but nobody has actually paid.
|
||
//
|
||
// Two ways a contribution gets into this tool. Tapping the action moves chips: the
|
||
// bet leaves the stack, sits in front of the player, and is swept into their hand
|
||
// total at the end of the street. The other way is the "without live betting" panel
|
||
// — a base pot amount, or chips counted out on a seat — where the dealer is
|
||
// recording a hand they are watching rather than driving, and nothing ever leaves
|
||
// anybody's stack.
|
||
//
|
||
// The pot wizard prices both the same way, and awarding it credits the winner. So
|
||
// in that second mode the table simply grew: measured at a three-handed table with
|
||
// a $50 base pot, paying the pot took the chips on the table from $600 to $750 and
|
||
// left the bank check blaming a rebuy that never happened.
|
||
//
|
||
// So before the pot is pushed, whatever was assumed rather than taken comes off the
|
||
// stacks that assumed it. Chips already committed or swept are left alone; they
|
||
// have been paid once already, and taking them twice is the same bug the other way
|
||
// round.
|
||
collectAssumedContributions(state) {
|
||
const taken = [];
|
||
state.seats.forEach((player, index) => {
|
||
const priced = HoldemState.computeContribution(player, state.chipLegend, state.basePotAmount);
|
||
const alreadyPaid = this.round(this.committed(player) + (Number(player.amountOverride) || 0));
|
||
const owed = this.round(priced - alreadyPaid);
|
||
if (owed <= this.EPSILON_CHIPS) return;
|
||
|
||
// Never more than they are holding. A seat priced above its own stack is a
|
||
// dealer's typo or a player who is short, and inventing the difference is
|
||
// what this whole function exists to stop.
|
||
const moved = this.round(Math.min(owed, this.stackOf(state, player)));
|
||
if (moved <= this.EPSILON_CHIPS) return;
|
||
|
||
player.stack = this.round(this.stackOf(state, player) - moved);
|
||
// Recorded where a swept bet lives, so the money is in exactly the place
|
||
// the rest of the tool looks for chips that are in the middle this hand.
|
||
player.amountOverride = this.round((Number(player.amountOverride) || 0) + moved);
|
||
taken.push({ index, name: HoldemState.displayName(player, index), amount: moved });
|
||
});
|
||
return { taken, total: this.round(taken.reduce((sum, row) => sum + row.amount, 0)) };
|
||
},
|
||
|
||
// A misdeal: the hand never happened, so every chip goes back where it came from.
|
||
//
|
||
// The rulings sheet in this tool has told dealers to redeal since the day it was
|
||
// written — first card to the wrong seat, a seat entitled to a hand dealt out, one
|
||
// of the first two cards exposed — and the tool had no way to do it. The only
|
||
// control that ended a live hand was Next Hand, which says out loud that it takes
|
||
// the money off the table without paying anybody. That is right for an abandoned
|
||
// pot and wrong for a misdeal, where the blinds and any calls belong to the people
|
||
// who put them in.
|
||
//
|
||
// Undo covers the first second of it — "↶ dealing the hand" is one tap — but only
|
||
// while the action history is still there. It lives in memory, so a dealer who
|
||
// refreshes the page mid-hand, or who is three calls in, has nothing.
|
||
//
|
||
// What is deliberately kept: the button, the blinds, the straddle and anyone
|
||
// posting in. A misdeal is the *same* hand dealt again, not the next one.
|
||
takeHandBack(state) {
|
||
const returned = [];
|
||
state.seats.forEach((player, index) => {
|
||
const back = this.round(this.committed(player) + (Number(player.amountOverride) || 0));
|
||
if (back > 0) {
|
||
player.stack = this.round(this.stackOf(state, player) + back);
|
||
returned.push({ index, name: HoldemState.displayName(player, index), amount: back });
|
||
}
|
||
player.committed = 0;
|
||
player.amountOverride = null;
|
||
player.hasActed = false;
|
||
player.folded = false;
|
||
player.cards = ["", ""];
|
||
});
|
||
|
||
state.bettingOpen = false;
|
||
state.street = "preflop";
|
||
state.currentBet = 0;
|
||
state.lastRaiseSize = 0;
|
||
state.actingSeatIndex = null;
|
||
state.streetAggressorIndex = null;
|
||
state.handAggressorIndex = null;
|
||
// Nothing was posted, as far as the next rotation is concerned: the hand this
|
||
// would have counted as is being dealt again from the same button.
|
||
state.postedBlinds = null;
|
||
state.postedStraddles = [];
|
||
|
||
return {
|
||
returned,
|
||
total: this.round(returned.reduce((sum, row) => sum + row.amount, 0)),
|
||
};
|
||
},
|
||
|
||
// 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;
|
||
// Posting a blind isn't aggression — a hand limped and checked all the way
|
||
// down has no aggressor at all, which is exactly the case the showdown rule
|
||
// sends to the seat left of the button.
|
||
state.streetAggressorIndex = null;
|
||
state.handAggressorIndex = null;
|
||
|
||
// Deal around anyone with no chips, before anything else reads the table.
|
||
//
|
||
// A busted player who hasn't rebought used to be dealt in anyway, and the
|
||
// result was a hand nobody could finish: the table promised a small blind from
|
||
// a seat with nothing to post it with, took it from nobody, put the action on
|
||
// the big blind with only their own money in front of them, and announced
|
||
// "3 players — all-in, running out the board" before a card was dealt.
|
||
//
|
||
// Sitting them out is what a dealer does. Seat, name and buy-in record are
|
||
// untouched, so dealing them back in is one tap when they buy chips.
|
||
this.brokeSeats(state).forEach(index => {
|
||
state.seats[index].inHand = false;
|
||
state.seats[index].folded = false;
|
||
});
|
||
|
||
// 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);
|
||
|
||
// A null big blind means there aren't enough players to post at all. A null
|
||
// small blind with a big blind behind it is the dead small blind, which is a
|
||
// hand that gets dealt like any other — it just has one blind in it.
|
||
if (bbIndex === null) {
|
||
state.currentBet = 0;
|
||
state.actingSeatIndex = null;
|
||
state.postedBlinds = null;
|
||
state.postedStraddles = [];
|
||
return;
|
||
}
|
||
|
||
if (sb > 0 && sbIndex !== null) this.putIn(state, sbIndex, sb);
|
||
if (bb > 0) this.putIn(state, bbIndex, bb);
|
||
|
||
// Anyone the dealer said would post to come in past the blinds. It's a big
|
||
// blind like any other — it buys them a hand they'd otherwise have to wait for
|
||
// — so it goes in the middle the same way, before the count below reads it.
|
||
const posting = Array.isArray(state.postingIn) ? state.postingIn : [];
|
||
if (bb > 0) {
|
||
state.seats.forEach((player, index) => {
|
||
if (index === sbIndex || index === bbIndex) return;
|
||
if (player.inHand && posting.includes(player.id)) this.putIn(state, index, bb);
|
||
});
|
||
}
|
||
// Deliberately not cleared here. repostBlinds takes every posted chip back and
|
||
// deals again through this same function, so a post that cleared itself on the
|
||
// way in would be refunded and never retaken — the dealer moves the button and
|
||
// somebody's post quietly vanishes. startNextHand is what ends it.
|
||
|
||
// What the next hand's rotation is worked out from. Recorded here, where the
|
||
// blinds are actually posted, because by the time it's needed the seats have
|
||
// moved on and the answer can no longer be read off the table.
|
||
state.postedBlinds = { sbIndex, bbIndex };
|
||
|
||
// Who got cards. Read next hand to tell a player who has been here all along
|
||
// from one who has just walked up and had the blinds go past them.
|
||
state.dealtLastHand = state.seats.filter(p => p.inHand).map(p => p.id);
|
||
|
||
// Straddles go out after the blinds and before the cards, each one left of the
|
||
// last. Posted here rather than left to the dealer to fake as a raise, because
|
||
// a raise from that seat would hand the action to the wrong player.
|
||
const straddles = this.straddleSeats(state);
|
||
straddles.forEach(({ index, amount }) => this.putIn(state, index, amount));
|
||
state.postedStraddles = straddles.map(({ index }) => index);
|
||
|
||
state.currentBet = this.round(state.seats.reduce(
|
||
(most, player) => Math.max(most, this.committed(player)), 0));
|
||
// A straddle is a blind raise, so what has to be matched to raise again is the
|
||
// straddle itself, not the big blind underneath it: $2 blinds with a $4
|
||
// straddle make the next raise $8, the same way the $2 blind makes it $4.
|
||
// Left alone, the minimum would come out at $6 and the dealer would be talked
|
||
// out of it by every player at the table.
|
||
state.lastRaiseSize = straddles.length > 0 ? state.currentBet : (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.
|
||
//
|
||
// A straddle moves that seat along: first to act is left of the last straddler,
|
||
// and the straddler keeps the option, which falls out of nobody having acted
|
||
// yet.
|
||
const lastPosted = straddles.length > 0
|
||
? straddles[straddles.length - 1].index
|
||
: bbIndex;
|
||
state.actingSeatIndex = headsUp
|
||
? (this.stackOf(state, state.seats[sbIndex]) > this.EPSILON_CHIPS ? sbIndex : this.nextToAct(state, sbIndex))
|
||
: this.nextToAct(state, lastPosted);
|
||
},
|
||
|
||
// 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.
|
||
// Rounded up to something the table's chips can actually build. Half the pot is
|
||
// constantly a half-chip amount — pre-flop at 1/2 it is $4.50, and the smallest
|
||
// chip in the default legend is a dollar, so the button offered a number the
|
||
// dealer would have to round themselves every single time.
|
||
//
|
||
// Only when the legend describes this game. A smallest chip *larger* than the big
|
||
// blind means the denominations were never set for these stakes, and rounding a
|
||
// 5c/10c table up to whole dollars would be the tool doing real damage on the
|
||
// strength of a field somebody forgot to fill in. Left exact there, and the wrong
|
||
// legend stays visible rather than being quietly applied.
|
||
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));
|
||
const exact = this.round((state.currentBet || 0) + potAfterCall * fraction);
|
||
|
||
const step = Money.fromCents(Money.chipStepCents(state.chipLegend));
|
||
const bigBlind = Number(state.bigBlind) || 0;
|
||
if (step <= 0 || (bigBlind > 0 && step > bigBlind)) return exact;
|
||
return Money.upToChip(exact, state.chipLegend);
|
||
},
|
||
|
||
// Who turns their hand over first.
|
||
//
|
||
// A call the dealer makes at every showdown that isn't a fold, and one nobody at
|
||
// the table volunteers for — everyone would rather see a hand than show one. The
|
||
// tool knew who last raised and who sits left of the button and said neither, so
|
||
// the dealer was working it out from memory while five people waited.
|
||
//
|
||
// Three cases, in the order the rule asks them:
|
||
// * somebody bet or raised on the final round — they show first;
|
||
// * the round was checked through — first live player left of the button;
|
||
// * nobody could bet, because the chips were already in — the last player who
|
||
// did put money in, on whichever round that was.
|
||
//
|
||
// Returns null when there's nothing to call: one player left, or none.
|
||
showdownOrder(state) {
|
||
const live = this.liveSeats(state);
|
||
if (live.length < 2) return null;
|
||
|
||
const seatOf = index =>
|
||
Number.isInteger(index) && live.some(s => s.index === index) ? index : null;
|
||
|
||
const streetAggressor = seatOf(state.streetAggressorIndex);
|
||
if (streetAggressor !== null) {
|
||
return { index: streetAggressor, reason: "aggressor" };
|
||
}
|
||
|
||
// Nobody could have bet this round, so "no bet on the final round" isn't a
|
||
// choice anybody made and the seat left of the button hasn't earned the
|
||
// obligation. It falls to whoever last put money in.
|
||
if (!this.canStillBet(state)) {
|
||
const handAggressor = seatOf(state.handAggressorIndex);
|
||
if (handAggressor !== null) return { index: handAggressor, reason: "allInAggressor" };
|
||
}
|
||
|
||
const order = HoldemState.liveOrderFromButton(state)
|
||
.filter(index => live.some(s => s.index === index));
|
||
return order.length > 0 ? { index: order[0], reason: "leftOfButton" } : null;
|
||
},
|
||
|
||
// 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;
|
||
}
|