JoshHeaps.Net/wwwroot/js/casino/holdem/actionBar.js

@@ -79,8 +79,14 @@ const ActionBar = {
     // Anything to act on? A hand with nobody dealt in doesn't get a bar — and that
     // still holds during setup, because a seated player is a live seat whether or not
     // the betting has been opened. An empty table stays uncluttered.
+    //
+    // A *named* table is not an empty one, though, and that was the hole: name six
+    // people without dealing any of them in and the bar hid itself, leaving a screen
+    // with six players on it, no way forward and nothing saying why. Anyone with a
+    // name on the felt is somebody the dealer has to be told about.
     isRunning() {
-        return Betting.liveSeats(this.state).length > 0;
+        return Betting.liveSeats(this.state).length > 0 ||
+            this.state.seats.some(p => (p.name || "").trim());
     },
 
     render() {
@@ -598,6 +604,36 @@ const ActionBar = {
             }
             line.classList.add("dealPromptBlocked");
             wrap.appendChild(line);
+
+            // Named seats that aren't in the hand. Naming a chair now seats whoever is
+            // in it, so reaching this takes something else — a table where everyone was
+            // sat out, or a save from before that was true — but the way out of it
+            // should still be one tap rather than a hunt through six seat editors.
+            const benched = this.state.seats
+                .map((player, index) => ({ player, index }))
+                .filter(({ player }) => (player.name || "").trim() && !player.inHand)
+                .map(({ index }) => index);
+
+            if (benched.length > 0) {
+                const aside = document.createElement("p");
+                aside.className = "dealPromptLine dealPromptAside dealPromptDebt";
+                const text = document.createElement("span");
+                text.textContent = benched.length === 1
+                    ? `${listNames(benched)} is sitting out.`
+                    : `${listNames(benched)} are sitting out.`;
+                aside.appendChild(text);
+                aside.appendChild(this.button(
+                    benched.length === 1 ? "Deal them in" : `Deal in all ${benched.length}`,
+                    "dealPromptDebtBtn",
+                    () => this.commit("dealing everybody in", () => {
+                        benched.forEach(index => {
+                            this.state.seats[index].inHand = true;
+                            this.state.seats[index].folded = false;
+                        });
+                    })
+                ));
+                wrap.appendChild(aside);
+            }
             return wrap;
         }
 

JoshHeaps.Net/wwwroot/js/casino/holdem/render.js

@@ -524,13 +524,41 @@ const Render = {
         this.updatePotBadge();
         this.renderSeatTotal(form, player);
         this.refreshPuck(index);
+        // The editor deliberately refreshes narrowly rather than redrawing everything —
+        // a full render on every keystroke would take the name field out from under the
+        // dealer mid-word. But the action bar answers "is there a table here at all",
+        // and seating somebody is exactly what changes that answer. Without this it
+        // stayed hidden until something else happened to redraw: two players seated, a
+        // dealable hand, and a blank bar until the page was reloaded.
+        //
+        // Safe to do on every keystroke: the bar is small, it's rebuilt on every action
+        // anyway, and nothing inside it can hold focus while the sidebar has it.
+        if (typeof ActionBar !== "undefined" && ActionBar.state) ActionBar.render();
     },
 
     wireSeatFields(form, player, index) {
         const nameInput = form.querySelector(".seatNameInput");
         nameInput.value = player.name;
         nameInput.addEventListener("input", () => {
+            // Putting a name on an empty chair is somebody sitting down, so they get
+            // dealt in. It used to be two separate acts, and the second one was easy to
+            // miss: a dealer setting up typed six names, got six seats that still
+            // weren't in the hand, and the action bar hid itself because by its reckoning
+            // nobody was playing. Six people at the table and a blank screen.
+            //
+            // Only for a chair that was empty — no name and not dealt in. Renaming
+            // somebody who is sitting out is a correction, not an arrival, and dealing
+            // them back in over a typo would be the tool overruling the dealer.
+            const wasEmpty = !player.name.trim() && !player.inHand;
             player.name = nameInput.value;
+            if (wasEmpty && player.name.trim()) {
+                player.inHand = true;
+                player.folded = false;
+                const inHandBox = form.querySelector(".inHandCheckbox");
+                if (inHandBox) inHandBox.checked = true;
+                const foldBox = form.querySelector(".foldCheckbox");
+                if (foldBox) { foldBox.checked = false; foldBox.disabled = false; }
+            }
             document.getElementById("seatEditorTitle").textContent = this.puckLabel(player, index);
             this.commitSeatChange(form, player, index);
         });

tests/holdem/load.js

@@ -29,6 +29,10 @@ globalThis.Render = Render;
 const HoldemState = require(path.join(SRC, "state.js"));
 globalThis.HoldemState = HoldemState;
 
+// actionBar.js after state, since its own module-level code reaches for neither but
+// its methods reach for both. Loaded last so nothing it touches is still undefined.
+const ActionBar = load("actionBar");
+
 // ---- Table builders ----------------------------------------------------------
 
 // A table with `seatCount` chairs where `seated` (a list of seat indexes) are dealt
@@ -81,6 +85,7 @@ module.exports = {
     SettleUp,
     Betting,
     HoldemState,
+    ActionBar,
     makeTable,
     chipsOnTable,
     contributions,

tests/holdem/seatingTheTable.test.js

@@ -0,0 +1,134 @@
+// Sitting people down, which is the first thing anybody does with the tool.
+//
+// Naming a chair and dealing that chair in were two separate acts and the second was
+// easy to miss. A dealer setting up typed six names, got six seats that still weren't
+// in the hand, and the action bar hid itself because by its reckoning nobody was
+// playing: six people at the table and a blank screen with no way forward.
+const test = require("node:test");
+const { describe } = require("node:test");
+const assert = require("node:assert");
+const { HoldemState, Betting, ActionBar, makeTable } = require("./load");
+
+const emptyTable = (seatCount = 10) => {
+    const state = HoldemState.createDefault();
+    HoldemState.resizeSeats(state, seatCount);
+    return state;
+};
+
+const bar = state => Object.assign(Object.create(ActionBar), { state });
+
+describe("the bar knows the difference between an empty table and a named one", () => {
+    test("a table nobody has touched gets no bar", () => {
+        assert.equal(bar(emptyTable()).isRunning(), false, "an empty felt stays uncluttered");
+    });
+
+    test("a table with names on it gets one, dealt in or not", () => {
+        const state = emptyTable();
+        state.seats[0].name = "Ann";
+        state.seats[1].name = "Ben";
+
+        assert.equal(Betting.liveSeats(state).length, 0, "nobody is in the hand");
+        assert.equal(bar(state).isRunning(), true, "but there are people at the table to say something to");
+    });
+
+    test("whitespace isn't a player", () => {
+        const state = emptyTable();
+        state.seats[0].name = "   ";
+        assert.equal(bar(state).isRunning(), false);
+    });
+
+    test("a table that is playing still gets one", () => {
+        assert.equal(bar(makeTable({ seatCount: 6, seated: [0, 1] })).isRunning(), true);
+    });
+});
+
+describe("naming an empty chair sits somebody down", () => {
+    // What the seat editor's name field does, as the rule it applies rather than
+    // through the DOM: a chair with no name and nobody in it is empty, and putting a
+    // name on it is somebody arriving.
+    const nameSeat = (player, name) => {
+        const wasEmpty = !player.name.trim() && !player.inHand;
+        player.name = name;
+        if (wasEmpty && player.name.trim()) { player.inHand = true; player.folded = false; }
+    };
+
+    test("an empty chair gets dealt in", () => {
+        const state = emptyTable();
+        nameSeat(state.seats[0], "Ann");
+        assert.equal(state.seats[0].inHand, true);
+        assert.equal(state.seats[0].folded, false);
+    });
+
+    test("six names is six players, not six benched seats", () => {
+        const state = emptyTable();
+        state.defaultStack = 200;    // a table that has told the tool what a buy-in is
+        ["Ann", "Ben", "Cal", "Dee", "Eve", "Fay"].forEach((name, i) => nameSeat(state.seats[i], name));
+
+        assert.equal(state.seats.filter(p => p.inHand).length, 6);
+        assert.equal(bar(state).isRunning(), true);
+        assert.ok(Betting.blindPreview(state), "and there's a hand to deal");
+    });
+
+    test("renaming somebody who is sitting out doesn't deal them back in", () => {
+        // A correction, not an arrival. Dealing them in over a typo would be the tool
+        // overruling a dealer who sat them out on purpose.
+        const state = emptyTable();
+        state.seats[0].name = "Ann";
+        state.seats[0].inHand = false;
+
+        nameSeat(state.seats[0], "Anne");
+        assert.equal(state.seats[0].inHand, false, "still sitting out, now spelled right");
+    });
+
+    test("clearing a name doesn't sit anybody down", () => {
+        const state = emptyTable();
+        nameSeat(state.seats[0], "Ann");
+        nameSeat(state.seats[0], "");
+        assert.equal(state.seats[0].name, "");
+    });
+
+    test("a chair already in the hand is left alone", () => {
+        const state = makeTable({ seatCount: 6, seated: [0] });
+        state.seats[0].folded = true;
+        nameSeat(state.seats[0], "Ann");
+        assert.equal(state.seats[0].folded, true, "mid-hand a fold is not undone by typing");
+    });
+});
+
+describe("the way back from a table where everybody is sat out", () => {
+    test("there are named seats to offer", () => {
+        // Can't be reached by naming any more, but a table where everyone was sat out
+        // — or a save from before naming seated people — still lands here.
+        const state = emptyTable();
+        ["Ann", "Ben", "Cal"].forEach((name, i) => { state.seats[i].name = name; });
+
+        const benched = state.seats
+            .map((player, index) => ({ player, index }))
+            .filter(({ player }) => (player.name || "").trim() && !player.inHand)
+            .map(({ index }) => index);
+
+        assert.deepEqual(benched, [0, 1, 2]);
+        assert.equal(Betting.blindPreview(state), null, "no hand to deal until they're in");
+    });
+
+    test("dealing them all in makes a hand possible", () => {
+        const state = emptyTable();
+        ["Ann", "Ben", "Cal"].forEach((name, i) => { state.seats[i].name = name; state.seats[i].stack = 100; });
+
+        state.seats.forEach(player => {
+            if ((player.name || "").trim()) { player.inHand = true; player.folded = false; }
+        });
+
+        assert.equal(Betting.liveSeats(state).length, 3);
+        assert.ok(Betting.blindPreview(state), "the table can be dealt");
+    });
+
+    test("an unnamed chair is never swept in by it", () => {
+        const state = emptyTable();
+        state.seats[0].name = "Ann";
+        state.seats.forEach(player => {
+            if ((player.name || "").trim()) { player.inHand = true; }
+        });
+        assert.equal(state.seats.filter(p => p.inHand).length, 1, "empty chairs stay empty");
+    });
+});