Poker bot

// poker.mjs: a Texas Hold'em dealer, one bot per room, with play chips. Each player's two cards go
// to that player alone; the deck stays with the bot, so there is nothing in the room to read.
// Members write "!sit" to take a seat and "!deal" to start. Node 22+. npm install, then npm start
// (reads .env).
//
// Its key (dashboard, New API key): rights subscribe and client_events, kind presence,
// channels: prefix presence-poker-.
//
// Players are told apart by the user_id your backend signed into their join token, which the server
// passes on with each event: {"user_id": "42", "name": "Ada"}. Nothing a player sends says who they are.
//
// Play chips only: no real money and nothing that can be cashed in. Playing for money is gambling,
// and needs a license.
import { Pikoman, TokenSigner } from "@pikoman/ws";
import { bestHand, compare, shuffledDeck } from "./hand.mjs";

const ROOM = process.env.ROOM || "presence-poker-1";
const START_CHIPS = Number(process.env.START_CHIPS || 1000);
const BIG_BLIND = Number(process.env.BIG_BLIND || 20);
const SMALL_BLIND = Math.floor(BIG_BLIND / 2);
const TURN_SECONDS = Number(process.env.TURN_SECONDS || 30);
const PAUSE_SECONDS = Number(process.env.PAUSE_SECONDS || 5); // between two hands
const MAX_SEATS = 8;
const STREETS = { preflop: 3, flop: 1, turn: 1 }; // how many cards each next street puts on the board

const pikoman = new Pikoman(process.env.PIKOMAN_APP, {
  ws_address: process.env.PIKOMAN_WS || "wss://next.pikoman.se",
});
const auth = TokenSigner.fromSecret(process.env.PIKOMAN_API_KEY, { name: "Dealer" }, 3);
const room = pikoman.listenPresence(ROOM, auth);

// A connection may send ten client events a second, so everything waits its turn, nine a second.
// The game goes first and the chat lines after it, so a player sees the next turn at once.
const game = [];
const chat = [];
let waiting = false;
function pump() {
  if (waiting) return;
  const next = game.shift() ?? chat.shift();
  if (!next) return;
  next();
  waiting = true;
  setTimeout(() => {
    waiting = false;
    pump();
  }, 110);
}
const inTurn = (lane, fn) => {
  lane.push(fn);
  queueMicrotask(pump); // after the handler that called it: its table goes before its chat line
};
const tell = (event, data) => inTurn(game, () => room.send(event, data));
const tellUser = (user, event, data) => inTurn(game, () => room.sendTo({ userId: user }, event, data));
const say = (text) => inTurn(chat, () => room.send("message", { text }));

// A seat: { user, name, chips, bet, total, folded, cards }. bet is this street, total this hand.
let seats = [];
let dealer = -1;
let playing = false; // a hand is on
let stage = null;
let deck = [];
let board = [];
let handNumber = 0;
let toCall = 0; // what everyone must have bet on this street
let minRaise = 0;
let toAct = new Set(); // the seats that still have to answer
let turn = -1;
let moveNumber = 0; // a move names the one it answers, so a late or doubled click does nothing
let deadline = 0;
let timer = null;

const live = () => seats.filter((s) => !s.folded);
const connected = (user) => [...room.getMembers().values()].some((m) => String(m?.user_id) === user);

/** What everyone may know, and nothing else: never the deck, never a player's cards. */
function sendTable() {
  tell("table", table());
}

function table() {
  return {
    hand: handNumber,
    stage,
    board,
    pot: seats.reduce((sum, s) => sum + s.total, 0),
    dealer: seats[dealer]?.user ?? null,
    turn: playing && toAct.size ? seats[turn]?.user ?? null : null,
    move: moveNumber,
    toCall,
    minRaise: toCall + minRaise,
    seconds: Math.max(0, Math.ceil((deadline - Date.now()) / 1000)),
    seats: seats.map(({ user, name, chips, bet, folded }) => ({ user, name, chips, bet, folded })),
  };
}

function pay(seat, amount) {
  const paid = Math.min(amount, seat.chips);
  seat.chips -= paid;
  seat.bet += paid;
  seat.total += paid;
}

