jheapsandClaude Opus 5
60d192a9ec
Ran out of things I could find by auditing the UI, so I went and read what people
who run home games actually complain about. The recurring one isn't a dealing
mistake, it's a banking one: "the last two guys go to cash out at the end of some
all-night game and there isn't enough cash to cover the chips they have."
Every chip on the table is a promise to pay cash for it later. Nothing in here
checked that the promise could be kept, and there's no way to notice by eye —
it's always a rebuy nobody wrote down, or chips taken without paying, and it
stays silent until the box is empty and two people are still holding chips.
The books now add up, or say why not
HoldemState.bankReconciliation compares the cash taken in against every chip that
could be handed back — stacks, chips in front of players, and the pot waiting to
be won. The sidebar shows both numbers and what they mean:
Balanced — the cash covers every chip on the table.
$160 more in chips than cash taken. Someone's rebuy probably wasn't
recorded — the box will be short at cash-out.
$150 more cash than chips in play. Someone has paid for chips they
haven't been given.
Money in the middle counts as chips in play, so an open pot isn't reported as a
shortfall — otherwise it would cry wolf during almost every hand.
Players who had bought in were missing from the settle-up
sessionStandings was built from the hand log, so anybody who hadn't yet been in a
recorded hand didn't appear at all. Somebody hands over $200, sits down, folds a
few, and the banker's own record doesn't mention them — then they turn up at
cash-out holding chips the list never accounted for. Anyone with money in the
game is in the list now, whether or not they've played a logged hand.
The settle-up number was already being computed and hidden
cashPosition — chips in front of them less the cash they handed over — was
calculated for every player and written to the CSV, but never shown on screen.
It's the number you read while counting out cash at the end of the night, so it's
a column now.
15 tests (127 total): a buy-in with no hands played still appears and reads as
level rather than a loss, empty chairs stay out, a player who cashed out shows
what they took, both directions of imbalance are caught, an open pot is not a
discrepancy, six played-and-settled hands never knock the books out, a proper
rebuy balances while a chip grab doesn't, and float dust isn't an alarm.
Validated with Playwright through real play — seated, blinds posted, pot open,
hand settled, rebuy — balanced at every step, plus the three seeded verdicts and
a fresh table where the panel stays hidden.
Sources: pokerlistings.com/blog/how-to-run-a-home-poker-game,
chipsoffury.com/learn/how-to-handle-poker-buy-ins-with-friends/
Co-Authored-By: Claude Opus 5 <[email protected]>
Claude-Session: https://claude.ai/code/session_015bnp7xKUPFFSpwkYNFaPgb
170 lines
7.4 KiB
JavaScript
170 lines
7.4 KiB
JavaScript
// The banker's job, which is a different job from the dealer's: every chip on the
|
|
// table is a promise to pay cash for it later, and somebody has to be able to check
|
|
// that the promise can be kept before the last two players try to cash out.
|
|
const { test, describe } = require("node:test");
|
|
const assert = require("node:assert/strict");
|
|
const { Betting, HoldemState, Money, makeTable } = require("./load");
|
|
|
|
const seat = (state, index, name, cash, chips) => {
|
|
const p = state.seats[index];
|
|
p.name = name; p.inHand = true; p.buyIns = cash; p.stack = chips;
|
|
return p;
|
|
};
|
|
|
|
describe("everyone with money in the game is accounted for", () => {
|
|
test("a player who has bought in but played no logged hand still appears", () => {
|
|
const state = makeTable({ seatCount: 6, seated: [0, 1, 2], stack: 0 });
|
|
seat(state, 0, "Ann", 100, 100);
|
|
seat(state, 1, "Ben", 100, 100);
|
|
seat(state, 2, "Cal", 200, 200); // just sat down
|
|
|
|
state.seats[0].amountOverride = 10;
|
|
state.seats[1].amountOverride = 10;
|
|
HoldemState.recordHand(state, [{ id: state.seats[0].id, label: "Ann", amount: 20 }]);
|
|
state.seats[0].amountOverride = null;
|
|
state.seats[1].amountOverride = null;
|
|
|
|
const names = HoldemState.sessionStandings(state).map(r => r.name);
|
|
assert.ok(names.includes("Cal"), `Cal handed over $200 and is missing: ${names.join(", ")}`);
|
|
});
|
|
|
|
test("their row reads as no hands played, not as a loss", () => {
|
|
const state = makeTable({ seatCount: 4, seated: [0, 1], stack: 0 });
|
|
seat(state, 0, "Ann", 100, 100);
|
|
seat(state, 1, "Ben", 200, 200);
|
|
|
|
const cal = HoldemState.sessionStandings(state).find(r => r.name === "Ben");
|
|
assert.equal(cal.in, 0);
|
|
assert.equal(cal.won, 0);
|
|
assert.equal(cal.net, 0);
|
|
assert.equal(cal.boughtIn, 200);
|
|
assert.equal(cal.cashPosition, 0, "level: they've bought chips and still hold them");
|
|
});
|
|
|
|
test("an empty chair is not dragged into the settle-up", () => {
|
|
const state = makeTable({ seatCount: 9, seated: [0], stack: 0 });
|
|
seat(state, 0, "Ann", 100, 100);
|
|
const rows = HoldemState.sessionStandings(state);
|
|
assert.equal(rows.length, 1);
|
|
});
|
|
|
|
test("somebody who has cashed out completely still shows what they took", () => {
|
|
const state = makeTable({ seatCount: 4, seated: [0, 1], stack: 0 });
|
|
seat(state, 0, "Ann", 100, 0); // handed every chip back
|
|
seat(state, 1, "Ben", 100, 200);
|
|
const ann = HoldemState.sessionStandings(state).find(r => r.name === "Ann");
|
|
assert.equal(ann.cashPosition, -100, "down the whole buy-in");
|
|
});
|
|
});
|
|
|
|
describe("does the cash box cover the chips on the table", () => {
|
|
test("a straight game balances", () => {
|
|
const state = makeTable({ seatCount: 4, seated: [0, 1, 2], stack: 0 });
|
|
seat(state, 0, "Ann", 100, 60);
|
|
seat(state, 1, "Ben", 100, 140);
|
|
seat(state, 2, "Cal", 100, 100);
|
|
|
|
const bank = HoldemState.bankReconciliation(state);
|
|
assert.equal(bank.cashIn, 300);
|
|
assert.equal(bank.chipsInPlay, 300);
|
|
assert.equal(bank.difference, 0);
|
|
assert.equal(bank.balanced, true);
|
|
});
|
|
|
|
test("chips outrunning the cash box is caught before cash-out", () => {
|
|
// The 2am failure: the last players out can't be paid.
|
|
const state = makeTable({ seatCount: 4, seated: [0, 1, 2], stack: 0 });
|
|
seat(state, 0, "Ann", 100, 100);
|
|
seat(state, 1, "Ben", 100, 100);
|
|
seat(state, 2, "Cal", 100, 260); // took chips for a rebuy nobody wrote down
|
|
|
|
const bank = HoldemState.bankReconciliation(state);
|
|
assert.equal(bank.cashIn, 300);
|
|
assert.equal(bank.chipsInPlay, 460);
|
|
assert.equal(bank.difference, 160);
|
|
assert.equal(bank.balanced, false);
|
|
});
|
|
|
|
test("cash taken for chips never handed over is caught too", () => {
|
|
const state = makeTable({ seatCount: 4, seated: [0, 1], stack: 0 });
|
|
seat(state, 0, "Ann", 200, 100); // paid 200, only got 100 in chips
|
|
seat(state, 1, "Ben", 100, 100);
|
|
|
|
const bank = HoldemState.bankReconciliation(state);
|
|
assert.equal(bank.difference, -100);
|
|
assert.equal(bank.balanced, false);
|
|
});
|
|
|
|
test("chips in the middle still count as chips in play", () => {
|
|
// Money in the pot is somebody's; it just hasn't been won yet. Leaving it out
|
|
// would report a shortfall every time a hand was open — which is nearly always.
|
|
const state = makeTable({ seatCount: 4, seated: [0, 1, 2], dealerSeatIndex: 0 });
|
|
state.seats.forEach(p => { if (p.inHand) p.buyIns = 100; });
|
|
|
|
const before = HoldemState.bankReconciliation(state);
|
|
assert.equal(before.balanced, true);
|
|
|
|
Betting.beginHand(state); // blinds go in
|
|
Betting.raiseTo(state, 0, 25); // and a raise
|
|
Betting.sweepToHandTotals(state); // banked into the pot
|
|
|
|
const during = HoldemState.bankReconciliation(state);
|
|
assert.equal(during.balanced, true, "an open pot is not a discrepancy");
|
|
assert.equal(during.chipsInPlay, before.chipsInPlay);
|
|
});
|
|
|
|
test("a whole session of play never knocks the books out", () => {
|
|
const state = makeTable({ seatCount: 6, seated: [0, 1, 2, 3], dealerSeatIndex: 0 });
|
|
state.seats.forEach(p => { if (p.inHand) p.buyIns = 100; });
|
|
|
|
for (let hand = 0; hand < 6; hand++) {
|
|
Betting.beginHand(state);
|
|
Betting.liveSeats(state).forEach(s => {
|
|
if (Betting.toCall(state, s.player) > 0) Betting.call(state, s.index);
|
|
});
|
|
Betting.sweepToHandTotals(state);
|
|
|
|
const pot = HoldemState.totalPot(state);
|
|
const winner = Betting.liveSeats(state)[0];
|
|
const payouts = [{ id: winner.player.id, label: "w", amount: pot }];
|
|
HoldemState.recordHand(state, payouts);
|
|
Betting.creditWinnings(state, payouts);
|
|
HoldemState.startNextHand(state);
|
|
|
|
assert.equal(HoldemState.bankReconciliation(state).balanced, true, `books off after hand ${hand + 1}`);
|
|
}
|
|
});
|
|
|
|
test("a rebuy keeps the books straight, a chip grab doesn't", () => {
|
|
const state = makeTable({ seatCount: 4, seated: [0, 1], stack: 0 });
|
|
seat(state, 0, "Ann", 100, 100);
|
|
seat(state, 1, "Ben", 100, 100);
|
|
|
|
// A proper rebuy: cash to the banker, chips to the player.
|
|
state.seats[0].buyIns += 100;
|
|
state.seats[0].stack += 100;
|
|
assert.equal(HoldemState.bankReconciliation(state).balanced, true);
|
|
|
|
// Chips taken without paying.
|
|
state.seats[1].stack += 50;
|
|
const bank = HoldemState.bankReconciliation(state);
|
|
assert.equal(bank.balanced, false);
|
|
assert.equal(bank.difference, 50);
|
|
});
|
|
|
|
test("nothing to reconcile before anybody has bought in", () => {
|
|
const state = makeTable({ seatCount: 6, seated: [], stack: 0 });
|
|
const bank = HoldemState.bankReconciliation(state);
|
|
assert.equal(bank.cashIn, 0);
|
|
assert.equal(bank.chipsInPlay, 0);
|
|
assert.equal(bank.balanced, true);
|
|
});
|
|
|
|
test("float dust is not a discrepancy", () => {
|
|
const state = makeTable({ seatCount: 4, seated: [0, 1], stack: 0 });
|
|
seat(state, 0, "Ann", 0.1 + 0.2, 0.3);
|
|
seat(state, 1, "Ben", 10, 10);
|
|
assert.equal(HoldemState.bankReconciliation(state).balanced, true);
|
|
});
|
|
});
|