欢乐斗地主项目实战：规则、权威与可审计性的工程实现

// rank: 3=3, ..., 10=10, J=11, Q=12, K=13, A=14, 2=15, 小王=16, 大王=17
function identify(cards) {
  const freq = new Map();
  cards.forEach(c => freq.set(c, (freq.get(c) || 0) + 1));
  const n = cards.length;

  if (n === 2 && freq.has(16) && freq.has(17)) return "KingBomb";
  if (n === 4 && [...freq.values()].includes(4)) return "Bomb";
  if (n === 1) return "Single";
  if (n === 2 && freq.size === 1) return "Pair";

  const sorted = [...freq.keys()].sort((a, b) => a - b);
  const max = Math.max(...sorted), min = Math.min(...sorted);
  const allSingle = freq.size === n;

  // 顺子：≥5张、不含2和王
  if (n >= 5 && allSingle && max <= 14 && max - min === n - 1) return "Straight";

  // 连对：≥3对、连续、不含2和王
  if (n >= 6 && n % 2 === 0 && freq.size === n / 2
      && [...freq.values()].every(v => v === 2)
      && max <= 14 && max - min === freq.size - 1) return "DoubleStraight";

  return tryAirplane(freq, n); // 飞机带翅膀，递归回溯
}

function tryAirplane(freq, n) {
  const triples = [...freq.entries()].filter(([, c]) => c >= 3)
    .map(([r]) => r).sort((a, b) => a - b);
  // 寻找至少两个连续三条作为飞机主体，然后回溯检查翅膀
  for (let i = 0; i < triples.length; i++) {
    for (let j = i + 1; j < triples.length && triples[j] === triples[j - 1] + 1; j++) {
      const bodyLen = j - i + 1;
      if (bodyLen < 2) continue;
      const wingsNeeded = n - bodyLen * 3;
      if (wingsNeeded === bodyLen || wingsNeeded === bodyLen * 2)
        return "PlaneWithWings";
    }
  }
  return "Invalid";
}

function handlePlay(ws, msg) {
  const room = rooms.get(clients.get(ws).roomId);
  if (!room || room.turn !== msg.playerId) return reject(ws, "不是你的回合");

  const player = room.players.find(p => p.id === msg.playerId);
  if (!containsAll(player.cards, msg.cards)) return reject(ws, "手牌不含所出牌");
  if (!beats(msg.cards, room.lastPlay)) return reject(ws, "管不上");

  room.lastPlay = { playerId: msg.playerId, cards: msg.cards };
  room.turn = nextSeat(room.turn);
  room.version++;   // 乐观锁，防并发修改

  broadcast(room.id, {
    type: "state",
    hands: room.players.map(p => p.cards.length),
    lastPlay: room.lastPlay,
    turn: room.turn,
    version: room.version
  });
}

class DeterministicDealer {
  constructor(seed) { this.seed = seed; this.rng = new SeededRandom(seed); }

  deal() {
    const deck = [...Array(54).keys()]; // 0–53
    for (let i = 53; i > 0; i--) {
      const j = Math.floor(this.rng.next() * (i + 1));
      [deck[i], deck[j]] = [deck[j], deck[i]];
    }
    return {
      hands: [deck.slice(0, 17), deck.slice(17, 34), deck.slice(34, 51)],
      bottom: deck.slice(51, 54),
      seed: this.seed
    };
  }
}

function botTurn(room, botId) {
  const candidates = enumerateLegalMoves(room.players.find(p => p.id === botId).cards,
                                         room.lastPlay); // 返回 [{id, cards, type}, ...]
  const choice = llmPick(candidates.map(c => ({ id: c.id, type: c.type })));
  const selected = candidates.find(c => c.id === choice.id);
  if (!selected) return conservativeFallback(candidates); // 编号越界显式降级
  return selected;
}