function startHand() {
  // Whoever is out of chips or has left the room loses the seat. The button moves to the next one that stays.
  const stays = (s) => s.chips > 0 && connected(s.user);
  let next = dealer;
  for (let i = 0; i < seats.length; i++) {
    next = (next + 1) % seats.length;
    if (stays(seats[next])) break;
  }
  const button = seats[next];
  seats = seats.filter(stays);
  if (seats.length < 2) {
    playing = false;
    stage = null;
    board = [];
    for (const s of seats) Object.assign(s, { bet: 0, total: 0, cards: null, folded: true });
    say("Waiting for two players: write !sit, then !deal.");
    return sendTable();
  }
  dealer = seats.indexOf(button);
  playing = true;
  handNumber++;
  stage = "preflop";
  deck = shuffledDeck();
  board = [];
  for (const s of seats) Object.assign(s, { bet: 0, total: 0, folded: false, cards: [deck.pop(), deck.pop()] });

  // Two players: the button is the small blind and acts first before the flop.
  const at = (offset) => (dealer + offset) % seats.length;
  const small = seats.length === 2 ? dealer : at(1);
  const big = at(seats.length === 2 ? 1 : 2);
  pay(seats[small], SMALL_BLIND);
  pay(seats[big], BIG_BLIND);
  toCall = BIG_BLIND;
  minRaise = BIG_BLIND;
  toAct = new Set(seats.filter((s) => s.chips > 0));
  turn = big;

  for (const s of seats) tellUser(s.user, "cards", { hand: handNumber, cards: s.cards });
  say(`Hand ${handNumber}: ${seats[dealer].name} has the button.`);
  advance();
}

/** The next thing that happens: the next player's turn, the next street, or the end of the hand. */
function advance() {
  clearTimeout(timer);
  if (live().length === 1) return finish();
  for (const s of toAct) if (s.chips === 0 || s.folded) toAct.delete(s);
  if (toAct.size === 0) return nextStreet();

  do turn = (turn + 1) % seats.length;
  while (!toAct.has(seats[turn]));
  moveNumber++;
  deadline = Date.now() + TURN_SECONDS * 1000;
  // The bot's clock decides. A player who is gone or asleep checks if they can, and otherwise folds.
  const seat = seats[turn];
  timer = setTimeout(() => {
    say(`${seat.name} ran out of time.`);
    apply(seat, seat.bet === toCall ? "check" : "fold");
  }, TURN_SECONDS * 1000);
  sendTable();
}

function nextStreet() {
  for (const s of seats) s.bet = 0;
  toCall = 0;
  minRaise = BIG_BLIND;
  const cards = STREETS[stage];
  if (!cards) return finish();
  board.push(...deck.splice(-cards));
  stage = { preflop: "flop", flop: "turn", turn: "river" }[stage];
  turn = dealer;
  toAct = new Set(live().filter((s) => s.chips > 0));
  // At most one player can still bet: nobody to bet against, so the rest of the board just comes.
  if (toAct.size < 2) {
    toAct.clear();
    sendTable();
    timer = setTimeout(nextStreet, 1500);
    return;
  }
  advance();
}

function apply(seat, action, amount) {
  clearTimeout(timer);
  if (action === "fold") {
    seat.folded = true;
    say(`${seat.name} folds.`);
  } else if (action === "check") {
    say(`${seat.name} checks.`);
  } else if (action === "call") {
    pay(seat, toCall - seat.bet);
    say(`${seat.name} calls.`);
  } else {
    // A raise is the total to bet this street. A smaller one than minRaise is fine only all in.
    if (amount - toCall >= minRaise) minRaise = amount - toCall;
    pay(seat, amount - seat.bet);
    toCall = amount;
    toAct = new Set(live().filter((s) => s.chips > 0));
    say(`${seat.name} raises to ${amount}.`);
  }
  toAct.delete(seat);
  advance();
}

