jheaps/JoshHeaps.Net
1
0
Fork 0
Code Issues Pull Requests 2 Actions Packages Projects Releases Wiki Activity

Say who can win each pot in the fewest names that answer it

Browse Source 
The pot breakdown listed every eligible player for every pot. Pot
eligibility is nested — the main pot is everyone still live and each side
pot above it drops whoever was all-in below — so the main pot's line was
every name at the table and each side pot repeated it minus one.

The lines too long to fit were exactly the ones nobody needed spelled
out, and the short ones at the bottom were the side pots a dealer
actually announces by name. Measured on an iPhone 14: a single all-in
five-handed already clipped the main pot, and twelve-handed the first row
wanted 521px of a 254px slot. There was no count and no title, so a
dealer reading "Alexandra…" could not tell whether three people or eleven
were eligible — the number the showdown turns on.

Each line now names whichever of "who is in" and "who is out" is shorter,
which nesting guarantees is never more than half the table, and leads
with the count because the line is right-aligned and it is the tail that
gets cut off. "all 9", "8 in, not Mike from work". On a phone this takes
one, two and three all-ins from every main-pot line clipped to nothing
clipped at all; twelve-handed goes 6 clipped rows to 5, and even a cut
row still opens with "9 in".

The wizard's copy of the same announcement wraps instead — it is a dialog
that scrolls, and it is what the dealer reads out before anybody shows a
hand — so nothing there is ever cut off. The full list is also on the
title for anyone with a pointer, which is the extra rather than the
answer, since a tooltip is not a mechanism a keyboard reaches.

potCalculator.test.js now proves the nesting across 20,000 random tables
and asserts on its own generator, so the loop cannot go vacuous. Audit
unchanged at 2 failing configurations and 3 offenders, both pre-existing.
787 unit tests pass.

