终端版Connect Four游戏胜利检测逻辑调试求助

我正在开发终端版Connect Four游戏，但无法检测到一行中四个相邻的相同元素。调试时，从diagonal1(grid)到静态方法checkWin()的代码段会直接导致程序关闭，根本无法进入checkWin()方法。最困惑的是遍历line的最内层for循环总是返回空数组，而不是预期的['X', 'X', 'X', 'X']这类结果。我需要这个循环找出一行中四个连续的相同元素并返回对应的数组。

我的代码如下：

class Myclass {
  constructor() {
    this.playerTurn = "O";
    this.grid = [[' ',' ',' ',' ',' ',' ',' '],
                 [' ',' ',' ',' ',' ',' ',' '],
                 [' ',' ',' ',' ',' ',' ',' '],
                 [' ',' ',' ',' ',' ',' ',' '],
                 [' ',' ',' ',' ',' ',' ',' '],
                 [' ',' ',' ',' ',' ',' ',' ']]

    this.cursor = new Cursor(6, 7);

    // Initialize a 6x7 connect-four grid
    Screen.initialize(6, 7);
    Screen.setGridlines(true);

    // Replace this with real commands
    Screen.addCommand('up', 'move up', this.cursor.up);
    Screen.addCommand('down', 'move down', this.cursor.down);
    Screen.addCommand('right', 'move right', this.cursor.right);
    Screen.addCommand('left', 'move left', this.cursor.left);

    this.cursor.setBackgroundColor();
    Screen.render();
  }

  diagonal1(grid) {
    let diagonals = [];

    for (let i = 0; i < grid.length; i++) {
      for (let j = 0; j < grid[i].length; j++) {
        let diagonal = [];

        let row = i;
        let col = j;
        while (row < grid.length && col < grid[i].length) {
          diagonal.push(grid[row][col]);
          row++;
          col++;
        }
        if (diagonal.length > 4) {
          diagonals.push(diagonal);
        }
      }
    }
    return diagonals;
  }

  diagonal2(grid) {
    let diagonals = [];

    for (let i = grid.length - 1; i >= 0; i--) {
      for (let j = grid[i].length - 1; j >= 0; j--) {
        let diagonal = [];

        let row = i;
        let col = j;
        while (row >= 0 && col >= 0) {
          diagonal.push(grid[row][col]);
          row--;
          col--;
        }
        if (diagonal.length > 4) {
          diagonals.push(diagonal);
        }
      }
    }
    return diagonals;
  }

  static checkWin(grid) {
    const players = ['X', 'O'];
    const columns = grid[0].map((_, i) => grid.map(row => row[i]));
    const rows = grid;
    const obj = new ConnectFour();
    const downwardDiagonals = obj.diagonal1(grid);
    const upwardDiagonals = obj.diagonal2(grid);

    if (grid.flat().every(cell => cell === ' ')) {
      return false;
    }

    for (let player of players) {
      let winner = [];
      for (let line of [...rows, ...columns, ...downwardDiagonals, ...upwardDiagonals]) {
        // find the player that takes four cells of a line consequtively
        let currentElement = [];
        let count = 0;
        let winner = [];

        for (let i = 0; i < line.length; i++) {
          if (line[i] !== ' ' && line[i] === currentElement) {
            count++;
          } else {
            currentElement = line[i];
            count = 0;
          }
          if (count >= 4) {
            winner.push(currentElement);
          }
        }
        console.log(winner)
        return winner;
      }
      // ------------------------------
      if (winner.length >= 4) return player;
      
      if (grid.flat().every(cell => cell !== ' ')) {
        return "T";
      }
    }
    return false;
  }

  static endGame(winner) {
    if (winner === 'O' || winner === 'X') {
      Screen.setMessage(`Player ${winner} wins!`);
    } else if (winner === 'T') {
      Screen.setMessage(`Tie game!`);
    } else {
      Screen.setMessage(`Game Over`);
    }
    Screen.render();
    Screen.quit();
  }
}

测试返回以下错误：

• Connect Four 识别横向胜利：AssertionError: expected [] to equal 'X'
• Connect Four 识别纵向胜利：AssertionError: expected [] to equal 'X'
• Connect Four 识别右下对角线胜利：AssertionError: expected [] to equal 'X'
• Connect Four 识别左上对角线胜利：AssertionError: expected [] to equal 'O'

问题修复方案 #

1. 终止逻辑错误 #

checkWin方法的最内层循环结束后直接return winner，导致仅检查第一条线就退出，无法遍历所有可能的胜利路径。删除该提前返回语句，仅在确认胜利时返回结果。

2. 连续计数逻辑错误 #

• currentElement初始值为数组[]，与单元格字符串值永远不匹配，导致计数逻辑失效，改为初始化为null。
• 连续4个相同元素的计数条件应为streak >= 4，调整计数起始值为1，匹配时递增。
• 找到胜利条件后直接返回当前玩家，无需继续收集元素。

3. 对角线收集逻辑错误 #

• diagonal1和diagonal2中判断对角线长度的条件为>4，但胜利只需要长度≥4的线，改为>=4，避免漏掉刚好4个元素的有效对角线。
• diagonal2的遍历逻辑会重复收集对角线，调整遍历起始点，仅从能形成有效对角线的位置开始。

4. 类实例化错误 #

checkWin是静态方法，内部实例化ConnectFour但类实际名为Myclass，改为new Myclass()，或把对角线方法改为静态方法。

修复后的核心代码示例 #

修复后的checkWin方法

static checkWin(grid) {
  const columns = grid[0].map((_, i) => grid.map(row => row[i]));
  const rows = grid;
  const obj = new Myclass();
  const downwardDiagonals = obj.diagonal1(grid);
  const upwardDiagonals = obj.diagonal2(grid);

  // 空棋盘直接返回
  if (grid.flat().every(cell => cell === ' ')) {
    return false;
  }

  // 遍历所有可能的胜利线
  const allLines = [...rows, ...columns, ...downwardDiagonals, ...upwardDiagonals];
  for (let line of allLines) {
    let currentPlayer = null;
    let streak = 0;
    for (let cell of line) {
      if (cell === ' ') {
        currentPlayer = null;
        streak = 0;
        continue;
      }
      if (cell === currentPlayer) {
        streak++;
        if (streak >= 4) {
          return currentPlayer;
        }
      } else {
        currentPlayer = cell;
        streak = 1;
      }
    }
  }

  // 检查平局
  if (grid.flat().every(cell => cell !== ' ')) {
    return "T";
  }

  return false;
}

修复后的diagonal1方法

diagonal1(grid) {
  let diagonals = [];
  const rows = grid.length;
  const cols = grid[0].length;

  for (let i = 0; i < rows; i++) {
    for (let j = 0; j < cols; j++) {
      let diagonal = [];
      let row = i;
      let col = j;
      while (row < rows && col < cols) {
        diagonal.push(grid[row][col]);
        row++;
        col++;
      }
      if (diagonal.length >= 4) {
        diagonals.push(diagonal);
      }
    }
  }
  return diagonals;
}

修复后的diagonal2方法

diagonal2(grid) {
  let diagonals = [];
  const rows = grid.length;
  const cols = grid[0].length;

  for (let i = 0; i < rows; i++) {
    for (let j = cols - 1; j >= 0; j--) {
      let diagonal = [];
      let row = i;
      let col = j;
      while (row < rows && col >= 0) {
        diagonal.push(grid[row][col]);
        row++;
        col--;
      }
      if (diagonal.length >= 4) {
        diagonals.push(diagonal);
      }
    }
  }
  return diagonals;
}

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