/** The pots, then the cards of those still in. Folded hands stay hidden, and so does a hand nobody called. */
function finish() {
  clearTimeout(timer);
  const players = live();
  const showdown = players.length > 1;
  const best = new Map(showdown ? players.map((s) => [s, bestHand([...s.cards, ...board])]) : []);

  // One pot per all-in size: a player wins only as much from each other player as they put in.
  const won = new Map();
  const levels = [...new Set(players.map((s) => s.total))].sort((a, b) => a - b);
  let below = 0;
  levels.forEach((level, i) => {
    const top = i === levels.length - 1 ? Infinity : level; // the last pot takes what folded players left above it
    const pot = seats.reduce((sum, s) => sum + Math.min(s.total, top) - Math.min(s.total, below), 0);
    below = level;
    const entitled = players.filter((s) => s.total >= level);
    let winners = [entitled[0]];
    for (const s of entitled.slice(1)) {
      const order = compare(best.get(s).score, best.get(winners[0]).score);
      if (order > 0) winners = [s];
      else if (order === 0) winners.push(s);
    }
    // A split pot's odd chips go to the first winner after the button, one each.
    const afterButton = (s) => (seats.indexOf(s) - dealer - 1 + seats.length) % seats.length;
    winners.sort((a, b) => afterButton(a) - afterButton(b));
    winners.forEach((s, n) => {
      const share = Math.floor(pot / winners.length) + (n < pot % winners.length ? 1 : 0);
      won.set(s, (won.get(s) ?? 0) + share);
    });
  });
  for (const [s, chips] of won) s.chips += chips;

  tell("showdown", {
    hand: handNumber,
    board,
    players: showdown ? players.map((s) => ({ user: s.user, name: s.name, cards: s.cards, hand: best.get(s).name })) : [],
    winners: [...won].map(([s, chips]) => ({ user: s.user, name: s.name, won: chips })),
  });
  for (const [s, chips] of won) {
    say(showdown ? `${s.name} wins ${chips} with ${best.get(s).name}.` : `${s.name} wins ${chips}.`);
  }
  for (const s of seats) Object.assign(s, { bet: 0, total: 0, cards: null, folded: true });
  toAct.clear();
  toCall = 0;
  stage = "between";
  sendTable();
  timer = setTimeout(startHand, PAUSE_SECONDS * 1000);
}

// "!sit" and "!deal" in the room. A seat taken during a hand plays from the next one.
room.onClient("message", (from, data, info) => {
  const text = String(data?.text ?? "").trim();
  if ((text !== "!sit" && text !== "!deal") || room.isBot(from)) return;
  const user = info?.userId;
  if (user === undefined) return tell("message", { text: "Your join token needs a user_id to play." });
  const seated = seats.find((s) => s.user === user);
  if (text === "!sit") {
    if (seated) return;
    if (seats.length >= MAX_SEATS) return say("The table is full.");
    const name = String(room.getMember(from)?.name ?? "Someone").slice(0, 40);
    seats.push({ user, name, chips: START_CHIPS, bet: 0, total: 0, folded: true, cards: null });
    say(`${name} sits down with ${START_CHIPS} chips.`);
    sendTable();
  } else if (seated && !playing) {
    startHand();
  }
});

// A move, sent to the bot alone: room.sendTo(bot, "move", { move: 7, action: "raise", amount: 60 }).
room.onClient("move", (from, data, info) => {
  const seat = seats[turn];
  if (!playing || !toAct.has(seat) || info?.userId !== seat.user || data?.move !== moveNumber) return;
  const { action, amount } = data;
  const most = seat.bet + seat.chips;
  if (action === "fold") apply(seat, "fold");
  else if (action === "check" && seat.bet === toCall) apply(seat, "check");
  else if (action === "call" && seat.bet < toCall) apply(seat, "call");
  else if (action === "raise" && Number.isInteger(amount) && amount > toCall && amount <= most) {
    if (amount - toCall >= minRaise || amount === most) apply(seat, "raise", amount);
  }
});

// Someone joins, or comes back with a new page: the table, and their own cards if they have any.
room.subscribe((_type, _count, id, data) => {
  if (!playing && seats.length === 0) return;
  inTurn(game, () => room.sendTo(id, "table", table()));
  const seat = seats.find((s) => s.user === String(data?.user_id));
  if (seat?.cards) inTurn(game, () => room.sendTo(id, "cards", { hand: handNumber, cards: seat.cards }));
});

room.refused((code) => console.error(`${ROOM}: ${code}`));
console.log(`Dealer in ${ROOM}: ${START_CHIPS} chips, blinds ${SMALL_BLIND}/${BIG_BLIND}`);
pikoman.revoked(() => {
  console.error("The bot's key was deleted.");
  process.exit(1);
});