Co-Authored-By: Claude Opus 5 <[email protected]>
Claude-Session: https://claude.ai/code/session_015bnp7xKUPFFSpwkYNFaPgb
This commit is contained in:
jheaps
2026-09-05 21:23:19 -06:00
co-authored by Claude Opus 5
parent 13d704301d
commit bd8ee11f77
5 changed files with 266 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files
JoshHeaps.Net/wwwroot/css/casino/holdem.css
+9
View File
@@ -3027,6 +3027,15 @@ body.hasActionBar #holdemSidebar {
margin-bottom: var(--sp-4);
}
/* The action bar is a fixed strip and its rows have to stay one line each; the wizard
is a dialog that scrolls, and this is the announcement a dealer reads out loud before
anybody shows a hand. So here the names are allowed the room to be read, and nothing
in the announcement is ever cut off. */
.potBreakdownWizard .potLayerWho {
white-space: normal;
overflow: visible;
}
.potLayerReturn .potLayerLabel,
.potLayerReturn .potLayerAmount {
color: var(--text-muted);
JoshHeaps.Net/wwwroot/js/casino/holdem/render.js
+43 -2
View File
@@ -2096,7 +2096,7 @@ const Render = {
wrap.appendChild(title);
}
const addRow = (label, amount, who, className) => {
const addRow = (label, amount, who, className, full) => {
const row = document.createElement("div");
row.className = `potLayer ${className || ""}`;
@@ -2111,6 +2111,11 @@ const Render = {
const whoEl = document.createElement("span");
whoEl.className = "potLayerWho";
whoEl.textContent = who;
// The line can still run out of room on a phone. A tooltip is not a mechanism
// a keyboard reaches, which is why the count is in the text itself rather
// than only here — this is the extra for anyone with a pointer, not the
// answer to "how many hands am I asking for".
if (full) whoEl.title = full;
row.appendChild(labelEl);
row.appendChild(amountEl);
@@ -2118,12 +2123,48 @@ const Render = {
wrap.appendChild(row);
};
pots.forEach(pot => addRow(pot.label, pot.amount, pot.eligible.map(nameFor).join(", ")));
pots.forEach(pot => addRow(
pot.label, pot.amount,
this.describeEligible(pot.eligible, pots[0].eligible, nameFor),
"",
pot.eligible.map(nameFor).join(", ")));
returns.forEach(ret => addRow("Uncalled", ret.amount, `back to ${nameFor(ret.id)}`, "potLayerReturn"));
return wrap;
},
// Who can win a pot, said in the fewest names that answer it.
//
// Listing every eligible player spelled the same names out again for every pot, and
// the lists that were too long to fit were the ones nobody needed: pot eligibility
// is strictly nested — the main pot is everyone still live, and each side pot above
// it drops whoever was all-in below — so the main pot's list contains every other
// list, and the side pot a dealer actually announces by name is the short one at the
// top. Measured on an iPhone 14: a single all-in five-handed already clipped the
// main pot's line, and twelve-handed the first row asked for 521px of a 254px slot.
//
// Nesting is what makes the short form safe, and it is a property rather than a
// habit — potCalculator.test.js checks it across 20,000 random tables — so "who is
// in" and "who is out" are complements and the shorter of the two is never more than
// half the table.
//
// The count leads because .potLayerWho is right-aligned with an ellipsis, so it is
// the tail that gets eaten. A dealer who can only read the start of the line still
// learns how many hands to ask for, which is the number the showdown turns on.
describeEligible(eligible, everyone, nameFor) {
const listOf = names => (names.length <= 1
? (names[0] || "")
: `${names.slice(0, -1).join(", ")} and ${names[names.length - 1]}`);
if (eligible.length >= everyone.length) return `all ${eligible.length}`;
const inSet = new Set(eligible);
const out = everyone.filter(id => !inSet.has(id));
return out.length < eligible.length
? `${eligible.length} in, not ${listOf(out.map(nameFor))}`
: `${eligible.length} in, ${listOf(eligible.map(nameFor))}`;
},
// ---- Session standings ----
renderStandings() {
tests/holdem/README.md
+27
View File
@@ -24,6 +24,7 @@ other in the page, in the load order from `TexasHoldem.cshtml`.
| `readingTheShowdown.test.js` | The board, the picker that fills it, and who wins a side pot |
| `theRail.test.js` | A phone on its side: which shape the bar is in, what it leaves under the felt, how a name is shortened, how the ring is pulled back onto the table |
| `feltShape.test.js` | What shape the felt is at each phone size, resolved through the media queries in source order (see below) |
| `potBreakdown.test.js` | How each pot says who can win it, and the nesting property that wording rests on (see below) |
| `invariants.test.js` | 1000 randomised hands per property (see below) |
## The layout audit
@@ -184,6 +185,32 @@ twelve are visible. The slit the floor defended against turned out to be unreach
it came from forcing the custom property by hand. A test now asserts the floor is
*absent*, with the numbers, so it doesn't get re-added by someone reasoning the same way.
## A property the wording depends on
`potBreakdown.test.js` covers how the pot breakdown says who can win each pot, and it
leans on something `potCalculator.test.js` now proves: **pot eligibility is nested.** The
main pot is everyone still live, and each side pot above it drops whoever was all-in
below, so every side pot's players are a strict subset of the pot beneath it.
That makes "who is in" and "who is out" complements, which is what lets the line name
whichever of the two is shorter and never spell out more than half the table. Listing
every eligible player instead meant the main pot's line was every name at the table and
each side pot repeated it minus one — and the lines too long to fit were exactly the ones
nobody needed, while the short ones at the bottom were the side pots a dealer actually
announces by name.
The nesting check runs 20,000 random tables, and it asserts on its own generator as well
as on the code: if a change to the shapes stopped producing side pots, every assertion in
the loop would be vacuous and the test would still pass, so it also requires that more
than ten thousand of those tables had one.
Writing that check is where a comparison against `Set.length` went in — a `Set` has
`.size`, so `here.length < below.length` was `2 < undefined`, which is false. As an
assertion it failed everything; as a filter in a throwaway script it had passed
everything, which is how it survived long enough to be written down. Both readings are
silent. Prefer asserting the count you expect over comparing two things whose shapes you
have not checked.
## Why the hand evaluator is tested the way it is
`handRank.js` is the only module here that can pay the wrong person without anybody
tests/holdem/potBreakdown.test.js
+127
View File
@@ -0,0 +1,127 @@
// Who can win each pot, said in the fewest names that answer it.
//
// The breakdown used to list every eligible player for every pot. Pot eligibility is
// nested — potCalculator.test.js checks that across 20,000 tables — so the main pot's
// line was every name at the table and each side pot repeated it minus one. The lines
// that were too long to fit were exactly the ones nobody needed spelled out, and the
// short ones at the bottom were the side pots a dealer actually announces by name.
//
// Measured on an iPhone 14 before this: one all-in five-handed already clipped the main
// pot, and twelve-handed the first row wanted 521px of a 254px slot, with no count and
// no title — a dealer reading "Alexandra…" could not tell whether three people or
// eleven were eligible, which is the number the showdown turns on.
const test = require("node:test");
const { describe } = require("node:test");
const assert = require("node:assert");
const { Render } = require("./load");
// Names are "P<id>" so a test reads as ids and the joining is still exercised.
const nameFor = id => `P${id}`;
const say = (eligible, everyone) => Render.describeEligible(eligible, everyone, nameFor);
describe("the eligible line", () => {
test("says so plainly when the whole table can win it", () => {
// The main pot, every hand. Twelve names to say "nobody is excluded yet" was
// the single longest line in the component and the least informative.
assert.equal(say(["a", "b", "c"], ["a", "b", "c"]), "all 3");
assert.equal(say(["a"], ["a"]), "all 1");
});
test("names who is out when that is the shorter list", () => {
const table = ["a", "b", "c", "d", "e", "f", "g", "h"];
assert.equal(say(["b", "c", "d", "e", "f", "g", "h"], table), "7 in, not Pa");
assert.equal(say(["c", "d", "e", "f", "g", "h"], table), "6 in, not Pa and Pb");
assert.equal(say(["d", "e", "f", "g", "h"], table), "5 in, not Pa, Pb and Pc");
});
test("names who is in when that is the shorter list", () => {
// The far side pots, which are the ones a dealer announces by name: "side pot
// is 80 between Ben and Carlos".
const table = ["a", "b", "c", "d", "e", "f", "g", "h"];
assert.equal(say(["g", "h"], table), "2 in, Pg and Ph");
assert.equal(say(["h"], table), "1 in, Ph");
assert.equal(say(["f", "g", "h"], table), "3 in, Pf, Pg and Ph");
});
test("and when the two are the same length, says who is in", () => {
// A tie is not a reason to make the dealer do the subtraction: "who can win
// this" is the question, so answer it directly when it costs nothing.
const table = ["a", "b", "c", "d"];
assert.equal(say(["c", "d"], table), "2 in, Pc and Pd");
});
test("leads with the count, because it is the tail that gets cut off", () => {
// .potLayerWho is right-aligned with an ellipsis, so a line too long for a phone
// loses its end. Every form has to begin with the number of hands to ask for.
const table = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l"];
[table, ["c", "d", "e", "f", "g", "h", "i", "j", "k", "l"], ["k", "l"]]
.forEach(eligible => assert.match(say(eligible, table), /^(all \d+|\d+ in,)/,
`"${say(eligible, table)}" buries the count where a narrow screen can eat it`));
});
test("never spells out more than half the table", () => {
// The point of picking the shorter side. Nested eligibility makes the two lists
// complements, so this is a guarantee rather than a hope.
const table = Array.from({ length: 12 }, (_, i) => `s${i}`);
for (let inCount = 1; inCount <= 12; inCount++) {
const line = say(table.slice(0, inCount), table);
const named = (line.match(/P/g) || []).length;
assert.ok(named <= 6, `${inCount} of 12 named ${named} people: "${line}"`);
}
});
});
// A stub rather than a DOM: the file has no jsdom and does not want one. Enough of an
// element to answer what the row is made of.
const fakeDom = () => {
const make = () => ({
className: "", textContent: "", title: "", children: [],
classList: { add() {} },
appendChild(child) { this.children.push(child); return child; },
});
global.document = { createElement: make };
return () => { delete global.document; };
};
describe("the row it builds", () => {
const pots = [
{ label: "Main pot", amount: 300, eligible: ["a", "b", "c", "d"] },
{ label: "Side pot 1", amount: 150, eligible: ["c", "d"] },
];
const textOf = row => row.children.map(c => c.textContent);
test("carries the full list in a title, for anyone with a pointer", () => {
const undo = fakeDom();
try {
const wrap = Render.buildPotBreakdown(pots, [], nameFor);
const who = wrap.children.map(row => row.children[2]);
assert.equal(who[0].title, "Pa, Pb, Pc, Pd");
assert.equal(who[1].title, "Pc, Pd");
// The visible text is the short form; the title is the long one. A tooltip
// is not a mechanism a keyboard reaches, which is why it is the extra and
// not the answer.
assert.equal(who[0].textContent, "all 4");
assert.equal(who[1].textContent, "2 in, Pc and Pd");
} finally { undo(); }
});
test("puts the label, the money and the people in that order", () => {
const undo = fakeDom();
try {
const wrap = Render.buildPotBreakdown(pots, [], nameFor);
assert.deepEqual(textOf(wrap.children[0]), ["Main pot", "$300", "all 4"]);
} finally { undo(); }
});
test("and an uncalled bet still reads as money going back", () => {
// Not an eligibility question — nobody is competing for it — so it keeps its
// own wording and gets no title to expand.
const undo = fakeDom();
try {
const wrap = Render.buildPotBreakdown(pots, [{ id: "a", amount: 25 }], nameFor);
const row = wrap.children[2];
assert.deepEqual(textOf(row), ["Uncalled", "$25", "back to Pa"]);
assert.equal(row.children[2].title, "");
} finally { undo(); }
});
});
tests/holdem/potCalculator.test.js
+60
View File
@@ -122,3 +122,63 @@ describe("PotCalculator.resolveRound", () => {
assert.throws(() => PotCalculator.resolveRound(entries, ["ghost"]), /No valid winners/);
});
});
// The pots come out of layers() in one order and with one relationship between them,
// and the action bar's wording now depends on both. If eligibility were not nested,
// "8 in, not Mike and Bob" would be a lie — there would be someone eligible for a side
// pot who was never eligible for the main one, and naming the complement would hide
// them. It is a property of how the layers are built rather than an accident of the
// examples above, so it is checked as one.
describe("pot eligibility is nested", () => {
function rng(seed) {
let s = seed >>> 0;
return () => {
s = (s * 1664525 + 1013904223) >>> 0;
return s / 4294967296;
};
}
test("every side pot's players are a strict subset of the pot below it", () => {
const random = rng(20260905);
let multiPotTables = 0;
let pairs = 0;
for (let table = 0; table < 20000; table++) {
const n = 2 + Math.floor(random() * 11);
const players = Array.from({ length: n }, (_, i) => p(
`p${i}`,
// A sixth of the table never puts anything in, which is a table mid-deal.
random() < 1 / 6 ? 0 : (1 + Math.floor(random() * 8)) * 25,
random() < 0.2));
const layers = PotCalculator.layers(players);
if (layers.length > 1) multiPotTables++;
for (let i = 1; i < layers.length; i++) {
const below = layers[i - 1].eligible;
const belowSet = new Set(below);
const here = layers[i].eligible;
pairs++;
assert.ok(here.every(id => belowSet.has(id)),
`table ${table}: ${layers[i].label} has a player ${layers[i - 1].label} does not\n` +
JSON.stringify(players));
assert.ok(here.length < below.length,
`table ${table}: ${layers[i].label} is no smaller than ${layers[i - 1].label} — ` +
`layers with the same eligibility are supposed to be merged into one pot\n` +
JSON.stringify(players));
}
}
// Guards the generator rather than the code: a shape that stopped producing side
// pots would make every assertion above vacuous and the test would still pass.
assert.ok(multiPotTables > 10000, `only ${multiPotTables} tables had a side pot`);
assert.ok(pairs > 20000, `only ${pairs} adjacent pairs to check`);
});
test("so the main pot is everyone still live, and it is the widest", () => {
const layers = PotCalculator.layers([p("a", 100), p("b", 40), p("c", 100), p("d", 25)]);
assert.deepEqual(layers[0].eligible.sort(), ["a", "b", "c", "d"]);
layers.slice(1).forEach(layer =>
assert.ok(layer.eligible.length < layers[0].eligible.length));
});
});