Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
  jheapsandClaude Opus 5
|
01f5139740 | ||
|
jheapsandClaude Opus 5
|
c76ebf4d18 |
@@ -141,7 +141,13 @@
|
||||
</div>
|
||||
|
||||
<h3 class="panelSubhead">Hands</h3>
|
||||
<div class="handHistoryFilterRow">
|
||||
<input id="handHistoryFilter" type="search" class="handHistoryFilter"
|
||||
placeholder="Find a hand — name, amount or #" aria-label="Filter the hand log by player, amount or hand number" />
|
||||
<span id="handHistoryCount" class="handHistoryCount" hidden></span>
|
||||
</div>
|
||||
<div id="handHistoryList"></div>
|
||||
<p id="handHistoryNoMatch" class="fieldHint" hidden></p>
|
||||
<p id="handHistoryEmptyHint" class="fieldHint">Resolved pots are logged here, in case a chip count is disputed later.</p>
|
||||
|
||||
<div class="handHistoryActions">
|
||||
|
||||
@@ -1957,11 +1957,52 @@ button,
|
||||
color: #e07b7b;
|
||||
}
|
||||
|
||||
.handHistoryFilterRow {
|
||||
display: flex;
|
||||
align-items: center;
|
||||
gap: 0.5rem;
|
||||
margin-bottom: 0.45rem;
|
||||
}
|
||||
|
||||
.handHistoryFilter {
|
||||
flex: 1 1 auto;
|
||||
min-width: 0;
|
||||
/* 16px or iOS zooms the whole page on focus, which on a phone at the table throws
|
||||
the felt off screen mid-hand. Every other field in this panel is held at 16px
|
||||
for the same reason. */
|
||||
font-size: 16px;
|
||||
padding: 0.35rem 0.5rem;
|
||||
background: #141414;
|
||||
border: 1px solid #2c2c2c;
|
||||
border-radius: 6px;
|
||||
color: #e6e6e6;
|
||||
}
|
||||
|
||||
.handHistoryFilter::placeholder {
|
||||
color: #8a8a8a;
|
||||
}
|
||||
|
||||
.handHistoryFilter:focus-visible {
|
||||
outline: 2px solid #d8b46a;
|
||||
outline-offset: 1px;
|
||||
}
|
||||
|
||||
.handHistoryCount {
|
||||
flex: 0 0 auto;
|
||||
font-size: 0.72rem;
|
||||
color: #8a8a8a;
|
||||
font-variant-numeric: tabular-nums;
|
||||
}
|
||||
|
||||
#handHistoryList {
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
gap: 0.4rem;
|
||||
max-height: 260px;
|
||||
/* Was a flat 260px, which is about four and a half rows — the same four and a half
|
||||
whether the dealer is on a phone or a 27" screen with room for twenty. The floor
|
||||
keeps it honest on a short window; the ceiling stops the panel from running away
|
||||
on a tall one and pushing everything below it out of reach. */
|
||||
max-height: clamp(200px, 42vh, 560px);
|
||||
overflow-y: auto;
|
||||
}
|
||||
|
||||
@@ -3406,6 +3447,38 @@ textarea:focus-visible {
|
||||
color: #9a9a9a;
|
||||
}
|
||||
|
||||
/* An aside that has something to press. It wraps rather than squeezing the button:
|
||||
on a phone the sentence takes the width it needs and the button drops under it,
|
||||
still at full tap size, instead of being crushed to a sliver at the end of a line. */
|
||||
.dealPromptLine.dealPromptDebt {
|
||||
display: flex;
|
||||
flex-wrap: wrap;
|
||||
align-items: center;
|
||||
justify-content: center;
|
||||
gap: 0.4rem 0.55rem;
|
||||
}
|
||||
|
||||
.dealPromptDebtBtn {
|
||||
/* Sized down from a full action button — it's an option beside a sentence, not
|
||||
the thing the dealer came here to press. "Post blinds & deal" stays the button
|
||||
that looks like the button. */
|
||||
flex: 0 0 auto;
|
||||
min-height: 32px;
|
||||
padding: 0.24rem 0.7rem;
|
||||
font-size: 0.72rem;
|
||||
background: rgba(245, 213, 71, 0.1);
|
||||
border: 1px solid rgba(245, 213, 71, 0.45);
|
||||
color: #f0d98c;
|
||||
}
|
||||
|
||||
@media (max-width: 700px), (pointer: coarse) {
|
||||
/* A fingertip needs 44px, and this one moves money. */
|
||||
.dealPromptDebtBtn {
|
||||
min-height: 44px;
|
||||
padding: 0.4rem 0.9rem;
|
||||
}
|
||||
}
|
||||
|
||||
/* ---------- Touch targets on a wide touch screen ----------
|
||||
|
||||
Every touch-target rule in this file sits behind `max-width: 700px`, and width was
|
||||
|
||||
@@ -643,6 +643,44 @@ const ActionBar = {
|
||||
wrap.appendChild(out);
|
||||
}
|
||||
|
||||
// Somebody who has just sat down between the button and the big blind has had
|
||||
// the blinds go past them, and dealing them in there is a free hand in late
|
||||
// position. At a table the answer is that they post the big blind to come in
|
||||
// now, or wait for it to reach them. The tool used to do neither and say
|
||||
// nothing: it dealt them in for free, and the dealer had no way to know it had
|
||||
// happened. Both answers are offered here; neither is forced, because a home
|
||||
// game that doesn't care shouldn't have to argue with its own scoreboard.
|
||||
// One line for however many have walked up, not one each. The bar is docked
|
||||
// over the felt and the felt has already shrunk as far as it will go on a
|
||||
// phone, so every line here is taken out of the ring of seats: measured at
|
||||
// 390x844 with two newcomers, a line apiece put the bar over two fifths of the
|
||||
// bottom seat. They post together or they wait together, which is what happens
|
||||
// at a table anyway when two people sit down at once.
|
||||
if (preview.debtors.length > 0) {
|
||||
const ids = preview.debtors.map(i => this.state.seats[i].id);
|
||||
const posting = ids.every(id => preview.posting.includes(id));
|
||||
const who = listNames(preview.debtors);
|
||||
const each = preview.debtors.length > 1 ? " each" : "";
|
||||
|
||||
const line = document.createElement("p");
|
||||
line.className = "dealPromptLine dealPromptAside dealPromptDebt";
|
||||
|
||||
const text = document.createElement("span");
|
||||
text.textContent = posting
|
||||
? `${who} posting ${Money.format(preview.bigBlind)}${each} to come in.`
|
||||
: `${who} sat down after the blinds — ${preview.debtors.length > 1 ? "free hands" : "a free hand"} unless they post.`;
|
||||
line.appendChild(text);
|
||||
|
||||
line.appendChild(this.button(
|
||||
posting ? "Don't post" : `Post ${Money.format(preview.bigBlind)}${each}`,
|
||||
"dealPromptDebtBtn",
|
||||
() => this.commit(
|
||||
posting ? `${who} waiting for the blind` : `${who} posting to come in`,
|
||||
() => { this.state.postingIn = posting ? [] : ids; })
|
||||
));
|
||||
wrap.appendChild(line);
|
||||
}
|
||||
|
||||
const row = document.createElement("div");
|
||||
row.className = "actionButtons";
|
||||
row.appendChild(this.button("Post blinds & deal", "actionDeal", () => {
|
||||
|
||||
@@ -83,6 +83,11 @@ const Betting = {
|
||||
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,
|
||||
@@ -462,11 +467,30 @@ const Betting = {
|
||||
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);
|
||||
|
||||
state.currentBet = this.round(Math.max(
|
||||
sbIndex === null ? 0 : this.committed(state.seats[sbIndex]),
|
||||
this.committed(state.seats[bbIndex])));
|
||||
|
||||
@@ -591,15 +591,33 @@ document.addEventListener("DOMContentLoaded", () => {
|
||||
if (!ok) return;
|
||||
|
||||
HoldemState.clearHistory(state);
|
||||
Render.historyFilter = "";
|
||||
document.getElementById("handHistoryFilter").value = "";
|
||||
hooks.save(state);
|
||||
Render.renderAll();
|
||||
Toast.show("Hand history cleared.", { duration: 2500 });
|
||||
});
|
||||
|
||||
// The filter is how the dealer looks at the log, not something about the table, so
|
||||
// it lives on the view: it isn't saved, isn't undoable, and doesn't reach the other
|
||||
// tab. Clearing the history clears it too, since there is nothing left to filter.
|
||||
document.getElementById("handHistoryFilter").addEventListener("input", e => {
|
||||
Render.historyFilter = e.target.value;
|
||||
Render.renderHandHistory();
|
||||
});
|
||||
|
||||
document.getElementById("exportHistoryBtn").addEventListener("click", () => {
|
||||
if ((state.handHistory || []).length === 0) return;
|
||||
// Always the whole night. A filter is for reading the panel; an export that
|
||||
// quietly dropped the hands scrolled past would be a record with holes in it,
|
||||
// and nothing on the CSV would say so.
|
||||
HandHistoryExport.download(state.handHistory, HoldemState.sessionStandings(state),
|
||||
{ notes: state.notes });
|
||||
if (Render.historyFilter) {
|
||||
Toast.show(`Exported all ${state.handHistory.length} hands, not just the ${
|
||||
state.handHistory.filter(h => Render.handMatchesFilter(h, Render.historyFilter)).length} shown.`,
|
||||
{ duration: 3500 });
|
||||
}
|
||||
});
|
||||
|
||||
// The load happens on the first line of this file, long before there's a Toast to
|
||||
|
||||
@@ -967,9 +967,50 @@ const Render = {
|
||||
newest ? newest.handNumber : "",
|
||||
newest ? newest.timestamp : "",
|
||||
newest ? newest.pot : "",
|
||||
// Typing in the filter changes the list without changing the history, and
|
||||
// the redraw is skipped when the signature matches — leave this out and the
|
||||
// box takes input and does nothing.
|
||||
this.historyFilter || "",
|
||||
].join("|");
|
||||
},
|
||||
|
||||
// What the dealer opens the log for is one hand: the one somebody is arguing
|
||||
// about. A night runs to sixty or more, five at a time in the panel, so finding it
|
||||
// meant scrolling and reading every row. A name, an amount, or a hand number
|
||||
// narrows it instead.
|
||||
//
|
||||
// Matching is deliberately loose. "fay" finds Fay whatever case it's typed in;
|
||||
// "190" finds a $190 pot, a $190 payout, or hand 190, because a dealer half
|
||||
// remembering an amount shouldn't have to know which of those they mean; "#12"
|
||||
// pins it to the hand number, for when they do.
|
||||
handMatchesFilter(entry, query) {
|
||||
if (!query) return true;
|
||||
const term = query.trim().toLowerCase();
|
||||
if (!term) return true;
|
||||
|
||||
const handNumber = String(entry.handNumber || "");
|
||||
if (term.startsWith("#")) return handNumber.startsWith(term.slice(1));
|
||||
|
||||
// Only what the row itself shows. Matching the hand's full ledger as well was
|
||||
// the first attempt, on the reasoning that a dealer might hunt for the hand
|
||||
// that broke somebody by the loser's name — but the ledger holds everyone who
|
||||
// put a chip in, so at a table where nobody folds it matched every hand.
|
||||
// Measured on a seven-handed night: "Fay" returned 60 of 60. Searching text the
|
||||
// panel doesn't display is a filter that looks broken even when it's right.
|
||||
const labels = (entry.payouts || []).map(p => String(p.label || "").toLowerCase()).join(" ");
|
||||
if (labels.includes(term)) return true;
|
||||
|
||||
// Amounts, matched on the digits so "$190", "190" and "1,90" all behave.
|
||||
const digits = term.replace(/[^0-9.]/g, "");
|
||||
if (digits) {
|
||||
const amounts = [entry.pot, ...(entry.payouts || []).map(p => p.amount)]
|
||||
.map(a => String(Money.round(Number(a) || 0)));
|
||||
if (amounts.some(a => a.startsWith(digits))) return true;
|
||||
if (handNumber === digits) return true;
|
||||
}
|
||||
return false;
|
||||
},
|
||||
|
||||
// Rebuilding this panel measured 25.7ms of the 30ms a full re-render costs — and a
|
||||
// full re-render runs after every fold, call and raise. The log only changes when a
|
||||
// hand is settled or the history is cleared, perhaps once every thirty taps, so it
|
||||
@@ -988,10 +1029,29 @@ const Render = {
|
||||
emptyHint.hidden = history.length > 0;
|
||||
document.getElementById("exportHistoryBtn").disabled = history.length === 0;
|
||||
|
||||
const query = this.historyFilter || "";
|
||||
const shown = query ? history.filter(entry => this.handMatchesFilter(entry, query)) : history;
|
||||
|
||||
// How much of the night is being hidden. Without it a filter that matches one
|
||||
// hand looks exactly like a table that only played one, which is the sort of
|
||||
// thing a dealer reads wrong at 2am with somebody leaning over the rail.
|
||||
const count = document.getElementById("handHistoryCount");
|
||||
if (count) {
|
||||
count.hidden = !query || history.length === 0;
|
||||
count.textContent = `${shown.length} of ${history.length}`;
|
||||
}
|
||||
const noMatch = document.getElementById("handHistoryNoMatch");
|
||||
if (noMatch) {
|
||||
noMatch.hidden = !(query && history.length > 0 && shown.length === 0);
|
||||
noMatch.textContent = `No hand matches “${query.trim()}”. The log still has all ${history.length}.`;
|
||||
}
|
||||
const filterBox = document.getElementById("handHistoryFilter");
|
||||
if (filterBox) filterBox.hidden = history.length === 0;
|
||||
|
||||
// Built off-document so the panel is laid out once instead of once per row.
|
||||
const fragment = document.createDocumentFragment();
|
||||
const template = document.getElementById("handHistoryRowTemplate");
|
||||
history.forEach(entry => {
|
||||
shown.forEach(entry => {
|
||||
const row = template.content.firstElementChild.cloneNode(true);
|
||||
row.querySelector(".handHistoryHandNumber").textContent = `Hand #${entry.handNumber}`;
|
||||
row.querySelector(".handHistoryPot").textContent = Money.format(entry.pot);
|
||||
|
||||
@@ -86,6 +86,14 @@ const HoldemState = {
|
||||
// seating as it stands, because by then the people it needs to know about
|
||||
// are exactly the ones who have got up and gone.
|
||||
postedBlinds: null,
|
||||
// Player ids that were dealt in the last hand actually dealt. What makes a
|
||||
// seat recognisable as having *just* joined — new to the table, or back
|
||||
// from sitting out — which is the whole question behind owing a blind.
|
||||
dealtLastHand: [],
|
||||
// Ids the dealer has said will buy in past the blinds this hand, by posting
|
||||
// the big blind rather than waiting for it. Cleared every hand: it's a
|
||||
// decision about one deal, not a standing arrangement.
|
||||
postingIn: [],
|
||||
// Set when somebody leaves out of the blinds and the rotation has to hold
|
||||
// to the seats to keep the big blind moving one player at a time. The
|
||||
// button then sits on the chair they vacated, and no small blind is posted.
|
||||
@@ -175,6 +183,12 @@ const HoldemState = {
|
||||
// way, which is what that table was already doing.
|
||||
parsed.deadButton = parsed.deadButton === true;
|
||||
parsed.deadSmallBlind = parsed.deadSmallBlind === true;
|
||||
// An old save has no record of who was dealt last hand. Empty is the
|
||||
// honest answer — it reads as "this table hasn't played yet", so the first
|
||||
// hand after reopening treats nobody as having just walked up, rather than
|
||||
// asking the whole table to post.
|
||||
if (!Array.isArray(parsed.dealtLastHand)) parsed.dealtLastHand = [];
|
||||
if (!Array.isArray(parsed.postingIn)) parsed.postingIn = [];
|
||||
|
||||
// A table saved before dealing and betting were separate has no flag, and
|
||||
// guessing false would show "deal the hand" over a hand already in
|
||||
@@ -460,6 +474,29 @@ const HoldemState = {
|
||||
return { dealerIndex, sbIndex: live[0], bbIndex: live[1], headsUp: false };
|
||||
},
|
||||
|
||||
// Seats about to be dealt a hand they haven't paid for.
|
||||
//
|
||||
// Somebody who walks up and sits down between the button and the big blind has had
|
||||
// the blinds go past them. Dealing them in there is a free hand in late position —
|
||||
// which is exactly what posting is for, and it comes out of everybody else's night
|
||||
// a couple of dollars at a time. At a real table they either post the big blind to
|
||||
// come straight in, or they wait for it to reach them.
|
||||
//
|
||||
// The seat that *is* the big blind this hand isn't owed anything: they're paying.
|
||||
// Neither is anyone at a table that hasn't dealt a hand yet, where everybody is new
|
||||
// and nobody has been skipped.
|
||||
blindDebtors(state, bbIndex) {
|
||||
const played = Array.isArray(state.dealtLastHand) && state.dealtLastHand.length > 0;
|
||||
if (!played) return [];
|
||||
return state.seats
|
||||
.map((player, index) => ({ player, index }))
|
||||
.filter(({ player, index }) =>
|
||||
player.inHand &&
|
||||
index !== bbIndex &&
|
||||
!state.dealtLastHand.includes(player.id))
|
||||
.map(({ index }) => index);
|
||||
},
|
||||
|
||||
// Where the button goes for the next hand, and whether anything is left dead.
|
||||
//
|
||||
// Ordinarily it follows the small blind round — the next player along, which is
|
||||
@@ -518,6 +555,9 @@ const HoldemState = {
|
||||
// the next one would freeze the blinds on two players for the rest of the
|
||||
// night, which is the opposite of what naming them once is for.
|
||||
state.blindOverride = null;
|
||||
// Posting to come in is a decision about one deal. Carrying it forward would
|
||||
// charge somebody an extra big blind every hand for the rest of the night.
|
||||
state.postingIn = [];
|
||||
state.seats.forEach(p => {
|
||||
p.folded = false;
|
||||
p.cards = ["", ""];
|
||||
|
||||
@@ -0,0 +1,123 @@
|
||||
// Finding one hand in a night of them.
|
||||
//
|
||||
// What the log is actually opened for is a single hand — the one somebody at the rail
|
||||
// is arguing about. A night runs to sixty or more, five at a time in the panel, and
|
||||
// there was no way to ask for one: the dealer scrolled and read every row.
|
||||
const test = require("node:test");
|
||||
const { describe } = require("node:test");
|
||||
const assert = require("node:assert");
|
||||
const { Render } = require("./load");
|
||||
|
||||
const hand = (handNumber, pot, payouts, ledger = []) => ({
|
||||
handNumber, pot, timestamp: Date.now(), payouts, ledger,
|
||||
});
|
||||
|
||||
// A night as the tool records it: labels carry the cards the wizard was shown.
|
||||
const NIGHT = [
|
||||
hand(1, 40, [{ label: "Ann (A♠ K♠)", amount: 40 }], [{ name: "Ann", in: 20 }, { name: "Ben", in: 20 }]),
|
||||
hand(2, 190, [{ label: "Fay", amount: 190 }], [{ name: "Fay", in: 95 }, { name: "Gus", in: 95 }]),
|
||||
hand(12, 19, [{ label: "Ben", amount: 19 }], [{ name: "Ben", in: 10 }, { name: "Ann", in: 9 }]),
|
||||
hand(120, 76, [{ label: "Cal", amount: 38 }, { label: "Dee", amount: 38 }], [{ name: "Cal" }, { name: "Dee" }]),
|
||||
];
|
||||
|
||||
const found = query => NIGHT.filter(h => Render.handMatchesFilter(h, query)).map(h => h.handNumber);
|
||||
|
||||
describe("no filter", () => {
|
||||
test("shows the whole night", () => {
|
||||
assert.deepEqual(found(""), [1, 2, 12, 120]);
|
||||
assert.deepEqual(found(" "), [1, 2, 12, 120]);
|
||||
assert.deepEqual(found(null), [1, 2, 12, 120]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("by name", () => {
|
||||
test("finds the hand somebody won", () => {
|
||||
assert.deepEqual(found("Fay"), [2]);
|
||||
});
|
||||
|
||||
test("case doesn't matter — nobody types a capital at 2am", () => {
|
||||
assert.deepEqual(found("fay"), [2]);
|
||||
assert.deepEqual(found("FAY"), [2]);
|
||||
});
|
||||
|
||||
test("a name inside a label with cards on it still matches", () => {
|
||||
// The wizard writes the label as "Ann (A♠ K♠)", so the name is a substring
|
||||
// rather than the whole cell.
|
||||
assert.deepEqual(found("ann"), [1]);
|
||||
});
|
||||
|
||||
test("matches what the row shows, not everyone who was in the hand", () => {
|
||||
// Gus is in hand 2's ledger — he paid for it — but the row names the winner,
|
||||
// and searching text the panel doesn't display is a filter that looks broken
|
||||
// even when it's right. Measured on a seven-handed night where nobody folded,
|
||||
// matching the ledger returned 60 of 60 for every name at the table.
|
||||
assert.deepEqual(found("gus"), []);
|
||||
});
|
||||
|
||||
test("a split pot is found by either winner", () => {
|
||||
assert.deepEqual(found("cal"), [120]);
|
||||
assert.deepEqual(found("dee"), [120]);
|
||||
});
|
||||
|
||||
test("a name nobody has finds nothing rather than everything", () => {
|
||||
assert.deepEqual(found("zed"), []);
|
||||
});
|
||||
});
|
||||
|
||||
describe("by amount", () => {
|
||||
test("finds a pot", () => {
|
||||
assert.deepEqual(found("190"), [2]);
|
||||
});
|
||||
|
||||
test("a dollar sign and commas are ignored", () => {
|
||||
assert.deepEqual(found("$190"), [2]);
|
||||
assert.deepEqual(found("$1,90"), [2], "typed badly, still found");
|
||||
});
|
||||
|
||||
test("finds a payout that isn't the whole pot", () => {
|
||||
assert.deepEqual(found("38"), [120], "half of a chopped $76");
|
||||
});
|
||||
|
||||
test("a partial amount narrows rather than missing", () => {
|
||||
// Half remembering "something around forty" should still get there.
|
||||
assert.deepEqual(found("4"), [1], "$40");
|
||||
assert.deepEqual(found("19"), [2, 12], "the $190 pot and the $19 one");
|
||||
});
|
||||
|
||||
test("a bare number is an exact hand number, not a prefix of one", () => {
|
||||
// Amounts match on their leading digits, because half a remembered figure is
|
||||
// still a lead. Hand numbers don't: typing 12 to mean the hand is a dealer who
|
||||
// knows which hand they want, and dragging 120 and 128 along with it is noise.
|
||||
// "#12" is there for when they do want the prefix.
|
||||
assert.ok(!found("12").includes(120));
|
||||
});
|
||||
});
|
||||
|
||||
describe("by hand number", () => {
|
||||
test("a bare number matches the hand number as well as amounts", () => {
|
||||
assert.ok(found("12").includes(12));
|
||||
});
|
||||
|
||||
test("a hash pins it to the hand number and nothing else", () => {
|
||||
assert.deepEqual(found("#12"), [12, 120], "12 and 120 both start with 12");
|
||||
assert.deepEqual(found("#2"), [2], "and not the $190 pot of hand 2's neighbours");
|
||||
});
|
||||
|
||||
test("a hash with a number nobody played finds nothing", () => {
|
||||
assert.deepEqual(found("#7"), []);
|
||||
});
|
||||
});
|
||||
|
||||
describe("odd input can't break it", () => {
|
||||
test("punctuation on its own doesn't match everything", () => {
|
||||
assert.deepEqual(found("$"), [], "no digits and no letters left to match on");
|
||||
assert.deepEqual(found("#"), [1, 2, 12, 120], "an empty hand number is a prefix of them all");
|
||||
});
|
||||
|
||||
test("an entry with pieces missing doesn't throw", () => {
|
||||
const broken = { handNumber: 5, pot: 10 };
|
||||
assert.doesNotThrow(() => Render.handMatchesFilter(broken, "ann"));
|
||||
assert.equal(Render.handMatchesFilter(broken, "ann"), false);
|
||||
assert.equal(Render.handMatchesFilter(broken, "10"), true, "the pot is still findable");
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,238 @@
|
||||
// Somebody who walks up and sits down after the blinds have gone past them.
|
||||
//
|
||||
// Dealing them straight in is a free hand in late position — which is what posting
|
||||
// exists to stop, and it comes out of everybody else's night a couple of dollars at a
|
||||
// time. The tool used to do it silently. It now says so, and takes the post if the
|
||||
// dealer says to.
|
||||
const test = require("node:test");
|
||||
const { describe } = require("node:test");
|
||||
const assert = require("node:assert");
|
||||
const { HoldemState, Betting, makeTable } = require("./load");
|
||||
|
||||
const NAMES = ["Ann", "Ben", "Cal", "Dee"];
|
||||
const table = (dealerSeatIndex = 0) => {
|
||||
const state = makeTable({ seatCount: 6, seated: [0, 1, 2, 3], stack: 200, dealerSeatIndex });
|
||||
NAMES.forEach((name, i) => { state.seats[i].name = name; });
|
||||
return state;
|
||||
};
|
||||
|
||||
// Eve walks up and takes seat 5 while the table is running.
|
||||
const seatEve = state => {
|
||||
state.seats[4].name = "Eve";
|
||||
state.seats[4].inHand = true;
|
||||
state.seats[4].stack = 200;
|
||||
state.seats[4].buyIns = 200;
|
||||
return 4;
|
||||
};
|
||||
|
||||
const debtors = state => {
|
||||
const { bbIndex } = HoldemState.getBlindSeats(state);
|
||||
return HoldemState.blindDebtors(state, bbIndex).map(i => state.seats[i].name);
|
||||
};
|
||||
|
||||
describe("who is owed a blind", () => {
|
||||
test("nobody, at a table that hasn't dealt a hand yet", () => {
|
||||
// Everyone is new on the first hand. Asking the whole table to post would be
|
||||
// the tool mistaking the start of the night for five people walking up late.
|
||||
const state = table();
|
||||
assert.deepEqual(debtors(state), []);
|
||||
});
|
||||
|
||||
test("nobody, on an ordinary hand where the same people are still sitting there", () => {
|
||||
const state = table();
|
||||
Betting.beginHand(state);
|
||||
HoldemState.startNextHand(state);
|
||||
assert.deepEqual(debtors(state), []);
|
||||
});
|
||||
|
||||
test("the player who has just sat down", () => {
|
||||
const state = table();
|
||||
Betting.beginHand(state);
|
||||
HoldemState.startNextHand(state);
|
||||
seatEve(state);
|
||||
|
||||
assert.deepEqual(debtors(state), ["Eve"]);
|
||||
});
|
||||
|
||||
test("not once they've been dealt a hand", () => {
|
||||
const state = table();
|
||||
Betting.beginHand(state);
|
||||
HoldemState.startNextHand(state);
|
||||
seatEve(state);
|
||||
Betting.beginHand(state);
|
||||
HoldemState.startNextHand(state);
|
||||
|
||||
assert.deepEqual(debtors(state), [], "she's one of the regulars now");
|
||||
});
|
||||
|
||||
test("not somebody who is the big blind this hand — they're paying already", () => {
|
||||
const state = table(0); // blinds Ben and Cal
|
||||
Betting.beginHand(state);
|
||||
HoldemState.startNextHand(state); // blinds move to Cal and Dee
|
||||
|
||||
// Dee sits out for a hand and comes straight back into her own big blind.
|
||||
state.seats[3].inHand = false;
|
||||
Betting.beginHand(state);
|
||||
HoldemState.startNextHand(state);
|
||||
state.seats[3].inHand = true;
|
||||
|
||||
const { bbIndex } = HoldemState.getBlindSeats(state);
|
||||
assert.ok(!HoldemState.blindDebtors(state, bbIndex).includes(bbIndex),
|
||||
"the big blind is never asked to post on top of their blind");
|
||||
});
|
||||
|
||||
test("somebody back from sitting out is owed one just like a newcomer", () => {
|
||||
const state = table();
|
||||
Betting.beginHand(state);
|
||||
HoldemState.startNextHand(state);
|
||||
|
||||
state.seats[3].inHand = false; // Dee stands up for a hand
|
||||
Betting.beginHand(state);
|
||||
HoldemState.startNextHand(state);
|
||||
state.seats[3].inHand = true; // and sits back down
|
||||
|
||||
assert.ok(debtors(state).includes("Dee"), "the blinds went past her while she was up");
|
||||
});
|
||||
|
||||
test("a seat sat out for having no chips isn't owed anything", () => {
|
||||
// They aren't being dealt in, so there's no free hand to charge for.
|
||||
const state = table();
|
||||
Betting.beginHand(state);
|
||||
HoldemState.startNextHand(state);
|
||||
const eve = seatEve(state);
|
||||
state.seats[eve].stack = 0;
|
||||
|
||||
const preview = Betting.blindPreview(state);
|
||||
assert.ok(!preview.debtors.includes(eve), "she's sitting out until she buys chips");
|
||||
});
|
||||
});
|
||||
|
||||
describe("posting to come in", () => {
|
||||
test("the post goes in the middle and buys a hand", () => {
|
||||
const state = table();
|
||||
Betting.beginHand(state);
|
||||
HoldemState.startNextHand(state);
|
||||
const eve = seatEve(state);
|
||||
|
||||
state.postingIn = [state.seats[eve].id];
|
||||
const before = Betting.stackOf(state, state.seats[eve]);
|
||||
Betting.beginHand(state);
|
||||
|
||||
assert.equal(Betting.committed(state.seats[eve]), state.bigBlind, "she's posted a big blind");
|
||||
assert.equal(Betting.stackOf(state, state.seats[eve]), before - state.bigBlind,
|
||||
"out of her own stack, not conjured");
|
||||
assert.equal(state.currentBet, state.bigBlind, "and it doesn't raise the hand");
|
||||
});
|
||||
|
||||
test("not posting leaves her stack alone", () => {
|
||||
const state = table();
|
||||
Betting.beginHand(state);
|
||||
HoldemState.startNextHand(state);
|
||||
const eve = seatEve(state);
|
||||
|
||||
const before = Betting.stackOf(state, state.seats[eve]);
|
||||
Betting.beginHand(state);
|
||||
|
||||
assert.equal(Betting.committed(state.seats[eve]), 0);
|
||||
assert.equal(Betting.stackOf(state, state.seats[eve]), before);
|
||||
});
|
||||
|
||||
test("the pot is what the blinds and the post add up to", () => {
|
||||
const state = table();
|
||||
Betting.beginHand(state);
|
||||
HoldemState.startNextHand(state);
|
||||
const eve = seatEve(state);
|
||||
|
||||
state.postingIn = [state.seats[eve].id];
|
||||
Betting.beginHand(state);
|
||||
|
||||
const middle = state.seats.reduce((sum, p) => sum + Betting.committed(p), 0);
|
||||
assert.equal(middle, state.smallBlind + state.bigBlind + state.bigBlind);
|
||||
});
|
||||
|
||||
test("it's spent after the hand, not a standing charge", () => {
|
||||
const state = table();
|
||||
Betting.beginHand(state);
|
||||
HoldemState.startNextHand(state);
|
||||
const eve = seatEve(state);
|
||||
|
||||
state.postingIn = [state.seats[eve].id];
|
||||
Betting.beginHand(state);
|
||||
HoldemState.startNextHand(state);
|
||||
|
||||
assert.deepEqual(state.postingIn, [], "or she'd pay an extra blind every hand all night");
|
||||
Betting.beginHand(state);
|
||||
assert.ok(Betting.committed(state.seats[eve]) === 0 ||
|
||||
state.seats[eve].id === state.seats[HoldemState.getBlindSeats(state).bbIndex]?.id,
|
||||
"she pays nothing extra on the next hand");
|
||||
});
|
||||
|
||||
test("moving the button after a post doesn't lose it", () => {
|
||||
// repostBlinds takes every posted chip back and deals again. A post that
|
||||
// cleared itself on the way in would be refunded and never retaken.
|
||||
const state = table();
|
||||
Betting.beginHand(state);
|
||||
HoldemState.startNextHand(state);
|
||||
const eve = seatEve(state);
|
||||
|
||||
state.postingIn = [state.seats[eve].id];
|
||||
Betting.beginHand(state);
|
||||
const chips = () => state.seats.reduce(
|
||||
(sum, p) => sum + Betting.stackOf(state, p) + Betting.handTotal(p), 0);
|
||||
const before = chips();
|
||||
|
||||
state.dealerSeatIndex = 2;
|
||||
Betting.repostBlinds(state);
|
||||
|
||||
assert.equal(Betting.committed(state.seats[eve]), state.bigBlind, "still posted");
|
||||
assert.equal(chips(), before, "and no chips made or lost in the shuffle");
|
||||
});
|
||||
|
||||
test("a post from somebody who isn't owed one is not taken", () => {
|
||||
// Only seats actually being dealt in can post, and only for their own chips.
|
||||
const state = table();
|
||||
state.postingIn = [state.seats[3].id];
|
||||
state.seats[3].inHand = false;
|
||||
Betting.beginHand(state);
|
||||
|
||||
assert.equal(Betting.committed(state.seats[3]), 0, "she isn't even in the hand");
|
||||
});
|
||||
});
|
||||
|
||||
describe("what the dealer is shown", () => {
|
||||
test("the prompt has something to say about it, and something to press", () => {
|
||||
const state = table();
|
||||
Betting.beginHand(state);
|
||||
HoldemState.startNextHand(state);
|
||||
const eve = seatEve(state);
|
||||
|
||||
const preview = Betting.blindPreview(state);
|
||||
assert.deepEqual(preview.debtors, [eve]);
|
||||
assert.deepEqual(preview.posting, [], "not posting until the dealer says so");
|
||||
|
||||
state.postingIn = [state.seats[eve].id];
|
||||
assert.deepEqual(Betting.blindPreview(state).posting, [state.seats[eve].id]);
|
||||
});
|
||||
|
||||
test("an old save reads as a table nobody has just walked up to", () => {
|
||||
const state = table();
|
||||
Betting.beginHand(state);
|
||||
const parsed = JSON.parse(JSON.stringify(state));
|
||||
delete parsed.dealtLastHand;
|
||||
delete parsed.postingIn;
|
||||
|
||||
const store = new Map([[HoldemState.STORAGE_KEY, JSON.stringify(parsed)]]);
|
||||
globalThis.localStorage = {
|
||||
getItem: key => (store.has(key) ? store.get(key) : null),
|
||||
setItem: (key, value) => store.set(key, value),
|
||||
removeItem: key => store.delete(key),
|
||||
};
|
||||
|
||||
const loaded = HoldemState.load();
|
||||
assert.deepEqual(loaded.dealtLastHand, []);
|
||||
assert.deepEqual(loaded.postingIn, []);
|
||||
assert.deepEqual(debtors(loaded), [],
|
||||
"reopening the tab doesn't ask the whole table to post");
|
||||
delete globalThis.localStorage;
|
||||
});
|
||||
});
|
||||
Reference in New Issue
Block a user