// hand.mjs: the cards. A card is two letters, rank and suit: "As" is the ace of spades, "Td" the ten
// of diamonds. A hand's strength is a list of numbers, compared from the left.
import { randomInt } from "node:crypto";

const RANKS = "23456789TJQKA";
const SUITS = "shdc";
const NAMES = ["high card", "a pair", "two pair", "three of a kind", "a straight", "a flush", "a full house", "four of a kind", "a straight flush"];

/** A new deck, shuffled with the system's secure random numbers: Math.random can be predicted. */
export function shuffledDeck() {
  const deck = [...RANKS].flatMap((rank) => [...SUITS].map((suit) => rank + suit));
  for (let i = deck.length - 1; i > 0; i--) {
    const j = randomInt(i + 1);
    [deck[i], deck[j]] = [deck[j], deck[i]];
  }
  return deck;
}

/** The strength of exactly five cards: [category, then the ranks that break a tie]. */
function strength(cards) {
  const ranks = cards.map((card) => RANKS.indexOf(card[0])).sort((a, b) => b - a);
  const count = new Map();
  for (const rank of ranks) count.set(rank, (count.get(rank) ?? 0) + 1);
  // The biggest group first, then the highest rank: a full house reads [three's rank, pair's rank].
  const groups = [...count].sort((a, b) => b[1] - a[1] || b[0] - a[0]);
  const shape = groups.map(([, n]) => n).join("");
  const order = groups.map(([rank]) => rank);

  const flush = cards.every((card) => card[1] === cards[0][1]);
  let high = -1; // the top card of a straight
  if (groups.length === 5) {
    if (ranks[0] - ranks[4] === 4) high = ranks[0];
    else if (ranks.join() === "12,3,2,1,0") high = 3; // A-2-3-4-5: the ace counts low, the five is top
  }

  if (flush && high >= 0) return [8, high];
  if (shape === "41") return [7, ...order];
  if (shape === "32") return [6, ...order];
  if (flush) return [5, ...ranks];
  if (high >= 0) return [4, high];
  if (shape === "311") return [3, ...order];
  if (shape === "221") return [2, ...order];
  if (shape === "2111") return [1, ...order];
  return [0, ...ranks];
}

/** Above zero when strength a beats b, zero for a tie. */
export function compare(a, b) {
  for (let i = 0; i < a.length; i++) {
    if (a[i] !== b[i]) return a[i] - b[i];
  }
  return 0;
}

/** The best five of a player's two cards and the board: { score, name }. */
export function bestHand(cards) {
  let score = null;
  for (let skipA = 0; skipA < cards.length; skipA++) {
    for (let skipB = skipA + 1; skipB < cards.length; skipB++) {
      const five = cards.filter((_, i) => i !== skipA && i !== skipB);
      const candidate = strength(five);
      if (!score || compare(candidate, score) > 0) score = candidate;
    }
  }
  return { score, name: NAMES[score[0]] };
}

"""poker.py: a Texas Hold'em dealer, one bot per room, with play chips, in Python. Each player's two
cards go to that player alone; the deck stays with the bot, so there is nothing in the room to read.
Members write "!sit" to take a seat and "!deal" to start. Python 3.10+.
pip install -r requirements.txt, then python poker.py (reads .env).

Its key (dashboard, New API key): rights subscribe and client_events, kind presence,
channels: prefix presence-poker-.

Players are told apart by the user_id your backend signed into their join token, which the server
passes on with each event: {"user_id": "42", "name": "Ada"}. Nothing a player sends says who they are.

Play chips only: no real money and nothing that can be cashed in. Playing for money is gambling,
and needs a license.
"""

import asyncio
import time
from collections import deque

from hand import best_hand, shuffled_deck
from pikoman_bot import Bot, env

ROOM = env("ROOM", "presence-poker-1")
START_CHIPS = int(env("START_CHIPS", "1000"))
BIG_BLIND = int(env("BIG_BLIND", "20"))
SMALL_BLIND = BIG_BLIND // 2
TURN_SECONDS = float(env("TURN_SECONDS", "30"))
PAUSE_SECONDS = float(env("PAUSE_SECONDS", "5"))  # between two hands
MAX_SEATS = 8
STREETS = {"preflop": (3, "flop"), "flop": (1, "turn"), "turn": (1, "river")}  # the next street, and its new cards

