Poker/server/tables.js

'use strict';

const crypto = require('crypto');
const config = require('./config');
const Blinds = require('../public/assets/blinds');
const { Hand } = require('./hand');

class Table {
  constructor(opts) {
    this.id = opts.id;
    this.name = opts.name;
    this.startingStack = opts.startingStack;
    this.baseSmallBlind = opts.smallBlind;
    this.baseBigBlind = opts.bigBlind;
    this.timerEnabled = opts.blindTimerEnabled;
    this.intervalMin = opts.blindIntervalMin;
    this.hostToken = opts.hostToken || null;
    this.maxSeats = config.MAX_SEATS;

    // { token, name, stack, buyIns, sittingOut, left }
    // left: ハンド中に退席した人。ハンドが終わるまで席を予約しておく
    this.seats = new Array(this.maxSeats).fill(null);
    this.hand = null;
    this.started = false;
    this.paused = false;
    this.pausedAt = null;
    this.level = 1;
    this.handNumber = 0;
    this.buttonSeat = null;
    this.nextHandAt = null;
    this.levelEndsAt = null;
    this.levelRemainingMs = this.intervalMs;

    this.createdAt = Date.now();
    this.emptySince = null;
  }

  get intervalMs() {
    return this.intervalMin * 60 * 1000;
  }

  get blinds() {
    return Blinds.blindsAt(this.baseSmallBlind, this.baseBigBlind, this.level);
  }

  get phase() {
    if (!this.hand) return 'WAITING';
    return this.hand.finished ? 'FINISHING' : this.hand.street;
  }

  get handActive() {
    return Boolean(this.hand && !this.hand.finished);
  }

  get playerCount() {
    return this.seats.filter((s) => s && !s.left).length;
  }

  seatOf(token) {
    return token ? this.seats.findIndex((s) => s && s.token === token) : -1;
  }

  isHost(token) {
    return Boolean(token) && token === this.hostToken;
  }

  // 次のハンドに参加できる席
  eligibleSeats() {
    return this.seats
      .map((s, i) => (s && !s.left && !s.sittingOut && s.stack > 0 ? i : -1))
      .filter((i) => i >= 0);
  }

  canDeal() {
    return this.started && !this.paused && this.eligibleSeats().length >= 2;
  }

  // 着席した席番号を返す。満席なら -1（観戦）
  join(token, name) {
    const existing = this.seatOf(token);
    if (existing >= 0) {
      const s = this.seats[existing];
      s.name = name;
      if (s.left) {
        s.left = false; // ハンド中に退席して戻ってきた
        if (this.seatOf(this.hostToken) < 0 || this.seats[this.seatOf(this.hostToken)].left) this.hostToken = token;
      }
      return existing;
    }
    const free = this.seats.findIndex((s) => !s);
    if (free < 0) return -1;
    this.seats[free] = { token, name, stack: this.startingStack, buyIns: 1, sittingOut: false, left: false };
    // ホスト（通常は作成者）が着席していなければ、この人がホストになる
    const host = this.seatOf(this.hostToken);
    if (host < 0 || this.seats[host].left) this.hostToken = token;
    return free;
  }

  leave(token) {
    const i = this.seatOf(token);
    if (i < 0 || this.seats[i].left) return false;
    if (this.hand && this.hand.players.has(i)) {
      // 結果表示やポット計算のため、ハンドが終わるまで席は残す
      this.seats[i].left = true;
      this.hand.forceFold(i);
    } else {
      this.seats[i] = null;
    }
    if (this.hostToken === token) {
      const next = this.seats.find((s) => s && !s.left);
      this.hostToken = next ? next.token : null;
    }
    return true;
  }

  removeLeftSeats() {
    this.seats = this.seats.map((s) => (s && s.left ? null : s));
  }

  nextOf(list, from) {
    for (let k = 1; k <= this.maxSeats; k++) {
      const i = (from + k) % this.maxSeats;
      if (list.includes(i)) return i;
    }
    return null;
  }

