Give CPUs distinct personalities built on different poker libraries

Each CPU now thinks with one of four engines, each backed by a different
published library (pinned versions):

- montecarlo (@pokertools/evaluator): the existing balanced Monte Carlo
  equity player, moved to server/bots/montecarlo.js.
- calculator (poker-calculations): the library's decideAction over the
  table state; push/fold below 12BB via its jam breakeven equity.
  Skipped automatically if the native addon cannot load.
- range (poker-utils): tight player; preflop by hand-strength percentile,
  postflop equity vs an estimated opponent range, bluffs only when
  alpha/bluffEV say they pay.
- madehand (pokersolver): loose, sticky player that only looks at the
  made hand and draws.

server/ai.js assigns a mix of engines per table (makeStyles), falls back
to the Monte Carlo engine on errors, and legalizes every decision.
The engine and its parameters stay server-side; players cannot tell
which library a CPU uses. Tests cover every engine and the no-leak rule.

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

server/bots/montecarlo.js

@@ -0,0 +1,118 @@
+'use strict';
+
+// バランス型: @pokertools/evaluator の役判定でモンテカルロ法の勝率を見積もり、
+// ポットオッズ・レイズの回数・相手の人数から行動を決める。
+const { evaluate, getCardCode } = require('@pokertools/evaluator');
+const { situation, CHECK, CALL, FOLD, allIn, raisePot, between } = require('./common');
+
+// hole / board は "As" 形式。opponents 人のランダムな手札を相手にした勝率（引き分けは等分）
+// 役の強さのスコアは小さいほど強い。カードは 0〜51 の整数
+function equity(hole, board, opponents, iterations, rng = Math.random) {
+  const mine = hole.map(getCardCode);
+  const known = board.map(getCardCode);
+  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 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 (!lost) score += 1 / (ties + 1);
+  }
+  return score / iterations;
+}
+
+function randomStyle(rng) {
+  return {
+    aggression: between(rng, 0.8, 1.25), // 大きいほど積極的にベット・レイズする
+    bluff: between(rng, 0.03, 0.12), // 弱い手でベットする頻度
+    looseness: between(rng, 0, 0.08), // 大きいほど弱い手でもコールする
+  };
+}
+
+const DEFAULT_STYLE = { aggression: 1, bluff: 0.06, looseness: 0.04 };
+
+function decide(hand, seat, { style = DEFAULT_STYLE, rng = Math.random, iterations = 500 } = {}) {
+  const s = situation(hand, seat);
+  if (!s) return null;
+  const { o, p, stack, bb, preflop, opponents, pot, potOdds, raises } = s;
+  const aggr = style.aggression;
+  const raiseTo = (fraction) => raisePot(hand, seat, fraction);
+  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 allIn(o);
+
+    // 誰もレイズしていなければオープン（残りの人数が少ないほど広く）、レイズされていたら 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 CHECK;
+    // コール: レイズしてきた相手は強い手を持っているので、その分だけ割り引いてポットオッズと比べる
+    const callScore = hs - 0.18 * raises - 0.04 * Math.max(0, opponents - 1);
+    if (callScore + style.looseness >= potOdds + 0.08) return CALL;
+    return 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 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 CHECK;
+  }
+
+  // コールするか: 勝率がポットオッズを上回るか
+  if (e + style.looseness >= potOdds + 0.02) return CALL;
+  if (o.canRaise && raises <= 1 && opponents === 1 && rng() < style.bluff * 0.4) return raiseTo(0.75);
+  return FOLD;
+}
+
+module.exports = { decide, randomStyle, equity, DEFAULT_STYLE };