bot = Bot("Dealer", access=3)
room = bot.join(ROOM)

# A connection may send ten client events a second, so everything waits its turn, nine a second.
# The game goes first and the chat lines after it, so a player sees the next turn at once.
moves = deque()
chat = deque()
pumping = None  # the task that sends, kept so it is not collected while it runs


async def pump():
    global pumping
    while moves or chat:
        send = moves.popleft() if moves else chat.popleft()
        await send()
        await asyncio.sleep(0.11)
    pumping = None


def in_turn(lane, send):
    global pumping
    lane.append(send)
    if pumping is None:
        pumping = asyncio.create_task(pump())


def tell(event, data):
    in_turn(moves, lambda: room.send(event, data))


def tell_to(member, event, data):
    in_turn(moves, lambda: room.send_to(member, event, data))


def say(text):
    in_turn(chat, lambda: room.send("message", {"text": text}))


class Seat:
    def __init__(self, user, name):
        self.user, self.name = user, name
        self.chips = START_CHIPS
        self.clear()

    def clear(self):
        self.bet = 0  # this street
        self.total = 0  # this hand
        self.folded = True
        self.cards = None

    def pay(self, amount):
        paid = min(amount, self.chips)
        self.chips -= paid
        self.bet += paid
        self.total += paid


class Game:
    def __init__(self):
        self.seats = []
        self.dealer = -1
        self.playing = False  # a hand is on
        self.stage = None
        self.deck = []
        self.board = []
        self.hand = 0
        self.to_call = 0  # what everyone must have bet on this street
        self.min_raise = 0
        self.to_act = set()  # the seats that still have to answer
        self.turn = -1
        self.move = 0  # a move names the one it answers, so a late or doubled click does nothing
        self.deadline = 0
        self.timer = None

    def live(self):
        return [s for s in self.seats if not s.folded]

    def table(self):
        """What everyone may know, and nothing else: never the deck, never a player's cards."""
        turn = self.seats[self.turn].user if self.playing and self.to_act else None
        return {
            "hand": self.hand,
            "stage": self.stage,
            "board": self.board,
            "pot": sum(s.total for s in self.seats),
            "dealer": self.seats[self.dealer].user if 0 <= self.dealer < len(self.seats) else None,
            "turn": turn,
            "move": self.move,
            "toCall": self.to_call,
            "minRaise": self.to_call + self.min_raise,
            "seconds": max(0, round(self.deadline - time.monotonic())),
            "seats": [{"user": s.user, "name": s.name, "chips": s.chips, "bet": s.bet, "folded": s.folded} for s in self.seats],
        }

    def later(self, seconds, fn):
        self.cancel()
        self.timer = asyncio.get_running_loop().call_later(seconds, fn)

    def cancel(self):
        if self.timer:
            self.timer.cancel()
            self.timer = None

    def start_hand(self):
        # Whoever is out of chips or has left the room loses the seat. The button moves to the next one that stays.
        here = {str(m.get("user_id")) for m in room.members.values() if isinstance(m, dict)}

        def stays(s):
            return s.chips > 0 and s.user in here

        button = None
        for i in range(1, len(self.seats) + 1):
            seat = self.seats[(self.dealer + i) % len(self.seats)]
            if stays(seat):
                button = seat
                break
        self.seats = [s for s in self.seats if stays(s)]
        if len(self.seats) < 2:
            self.playing = False
            self.stage = None
            self.board = []
            for s in self.seats:
                s.clear()
            say("Waiting for two players: write !sit, then !deal.")
            return tell("table", self.table())
        self.dealer = self.seats.index(button)
        self.playing = True
        self.hand += 1
        self.stage = "preflop"
        self.deck = shuffled_deck()
        self.board = []
        for s in self.seats:
            s.clear()
            s.folded = False
            s.cards = [self.deck.pop(), self.deck.pop()]

        # Two players: the button is the small blind and acts first before the flop.
        count = len(self.seats)
        small = self.dealer if count == 2 else (self.dealer + 1) % count
        big = (self.dealer + (1 if count == 2 else 2)) % count
        self.seats[small].pay(SMALL_BLIND)
        self.seats[big].pay(BIG_BLIND)
        self.to_call = BIG_BLIND
        self.min_raise = BIG_BLIND
        self.to_act = {s for s in self.seats if s.chips > 0}
        self.turn = big

        for s in self.seats:
            tell_to({"user_id": s.user}, "cards", {"hand": self.hand, "cards": s.cards})
        say(f"Hand {self.hand}: {self.seats[self.dealer].name} has the button.")
        self.advance()

    def advance(self):
        """The next thing that happens: the next player's turn, the next street, or the end of the hand."""
        self.cancel()
        if len(self.live()) == 1:
            return self.finish()
        self.to_act = {s for s in self.to_act if s.chips > 0 and not s.folded}
        if not self.to_act:
            return self.next_street()

        self.turn = (self.turn + 1) % len(self.seats)
        while self.seats[self.turn] not in self.to_act:
            self.turn = (self.turn + 1) % len(self.seats)
        self.move += 1
        self.deadline = time.monotonic() + TURN_SECONDS
        # The bot's clock decides. A player who is gone or asleep checks if they can, and otherwise folds.
        seat = self.seats[self.turn]

        def out_of_time():
            say(f"{seat.name} ran out of time.")
            self.apply(seat, "check" if seat.bet == self.to_call else "fold")

        self.later(TURN_SECONDS, out_of_time)
        tell("table", self.table())

    def next_street(self):
        for s in self.seats:
            s.bet = 0
        self.to_call = 0
        self.min_raise = BIG_BLIND
        if self.stage not in STREETS:
            return self.finish()
        cards, self.stage = STREETS[self.stage]
        self.board = self.board + [self.deck.pop() for _ in range(cards)]
        self.turn = self.dealer
        self.to_act = {s for s in self.live() if s.chips > 0}
        # At most one player can still bet: nobody to bet against, so the rest of the board just comes.
        if len(self.to_act) < 2:
            self.to_act = set()
            tell("table", self.table())
            return self.later(1.5, self.next_street)
        self.advance()

    def apply(self, seat, action, amount=0):
        self.cancel()
        if action == "fold":
            seat.folded = True
            say(f"{seat.name} folds.")
        elif action == "check":
            say(f"{seat.name} checks.")
        elif action == "call":
            seat.pay(self.to_call - seat.bet)
            say(f"{seat.name} calls.")
        else:
            # A raise is the total to bet this street. A smaller one than min_raise is fine only all in.
            if amount - self.to_call >= self.min_raise:
                self.min_raise = amount - self.to_call
            seat.pay(amount - seat.bet)
            self.to_call = amount
            self.to_act = {s for s in self.live() if s.chips > 0}
            say(f"{seat.name} raises to {amount}.")
        self.to_act.discard(seat)
        self.advance()

    def finish(self):
        """The pots, then the cards of those still in. Folded hands stay hidden, and so does a hand nobody called."""
        self.cancel()
        players = self.live()
        showdown = len(players) > 1
        best = {s: best_hand(s.cards + self.board) if len(self.board) == 5 else (None, "") for s in players}

        def after_button(s):
            return (self.seats.index(s) - self.dealer - 1) % len(self.seats)

        # One pot per all-in size: a player wins only as much from each other player as they put in.
        won = {}
        levels = sorted({s.total for s in players})
        below = 0
        for i, level in enumerate(levels):
            top = float("inf") if i == len(levels) - 1 else level  # the last pot takes what folded players left above it
            pot = sum(min(s.total, top) - min(s.total, below) for s in self.seats)
            below = level
            entitled = [s for s in players if s.total >= level]
            if showdown:
                high = max(best[s][0] for s in entitled)
                winners = [s for s in entitled if best[s][0] == high]
            else:
                winners = entitled
            # A split pot's odd chips go to the first winner after the button, one each.
            winners.sort(key=after_button)
            for n, s in enumerate(winners):
                won[s] = won.get(s, 0) + pot // len(winners) + (1 if n < pot % len(winners) else 0)
        for s, chips in won.items():
            s.chips += chips

        tell("showdown", {
            "hand": self.hand,
            "board": self.board,
            "players": [{"user": s.user, "name": s.name, "cards": s.cards, "hand": best[s][1]} for s in players] if showdown else [],
            "winners": [{"user": s.user, "name": s.name, "won": chips} for s, chips in won.items()],
        })
        for s, chips in won.items():
            say(f"{s.name} wins {chips} with {best[s][1]}." if showdown else f"{s.name} wins {chips}.")
        for s in self.seats:
            s.clear()
        self.to_act = set()
        self.to_call = 0
        self.stage = "between"
        tell("table", self.table())
        self.later(PAUSE_SECONDS, self.start_hand)


