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

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

    // 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 = JSON.parse(JSON.stringify(state));
        mutate(state.seats[index], index);
        HoldemState.save(state);
        Render.renderAll();

        Toast.show(message, {
            actionLabel: "Undo",
            onAction: () => {
                Object.keys(state).forEach(key => delete state[key]);
                Object.assign(state, snapshot);
                HoldemState.save(state);
                Render.renderAll();
                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),
    };

    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 dealtIn = state.seats[index].inHand;
            seatAction(index, dealtIn ? `${nameOf(index)} sits out.` : `${nameOf(index)} is dealt in.`, p => {
                p.inHand = !dealtIn;
                if (!p.inHand) p.folded = false;
            });
        },
        makeDealer: index => seatAction(index, `Button on ${nameOf(index)}.`, () => { state.dealerSeatIndex = index; }),
        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 = Math.round((Betting.stackOf(state, player) + amount) * 100) / 100;
                player.buyIns = Math.round(((Number(player.buyIns) || 0) + amount) * 100) / 100;
            });
        }),
    };

    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: JSON.parse(JSON.stringify(state)) });
            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;
            Object.keys(state).forEach(key => delete state[key]);
            Object.assign(state, step.snapshot);
            hooks.save(state);
            Render.renderAll();
            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 = JSON.parse(JSON.stringify(state));
        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: () => {
                Object.keys(state).forEach(key => delete state[key]);
                Object.assign(state, snapshot);
                hooks.save(state);
                Render.renderAll();
                Toast.show("Undone.", { duration: 2500 });
            },
        });
    };

    document.getElementById("seatCountInput").addEventListener("change", e => {
        HoldemState.resizeSeats(state, Number(e.target.value));
        hooks.save(state);
        Render.renderAll();
    });

    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));
    });
});