Add CPU opponents and a table type selector (cash only / friends / CPU)

- Create screen: choose キャッシュオンリー (real cards, chips only), 友人戦
  (server deals and settles) or CPU戦 (友人戦 plus 1–8 CPU players); replaces
  the card toggle. The lobby shows each table's type
- Poker AI written from scratch (server/ai.js, no libraries): fast 7-card
  evaluator (checked against bestHand), Monte Carlo equity, and decisions from
  hand rank, pot odds, raise count, opponents and a per-CPU style (aggression,
  bluff rate); continuation bets via the last aggressor. It never sees other
  players' hole cards
- CPU seats: think time of 0.7–1.8s (faster when no human is left in the hand),
  automatic rebuy, never the host, no new hand unless a human is playing,
  re-think after pause
- Play UI: robot avatars and a "考えています…" status for CPU turns
- Tests for the evaluator, equity, legality of AI actions and CPU tables

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

server/ai.js

@@ -0,0 +1,213 @@
+'use strict';
+
+// CPU プレイヤーの思考。
+// モンテカルロで「残っている相手に勝つ確率（エクイティ）」を見積もり、
+// ポットオッズ・ポジション・その CPU の性格（攻撃性・ブラフ頻度）から行動を決める。
+// 相手の手札は見ない（自分の手札と場札、公開されているベット状況だけを使う）。
+
+const RANKS = '23456789TJQKA';
+const SUITS = 'shdc';
+
+// "As" → 0〜51（rank * 4 + suit）
+const toInt = (c) => RANKS.indexOf(c[0]) * 4 + SUITS.indexOf(c[1]);
+
+// 13ビットのランクの集合から最も高いストレートの上端（0〜12）。無ければ -1
+function straightHigh(mask) {
+  for (let h = 12; h >= 4; h--) {
+    const need = 0b11111 << (h - 4);
+    if ((mask & need) === need) return h;
+  }
+  // A-2-3-4-5
+  if ((mask & 0b1000000001111) === 0b1000000001111) return 3;
+  return -1;
+}
+
+// [役, 比較用の数字...] を1つの整数にする（大きいほど強い）
+function encode(category, kickers) {
+  let v = category;
+  for (let i = 0; i < 5; i++) v = v * 16 + (kickers[i] === undefined ? 0 : kickers[i] + 1);
+  return v;
+}
+
+// 上位から n 個のランク（mask のビット）
+function topRanks(mask, n, exclude = []) {
+  const out = [];
+  for (let r = 12; r >= 0 && out.length < n; r--) if (mask & (1 << r) && !exclude.includes(r)) out.push(r);
+  return out;
+}
+
+// 5〜7枚（整数）の最強の役の強さ。cards.js の bestHand と同じ順序になる（テストで確認）
+function evaluate(cards) {
+  const counts = new Array(13).fill(0);
+  const suitCount = [0, 0, 0, 0];
+  const suitMask = [0, 0, 0, 0];
+  let mask = 0;
+  for (const c of cards) {
+    const r = c >> 2;
+    const s = c & 3;
+    counts[r]++;
+    suitCount[s]++;
+    suitMask[s] |= 1 << r;
+    mask |= 1 << r;
+  }
+
+  let flushMask = 0;
+  for (let s = 0; s < 4; s++) if (suitCount[s] >= 5) flushMask = suitMask[s];
+  if (flushMask) {
+    const sf = straightHigh(flushMask);
+    if (sf >= 0) return encode(8, [sf]);
+  }
+
+  let quad = -1;
+  const trips = [];
+  const pairs = [];
+  for (let r = 12; r >= 0; r--) {
+    if (counts[r] === 4) quad = r;
+    else if (counts[r] === 3) trips.push(r);
+    else if (counts[r] === 2) pairs.push(r);
+  }
+  if (quad >= 0) return encode(7, [quad, topRanks(mask, 1, [quad])[0]]);
+  if (trips.length && (trips.length > 1 || pairs.length)) {
+    const pair = Math.max(trips[1] === undefined ? -1 : trips[1], pairs[0] === undefined ? -1 : pairs[0]);
+    return encode(6, [trips[0], pair]);
+  }
+  if (flushMask) return encode(5, topRanks(flushMask, 5));
+  const st = straightHigh(mask);
+  if (st >= 0) return encode(4, [st]);
+  if (trips.length) return encode(3, [trips[0], ...topRanks(mask, 2, [trips[0]])]);
+  if (pairs.length >= 2) return encode(2, [pairs[0], pairs[1], topRanks(mask, 1, [pairs[0], pairs[1]])[0]]);
+  if (pairs.length) return encode(1, [pairs[0], ...topRanks(mask, 3, [pairs[0]])]);
+  return encode(0, topRanks(mask, 5));
+}
+
+// hole / board は "As" 形式。opponents 人のランダムな手札を相手にした勝率（引き分けは等分）
+function equity(hole, board, opponents, iterations, rng = Math.random) {
+  const mine = hole.map(toInt);
+  const known = board.map(toInt);
+  const used = new Set([...mine, ...known]);
+  const deck = [];
+  for (let c = 0; c < 52; c++) if (!used.has(c)) deck.push(c);
+  const needBoard = 5 - known.length;
+  const need = needBoard + opponents * 2;
+
+  let score = 0;
+  for (let it = 0; it < iterations; it++) {
+    // 必要な枚数だけ部分的にシャッフル
+    for (let i = 0; i < need; i++) {
+      const j = i + Math.floor(rng() * (deck.length - i));
+      const tmp = deck[i];
+      deck[i] = deck[j];
+      deck[j] = tmp;
+    }
+    const fullBoard = known.concat(deck.slice(0, needBoard));
+    const me = evaluate(mine.concat(fullBoard));
+    let best = 0;
+    let ties = 0;
+    let lost = false;
+    for (let k = 0; k < opponents; k++) {
+      const o = needBoard + k * 2;
+      const v = evaluate([deck[o], deck[o + 1]].concat(fullBoard));
+      if (v > me) {
+        lost = true;
+        break;
+      }
+      if (v === me) ties++;
+      if (v > best) best = v;
+    }
+    if (!lost) score += 1 / (ties + 1);
+  }
+  return score / iterations;
+}
+
+// CPU ごとの性格（作成時にランダムに決める）
+function randomStyle(rng = Math.random) {
+  return {
+    aggression: 0.8 + rng() * 0.45, // 大きいほど積極的にベット・レイズする
+    bluff: 0.03 + rng() * 0.09, // 弱い手でベットする頻度
+    looseness: rng() * 0.08, // 大きいほど弱い手でもコールする
+  };
+}
+
+const DEFAULT_STYLE = { aggression: 1, bluff: 0.06, looseness: 0.04 };
+
+// 手番の CPU の行動を決める。{ type, amount } を返す（hand.act にそのまま渡せる）
+function decide(hand, seat, { style = DEFAULT_STYLE, rng = Math.random, iterations = 500 } = {}) {
+  const o = hand.options(seat);
+  if (!o) return null;
+  const p = hand.players.get(seat);
+  const stack = hand.seats[seat].stack;
+  const bb = hand.bb;
+  const preflop = hand.board.length === 0;
+  const opponents = hand.live().length - 1;
+  const pot = hand.potTotal;
+  const potOdds = o.toCall / (pot + o.toCall);
+  const raises = hand.raises || 0;
+  const aggr = style.aggression;
+
+  const raiseTo = (fraction) => {
+    // ポットの fraction 倍のレイズ。最低額〜オールインに収め、SB 単位に丸める
+    const unit = Math.max(1, hand.sb);
+    let to = hand.currentBet + Math.round(fraction * (pot + o.toCall));
+    to = Math.round(to / unit) * unit;
+    to = Math.min(o.maxRaiseTo, Math.max(o.minRaiseTo, to));
+    // 残りがわずかになるならオールイン
+    if (to - p.bet >= stack * 0.7) to = o.maxRaiseTo;
+    return { type: 'raise', amount: to };
+  };
+  const sizing = () => {
+    const r = rng();
+    return r < 0.4 ? 0.5 : r < 0.8 ? 0.75 : 1;
+  };
+
+  if (preflop) {
+    // プリフロップ: 1人のランダムな手に対する勝率で手の強さを順位付けする
+    // （0.6 ≒ 上位15%、0.65 ≒ 上位5%、0.7 ≒ 上位3%）
+    const hs = equity(p.cards, [], 1, iterations, rng);
+    const s1 = (hs - 0.5) / 0.5;
+
+    // スタックが少ないときはプッシュかフォールド
+    if (o.canRaise && stack + p.bet <= 10 * bb && s1 > 0.24 / aggr) return { type: 'raise', amount: o.maxRaiseTo };
+
+    // 誰もレイズしていなければオープン（残りの人数が少ないほど広く）、レイズされていたら 3bet・4bet
+    const raiseBar = (raises === 0 ? (opponents <= 3 ? 0.13 : 0.2) : raises === 1 ? 0.33 : 0.45) / aggr;
+    if (o.canRaise && (s1 > raiseBar || (raises === 1 && s1 > 0.1 && rng() < style.bluff * 0.5))) {
+      // オープンは 2.5〜3BB 程度、リレイズはポットの 0.75〜1倍
+      return raiseTo(raises === 0 ? 0.6 + rng() * 0.3 : 0.75 + rng() * 0.25);
+    }
+    if (o.canCheck) return { type: 'check' };
+    // コール: レイズしてきた相手は強い手を持っているので、その分だけ割り引いてポットオッズと比べる
+    const callScore = hs - 0.18 * raises - 0.04 * Math.max(0, opponents - 1);
+    if (callScore + style.looseness >= potOdds + 0.08) return { type: 'call' };
+    return { type: 'fold' };
+  }
+
+  // フロップ以降: 残っている相手全員のランダムな手に対する勝率
+  let e = equity(p.cards, hand.board, Math.max(1, opponents), iterations, rng);
+  // ベットしてきた相手は強い手を持っていることが多いので、ベットが大きいほど勝率を割り引く
+  if (o.toCall > 0) e *= 1 - 0.25 * Math.min(1, o.toCall / Math.max(pot - o.toCall, bb));
+  const fair = 1 / (Math.max(1, opponents) + 1);
+  const strength = (e - fair) / (1 - fair); // 0 で平均的、1 で必勝
+
+  // 強い手はベット・レイズ（何度もレイズされているほど慎重に）
+  const raiseBar = (0.35 + 0.17 * Math.min(raises, 3)) / aggr;
+  if (o.canRaise && strength > raiseBar) {
+    // 最強クラスはたまにスロープレイ
+    if (o.canCheck && strength > 0.85 && rng() < 0.2) return { type: 'check' };
+    return raiseTo(strength > 0.75 ? Math.max(0.75, sizing()) : sizing());
+  }
+
+  if (o.canCheck) {
+    // 前のストリートで最後にレイズした人は、相手が少なければ続けてベット（コンティニュエーションベット）
+    if (o.canRaise && hand.prevAggressor === seat && opponents <= 2 && rng() < 0.55 * aggr) return raiseTo(0.5);
+    // たまにブラフ
+    if (o.canRaise && opponents <= 2 && rng() < style.bluff * aggr) return raiseTo(0.5);
+    return { type: 'check' };
+  }
+
+  // コールするか: 勝率がポットオッズを上回るか
+  if (e + style.looseness >= potOdds + 0.02) return { type: 'call' };
+  if (o.canRaise && raises <= 1 && opponents === 1 && rng() < style.bluff * 0.4) return raiseTo(0.75);
+  return { type: 'fold' };
+}
+
+module.exports = { evaluate, equity, decide, randomStyle, toInt, straightHigh };