game = Game()


# "!sit" and "!deal" in the room. A seat taken during a hand plays from the next one.
@room.on("message")
def message(sender, data, info):
    text = str((data or {}).get("text", "")).strip()
    if text not in ("!sit", "!deal") or room.is_bot(sender):
        return
    user = info.get("user_id")
    if user is None:
        return say("Your join token needs a user_id to play.")
    seated = next((s for s in game.seats if s.user == user), None)
    if text == "!sit":
        if seated:
            return
        if len(game.seats) >= MAX_SEATS:
            return say("The table is full.")
        name = str(room.member(sender).get("name", "Someone"))[:40]
        game.seats.append(Seat(user, name))
        say(f"{name} sits down with {START_CHIPS} chips.")
        tell("table", game.table())
    elif seated and not game.playing:
        game.start_hand()


# A move, sent to the bot alone: room.sendTo(bot, "move", { move: 7, action: "raise", amount: 60 }).
@room.on("move")
def move(sender, data, info):
    if not game.playing or not game.to_act or not isinstance(data, dict):
        return
    seat = game.seats[game.turn]
    if seat not in game.to_act or info.get("user_id") != seat.user or data.get("move") != game.move:
        return
    action, amount = data.get("action"), data.get("amount")
    most = seat.bet + seat.chips
    if action == "fold":
        game.apply(seat, "fold")
    elif action == "check" and seat.bet == game.to_call:
        game.apply(seat, "check")
    elif action == "call" and seat.bet < game.to_call:
        game.apply(seat, "call")
    elif action == "raise" and type(amount) is int and game.to_call < amount <= most:
        if amount - game.to_call >= game.min_raise or amount == most:
            game.apply(seat, "raise", amount)