  startNewHand() {
    this.removeLeftSeats();
    const eligible = this.eligibleSeats();
    this.buttonSeat =
      this.buttonSeat == null
        ? eligible[crypto.randomInt(eligible.length)]
        : this.nextOf(eligible, this.buttonSeat);
    const order = [];
    for (let i = this.nextOf(eligible, this.buttonSeat); order.length < eligible.length; i = this.nextOf(eligible, i)) {
      order.push(i);
    }
    this.handNumber++;
    const { sb, bb } = this.blinds;
    this.nextHandAt = null;
    this.hand = new Hand({ number: this.handNumber, seats: this.seats, order, button: this.buttonSeat, sb, bb });
  }

  // ---- プレイヤー操作（エラー時はメッセージを返す） ----

  act(token, type, amount) {
    const i = this.seatOf(token);
    if (i < 0) return '着席していません';
    if (!this.handActive) return 'ハンドが進行していません';
    if (this.paused) return '一時停止中です';
    return this.hand.act(i, type, amount);
  }

  // ショーダウンの勝者を選べるのは、ショーダウンに残った人とホスト
  canAward(token) {
    if (!this.handActive || !this.hand.awaitingWinners) return false;
    const i = this.seatOf(token);
    const p = i >= 0 ? this.hand.players.get(i) : null;
    return this.isHost(token) || Boolean(p && !p.folded && !this.seats[i].left);
  }

  award(token, winners) {
    if (!this.handActive || !this.hand.awaitingWinners) return 'ショーダウンではありません';
    if (!this.canAward(token)) return 'ショーダウンに残った人かホストが選んでください';
    if (this.paused) return '一時停止中です';
    return this.hand.award(winners);
  }

  setSittingOut(token, value) {
    const i = this.seatOf(token);
    if (i < 0) return '着席していません';
    const s = this.seats[i];
    s.sittingOut = value;
    // 手番中に離席したら、その場でチェック/フォールド
    if (value && this.handActive && this.hand.toAct === i && !this.paused) this.hand.autoAct();
    return null;
  }

  rebuy(token) {
    const i = this.seatOf(token);
    if (i < 0) return '着席していません';
    const s = this.seats[i];
    if (s.stack > 0) return 'チップが残っています';
    if (this.handActive && this.hand.players.has(i) && !this.hand.players.get(i).folded) return 'ハンドの終了後にリバイできます';
    s.stack = this.startingStack;
    s.buyIns++;
    s.sittingOut = false;
    return null;
  }

  // ---- ホスト操作 ----

  start(token, now = Date.now()) {
    if (!this.isHost(token)) return 'ホストのみ開始できます';
    if (this.started) return 'すでに開始しています';
    if (this.eligibleSeats().length < 2) return '2人以上必要です';
    this.started = true;
    if (this.timerEnabled) this.levelEndsAt = now + this.intervalMs;
    this.startNewHand();
    return null;
  }

  togglePause(token, now = Date.now()) {
    if (!this.isHost(token)) return 'ホストのみ操作できます';
    if (!this.started) return 'まだ開始していません';
    if (this.paused) {
      // 止めていた時間だけ次のハンドの開始を後ろにずらす
      if (this.nextHandAt != null) this.nextHandAt += now - this.pausedAt;
      if (this.timerEnabled) this.levelEndsAt = now + this.levelRemainingMs;
      this.paused = false;
      this.pausedAt = null;
    } else {
      this.paused = true;
      this.pausedAt = now;
      if (this.timerEnabled) {
        this.levelRemainingMs = Math.max(0, this.levelEndsAt - now);
        this.levelEndsAt = null;
      }
    }
    return null;
  }

  // 時間で進む処理（ブラインドタイマー・次のハンドの開始）
  // 状態が変わったら true
  tick(now) {
    let changed = false;
    while (this.levelEndsAt != null && now >= this.levelEndsAt) {
      this.level++;
      this.levelEndsAt += this.intervalMs;
      changed = true;
    }
    if (this.paused) return changed;

    if (this.hand && this.hand.finished) {
      if (this.nextHandAt == null) {
        this.nextHandAt = now + (this.hand.showdown ? config.SHOWDOWN_MS : config.FOLD_WIN_MS);
      } else if (now >= this.nextHandAt) {
        if (this.canDeal()) this.startNewHand();
        else {
          this.hand = null;
          this.nextHandAt = null;
          this.removeLeftSeats();
        }
        changed = true;
      }
    } else if (!this.hand) {
      if (!this.canDeal()) this.nextHandAt = null;
      else if (this.nextHandAt == null) this.nextHandAt = now + config.NEXT_HAND_DELAY_MS;
      else if (now >= this.nextHandAt) {
        this.startNewHand();
        changed = true;
      }
    }
    return changed;
  }

