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

document.addEventListener("DOMContentLoaded", () => {
    const state = HoldemState.load();

    // Undo works by swapping the whole table back to a snapshot. `state` is handed out
    // by reference to every module at mount time, so it has to be refilled in place —
    // reassigning the variable would leave the renderer and the betting bar pointing at
    // the old object and quietly ignoring the undo.
    const snapshotState = () => JSON.parse(JSON.stringify(state));

    const restoreState = snapshot => {
        Object.keys(state).forEach(key => delete state[key]);
        Object.assign(state, snapshot);
        HoldemState.save(state);
        Render.renderAll();
    };

    // A gesture on a seat is a shortcut for something the dealer could do the long
    // way, so each one is undoable the same way the header buttons are.
    const seatAction = (index, message, mutate) => {
        const snapshot = snapshotState();
        mutate(state.seats[index], index);
        HoldemState.save(state);
        Render.renderAll();

        Toast.show(message, {
            actionLabel: "Undo",
            onAction: () => {
                restoreState(snapshot);
                Toast.show("Undone.", { duration: 2500 });
            },
            duration: 6000,
        });
    };

    const nameOf = index => HoldemState.displayName(state.seats[index], index);

    const hooks = {
        save: s => HoldemState.save(s),
        rerender: () => Render.renderAll(),

        onSeatDoubleTap: index => {
            const player = state.seats[index];
            if (!player.inHand) return;
            if (player.folded) {
                seatAction(index, `${nameOf(index)} is back in the hand.`, p => { p.folded = false; });
                return;
            }
            seatAction(index, `${nameOf(index)} folds.`, () => {
                if (state.actingSeatIndex === index) Betting.fold(state, index);
                else player.folded = true;
            });
        },

        onSeatLongPress: index => SeatMenu.open(state, seatMenuHooks, index),
        onGiveButton: index => seatMenuHooks.makeDealer(index),
    };

    const seatMenuHooks = {
        fold: index => hooks.onSeatDoubleTap(index),
        unfold: index => seatAction(index, `${nameOf(index)} is back in the hand.`, p => { p.folded = false; }),
        allIn: index => seatAction(index, `${nameOf(index)} is all-in.`, () => Betting.allIn(state, index)),
        toggleDealtIn: index => {
            const player = state.seats[index];
            const dealtIn = player.inHand;
            const handRunning = !Betting.onlyBlindsIn(state) || Betting.potSoFar(state) > 0;
            const alreadyIn = Betting.handTotal(player);

            // Somebody walking away mid-hand doesn't get their chips back — they're
            // dead money the winner collects. Say so, because the pot total pointedly
            // does not go down and a dealer needs to know that's deliberate.
            const message = dealtIn
                ? (alreadyIn > 0
                    ? `${nameOf(index)} is out — their ${Money.format(alreadyIn)} stays in the pot.`
                    : `${nameOf(index)} sits out.`)
                : (handRunning
                    ? `${nameOf(index)} is in from the next hand.`
                    : `${nameOf(index)} is dealt in.`);

            seatAction(index, message, p => {
                p.inHand = !dealtIn;
                if (!p.inHand) {
                    // Their chips stay put; only the fold flag is cleared, since being
                    // out of the hand already covers not winning it.
                    p.folded = false;
                    if (state.actingSeatIndex === index) Betting.passAction(state, index);
                } else if (handRunning) {
                    // Joining a hand already in progress means sitting this one out —
                    // you can't buy into a pot you haven't been paying for. `folded`
                    // is exactly that state, and the next hand clears it.
                    p.folded = true;
                }
            });
        },

        makeDealer: index => seatAction(index, `Button on ${nameOf(index)}.`, () => {
            state.dealerSeatIndex = index;
            // Before anyone has acted the blinds are still just sitting there, so
            // moving the button moves them too — a home game passes it round several
            // times before the cards come out, and the posted chips have to follow.
            if (Betting.onlyBlindsIn(state)) Betting.repostBlinds(state);
        }),

        assignBlind: (index, which) => {
            const blinds = HoldemState.getBlindSeats(state);
            const other = which === "sb" ? blinds.bbIndex : blinds.sbIndex;
            // Naming one blind pins the other where it already is, so the dealer only
            // has to state the part they're changing. If that would land both on one
            // player, the other blind moves to the next seat along.
            let partner = other !== null && other !== undefined && other !== index
                ? other
                : Betting.nextLiveIndex(state, index);
            if (partner === index || partner === null) partner = Betting.nextLiveIndex(state, index);

            const label = which === "sb" ? "small blind" : "big blind";
            seatAction(index, `${nameOf(index)} posts the ${label}.`, () => {
                state.blindOverride = which === "sb"
                    ? { sbIndex: index, bbIndex: partner }
                    : { sbIndex: partner, bbIndex: index };
                if (Betting.onlyBlindsIn(state)) Betting.repostBlinds(state);
            });
        },

        clearBlindOverride: () => seatAction(state.dealerSeatIndex, "Blinds follow the button again.", () => {
            state.blindOverride = null;
            if (Betting.onlyBlindsIn(state)) Betting.repostBlinds(state);
        }),

        editSeat: index => Render.toggleSeatEditor(index),

        addChips: index => AddChips.open(state, index, (seatIndex, amount) => {
            seatAction(seatIndex, `${nameOf(seatIndex)} added ${Money.format(amount)}.`, player => {
                // Chips in front and cash in are different questions — the stack moves
                // every hand, what they've handed over only moves when they buy.
                player.stack = Money.round(Betting.stackOf(state, player) + amount);
                player.buyIns = Money.round((Number(player.buyIns) || 0) + amount);
            });
        }),
    };

    Render.mount(state, hooks);

    const openPotWizard = () => {
        // Chips still in front of players belong in the pot being priced, so bank them
        // before the wizard reads anyone's contribution.
        Betting.sweepToHandTotals(state);
        hooks.save(state);
        Render.renderAll();

        PotWizard.open(state, payouts => {
            const paid = payouts.map(p => `${p.label} ${Money.format(p.amount)}`).join(", ");
            runUndoable(paid ? `Paid ${paid}.` : "Hand closed with nothing to pay out.", () => {
                if (payouts.length > 0) {
                    HoldemState.recordHand(state, payouts);
                    // Winnings go straight back in front of the player, so the next
                    // hand's stacks are already right.
                    Betting.creditWinnings(state, payouts);
                }
                HoldemState.startNextHand(state);
                Betting.beginHand(state);
            });
        });
    };

    // A short history of actions taken from the bar, so a misclicked Fold can be taken
    // back — and the one before it, since a dealer usually notices a beat late. Kept in
    // memory only: this is for the mistake you just made, not last night's hand.
    const MAX_UNDO_STEPS = 12;
    const actionHistory = [];

    ActionBar.mount(state, {
        save: hooks.save,
        rerender: hooks.rerender,
        resolvePot: openPotWizard,

        beginAction: label => {
            actionHistory.push({ label, snapshot: snapshotState() });
            if (actionHistory.length > MAX_UNDO_STEPS) actionHistory.shift();
        },

        lastActionLabel: () => (actionHistory.length ? actionHistory[actionHistory.length - 1].label : null),

        undoLast: () => {
            const step = actionHistory.pop();
            if (!step) return;
            restoreState(step.snapshot);
            Toast.show(`Took back ${step.label}.`, { duration: 2500 });
        },
    });

    // Anything that ends the hand makes the per-action history meaningless — the
    // snapshots refer to a hand that no longer exists.
    const clearActionHistory = () => { actionHistory.length = 0; };

    // Keyboard shortcuts press the very same buttons a dealer would tap, rather than
    // calling the betting engine themselves — there's no second code path to drift out
    // of step with what the bar is actually offering right now.
    const pressInBar = selector => {
        const btn = document.querySelector(`#actionBar ${selector}`);
        if (!btn || btn.disabled) return false;
        btn.click();
        return true;
    };

    const quickRaiseButton = label =>
        [...document.querySelectorAll("#actionBar .raiseQuickBtn")]
            .find(b => b.querySelector(".actionBtnLabel").textContent === label);

    Shortcuts.mount({
        fold: () => pressInBar(".actionFold"),
        checkOrCall: () => pressInBar(".actionCheck") || pressInBar(".actionCall"),
        raise: () => pressInBar(".actionRaise"),
        allIn: () => {
            // Open the raise pad first if it isn't already, then take its All-in amount.
            if (!document.querySelector("#actionBar .raisePad") && !pressInBar(".actionRaise")) return false;
            const quick = quickRaiseButton("All-in");
            if (!quick) return false;
            quick.click();
            return true;
        },
        // Enter confirms a raise if one is being entered, otherwise moves the hand on.
        advance: () => pressInBar(".raiseConfirm") || pressInBar(".actionAdvance"),
        undo: () => pressInBar(".actionUndo"),
        cancel: () => pressInBar(".raiseCancel"),
    });

    // Moving to the next hand used to ask "are you sure?" every single time —
    // the most-pressed button in a session, gated behind a system dialog. It now
    // just happens, and the toast offers the way back for the few seconds anyone
    // would notice a misclick. The snapshot is deliberately in-memory only: an
    // undo is for the mistake you just made, not one from last night's session.
    const runUndoable = (message, mutate) => {
        const snapshot = snapshotState();
        mutate();
        // Starting or settling a hand invalidates the per-action history: those
        // snapshots describe a hand that's over. The whole-step Undo below replaces it.
        clearActionHistory();
        hooks.save(state);
        Render.renderAll();

        Toast.show(message, {
            actionLabel: "Undo",
            onAction: () => {
                restoreState(snapshot);
                Toast.show("Undone.", { duration: 2500 });
            },
        });
    };

    // A seat that has anything of a player in it — a name, chips, cash in, or a hand
    // in progress. Shrinking the table throws these away permanently, and it also
    // orphans them in the session standings, where they keep their winnings but lose
    // the stack and buy-in the settle-up is worked out from.
    const seatHasSomeoneIn = player =>
        !!(player.name && player.name.trim()) ||
        player.inHand ||
        (Number(player.stack) || 0) > 0 ||
        (Number(player.buyIns) || 0) > 0 ||
        (Number(player.amountOverride) || 0) > 0;

    document.getElementById("seatCountInput").addEventListener("change", async e => {
        const requested = Math.max(2, Math.min(24, Math.floor(Number(e.target.value)) || state.seatCount));
        const losing = state.seats.slice(requested).filter(seatHasSomeoneIn);

        if (losing.length > 0) {
            const who = losing
                .map((p, i) => HoldemState.displayName(p, requested + state.seats.slice(requested).indexOf(p)))
                .join(", ");
            const ok = await Dialog.confirm({
                title: `Remove ${losing.length} ${losing.length === 1 ? "player" : "players"}?`,
                message: `Going down to ${requested} seats takes ${who} off the table along with their chips and buy-ins, and their session totals stop adding up.`,
                confirmLabel: "Remove them",
                danger: true,
            });
            if (!ok) {
                e.target.value = state.seatCount;
                return;
            }
        }

        runUndoable(`Table set to ${requested} seats.`, () => HoldemState.resizeSeats(state, requested));
    });

    document.getElementById("directionSelect").addEventListener("change", e => {
        state.direction = e.target.value;
        hooks.save(state);
        Render.renderSeats();
    });

    document.getElementById("basePotInput").addEventListener("input", e => {
        state.basePotAmount = e.target.value === "" ? null : Number(e.target.value);
        hooks.save(state);
        Render.renderAll();
    });

    document.getElementById("dedicatedDealerToggle").addEventListener("change", e => {
        state.dedicatedDealer = e.target.checked;
        hooks.save(state);
        Render.renderSeats();
        Render.renderTableHint();
    });

    document.getElementById("tableNotes").addEventListener("input", e => {
        state.notes = e.target.value;
        hooks.save(state);
    });

    document.getElementById("addChipColorBtn").addEventListener("click", () => {
        state.chipLegend.push({
            id: HoldemState.makeId("chip"),
            color: "#888888",
            value: 1,
        });
        hooks.save(state);
        Render.renderAll();
    });

    document.getElementById("nextHandBtn").addEventListener("click", () => {
        // startNextHand moves the button on by one; say where it landed so the
        // dealer can confirm the rotation without hunting for the badge.
        const nextDealer = HoldemState.nextSeatIndex(state, state.dealerSeatIndex, 1);
        const where = state.dedicatedDealer
            ? `small blind on seat ${HoldemState.nextSeatIndex(state, nextDealer, 1) + 1}`
            : `button on seat ${nextDealer + 1}`;

        runUndoable(`Next hand — ${where}. Blinds posted.`, () => {
            HoldemState.startNextHand(state);
            Betting.beginHand(state);
        });
    });

    document.getElementById("resetTableBtn").addEventListener("click", async () => {
        const ok = await Dialog.confirm({
            title: "Reset the whole table?",
            message: "Every seat, chip colour and note goes back to defaults. The hand history and session standings are cleared too.",
            confirmLabel: "Reset table",
            danger: true,
        });
        if (!ok) return;

        HoldemState.clear();
        Object.assign(state, HoldemState.createDefault());
        clearActionHistory();
        Render.mount(state, hooks);
        Toast.show("Table reset.", { duration: 2500 });
    });

    document.getElementById("resolvePotBtn").addEventListener("click", openPotWizard);

    [
        ["smallBlindInput", "smallBlind"],
        ["bigBlindInput", "bigBlind"],
        ["defaultStackInput", "defaultStack"],
    ].forEach(([id, key]) => {
        document.getElementById(id).addEventListener("input", e => {
            state[key] = e.target.value === "" ? null : Number(e.target.value);
            hooks.save(state);
            Render.renderAll();
        });
    });

    document.getElementById("closeSeatEditorBtn").addEventListener("click", () => Render.closeSeatEditor());

    document.getElementById("addChipsConfirmBtn").addEventListener("click", () => AddChips.confirm());
    document.getElementById("addChipsCancelBtn").addEventListener("click", () => AddChips.close());
    document.getElementById("addChipsOverlay").addEventListener("click", e => {
        if (e.target.id === "addChipsOverlay") AddChips.close();
    });
    document.getElementById("addChipsInput").addEventListener("keydown", e => {
        if (e.key === "Enter") AddChips.confirm();
    });

    const rulingsOverlay = document.getElementById("rulingsOverlay");
    const closeRulings = () => { rulingsOverlay.hidden = true; };
    document.getElementById("openRulingsBtn").addEventListener("click", () => { rulingsOverlay.hidden = false; });
    document.getElementById("closeRulingsBtn").addEventListener("click", closeRulings);
    rulingsOverlay.addEventListener("click", e => {
        if (e.target === rulingsOverlay) closeRulings();
    });
    document.addEventListener("keydown", e => {
        if (e.key === "Escape" && !rulingsOverlay.hidden) closeRulings();
    });

    document.getElementById("seatMenuCancelBtn").addEventListener("click", () => SeatMenu.close());
    document.getElementById("seatMenuOverlay").addEventListener("click", e => {
        if (e.target.id === "seatMenuOverlay") SeatMenu.close();
    });

    document.getElementById("cardPickerCloseBtn").addEventListener("click", () => CardPicker.close());
    document.getElementById("cardPickerClearBtn").addEventListener("click", () => CardPicker.clearSlot());
    document.getElementById("cardPickerOverlay").addEventListener("click", e => {
        if (e.target.id === "cardPickerOverlay") CardPicker.close();
    });

    document.getElementById("closePotWizardBtn").addEventListener("click", () => PotWizard.close());
    document.getElementById("potWizardOverlay").addEventListener("click", e => {
        if (e.target.id === "potWizardOverlay") PotWizard.close();
    });

    document.getElementById("clearHistoryBtn").addEventListener("click", async () => {
        const ok = await Dialog.confirm({
            title: "Clear the hand history?",
            message: "This wipes every logged hand and the session standings, and puts the hand counter back to #1. Export first if anyone might want the numbers.",
            confirmLabel: "Clear history",
            danger: true,
        });
        if (!ok) return;

        HoldemState.clearHistory(state);
        hooks.save(state);
        Render.renderAll();
        Toast.show("Hand history cleared.", { duration: 2500 });
    });

    document.getElementById("exportHistoryBtn").addEventListener("click", () => {
        if ((state.handHistory || []).length === 0) return;
        HandHistoryExport.download(state.handHistory, HoldemState.sessionStandings(state));
    });
});