# Someone joins, or comes back with a new page: the table, and their own cards if they have any.
@room.on_join
def joined(connection, data):
    if not game.playing and not game.seats:
        return
    tell_to(connection, "table", game.table())
    user = str(data.get("user_id")) if isinstance(data, dict) else None
    seat = next((s for s in game.seats if s.user == user), None)
    if seat and seat.cards:
        tell_to(connection, "cards", {"hand": game.hand, "cards": seat.cards})


print(f"Dealer in {ROOM}: {START_CHIPS} chips, blinds {SMALL_BLIND}/{BIG_BLIND}")
bot.start()

"""hand.py: the cards. A card is two letters, rank and suit: "As" is the ace of spades, "Td" the ten
of diamonds. A hand's strength is a tuple of numbers, and Python compares tuples from the left.
"""

import secrets
from collections import Counter
from itertools import combinations

RANKS = "23456789TJQKA"
SUITS = "shdc"
NAMES = ["high card", "a pair", "two pair", "three of a kind", "a straight", "a flush", "a full house", "four of a kind", "a straight flush"]


def shuffled_deck():
    """A new deck, shuffled with the system's secure random numbers: random.shuffle can be predicted."""
    deck = [rank + suit for rank in RANKS for suit in SUITS]
    secrets.SystemRandom().shuffle(deck)
    return deck


