Poker/server/bots/montecarlo.js

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