jheapsandClaude Opus 5
fc866597eb
A straddle is a blind raise put out before the cards by the player left of the
big blind, for twice it. Home games run them constantly, and the tool had no
idea they existed — so a dealer's only way through was to deal the hand and have
the straddler "raise" to $4, which gets the money right and the other two rules
wrong.
There are three at once:
- the amount doubles as it goes left, and re-straddles carry on doubling;
- first to act is left of the *straddler*, not left of the big blind, and the
straddler keeps the option when it comes back round even if nobody raised;
- the minimum raise is twice the straddle. Measured off the big blind
underneath it, a $2/$4 game prices the next raise at $6, and every player at
the table will argue — correctly.
Tap Straddle on the deal prompt and the tool posts it, puts the right player on
the clock and prices the raise. The seat wears an STR badge for the hand, read
off what the deal actually posted rather than off the count, so the badge can't
outlive the chips it stands for. It's a one-hand decision, like posting in, and
it clears when the button moves.
The control sits on the deal row rather than a line of its own: measured at
390x844, its own line cost 44px of felt on every deal prompt, straddle or no
straddle, and this bar is docked over the seats. Three buttons across a 360px
phone want to wrap, which made the bar 64px taller and put the bottom seat three
fifths behind it — this layout deliberately doesn't shrink the felt to suit, so
the deal button is given a 7rem floor instead, which keeps the row to one line
and the cost to nothing.
20 new tests, checked by breaking each of the three rules on purpose first: the
wrong first-to-act, the minimum measured off the big blind, and a flat rather
than doubling chain each fail a different one.
Co-Authored-By: Claude Opus 5 <[email protected]>
Claude-Session: https://claude.ai/code/session_015bnp7xKUPFFSpwkYNFaPgb
679 lines
32 KiB
JavaScript
679 lines
32 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);
|
||
},
|
||
|
||
// 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;
|
||
}
|