def strength(cards):
    """The strength of exactly five cards: (category, then the ranks that break a tie)."""
    ranks = sorted((RANKS.index(card[0]) for card in cards), reverse=True)
    # The biggest group first, then the highest rank: a full house reads (three's rank, pair's rank).
    groups = sorted(Counter(ranks).items(), key=lambda group: (-group[1], -group[0]))
    shape = [n for _, n in groups]
    order = [rank for rank, _ in groups]

    flush = all(card[1] == cards[0][1] for card in cards)
    high = -1  # the top card of a straight
    if len(groups) == 5:
        if ranks[0] - ranks[4] == 4:
            high = ranks[0]
        elif ranks == [12, 3, 2, 1, 0]:  # A-2-3-4-5: the ace counts low, the five is top
            high = 3

    if flush and high >= 0:
        return (8, high)
    if shape == [4, 1]:
        return (7, *order)
    if shape == [3, 2]:
        return (6, *order)
    if flush:
        return (5, *ranks)
    if high >= 0:
        return (4, high)
    if shape == [3, 1, 1]:
        return (3, *order)
    if shape == [2, 2, 1]:
        return (2, *order)
    if shape == [2, 1, 1, 1]:
        return (1, *order)
    return (0, *ranks)


def best_hand(cards):
    """The best five of a player's two cards and the board: (score, name)."""
    score = max(strength(five) for five in combinations(cards, 5))
    return score, NAMES[score[0]]

// page.js: the poker table on a player's page. Your own cards come to you alone; everything else
// is what the bot tells the room. Trust only the bot: room.isBot(from) is set by the server, never
// by a member. `room` is the presence channel your page already joined:
// pikoman.listenPresence("presence-poker-1"). `me` is the user_id your backend signed for this player.
const SUITS = { s: "♠", h: "♥", d: "♦", c: "♣" };
const show = (card) => (card[0] === "T" ? "10" : card[0]) + SUITS[card[1]];

export function playPoker(room, box, me) {
  const line = () => box.appendChild(document.createElement("p"));
  let mine = [];
  let last = null;

  const bot = () => [...room.getBots().keys()][0];
  const button = (text, parent, click) => {
    const b = parent.appendChild(Object.assign(document.createElement("button"), { type: "button", textContent: text }));
    b.addEventListener("click", click);
    return b;
  };
  const move = (action, amount) => room.sendTo(bot(), "move", { move: last.move, action, amount });

  function draw(t) {
    last = t;
    box.replaceChildren();
    line().textContent = `Board: ${t.board.map(show).join(" ") || "none yet"}. Pot: ${t.pot}.`;
    const seats = box.appendChild(document.createElement("ul"));
    for (const s of t.seats) {
      const marks = [s.user === t.dealer && "button", s.user === t.turn && "to act", s.folded && t.stage !== "between" && "folded"];
      seats.appendChild(document.createElement("li")).textContent =
        `${s.name}: ${s.chips} chips, bet ${s.bet} ${marks.filter(Boolean).join(", ")}`;
    }
    const seat = t.seats.find((s) => s.user === me);
    line().textContent = mine.length ? `Your cards: ${mine.map(show).join(" ")}` : "";

    if (!seat) return button("Take a seat", box, () => room.send("message", { text: "!sit" }));
    if (t.stage === null) return button("Deal", box, () => room.send("message", { text: "!deal" }));
    if (t.turn !== me) return;

    const owed = t.toCall - seat.bet;
    button("Fold", box, () => move("fold"));
    if (owed > 0) button(`Call ${Math.min(owed, seat.chips)}`, box, () => move("call"));
    else button("Check", box, () => move("check"));
    const most = seat.bet + seat.chips;
    if (most > t.toCall) {
      const amount = box.appendChild(Object.assign(document.createElement("input"), {
        type: "number",
        min: Math.min(t.minRaise, most),
        max: most,
        value: Math.min(t.minRaise, most),
      }));
      amount.setAttribute("aria-label", "Raise to");
      button("Raise to", box, () => move("raise", Number(amount.value)));
    }
  }

  room.onClient("table", (from, table) => {
    if (room.isBot(from)) draw(table);
  });
  room.onClient("cards", (from, { cards }, info) => {
    if (!room.isBot(from) || !info?.direct) return;
    mine = cards;
    if (last) draw(last);
  });
  room.onClient("showdown", (from, { players, winners }) => {
    if (!room.isBot(from)) return;
    mine = [];
    if (last) draw(last);
    for (const p of players) line().textContent = `${p.name}: ${p.cards.map(show).join(" ")}, ${p.hand}`;
    for (const w of winners) line().textContent = `${w.name} wins ${w.won}.`;
  });
}