most-box 0.1.3 → 0.1.5

package/server/src/games/gandengyan.js

@@ -1,173 +1,40 @@
-import crypto from 'node:crypto'
-
 const SUITS = ['S', 'H', 'C', 'D']
 const RANKS = ['3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A', '2']
 const STRAIGHT_RANKS = RANKS.filter(rank => rank !== '2')
 const RANK_VALUE = new Map(RANKS.map((rank, index) => [rank, index + 3]))
 const INITIAL_HAND_SIZE = 5
 const SEALED_PENALTY = 15
-
-export function createGanDengYanSocketHandlers() {
-  const rooms = new Map()
-  const clients = new Map()
-
-  function bindClient(ws) {
-    const id = crypto.randomUUID()
-    clients.set(ws, { id, roomId: null, name: '玩家', address: '' })
-    send(ws, 'gandengyan:hello', { playerId: id })
-  }
-
-  function unbindClient(ws) {
-    const client = clients.get(ws)
-    if (client?.roomId && rooms.has(client.roomId)) {
-      const room = rooms.get(client.roomId)
-      leaveRoom(room, client.id)
-      broadcastRoom(room)
-    }
-    clients.delete(ws)
-  }
-
-  function handleMessage(ws, event, data = {}) {
-    if (!event.startsWith('gandengyan:')) return false
-    const client = clients.get(ws)
-    if (!client) return true
-
-    try {
-      const identity = normalizeIdentity(data.identity)
-      if (identity.name) client.name = identity.name
-      if (identity.address) client.address = identity.address
-
-      switch (event) {
-        case 'gandengyan:createRoom': {
-          const room = createRoom({
-            roomId: makeRoomId(rooms),
-            ownerId: client.id,
-            ownerName: client.name,
-            ownerAddress: client.address,
-          })
-          rooms.set(room.id, room)
-          client.roomId = room.id
-          send(ws, 'gandengyan:roomCreated', { roomId: room.id })
-          broadcastRoom(room)
-          return true
-        }
-        case 'gandengyan:joinRoom': {
-          const roomId = String(data.roomId || '').trim().toUpperCase()
-          const room = rooms.get(roomId)
-          if (!room) throw new Error('房间不存在')
-          joinRoom(room, client.id, client.name, client.address)
-          client.roomId = room.id
-          broadcastRoom(room)
-          return true
-        }
-        default:
-          break
-      }
-
-      const room = rooms.get(client.roomId)
-      if (!room) throw new Error('请先进入房间')
-
-      if (event === 'gandengyan:settings') {
-        if (room.ownerId !== client.id) throw new Error('只有房主可以修改设置')
-        setRoomSettings(room, data.settings || {})
-        broadcastRoom(room)
-        return true
-      }
-
-      if (event === 'gandengyan:start') {
-        if (room.ownerId !== client.id) throw new Error('只有房主可以开始')
-        startGame(room)
-        broadcastRoom(room)
-        scheduleBots(room, broadcastRoom)
-        return true
-      }
-
-      if (event === 'gandengyan:play') {
-        playCards(room, client.id, Array.isArray(data.cardIds) ? data.cardIds : [])
-        broadcastRoom(room)
-        scheduleBots(room, broadcastRoom)
-        return true
-      }
-
-      if (event === 'gandengyan:pass') {
-        passTurn(room, client.id)
-        broadcastRoom(room)
-        scheduleBots(room, broadcastRoom)
-        return true
-      }
-
-      if (event === 'gandengyan:restart') {
-        if (room.ownerId !== client.id) throw new Error('只有房主可以再来一局')
-        startGame(room)
-        broadcastRoom(room)
-        scheduleBots(room, broadcastRoom)
-        return true
-      }
-    } catch (error) {
-      send(ws, 'gandengyan:error', {
-        message: error instanceof Error ? error.message : '请求失败',
-      })
-    }
-
-    return true
-  }
-
-  function broadcastRoom(room) {
-    for (const [ws, client] of clients.entries()) {
-      if (client.roomId === room.id && ws.readyState === 1) {
-        send(ws, 'gandengyan:state', publicRoom(room, client.id))
-      }
-    }
+const INITIAL_SCORE = 1000
+
+export function createGanDengYanRoom({
+  roomCode,
+  ownerAddress,
+  ownerName,
+  players = [],
+  random = Math.random,
+}) {
+  const roomPlayers = normalizePlayers(players)
+  if (!roomPlayers.some(player => player.address === normalizeAddress(ownerAddress))) {
+    roomPlayers.unshift({
+      address: normalizeAddress(ownerAddress),
+      name: cleanName(ownerName),
+    })
   }
 
-  return { bindClient, unbindClient, handleMessage }
-}
-
-function normalizeIdentity(identity) {
-  if (!identity || typeof identity !== 'object') return {}
-  return {
-    name: cleanName(identity.displayName || identity.username || identity.name),
-    address: String(identity.address || '').trim().slice(0, 64),
-  }
-}
-
-function send(ws, event, data) {
-  if (ws.readyState === 1) {
-    ws.send(JSON.stringify({ event, data }))
-  }
-}
-
-function scheduleBots(room, broadcastRoom) {
-  setTimeout(() => {
-    let moved = false
-    let guard = 0
-    while (room.status === 'playing' && guard < 8 && botStep(room)) {
-      moved = true
-      guard += 1
-    }
-    if (moved) broadcastRoom(room)
-  }, 650)
-}
-
-function createRoom({ roomId, ownerId, ownerName, ownerAddress }) {
   const room = {
-    id: roomId,
-    ownerId,
+    id: String(roomCode || '').toUpperCase(),
+    ownerAddress: normalizeAddress(ownerAddress),
     status: 'lobby',
-    settings: { decks: 1, seats: 2, bots: 1 },
-    players: [
-      {
-        id: ownerId,
-        address: ownerAddress || '',
-        name: ownerName || '玩家',
-        bot: false,
-        seat: 0,
-        connected: true,
-        hand: [],
-        score: 0,
-        playedCards: 0,
-      },
-    ],
+    seq: 1,
+    players: roomPlayers.slice(0, 6).map((player, seat) => ({
+      address: player.address,
+      name: cleanName(player.name),
+      seat,
+      hand: [],
+      handCount: 0,
+      score: INITIAL_SCORE,
+      playedCards: 0,
+    })),
     deck: [],
     discard: [],
     table: null,
@@ -181,185 +48,230 @@ function createRoom({ roomId, ownerId, ownerName, ownerAddress }) {
     roundResult: null,
     log: ['房间已创建'],
     winnerSeat: null,
-    updatedAt: Date.now(),
-  }
-  syncBots(room)
-  return room
-}
-
-function setRoomSettings(room, settings) {
-  if (room.status !== 'lobby') throw new Error('游戏开始后不能修改设置')
-  room.settings.decks = clamp(Number(settings.decks) || 1, 1, 2)
-  room.settings.seats = clamp(Number(settings.seats) || 2, 2, 6)
-  room.settings.bots = clamp(Number(settings.bots) || 0, 0, room.settings.seats - 1)
-  syncBots(room)
-  room.updatedAt = Date.now()
-}
-
-function joinRoom(room, playerId, name, address) {
-  let player = room.players.find(item => item.id === playerId)
-  if (player) {
-    player.connected = true
-    if (name) player.name = name
-    if (address) player.address = address
-    return player
-  }
-  if (room.status !== 'lobby') throw new Error('游戏已经开始')
-  const seat = firstOpenHumanSeat(room)
-  if (seat === -1) throw new Error('房间已满')
-  player = {
-    id: playerId,
-    address: address || '',
-    name: name || `玩家${seat + 1}`,
-    bot: false,
-    seat,
-    connected: true,
-    hand: [],
-    score: 0,
-    playedCards: 0,
-  }
-  room.players = room.players.filter(item => item.seat !== seat)
-  room.players.push(player)
-  room.players.sort((a, b) => a.seat - b.seat)
-  syncBots(room)
-  room.log.unshift(`${player.name} 加入牌桌`)
-  room.updatedAt = Date.now()
-  return player
-}
-
-function leaveRoom(room, playerId) {
-  const player = room.players.find(item => item.id === playerId)
-  if (!player || player.bot) return
-  player.connected = false
-  if (room.status === 'lobby') {
-    room.players = room.players.filter(item => item.id !== playerId)
-    syncBots(room)
-  }
-  room.updatedAt = Date.now()
-}
-
-function startGame(room) {
-  if (room.players.filter(player => !player.bot).length < 1) {
-    throw new Error('至少需要 1 名真人玩家')
-  }
-  syncBots(room)
-  room.deck = shuffle(createDeck(room.settings.decks))
-  room.discard = []
-  room.table = null
-  room.passSeats = []
-  room.winnerSeat = null
-  room.roundResult = null
-  room.baseScore = 1
-  room.bombCount = 0
-  room.status = 'playing'
-  for (const player of orderedPlayers(room)) {
-    player.hand = draw(room, INITIAL_HAND_SIZE)
+    random,
+  }
+  return publicGanDengYanRoom(room)
+}
+
+export function syncGanDengYanLobby(room, players = []) {
+  const state = hydrateGanDengYanRoom(room)
+  if (!state || state.status !== 'lobby') return state
+  const currentScores = new Map(state.players.map(player => [player.address, player.score]))
+  state.players = normalizePlayers(players)
+    .slice(0, 6)
+    .map((player, seat) => ({
+      address: player.address,
+      name: cleanName(player.name),
+      seat,
+      hand: [],
+      handCount: 0,
+      score: currentScores.get(player.address) ?? INITIAL_SCORE,
+      playedCards: 0,
+    }))
+  state.seq += 1
+  return publicGanDengYanRoom(state)
+}
+
+export function startGanDengYanRound(room, random = Math.random) {
+  const state = hydrateGanDengYanRoom(room)
+  if (!state || state.players.length < 2) {
+    throw new Error('至少需要 2 名玩家')
+  }
+
+  state.deck = shuffle(createDeck(), random)
+  state.discard = []
+  state.table = null
+  state.passSeats = []
+  state.winnerSeat = null
+  state.roundResult = null
+  state.baseScore = 1
+  state.bombCount = 0
+  state.status = 'playing'
+  for (const player of orderedPlayers(state)) {
+    player.hand = draw(state, INITIAL_HAND_SIZE)
+    player.handCount = player.hand.length
     player.playedCards = 0
     sortHand(player.hand)
   }
-  const starter = chooseStarter(room)
-  room.currentSeat = starter.seat
-  room.lastWinnerSeat = null
-  room.log = [`新一局开始，${starter.name} 先出牌`]
-  if (room.diceRolls.length > 0) {
-    room.log.unshift(`骰子结果：${room.diceRolls.map(roll => `${roll.name} ${roll.value}`).join('，')}`)
+  const starter = chooseStarter(state, random)
+  state.currentSeat = starter.seat
+  state.lastWinnerSeat = null
+  state.log = [`新一局开始，${starter.name} 先出牌`]
+  if (state.diceRolls.length > 0) {
+    state.log.unshift(
+      `骰子结果：${state.diceRolls
+        .map(roll => `${roll.name} ${roll.value}`)
+        .join('，')}`
+    )
   }
-  room.updatedAt = Date.now()
+  state.seq += 1
+  return publicGanDengYanRoom(state)
 }
 
-function playCards(room, playerId, cardIds) {
-  const player = currentPlayer(room)
-  if (!player || player.id !== playerId) throw new Error('还没轮到你')
+export function playGanDengYanCards(room, address, cardIds) {
+  const state = hydrateGanDengYanRoom(room)
+  const player = currentPlayer(state)
+  const normalizedAddress = normalizeAddress(address)
+  if (!player || player.address !== normalizedAddress) {
+    return { ok: false, error: '还没轮到你', state: publicGanDengYanRoom(state) }
+  }
+
   const cards = cardIds.map(id => player.hand.find(card => card.id === id))
-  if (cards.length === 0 || cards.some(card => !card)) throw new Error('手牌不存在')
+  if (cards.length === 0 || cards.some(card => !card)) {
+    return { ok: false, error: '手牌不存在', state: publicGanDengYanRoom(state) }
+  }
   const combo = analyzeCards(cards)
-  if (!combo) throw new Error('这个牌型不合法')
-  if (!canBeat(combo, room.table?.combo)) throw new Error('出的牌压不过上一手')
+  if (!combo) {
+    return { ok: false, error: '这个牌型不合法', state: publicGanDengYanRoom(state) }
+  }
+  if (!canBeat(combo, state.table?.combo)) {
+    return { ok: false, error: '出的牌压不过上一手', state: publicGanDengYanRoom(state) }
+  }
+
   player.hand = player.hand.filter(card => !cardIds.includes(card.id))
+  player.handCount = player.hand.length
   player.playedCards += cards.length
-  room.discard.push(...cards)
-  room.table = { seat: player.seat, playerName: player.name, cards, combo }
-  room.passSeats = []
-  room.lastWinnerSeat = player.seat
+  state.discard.push(...cards)
+  state.table = { seat: player.seat, playerName: player.name, cards, combo }
+  state.passSeats = []
+  state.lastWinnerSeat = player.seat
   if (combo.type === 'bomb') {
-    room.bombCount += 1
-    room.baseScore *= 2
-  }
-  room.log.unshift(`${player.name} 出 ${combo.label} ${cards.map(labelCard).join(' ')}${combo.type === 'bomb' ? `，底分 ${room.baseScore}` : ''}`)
+    state.bombCount += 1
+    state.baseScore *= 2
+  }
+  state.log.unshift(
+    `${player.name} 出 ${combo.label} ${cards.map(labelCard).join(' ')}${
+      combo.type === 'bomb' ? `，底分 ${state.baseScore}` : ''
+    }`
+  )
   if (player.hand.length === 0) {
-    finishGame(room, player)
+    finishGame(state, player)
   } else {
-    advanceTurn(room)
-  }
-  room.updatedAt = Date.now()
-}
-
-function passTurn(room, playerId) {
-  const player = currentPlayer(room)
-  if (!player || player.id !== playerId) throw new Error('还没轮到你')
-  if (!room.table) throw new Error('领出时不能不要')
-  if (!room.passSeats.includes(player.seat)) room.passSeats.push(player.seat)
-  room.log.unshift(`${player.name} 不要`)
-  const activeSeats = activePlayers(room).map(item => item.seat)
-  const seatsToBeat = activeSeats.filter(seat => seat !== room.lastWinnerSeat)
-  if (seatsToBeat.every(seat => room.passSeats.includes(seat))) {
-    refillAfterRound(room)
-    room.currentSeat = room.lastWinnerSeat
-    room.table = null
-    room.passSeats = []
-    room.log.unshift('本轮结束，所有玩家各补 1 张，重新领出')
-  } else {
-    advanceTurn(room)
+    advanceTurn(state)
   }
-  room.updatedAt = Date.now()
+  state.seq += 1
+  return { ok: true, state: publicGanDengYanRoom(state) }
 }
 
-function botStep(room) {
-  const player = currentPlayer(room)
-  if (!player?.bot || room.status !== 'playing') return false
-  const move = chooseBotMove(player.hand, room.table?.combo)
-  if (move.length > 0) {
-    playCards(room, player.id, move.map(card => card.id))
+export function passGanDengYanTurn(room, address) {
+  const state = hydrateGanDengYanRoom(room)
+  const player = currentPlayer(state)
+  const normalizedAddress = normalizeAddress(address)
+  if (!player || player.address !== normalizedAddress) {
+    return { ok: false, error: '还没轮到你', state: publicGanDengYanRoom(state) }
+  }
+  if (!state.table) {
+    return { ok: false, error: '领出时不能不要', state: publicGanDengYanRoom(state) }
+  }
+
+  if (!state.passSeats.includes(player.seat)) state.passSeats.push(player.seat)
+  state.log.unshift(`${player.name} 不要`)
+  const activeSeats = activePlayers(state).map(item => item.seat)
+  const seatsToBeat = activeSeats.filter(seat => seat !== state.lastWinnerSeat)
+  if (seatsToBeat.every(seat => state.passSeats.includes(seat))) {
+    refillAfterRound(state)
+    state.currentSeat = state.lastWinnerSeat
+    state.table = null
+    state.passSeats = []
+    state.log.unshift('本轮结束，所有玩家各补 1 张，重新领出')
   } else {
-    passTurn(room, player.id)
+    advanceTurn(state)
   }
-  return true
+  state.seq += 1
+  return { ok: true, state: publicGanDengYanRoom(state) }
 }
 
-function publicRoom(room, viewerId) {
+export function publicGanDengYanRoom(room) {
+  if (!room) return null
   return {
     id: room.id,
-    ownerId: room.ownerId,
+    ownerAddress: room.ownerAddress,
     status: room.status,
-    settings: room.settings,
-    deckCount: room.deck.length,
-    discardCount: room.discard.length,
-    currentSeat: room.currentSeat,
-    lastWinnerSeat: room.lastWinnerSeat,
-    previousWinnerSeat: room.previousWinnerSeat,
-    baseScore: room.baseScore,
-    bombCount: room.bombCount,
-    diceRolls: room.diceRolls,
-    roundResult: room.roundResult,
-    table: room.table ? { ...room.table, cards: room.table.cards.map(publicCard) } : null,
-    passSeats: room.passSeats,
-    winnerSeat: room.winnerSeat,
-    log: room.log.slice(0, 18),
+    seq: Number(room.seq || 1),
+    deckCount: room.deck?.length || Number(room.deckCount || 0),
+    discardCount: room.discard?.length || Number(room.discardCount || 0),
+    currentSeat: Number(room.currentSeat || 0),
+    lastWinnerSeat:
+      room.lastWinnerSeat === null || room.lastWinnerSeat === undefined
+        ? null
+        : Number(room.lastWinnerSeat),
+    previousWinnerSeat:
+      room.previousWinnerSeat === null || room.previousWinnerSeat === undefined
+        ? null
+        : Number(room.previousWinnerSeat),
+    baseScore: Number(room.baseScore || 1),
+    bombCount: Number(room.bombCount || 0),
+    diceRolls: Array.isArray(room.diceRolls) ? room.diceRolls : [],
+    roundResult: room.roundResult || null,
+    table: room.table
+      ? { ...room.table, cards: room.table.cards.map(publicCard) }
+      : null,
+    passSeats: Array.isArray(room.passSeats) ? room.passSeats : [],
+    winnerSeat:
+      room.winnerSeat === null || room.winnerSeat === undefined
+        ? null
+        : Number(room.winnerSeat),
+    log: Array.isArray(room.log) ? room.log.slice(0, 18) : [],
     players: orderedPlayers(room).map(player => ({
-      id: player.id,
       address: player.address,
       name: player.name,
-      bot: player.bot,
       seat: player.seat,
-      connected: player.connected,
-      handCount: player.hand.length,
-      score: player.score,
-      playedCards: player.playedCards,
-      hand: player.id === viewerId ? player.hand.map(publicCard) : [],
+      handCount: player.hand?.length ?? player.handCount ?? 0,
+      score: Number(player.score ?? INITIAL_SCORE),
+      playedCards: Number(player.playedCards || 0),
+      hand: Array.isArray(player.hand) ? player.hand.map(publicCard) : [],
     })),
   }
 }
 
+export function hydrateGanDengYanRoom(input) {
+  if (!input || typeof input !== 'object') return null
+  return {
+    id: String(input.id || '').toUpperCase(),
+    ownerAddress: normalizeAddress(input.ownerAddress),
+    status:
+      input.status === 'playing' || input.status === 'finished'
+        ? input.status
+        : 'lobby',
+    seq: Number(input.seq || 1),
+    players: Array.isArray(input.players)
+      ? input.players.map(normalizeRoundPlayer).filter(Boolean)
+      : [],
+    deck: Array.isArray(input.deck) ? input.deck.map(normalizeCard).filter(Boolean) : [],
+    discard: Array.isArray(input.discard)
+      ? input.discard.map(normalizeCard).filter(Boolean)
+      : [],
+    table:
+      input.table && typeof input.table === 'object'
+        ? {
+            ...input.table,
+            cards: Array.isArray(input.table.cards)
+              ? input.table.cards.map(normalizeCard).filter(Boolean)
+              : [],
+          }
+        : null,
+    currentSeat: Number(input.currentSeat || 0),
+    lastWinnerSeat:
+      input.lastWinnerSeat === null || input.lastWinnerSeat === undefined
+        ? null
+        : Number(input.lastWinnerSeat),
+    previousWinnerSeat:
+      input.previousWinnerSeat === null || input.previousWinnerSeat === undefined
+        ? null
+        : Number(input.previousWinnerSeat),
+    passSeats: Array.isArray(input.passSeats) ? input.passSeats.map(Number) : [],
+    baseScore: Number(input.baseScore || 1),
+    bombCount: Number(input.bombCount || 0),
+    diceRolls: Array.isArray(input.diceRolls) ? input.diceRolls : [],
+    roundResult: input.roundResult || null,
+    log: Array.isArray(input.log) ? input.log.map(String) : [],
+    winnerSeat:
+      input.winnerSeat === null || input.winnerSeat === undefined
+        ? null
+        : Number(input.winnerSeat),
+  }
+}
+
 export function analyzeCards(cards) {
   if (!cards?.length) return null
   const jokerCount = cards.filter(isJoker).length
@@ -367,7 +279,9 @@ export function analyzeCards(cards) {
   if (normals.length === 0) return null
   const bomb = analyzeBomb(cards, normals, jokerCount)
   if (bomb) return bomb
-  if (cards.length === 1 && jokerCount === 0) return makeCombo('single', cardValue(cards[0]), 1, [cardValue(cards[0])])
+  if (cards.length === 1 && jokerCount === 0) {
+    return makeCombo('single', cardValue(cards[0]), 1, [cardValue(cards[0])])
+  }
   if (cards.length === 2 && canRepresentSameRank(normals, jokerCount)) {
     const value = sameRankValue(normals)
     return makeCombo('pair', value, 2, [value, value])
@@ -378,14 +292,26 @@ export function analyzeCards(cards) {
 function analyzeBomb(cards, normals, jokerCount) {
   if (cards.length < 3 || !canRepresentSameRank(normals, jokerCount)) return null
   const value = sameRankValue(normals)
-  return makeCombo('bomb', value, cards.length, Array(cards.length).fill(value), jokerCount === 0)
+  return makeCombo(
+    'bomb',
+    value,
+    cards.length,
+    Array(cards.length).fill(value),
+    jokerCount === 0
+  )
 }
 
 function analyzeStraight(cards) {
   if (cards.length < 3) return null
   for (let start = 0; start <= STRAIGHT_RANKS.length - cards.length; start += 1) {
-    const values = STRAIGHT_RANKS.slice(start, start + cards.length).map(rank => RANK_VALUE.get(rank))
-    if (cards.every((card, index) => isJoker(card) || cardValue(card) === values[index])) {
+    const values = STRAIGHT_RANKS.slice(start, start + cards.length).map(rank =>
+      RANK_VALUE.get(rank)
+    )
+    if (
+      cards.every(
+        (card, index) => isJoker(card) || cardValue(card) === values[index]
+      )
+    ) {
       return makeCombo('straight', values.at(-1), cards.length, values)
     }
   }
@@ -396,9 +322,15 @@ function analyzePairStraight(cards) {
   if (cards.length < 4 || cards.length % 2 !== 0) return null
   const pairCount = cards.length / 2
   for (let start = 0; start <= STRAIGHT_RANKS.length - pairCount; start += 1) {
-    const pairValues = STRAIGHT_RANKS.slice(start, start + pairCount).map(rank => RANK_VALUE.get(rank))
+    const pairValues = STRAIGHT_RANKS.slice(start, start + pairCount).map(rank =>
+      RANK_VALUE.get(rank)
+    )
     const values = pairValues.flatMap(value => [value, value])
-    if (cards.every((card, index) => isJoker(card) || cardValue(card) === values[index])) {
+    if (
+      cards.every(
+        (card, index) => isJoker(card) || cardValue(card) === values[index]
+      )
+    ) {
       return makeCombo('pairStraight', pairValues.at(-1), cards.length, values)
     }
   }
@@ -406,7 +338,14 @@ function analyzePairStraight(cards) {
 }
 
 function makeCombo(type, value, length, resolvedValues, pure = true) {
-  return { type, value, length, resolvedValues, pure, label: labelCombo({ type, value, length, resolvedValues, pure }) }
+  return {
+    type,
+    value,
+    length,
+    resolvedValues,
+    pure,
+    label: labelCombo({ type, value, length, resolvedValues, pure }),
+  }
 }
 
 function canBeat(combo, tableCombo) {
@@ -421,39 +360,59 @@ function canBeat(combo, tableCombo) {
   }
   if (combo.length !== tableCombo.length) return false
   if (combo.type === 'single' || combo.type === 'pair') {
-    return combo.value === nextValue(tableCombo.value) || combo.value === RANK_VALUE.get('2')
+    return (
+      combo.value === nextValue(tableCombo.value) ||
+      (combo.value === RANK_VALUE.get('2') && tableCombo.value !== RANK_VALUE.get('2'))
+    )
   }
   return combo.value === nextValue(tableCombo.value)
 }
 
-function syncBots(room) {
-  const seats = room.settings.seats
-  room.players = room.players.filter(player => player.seat < seats && (!player.bot || room.status === 'lobby'))
-  while (orderedPlayers(room).filter(player => player.bot).length > room.settings.bots) {
-    const bot = orderedPlayers(room).filter(player => player.bot).at(-1)
-    room.players = room.players.filter(player => player.id !== bot.id)
-  }
-  for (let seat = 0; orderedPlayers(room).filter(player => player.bot).length < room.settings.bots && seat < seats; seat += 1) {
-    if (!room.players.find(player => player.seat === seat)) room.players.push(makeBot(seat))
-  }
-  room.players.sort((a, b) => a.seat - b.seat)
-}
-
-function makeBot(seat) {
+function normalizePlayers(players) {
+  const seen = new Set()
+  return players
+    .map(player => ({
+      address: normalizeAddress(player.address),
+      name: cleanName(player.name),
+      publicKey: String(player.publicKey || ''),
+    }))
+    .filter(player => {
+      if (!player.address || seen.has(player.address)) return false
+      seen.add(player.address)
+      return true
+    })
+}
+
+function normalizeRoundPlayer(input) {
+  const address = normalizeAddress(input.address)
+  if (!address) return null
+  return {
+    address,
+    name: cleanName(input.name),
+    seat: Number(input.seat || 0),
+    hand: Array.isArray(input.hand) ? input.hand.map(normalizeCard).filter(Boolean) : [],
+    handCount: Number(input.handCount || 0),
+    score: Number(input.score ?? INITIAL_SCORE),
+    playedCards: Number(input.playedCards || 0),
+  }
+}
+
+function normalizeCard(card) {
+  if (!card || typeof card !== 'object') return null
+  const rank = String(card.rank || '')
+  const suit = String(card.suit || '')
+  if (!RANK_VALUE.has(rank) && rank !== 'SJ' && rank !== 'BJ') return null
+  if (!SUITS.includes(suit) && suit !== 'Joker') return null
   return {
-    id: `bot-${seat}-${Math.random().toString(36).slice(2, 8)}`,
-    address: '',
-    name: `人机${seat + 1}`,
-    bot: true,
-    seat,
-    connected: true,
-    hand: [],
-    score: 0,
-    playedCards: 0,
+    id: String(card.id || `${suit}-${rank}`),
+    suit,
+    rank,
+    label: card.label || labelCard({ suit, rank }),
+    color: card.color || cardColor({ suit, rank }),
   }
 }
 
-function chooseStarter(room) {
+function chooseStarter(room, random) {
   if (room.previousWinnerSeat !== null) {
     room.diceRolls = []
     return orderedPlayers(room).find(player => player.seat === room.previousWinnerSeat) || orderedPlayers(room)[0]
@@ -461,14 +420,20 @@ function chooseStarter(room) {
   let candidates = orderedPlayers(room)
   let rolls = []
   while (candidates.length > 1) {
-    rolls = candidates.map(player => ({ seat: player.seat, name: player.name, value: rollDice() }))
+    rolls = candidates.map(player => ({
+      seat: player.seat,
+      name: player.name,
+      value: rollDice(random),
+    }))
     const max = Math.max(...rolls.map(roll => roll.value))
     const winners = rolls.filter(roll => roll.value === max)
     if (winners.length === 1) {
       room.diceRolls = rolls
       return candidates.find(player => player.seat === winners[0].seat)
     }
-    candidates = candidates.filter(player => winners.some(roll => roll.seat === player.seat))
+    candidates = candidates.filter(player =>
+      winners.some(roll => roll.seat === player.seat)
+    )
   }
   room.diceRolls = rolls
   return candidates[0]
@@ -486,10 +451,23 @@ function finishGame(room, winner) {
     const loss = sealed ? SEALED_PENALTY : player.hand.length * room.baseScore
     player.score -= loss
     winnerGain += loss
-    losers.push({ seat: player.seat, name: player.name, loss, sealed, cardsLeft: player.hand.length })
+    losers.push({
+      seat: player.seat,
+      name: player.name,
+      loss,
+      sealed,
+      cardsLeft: player.hand.length,
+    })
   }
   winner.score += winnerGain
-  room.roundResult = { winnerSeat: winner.seat, winnerName: winner.name, winnerGain, baseScore: room.baseScore, bombCount: room.bombCount, losers }
+  room.roundResult = {
+    winnerSeat: winner.seat,
+    winnerName: winner.name,
+    winnerGain,
+    baseScore: room.baseScore,
+    bombCount: room.bombCount,
+    losers,
+  }
   room.log.unshift(`${winner.name} 获胜，赢 ${winnerGain} 分`)
 }
 
@@ -497,34 +475,27 @@ function refillAfterRound(room) {
   for (const player of activePlayers(room)) {
     if (room.deck.length === 0) break
     player.hand.push(...draw(room, 1))
+    player.handCount = player.hand.length
     sortHand(player.hand)
   }
 }
 
-function firstOpenHumanSeat(room) {
-  for (let seat = 0; seat < room.settings.seats; seat += 1) {
-    const player = room.players.find(item => item.seat === seat)
-    if (!player || player.bot) return seat
-  }
-  return -1
-}
-
-function createDeck(decks) {
+function createDeck() {
   const cards = []
-  for (let deck = 0; deck < decks; deck += 1) {
-    for (const suit of SUITS) {
-      for (const rank of RANKS) cards.push({ id: `${deck}-${suit}-${rank}`, suit, rank, deck })
+  for (const suit of SUITS) {
+    for (const rank of RANKS) {
+      cards.push({ id: `${suit}-${rank}`, suit, rank })
     }
-    cards.push({ id: `${deck}-SJ`, suit: 'Joker', rank: 'SJ', deck })
-    cards.push({ id: `${deck}-BJ`, suit: 'Joker', rank: 'BJ', deck })
   }
-  return cards
+  cards.push({ id: 'SJ', suit: 'Joker', rank: 'SJ' })
+  cards.push({ id: 'BJ', suit: 'Joker', rank: 'BJ' })
+  return cards.map(publicCard)
 }
 
-function shuffle(cards) {
+function shuffle(cards, random) {
   const copy = [...cards]
   for (let index = copy.length - 1; index > 0; index -= 1) {
-    const swapIndex = Math.floor(Math.random() * (index + 1))
+    const swapIndex = Math.floor(random() * (index + 1))
     ;[copy[index], copy[swapIndex]] = [copy[swapIndex], copy[index]]
   }
   return copy
@@ -547,7 +518,7 @@ function activePlayers(room) {
 }
 
 function orderedPlayers(room) {
-  return [...room.players].sort((a, b) => a.seat - b.seat)
+  return [...(room?.players || [])].sort((a, b) => a.seat - b.seat)
 }
 
 function advanceTurn(room) {
@@ -556,40 +527,7 @@ function advanceTurn(room) {
   room.currentSeat = seats[(currentIndex + 1) % seats.length]
 }
 
-function chooseBotMove(hand, tableCombo) {
-  const candidates = enumerateBotMoves(hand)
-  return candidates.find(cards => canBeat(analyzeCards(cards), tableCombo)) || []
-}
-
-function enumerateBotMoves(hand) {
-  const sorted = [...hand].sort(compareCards)
-  const moves = sorted.filter(card => !isJoker(card)).map(card => [card])
-  for (let size = 2; size <= Math.min(6, sorted.length); size += 1) {
-    for (const cards of combinations(sorted, size)) {
-      if (analyzeCards(cards)) moves.push(cards)
-    }
-  }
-  return moves.sort((a, b) => {
-    const comboA = analyzeCards(a)
-    const comboB = analyzeCards(b)
-    if (comboA.type === 'bomb' && comboB.type !== 'bomb') return 1
-    if (comboA.type !== 'bomb' && comboB.type === 'bomb') return -1
-    return comboA.length - comboB.length || comboA.value - comboB.value
-  })
-}
-
-function combinations(cards, size, start = 0, prefix = [], output = []) {
-  if (prefix.length === size) {
-    output.push(prefix)
-    return output
-  }
-  for (let index = start; index <= cards.length - (size - prefix.length); index += 1) {
-    combinations(cards, size, index + 1, [...prefix, cards[index]], output)
-  }
-  return output
-}
-
-function canRepresentSameRank(normals, jokerCount) {
+function canRepresentSameRank(normals, jokerCount = 0) {
   if (normals.length === 0) return false
   const first = normals[0].rank
   return normals.every(card => card.rank === first) && normals.length + jokerCount >= 2
@@ -616,7 +554,13 @@ function suitValue(suit) {
 }
 
 function publicCard(card) {
-  return { id: card.id, suit: card.suit, rank: card.rank, label: labelCard(card), color: cardColor(card) }
+  return {
+    id: card.id,
+    suit: card.suit,
+    rank: card.rank,
+    label: labelCard(card),
+    color: cardColor(card),
+  }
 }
 
 function labelCard(card) {
@@ -630,11 +574,15 @@ function suitSymbol(suit) {
 }
 
 function cardColor(card) {
-  return card.suit === 'H' || card.suit === 'D' || card.rank === 'BJ' ? 'red' : 'black'
+  return card.suit === 'H' || card.suit === 'D' || card.rank === 'BJ'
+    ? 'red'
+    : 'black'
 }
 
 function labelCombo(combo) {
-  const resolved = combo.resolvedValues?.length ? `（${combo.resolvedValues.map(valueLabel).join(' ')}）` : ''
+  const resolved = combo.resolvedValues?.length
+    ? `（${combo.resolvedValues.map(valueLabel).join(' ')}）`
+    : ''
   return `${{
     single: '单张',
     pair: '对子',
@@ -654,22 +602,15 @@ function nextValue(value) {
   return RANK_VALUE.get(RANKS[index + 1])
 }
 
-function makeRoomId(rooms) {
-  let id = ''
-  do {
-    id = Math.random().toString(36).slice(2, 8).toUpperCase()
-  } while (rooms.has(id))
-  return id
-}
-
-function cleanName(name) {
-  return String(name || '玩家').trim().slice(0, 16) || '玩家'
+function rollDice(random) {
+  return Math.floor(random() * 6) + 1
 }
 
-function rollDice() {
-  return Math.floor(Math.random() * 6) + 1
+function normalizeAddress(value) {
+  const address = String(value || '').trim()
+  return /^0x[a-fA-F0-9]{40}$/.test(address) ? address.toLowerCase() : ''
 }
 
-function clamp(value, min, max) {
-  return Math.max(min, Math.min(max, value))
+function cleanName(name) {
+  return String(name || '玩家').trim().slice(0, 16) || '玩家'
 }