  summary() {
    const { sb, bb } = this.blinds;
    return {
      id: this.id,
      name: this.name,
      playerCount: this.playerCount,
      maxSeats: this.maxSeats,
      startingStack: this.startingStack,
      smallBlind: sb,
      bigBlind: bb,
      level: this.level,
      phase: this.phase,
      paused: this.paused,
      timerEnabled: this.timerEnabled,
      intervalMin: this.intervalMin,
      createdAt: this.createdAt,
    };
  }

  // token = 閲覧者のトークン（他人のトークンは送らない）
  publicState(token, connectedTokens) {
    const now = Date.now();
    const { sb, bb } = this.blinds;
    const next = Blinds.blindsAt(this.baseSmallBlind, this.baseBigBlind, this.level + 1);
    const mySeat = this.seatOf(token);
    const h = this.hand;
    const hv = h ? h.view() : null;
    const me = mySeat >= 0 ? this.seats[mySeat] : null;
    const inLiveHand = Boolean(this.handActive && h.players.has(mySeat) && !h.players.get(mySeat).folded);

    return {
      id: this.id,
      name: this.name,
      startingStack: this.startingStack,
      maxSeats: this.maxSeats,
      level: this.level,
      smallBlind: sb,
      bigBlind: bb,
      nextBlinds: { smallBlind: next.sb, bigBlind: next.bb },
      timer: {
        enabled: this.timerEnabled,
        intervalMin: this.intervalMin,
        endsAt: this.levelEndsAt,
        remainingMs: this.levelEndsAt != null ? this.levelEndsAt - now : this.levelRemainingMs,
        running: this.levelEndsAt != null,
      },
      phase: this.phase,
      started: this.started,
      paused: this.paused,
      handNumber: this.handNumber,
      hand: hv,
      toAct: this.handActive ? h.toAct : null,
      seats: this.seats.map((s, i) =>
        s && !s.left
          ? {
              seat: i,
              name: s.name,
              stack: s.stack,
              connected: connectedTokens.has(s.token),
              sittingOut: s.sittingOut,
              ...(hv && hv.players[i] ? { inHand: true, ...hv.players[i] } : { inHand: false }),
            }
          : null
      ),
      mySeat: me && !me.left ? mySeat : -1,
      me:
        me && !me.left
          ? {
              stack: me.stack,
              net: me.stack + (inLiveHand ? h.players.get(mySeat).committed : 0) - me.buyIns * this.startingStack,
              buyIns: me.buyIns,
              sittingOut: me.sittingOut,
              canRebuy: me.stack === 0 && !inLiveHand,
              options: this.handActive && !this.paused ? h.options(mySeat) : null,
              canAward: this.canAward(token),
            }
          : null,
      isHost: this.isHost(token),
      serverNow: now,
    };
  }
}

class TableManager {
  constructor() {
    this.tables = new Map();
  }

  get(id) {
    return this.tables.get(id);
  }

  list() {
    return [...this.tables.values()]
      .sort((a, b) => b.createdAt - a.createdAt)
      .map((t) => t.summary());
  }

  nameTaken(name) {
    const n = name.toLowerCase();
    return [...this.tables.values()].some((t) => t.name.toLowerCase() === n);
  }

  suggestName() {
    for (;;) {
      const name = `Table #${1000 + crypto.randomInt(9000)}`;
      if (!this.nameTaken(name)) return name;
    }
  }

  create(opts) {
    let id;
    do id = crypto.randomBytes(4).toString('hex');
    while (this.tables.has(id));
    const table = new Table({ ...opts, id });
    this.tables.set(id, table);
    return table;
  }

  delete(id) {
    this.tables.delete(id);
  }
}

module.exports = { TableManager, Table };