server/config.js

@@ -67,6 +67,12 @@ module.exports = {
   SHOWDOWN_MS: 4000,
   CARD_SHOWDOWN_MS: 6000,
   FOLD_WIN_MS: 2500,
+  // CPU の考える時間（ランダム）。人間がハンドに残っていないときは BOT_FAST_MS
+  BOT_THINK_MIN_MS: 700,
+  BOT_THINK_MAX_MS: 1800,
+  BOT_FAST_MS: 400,
+  // CPU が勝率を見積もるときのシミュレーション回数
+  BOT_ITERATIONS: 800,
   // 参加者が2人揃ってから次のハンドを始めるまで
   NEXT_HAND_DELAY_MS: 2000,
 

server/hand.js

@@ -29,6 +29,10 @@ class Hand {
     this.pot = 0; // 前のストリートまでに集めた額
     this.currentBet = 0;
     this.minRaise = bb;
+    this.raises = 0; // このストリートのベット・レイズの回数（CPU の判断用）
+    this.actions = 0; // アクションの通し番号（CPU の手番の管理用）
+    this.aggressor = null; // このストリートで最後にベット・レイズした席（CPU の判断用）
+    this.prevAggressor = null; // 前のストリートで最後にベット・レイズした席
     this.toAct = null;
     this.finished = false;
     this.showdown = false;
@@ -75,6 +79,11 @@ class Hand {
     return this.list.filter((p) => !p.folded);
   }
 
+  // 前のストリートまでのポット + このストリートのベット
+  get potTotal() {
+    return this.pot + this.list.reduce((sum, p) => sum + p.bet, 0);
+  }
+
   put(p, amount) {
     const s = this.seats[p.seat];
     s.stack -= amount;
@@ -163,9 +172,11 @@ class Hand {
       const raiseSize = amount - this.currentBet;
       this.put(p, amount - p.bet);
       p.last = { type: o.isBet ? 'BET' : 'RAISE', amount };
+      this.aggressor = seat;
       if (raiseSize >= this.minRaise) {
         // 正規のレイズ: 他の人はもう一度アクションできる
         this.minRaise = raiseSize;
+        this.raises++;
         for (const q of this.list) if (q !== p) q.acted = false;
       }
       // 足りないオールインのレイズはアクション済みの人に再レイズ権を与えない
@@ -175,6 +186,7 @@ class Hand {
     }
     if (p.allIn) p.last = { type: 'ALLIN', amount: p.bet };
     p.acted = true;
+    this.actions++;
     this.setNextActor(seat);
     return null;
   }
@@ -225,6 +237,9 @@ class Hand {
     if (this.live().length === 1) return this.finishFoldWin();
     this.currentBet = 0;
     this.minRaise = this.bb;
+    this.raises = 0;
+    this.prevAggressor = this.aggressor;
+    this.aggressor = null;
 
     const noMoreBetting = this.live().filter((p) => !p.allIn).length < 2;
     if (!this.cards) {
@@ -365,7 +380,7 @@ class Hand {
       runout: this.runout,
       street: this.street,
       pot: this.pot,
-      potTotal: this.pot + this.list.reduce((sum, p) => sum + p.bet, 0),
+      potTotal: this.potTotal,
       currentBet: this.currentBet,
       button: this.button,
       sbSeat: this.sbSeat,

server/index.js

@@ -6,7 +6,7 @@ const express = require('express');
 const { Server } = require('socket.io');
 const config = require('./config');
 const auth = require('./auth');
-const { TableManager } = require('./tables');
+const { TableManager, MODES } = require('./tables');
 
 const PUBLIC = path.join(__dirname, '..', 'public');
 // 管理者専用のファイル（public の外に置き、管理者の Cookie があるときだけ返す）
@@ -114,7 +114,8 @@ app.post('/api/tables', (req, res) => {
   const bigBlind = b.bigBlind;
   const blindTimerEnabled = b.blindTimerEnabled === true;
   const blindIntervalMin = b.blindIntervalMin;
-  const cardsEnabled = b.cardsEnabled === true;
+  const mode = b.mode;
+  const cpuCount = b.cpuCount;
   const hostToken = cleanToken(b.token);
 
   if (tables.tables.size >= config.MAX_TABLES) return res.status(429).json({ error: 'テーブル数が上限に達しています' });
@@ -124,6 +125,10 @@ app.post('/api/tables', (req, res) => {
   if (!intIn(smallBlind, 1, startingStack)) return res.status(400).json({ error: 'SBが不正です' });
   if (!intIn(bigBlind, smallBlind, startingStack)) return res.status(400).json({ error: 'BBはSB以上・開始スタック以下にしてください' });
   if (blindTimerEnabled && !intIn(blindIntervalMin, 1, 240)) return res.status(400).json({ error: 'インターバルは1〜240分で入力してください' });
+  if (!MODES.includes(mode)) return res.status(400).json({ error: 'テーブルの種類が不正です' });
+  if (mode === 'cpu' && !intIn(cpuCount, 1, config.MAX_SEATS - 1)) {
+    return res.status(400).json({ error: `CPU の人数は1〜${config.MAX_SEATS - 1}人にしてください` });
+  }
   if (!hostToken) return res.status(400).json({ error: 'プレイヤーIDがありません' });
 
   const table = tables.create({
@@ -133,7 +138,8 @@ app.post('/api/tables', (req, res) => {
     bigBlind,
     blindTimerEnabled,
     blindIntervalMin: blindTimerEnabled ? blindIntervalMin : 10,
-    cardsEnabled,
+    mode,
+    cpuCount: mode === 'cpu' ? cpuCount : 0,
     hostToken,
   });
   broadcastLobby();

server/tables.js

@@ -4,6 +4,14 @@ const crypto = require('crypto');
 const config = require('./config');
 const Blinds = require('../public/assets/blinds');
 const { Hand } = require('./hand');
+const ai = require('./ai');
+
+// テーブルの種類
+//   chips  : キャッシュオンリー。カードは実物で配り、サイトはチップだけを管理する
+//   friends: 友人戦。サーバがカードを配り、ショーダウンも自動で判定する
+//   cpu    : CPU戦。友人戦に CPU プレイヤーが加わる
+const MODES = ['chips', 'friends', 'cpu'];
+const CPU_NAMES = ['ハル', 'ソラ', 'リク', 'ミオ', 'レン', 'ユイ', 'カイ', 'ナギ'];
 
 class Table {
   constructor(opts) {
@@ -14,14 +22,18 @@ class Table {
     this.baseBigBlind = opts.bigBlind;
     this.timerEnabled = opts.blindTimerEnabled;
     this.intervalMin = opts.blindIntervalMin;
-    // カード機能: サーバがカードを配り、ショーダウンの勝敗も自動で判定する（オフなら実物のカードで遊ぶ）
-    this.cardsEnabled = opts.cardsEnabled === true;
+    this.mode = MODES.includes(opts.mode) ? opts.mode : 'chips';
+    // カード機能: サーバがカードを配り、ショーダウンの勝敗も自動で判定する（キャッシュオンリーは実物のカード）
+    this.cardsEnabled = this.mode !== 'chips';
     this.hostToken = opts.hostToken || null;
     this.maxSeats = config.MAX_SEATS;
 
-    // { token, name, stack, buyIns, sittingOut, left }
+    // { token, name, stack, buyIns, sittingOut, left, bot, style }
     // left: ハンド中に退席した人。ハンドが終わるまで席を予約しておく
+    // bot : CPU プレイヤー（style は思考の性格）
     this.seats = new Array(this.maxSeats).fill(null);
+    this.botTurn = null; // { key, at }: CPU が行動する時刻
+    if (this.mode === 'cpu') this.seatBots(opts.cpuCount);
     this.hand = null;
     this.started = false;
     this.paused = false;
@@ -38,6 +50,28 @@ class Table {
     this.emptySince = null;
   }
 
+  // CPU は席1から順に座らせる（席0は作成者）
+  seatBots(count) {
+    const n = Math.max(1, Math.min(this.maxSeats - 1, Number.isInteger(count) ? count : 1));
+    const names = CPU_NAMES.slice();
+    for (let i = names.length - 1; i > 0; i--) {
+      const j = crypto.randomInt(i + 1);
+      [names[i], names[j]] = [names[j], names[i]];
+    }
+    for (let k = 0; k < n; k++) {
+      this.seats[k + 1] = {
+        token: crypto.randomBytes(16).toString('hex'), // ブラウザには渡さない
+        name: names[k],
+        stack: this.startingStack,
+        buyIns: 1,
+        sittingOut: false,
+        left: false,
+        bot: true,
+        style: ai.randomStyle(),
+      };
+    }
+  }
+
   get intervalMs() {
     return this.intervalMin * 60 * 1000;
   }
@@ -74,8 +108,10 @@ class Table {
       .filter((i) => i >= 0);
   }
 
+  // CPU だけでハンドを続けても意味がないので、人間が1人は参加している必要がある
   canDeal() {
-    return this.started && !this.paused && this.eligibleSeats().length >= 2;
+    const eligible = this.eligibleSeats();
+    return this.started && !this.paused && eligible.length >= 2 && eligible.some((i) => !this.seats[i].bot);
   }
 
   // 着席した席番号を返す。満席なら -1（観戦）
@@ -110,7 +146,7 @@ class Table {
       this.seats[i] = null;
     }
     if (this.hostToken === token) {
-      const next = this.seats.find((s) => s && !s.left);
+      const next = this.seats.find((s) => s && !s.left && !s.bot);
       this.hostToken = next ? next.token : null;
     }
     return true;
@@ -130,6 +166,13 @@ class Table {
 
   startNewHand() {
     this.removeLeftSeats();
+    // チップがなくなった CPU は自動でリバイ
+    for (const s of this.seats) {
+      if (s && s.bot && s.stack === 0) {
+        s.stack = this.startingStack;
+        s.buyIns++;
+      }
+    }
     const eligible = this.eligibleSeats();
     this.buttonSeat =
       this.buttonSeat == null
@@ -143,6 +186,7 @@ class Table {
     const { sb, bb } = this.blinds;
     this.nextHandAt = null;
     this.runoutAt = null;
+    this.botTurn = null;
     this.hand = new Hand({
       number: this.handNumber,
       seats: this.seats,
@@ -217,6 +261,7 @@ class Table {
       // 止めていた時間だけ次のハンドの開始・場札をめくる時刻を後ろにずらす
       if (this.nextHandAt != null) this.nextHandAt += now - this.pausedAt;
       if (this.runoutAt != null) this.runoutAt += now - this.pausedAt;
+      this.botTurn = null; // CPU は再開してから考え直す
       if (this.timerEnabled) this.levelEndsAt = now + this.levelRemainingMs;
       this.paused = false;
       this.pausedAt = null;
@@ -231,7 +276,33 @@ class Table {
     return null;
   }
 
-  // 時間で進む処理（ブラインドタイマー・オールイン後の場札・次のハンドの開始）
+  // CPU の考える時間。人間がハンドに残っていなければ早めに進める
+  botDelay() {
+    const h = this.hand;
+    const humanLive = h.live().some((p) => !this.seats[p.seat].bot && !this.seats[p.seat].left);
+    if (!humanLive) return config.BOT_FAST_MS;
+    return config.BOT_THINK_MIN_MS + crypto.randomInt(config.BOT_THINK_MAX_MS - config.BOT_THINK_MIN_MS + 1);
+  }
+
+  // 手番の CPU が考える時間を過ぎていたら行動する。行動したら true
+  botStep(now) {
+    const h = this.hand;
+    if (!h || h.finished || h.toAct == null || !this.seats[h.toAct].bot) return false;
+    const key = `${h.number}:${h.actions}`;
+    if (!this.botTurn || this.botTurn.key !== key) {
+      this.botTurn = { key, at: now + this.botDelay() };
+      return false;
+    }
+    if (now < this.botTurn.at) return false;
+    this.botTurn = null;
+    const seat = h.toAct;
+    const d = ai.decide(h, seat, { style: this.seats[seat].style, iterations: config.BOT_ITERATIONS });
+    // 万一判断が不正でも止まらないよう、チェック/フォールドにする
+    if (!d || h.act(seat, d.type, d.amount)) h.autoAct();
+    return true;
+  }
+
+  // 時間で進む処理（ブラインドタイマー・CPU の行動・オールイン後の場札・次のハンドの開始）
   // 状態が変わったら true
   tick(now) {
     let changed = false;
@@ -242,6 +313,8 @@ class Table {
     }
     if (this.paused) return changed;
 
+    if (this.botStep(now)) changed = true;
+
     const h = this.hand;
     if (h && h.runout) {
       if (this.runoutAt == null) this.runoutAt = now + config.RUNOUT_STEP_MS;
@@ -292,6 +365,7 @@ class Table {
       timerEnabled: this.timerEnabled,
       intervalMin: this.intervalMin,
       cardsEnabled: this.cardsEnabled,
+      mode: this.mode,
       createdAt: this.createdAt,
     };
   }
@@ -313,6 +387,7 @@ class Table {
       startingStack: this.startingStack,
       maxSeats: this.maxSeats,
       cardsEnabled: this.cardsEnabled,
+      mode: this.mode,
       level: this.level,
       smallBlind: sb,
       bigBlind: bb,
@@ -336,7 +411,8 @@ class Table {
               seat: i,
               name: s.name,
               stack: s.stack,
-              connected: connectedTokens.has(s.token),
+              connected: Boolean(s.bot) || connectedTokens.has(s.token),
+              bot: Boolean(s.bot),
               sittingOut: s.sittingOut,
               ...(hv && hv.players[i] ? { inHand: true, ...hv.players[i] } : { inHand: false }),
             }
@@ -402,4 +478,4 @@ class TableManager {
   }
 }
 
-module.exports = { TableManager, Table };
+module.exports = { TableManager, Table, MODES };