嘿，我完全懂你现在的困扰——Node.js的非阻塞特性确实会让习惯同步思维的开发者头疼，尤其是做这种需要严格按回合顺序来的多人游戏。我之前做回合制桌游的时候也踩过类似的坑，给你几个实用的解决方案，都是我实际用过的：

Node.js的单线程特性决定了不能用阻塞式的等待，我们要把每个玩家的操作转化为异步任务，通过Promise、async/await配合事件监听，让服务器在"等待"玩家响应时依然能处理其他事件，同时保证回合顺序不混乱。

方案1：用Promise + Async/Await 实现回合流程控制 #

假设你用Socket.io和客户端通信（HTML5端用WebSocket类也类似），可以把每个玩家的操作请求封装成一个Promise，用async/await按顺序处理每个玩家：

// 定义一个扑克桌类，管理游戏状态和回合流程
class PokerTable {
  constructor() {
    this.players = []; // 按回合顺序排列的玩家数组，每个元素包含socket和玩家信息
    this.currentPlayerIdx = 0;
    this.currentBet = 0;
    this.isRoundActive = false;
  }

  // 启动一轮新的 betting 阶段
  async startBettingRound() {
    if (this.isRoundActive) return;
    this.isRoundActive = true;

    while (this.currentPlayerIdx < this.players.length) {
      const currentPlayer = this.players[this.currentPlayerIdx];
      console.log(`等待玩家 ${currentPlayer.id} 操作`);

      // 向客户端发送操作请求
      currentPlayer.socket.emit('request-player-action', {
        availableActions: ['call', 'raise', 'fold'],
        requiredBet: this.currentBet - currentPlayer.currentBet
      });

      try {
        // 等待玩家响应，超时自动判弃牌
        const action = await this.waitForPlayerAction(currentPlayer.socket);
        // 处理玩家操作
        this.handlePlayerAction(currentPlayer, action);
        // 轮到下一位玩家
        this.currentPlayerIdx++;
      } catch (err) {
        // 玩家超时，自动执行弃牌
        console.log(`玩家 ${currentPlayer.id} 超时，自动弃牌`);
        this.handlePlayerAction(currentPlayer, { type: 'fold' });
        this.currentPlayerIdx++;
      }
    }

    // 一轮 betting 结束，重置状态
    this.currentPlayerIdx = 0;
    this.isRoundActive = false;
    this.endBettingRound();
  }

  // 封装等待玩家响应的逻辑，返回Promise
  waitForPlayerAction(socket) {
    return new Promise((resolve, reject) => {
      // 设置30秒超时
      const timeout = setTimeout(() => {
        reject(new Error('Player action timeout'));
        socket.off('player-action'); // 移除监听，避免内存泄漏
      }, 30000);

      // 只监听一次玩家操作事件，避免重复触发
      socket.once('player-action', (actionData) => {
        clearTimeout(timeout);
        resolve(actionData);
      });
    });
  }

  // 处理玩家的具体操作（call/raise/fold）
  handlePlayerAction(player, action) {
    switch (action.type) {
      case 'call':
        player.chips -= (this.currentBet - player.currentBet);
        player.currentBet = this.currentBet;
        break;
      case 'raise':
        this.currentBet = action.newBetAmount;
        player.chips -= (action.newBetAmount - player.currentBet);
        player.currentBet = action.newBetAmount;
        break;
      case 'fold':
        // 移除当前玩家，索引回退一位避免跳过下一个
        this.players.splice(this.currentPlayerIdx, 1);
        this.currentPlayerIdx--;
        break;
    }
    console.log(`玩家 ${player.id} 执行了 ${action.type} 操作`);
  }

  endBettingRound() {
    console.log("投注阶段结束，开始摊牌结算");
    // 这里写结算逻辑...
  }
}

这个方案的关键是：

• 用waitForPlayerAction把玩家的响应事件包装成Promise，让startBettingRound可以用await按顺序等待每个玩家的操作
• 用once替代on监听事件，避免同一个玩家多次触发操作逻辑
• 加入超时处理，防止服务器无限等待玩家响应

方案2：用任务队列管理动态回合 #

如果你的游戏有更复杂的回合规则（比如玩家中途加入、弃牌后跳过等），可以用任务队列来动态管理需要处理的玩家操作：

const actionTaskQueue = [];
let isProcessingQueue = false;

// 向队列中添加一个玩家操作任务
function addPlayerActionTask(player, socket) {
  actionTaskQueue.push(async () => {
    socket.emit('request-player-action', { /* 操作数据 */ });
    const action = await waitForPlayerAction(socket);
    handlePlayerAction(player, action);
  });

  // 如果队列未在处理，启动处理流程
  if (!isProcessingQueue) {
    processActionQueue();
  }
}

// 依次处理队列中的任务
async function processActionQueue() {
  isProcessingQueue = true;
  while (actionTaskQueue.length > 0) {
    const task = actionTaskQueue.shift();
    await task();
  }
  isProcessingQueue = false;
}

// 复用之前的waitForPlayerAction和handlePlayerAction函数

这种方式更灵活，比如玩家弃牌后可以直接跳过他的任务，或者新玩家加入时插入队列到指定位置。

1. 永远不要依赖客户端状态：所有游戏状态（筹码、当前赌注、玩家操作）都要在服务器端统一管理，客户端只负责展示和发送操作指令，防止作弊。
2. 处理异常情况：除了超时，还要考虑玩家断开连接的情况，比如在waitForPlayerAction中监听socket.disconnect事件，触发reject并处理玩家离场逻辑。
3. 避免内存泄漏：每次监听事件后一定要清理（比如用once或者off），防止无效的事件监听占用内存。

内容的提问来源于stack exchange，提问作者Barry Wood