连接四子游戏胜利检测算法

Question

我知道有很多关于四子棋检查胜利的问题。问题在于大多数其他算法会导致我的程序运行时错误，因为它们尝试访问数组之外的索引。

我的算法如下：

private int checkWin(int[][] gridTable,int rowNum,int colNum, int maxRow, int maxCol) 
{
//  For checking whether any win or lose condition is reached. Returns 1 if win or lose is reached. else returns 0
//  gridTable[][] is the game matrix(can be any number of rows and columns between 4 and 40)
//  colNum is the column number where the last token was placed
//  rowNum is the row number where the last token was placed
//  maxRow is the number of rows in my grid
//  maxCol is the number of columns in my grid

int player = gridTable[rowNum][colNum]; //player ID
int count=0;

// Horizontal check
for (int i=0;i<maxCol;i++)
{
    if (gridTable[rowNum][i]==player)
        count++;
    else
        count=0;

    if (count>=4)
        return 1;
}
//Vertical check
for (int i=0;i<maxRow;i++)
{
    if (gridTable[i][colNum]==player)
        count++;
    else
        count=0;

    if (count>=4)
        return 1;
} 
count=0;
// 4 in a row diagonally
for(int i=colNum+1,j=rowNum+1;i<maxRow && j<maxCol;i++,j++) 
{ 
    if(gridTable[j][i]!=player)
    {
        count=1;
        break;        
    }
    count++;
}
// 4 in a row diagonally
for(int i=colNum-1,j=rowNum-1;i>=0 && j>=0;i--,j--) 
{ 
    if(gridTable[j][i]!=player)
    {
        count=1;
        break;        
    }
    count++;
}
// 4 in a row diagonally
for(int i=colNum+1,j=rowNum-1;i<maxRow && j>=0;i++,j--) 
{ 
    if(gridTable[j][i]!=player)
    {
        count=1;
        break;        
    }
    count++;
}

for(int i=colNum-1,j=rowNum+1;i>=0 && j<maxCol;i--,j++) 
{ // 4 in a row diagonally
    if(gridTable[j][i]!=player)
    {
        count=1;
        break;        
    }
    count++;
}

if(count>=4)
    return 1;

return 0;
}

变量count用于检测胜利，如果count等于或大于4，则表示应该有4个或更多相同玩家的连续标记。

问题在于：有时方法会在没有4个按顺序排列的标记时检查胜利，而有时则不会在4个标记按顺序排列时检查胜利。

- madeluccar

---

所以索引越界错误出现在哪一行？ - Marc B

基本上，你有一个二维矩阵，在其中，你需要能够从给定点开始，并沿着给定方向移动，检查是否有四个匹配元素。我曾经为井字棋做过类似的事情（http://stackoverflow.com/questions/29788054/need-better-logic-for-tictactoe/29788374#29788374），但从概念上讲，这是相同的东西。 - MadProgrammer

@MadProgrammer 我尝试按照那样做，但当我有3个标记、一个空标记和另一个标记时，发生了一些事情，当我放下使5个连续标记的标记时，它没有返回胜利。 - madeluccar

是的，但基本上你有（至少）两种不同的方法。通过阅读您的代码，可能会发现即使用户只有一个令牌，计数实际上可能是2，这可能会导致问题。 - MadProgrammer

@MadProgrammer，你怎么修改代码让它能够正常工作？我已经和这个算法斗争了两天。它必须始终正常工作。 - madeluccar

Answer 1

出于某种原因，我不太喜欢计数器，所以我用了这种方式（它适用于不同尺寸的板子）。

public boolean areFourConnected(int player){

    // horizontalCheck 
    for (int j = 0; j<getHeight()-3 ; j++ ){
        for (int i = 0; i<getWidth(); i++){
            if (this.board[i][j] == player && this.board[i][j+1] == player && this.board[i][j+2] == player && this.board[i][j+3] == player){
                return true;
            }           
        }
    }
    // verticalCheck
    for (int i = 0; i<getWidth()-3 ; i++ ){
        for (int j = 0; j<this.getHeight(); j++){
            if (this.board[i][j] == player && this.board[i+1][j] == player && this.board[i+2][j] == player && this.board[i+3][j] == player){
                return true;
            }           
        }
    }
    // ascendingDiagonalCheck 
    for (int i=3; i<getWidth(); i++){
        for (int j=0; j<getHeight()-3; j++){
            if (this.board[i][j] == player && this.board[i-1][j+1] == player && this.board[i-2][j+2] == player && this.board[i-3][j+3] == player)
                return true;
        }
    }
    // descendingDiagonalCheck
    for (int i=3; i<getWidth(); i++){
        for (int j=3; j<getHeight(); j++){
            if (this.board[i][j] == player && this.board[i-1][j-1] == player && this.board[i-2][j-2] == player && this.board[i-3][j-3] == player)
                return true;
        }
    }
    return false;
}

- ferdelOlmo

---

我喜欢这个解决方案，因为它可以检查任意棋盘，而不需要知道上一个玩家的移动。 - Stevoisiak

升序对角线和降序对角线不是相反的吗？除此之外，终于有了一个不依赖于最后一颗石头的解决方案！ - techfly

Answer 2

看起来你的代码对于水平和垂直情况是正确的。棘手的部分是对角线情况。

让我们来看一张图片：

对于绿色线条，你的起始行位置是0 ... maxRow - 4。列应为0 ... startingRow -

伪代码:

// top-left to bottom-right - green diagonals
for( rowStart = 0; rowStart < rowMax - 4; rowStart++){
    count = 0;
    int row, col;
    for( row = rowStart, col = 0; row < rowMax && col < colMax; row++, col++ ){
        if(gridTable[row][col] == player){
            count++;
            if(count >= 4) return 1;
        }
        else {
            count = 0;
        }
    }
}

// top-left to bottom-right - red diagonals
for( colStart = 1; colStart < colMax - 4; colStart++){
    count = 0;
    int row, col;
    for( row = 0, col = colStart; row < rowMax && col < colMax; row++, col++ ){
        if(gridTable[row][col] == player){
            count++;
            if(count >= 4) return 1;
        }
        else {
            count = 0;
        }
    }
}

你可以为对角线往另一个方向（从左下到右上）做类似的操作。

- GreenGiant

---

你能帮我从右上到左下或者相反的方向完成这个吗？我已经卡了好几个小时了，但是不想在找到这个问题后再创建一个新的问题。 - DjoleRkc

@DjoleRkc 这里不是提问的地方，但我可以给你一个提示。如果你知道如何控制for循环遍历的方向，你就会有答案了。你怎么改变这里（col）的内部循环向下移动呢？"col++"是什么意思？你能把"col++"改成什么？如果你改变了它，起始点（col = colStart）和结束点（col < colMax）需要如何改变？ - GreenGiant

最初的算法很好，但我有一个内存释放的问题，我没有注意到...无论如何，感谢您的回答！ - DjoleRkc

Answer 3

所以，经过查看您的代码，似乎对角线检查只能在单个方向上获胜（如果我将一个令牌添加到最低行和最低列会发生什么？）

相反，基本的检查算法始终是相同的过程，无论您要检查哪个方向。

您需要一个起点（x / y）和x / y增量（移动方向）。 您可以将其总结为单个方法...

public boolean didWin(int[][] grid, int check, int row, int col, int rowDelta, int colDelta) {

    boolean win = true;
    for (int count = 0; count < 4; count++) {
        if (row < ROWS && row >= 0 && col < COLUMNS && col >= 0) {
            int test = grid[row][col];
            if (test != check) {
                win = false;
                break;
            }
        }
        row += rowDelta;
        col += colDelta;
    }
    return win;

}

这将基本上允许您检查四个方向，但也可以向后检查。

因此，如果我们使用类似于...

int[][] gridTable = new int[ROWS][COLUMNS];

gridTable[ROWS - 1][3] = 1;
gridTable[ROWS - 2][3] = 1;
gridTable[ROWS - 3][3] = 1;
gridTable[ROWS - 4][3] = 1;

System.out.println("Vertical");

System.out.println(didWin(gridTable, 1, ROWS - 4, 3, 1, 0) ? "Win" : "Lose");
System.out.println(didWin(gridTable, 1, ROWS - 1, 3, -1, 0) ? "Win" : "Lose");
System.out.println(didWin(gridTable, 1, 0, 3, 1, 0) ? "Win" : "Lose");

gridTable = new int[ROWS][COLUMNS];
gridTable[3][1] = 1;
gridTable[3][2] = 1;
gridTable[3][3] = 1;
gridTable[3][4] = 1;

System.out.println("");
System.out.println("Horizontal");
System.out.println(didWin(gridTable, 1, 3, 1, 0, 1) ? "Win" : "Lose");
System.out.println(didWin(gridTable, 1, 3, 4, 0, -1) ? "Win" : "Lose");
System.out.println(didWin(gridTable, 1, 3, 0, 0, 1) ? "Win" : "Lose");

gridTable = new int[ROWS][COLUMNS];
gridTable[0][1] = 1;
gridTable[1][2] = 1;
gridTable[2][3] = 1;
gridTable[3][4] = 1;

System.out.println("");
System.out.println("Diag");
System.out.println(didWin(gridTable, 1, 0, 1, 1, 1) ? "Win" : "Lose");
System.out.println(didWin(gridTable, 1, 3, 4, -1, -1) ? "Win" : "Lose");
System.out.println(didWin(gridTable, 1, 1, 2, 1, 1) ? "Win" : "Lose");

这个输出指的是什么？

Vertical
Win
Win
Lose

Horizontal
Win
Win
Lose

Diag
Win
Win
Lose

现在，你可以将其概括为...

public boolean didWin(int[][] grid, int check, int row, int col) {
    return didWin(grid, check, row, col, 1, 0) ||
                    didWin(grid, check, row, col, -1, 0) ||
                    didWin(grid, check, row, col, 0, 1) ||
                    didWin(grid, check, row, col, 0, -1) ||
                    didWin(grid, check, row, col, 1, 1) ||
                    didWin(grid, check, row, col, -1, -1) ||
                    didWin(grid, check, row, col, -1, 1) ||
                    didWin(grid, check, row, col, 1, -1);
}

因此，使用类似于...的东西......

int[][] gridTable = new int[ROWS][COLUMNS];

gridTable[ROWS - 1][3] = 1;
gridTable[ROWS - 2][3] = 1;
gridTable[ROWS - 3][3] = 1;
gridTable[ROWS - 4][3] = 1;

System.out.println("Vertical");

System.out.println(didWin(gridTable, 1, ROWS - 1, 3) ? "Win" : "Lose");
System.out.println(didWin(gridTable, 1, ROWS - 4, 3) ? "Win" : "Lose");

gridTable = new int[ROWS][COLUMNS];
gridTable[3][1] = 1;
gridTable[3][2] = 1;
gridTable[3][3] = 1;
gridTable[3][4] = 1;

System.out.println("");
System.out.println("Horizontal");
System.out.println(didWin(gridTable, 1, 3, 1) ? "Win" : "Lose");
System.out.println(didWin(gridTable, 1, 3, 4) ? "Win" : "Lose");

gridTable = new int[ROWS][COLUMNS];
gridTable[0][1] = 1;
gridTable[1][2] = 1;
gridTable[2][3] = 1;
gridTable[3][4] = 1;

System.out.println("");
System.out.println("Diag");
System.out.println(didWin(gridTable, 1, 0, 1) ? "Win" : "Lose");
System.out.println(didWin(gridTable, 1, 3, 4) ? "Win" : "Lose");

打印出类似于以下内容...

Vertical
Win
Win

Horizontal
Win
Win

Diag
Win
Win

我想补充一点，这种方法只有在您提供了一行中4个芯片的正确起始位置时才有效。例如，对于您的水平检查，didWin（gridTable，1，3，3）将提供false而不是true，因为循环只能检查一个方向。

我的意图并不是提供一个“开箱即用”的解决方案，而是提供一个概念，可以从中开发出更广泛的解决方案（我的意思是，我讨厌人们实际上必须去思考;））。我还根据OP知道最后一块放置的位置，即起点的想法设计了解决方案;)

通过略微修改didWin方法，可以从任何点检查n乘n网格...

public boolean didWin(int[][] grid, int check, int row, int col, int rowDelta, int colDelta) {
    boolean match = false;
    int matches = 0;
    while (row < ROWS && row >= 0 && col < COLUMNS && col >= 0) {
        int test = grid[row][col];
        if (test != check && match) {
            break;
        } else if (test == check) {
            match = true;
            matches++;
        }
        row += rowDelta;
        col += colDelta;
    }
    return matches == 4;
}

所以，我使用了...

public static final int ROWS = 8;
public static final int COLUMNS = 8;
//...
int[][] gridTable = new int[ROWS][COLUMNS];

gridTable[ROWS - 1][3] = 1;
gridTable[ROWS - 2][3] = 1;
gridTable[ROWS - 3][3] = 1;
gridTable[ROWS - 4][3] = 1;
for (int[] row : gridTable) {
    StringJoiner sj = new StringJoiner("|", "|", "|");
    for (int col : row) {
        sj.add(Integer.toString(col));
    }
    System.out.println(sj);
}
System.out.println(didWin(gridTable, 1, 3, 3));

我成功地让它工作了。有时候一个答案并不是完整的解决方案，而是一个种子，可以激发灵感带领某人走向新的领域 ;)

更进一步的改进将包括提供预期联接部件的数量，但我相信这是一个我真的不需要演示的改进 ;)

- MadProgrammer

---

非常感谢。你有什么书推荐吗？面向对象编程（OOP）？ - madeluccar

考虑阅读《Effective Java》。 - MadProgrammer

@Slvrfn 这是一个非常棒的想法，可以应用于 nxn 矩阵，也可以改装成类似战舰游戏的东西 :P - MadProgrammer

我想补充一点，这种方法只有在您提供了一行中4个芯片的正确起始位置时才有效。例如，didWin(gridTable, 1, 3, 3) 将为您的水平检查提供 false 而不是 true，因为循环只能检查一个方向。 - Akkusativobjekt

@Akkusativobjekt 所提供的解决方案旨在提供一个“开箱即用”的答案，它是一种思路，可以供OP扩展和探索，并希望在这个过程中学到新东西。我添加了更新内容，演示了如何将其修改为具有可变起点的nxn网格，进一步增强可能是包括预期相邻部件的数量，但我会把决定权留给其他编写代码的人 ;）。我还基于您知道上一个棋子落在哪里的想法设计了解决方案。 - MadProgrammer

Answer 4

我用C语言编写了自己的版本，我认为在另一种语言中重新解释它相当容易。

//Return values: 1 for Player 1, 2 for Player 2 and 0 for a tie.
// '-' represents an empty tile, 'X' Player 1, 'O' Player 2
#include <stddef.h>

int connect4(char *game[], size_t columns, size_t lines)
{
    int winner = -1;
    for (size_t l = 0; l < lines; l++)
    {
        for (size_t c = 0; c < columns; c++)
        {
            char player = game[l][c];
            if (player == '-')
                continue;
            if (c + 3 < columns && player == game[l][c + 1]
                && player == game[l][c + 2] && player == game[l][c + 3])
                winner = winner < 0 ? player : 0;
            if (l + 3 < lines && player == game[l + 1][c]
                && player == game[l + 2][c] && player == game[l + 3][c])
                winner = winner < 0 ? player : 0;
            if (c + 3 < columns && l + 3 < lines && player == game[l + 1][c + 1]
                && player == game[l + 2][c + 2] && player == game[l + 3][c + 3])
                winner = winner < 0 ? player : 0;
            if (c >= 3 && l + 3 < lines && player == game[l + 1][c - 1]
                && player == game[l + 2][c - 2] && player == game[l + 3][c - 3])
                winner = winner < 0 ? player : 0;
        }
    }
    if (winner < 1)
        return 0;
    else
        return winner == 88 ? 1 : 2;
}

- jack chouchani

Answer 5

如果有人仍然需要解决方案，我已经在GitHub存储库中编写了一个C#函数。

/// <summary>
    /// WinnerCalc check if blue or red win the game.
    /// </summary>
    /// <returns>Return 1 if 1 win and 2 if 2 win and -1 if no one win.</returns>
    /// <param name="matrix">2d array</param>
    /// <param name="lastRow">The row number.</param>
    /// <param name="lastColumn">The column number.</param>
    public static int WinnerCalc(int[,] matrix, int lastRow, int lastColumn)
    {
        int lastValue = matrix[lastRow, lastColumn];
        Console.WriteLine("drop in row: " + (lastRow) + " and column: " + (lastColumn) + " , the value is: " + lastValue);
        int rows = matrix.GetLength(0); //6
        int columns = matrix.GetLength(1); //7
        Console.WriteLine("number of rows is " + rows + ", and number of colums is " + columns);

        int numToWin = 4;
        int winner = -1;//is now one win tha game
        int match;

        match = 0;
        //check Horizontal
        for (int c = 0; c < columns; c++)
        {
            int currentValue = matrix[lastRow, c];
            if (currentValue == lastValue)
                match++;
            else match = 0;
            if(match == numToWin)
            {
                winner = lastValue;
                break;
            }
        }
        if (winner != -1)
        {
            Console.WriteLine("win Horizontal !");
            return winner;
        }

        match = 0;
        //check Vertical
        for (int r = 0; r < rows; r++)
        {
            int currentValue = matrix[r, lastColumn];
            if (currentValue == lastValue)
                match++;
            else match = 0;
            if (match == numToWin)
            {
                winner = lastValue;
                break;
            }
        }
        if (winner != -1)
        {
            Console.WriteLine("win Vertical !");
            return winner;
        }

        //check diagonal top-left to bottom-right - include middle
        match = 0;
        for (int r = 0; r <= rows - 4; r++)
        {
            int rowPosition = r;
            for (int column = 0; column < columns && rowPosition < rows; column++)
            {
                int currentValue = matrix[rowPosition, column];
                if (currentValue == lastValue)
                    match++;
                else match = 0;
                if (match == numToWin)
                {
                    winner = lastValue;
                    break;
                }
                rowPosition++;
            }
            if (winner != -1) break;
        }
        if (winner != -1)
        {
            Console.WriteLine("win Diagonal Top left! - include middle");
            return winner;
        }

        //check diagonal top-left to bottom-right - after middle
        match = 0;
        for (int c = 1; c <= columns - 4; c++)
        {
            int columnPosition = c;
            for (int row = 0; row < rows && columnPosition < columns; row++)
            {
                int currentValue = matrix[row, columnPosition];
                if (currentValue == lastValue)
                    match++;
                else match = 0;
                if (match == numToWin)
                {
                    winner = lastValue;
                    break;
                }
                columnPosition++;
            }
            if (winner != -1) break;
        }
        if (winner != -1)
        {
            Console.WriteLine("win Diagonal Top left! - after middle");
            return winner;
        }


        //check diagonal bottom-left to top-right - include middle
        match = 0;
        for (int r = rows - 1; r >= rows - 4; r--)
        {
            int rowPosition = r;
            for (int column = 0; column < columns && rowPosition < rows && rowPosition >= 0; column++)
            {
                int currentValue = matrix[rowPosition, column];
                if (currentValue == lastValue)
                    match++;
                else match = 0;
                if (match == numToWin)
                {
                    winner = lastValue;
                    break;
                }
                rowPosition--;
            }
            if (winner != -1) break;
        }
        if (winner != -1)
        {
            Console.WriteLine("win Diagonal Bottom left! - include middle");
            return winner;
        }


        //check diagonal bottom-left to top-right - after middle
        match = 0;
        for (int c = 1; c < columns; c++)
        {
            int columnPosition = c;
            for (int row = rows - 1; row < rows && columnPosition < columns && columnPosition >= 1; row--)
            {
                int currentValue = matrix[row, columnPosition];
                if (currentValue == lastValue)
                    match++;
                else match = 0;
                if (match == numToWin)
                {
                    winner = lastValue;
                    break;
                }
                columnPosition++;
            }
            if (winner != -1) break;
        }
        if (winner != -1)
        {
            Console.WriteLine("win Diagonal Bottom left! - after middle");
            return winner;
        }



        return winner; // no winner return -1
    }

}

这是代码库链接: https://github.com/JoshK2/connect-four-winner

- Josh

Answer 6

这是对我有效的方法，而且看起来并没有花费太长时间：
这些方法包括了行、列、对角线和反对角线的 X 和 O；

public static void checkVertO(){
    if (board[0][0] == 'O' && board[1][0] == 'O' && board[2][0] == 'O' && board[3][0] == 'O' || board[1][0] == 'O' && board[2][0] == 'O' && board[3][0] == 'O' && board[4][0] == 'O' ||
    board[2][0] == 'O' && board[3][0] == 'O' && board[4][0] == 'O' && board[5][0] == 'O' || board[0][1] == 'O' && board[1][1] == 'O' && board[2][1] == 'O' && board[3][1] == 'O' || 
    board[1][1] == 'O' && board[2][1] == 'O' && board[3][1] == 'O' && board[4][1] == 'O' || board[2][1] == 'O' && board[3][1] == 'O' && board[4][1] == 'O' && board[5][1] == 'O' || 
    board[0][2] == 'O' && board[1][2] == 'O' && board[2][2] == 'O' && board[3][2] == 'O' || board[1][2] == 'O' && board[2][2] == 'O' && board[3][2] == 'O' && board[4][2] == 'O' ||
    board[2][2] == 'O' && board[3][2] == 'O' && board[4][2] == 'O' && board[5][2] == 'O' || board[0][3] == 'O' && board[1][3] == 'O' && board[2][3] == 'O' && board[3][3] == 'O' || 
    board[1][3] == 'O' && board[2][3] == 'O' && board[3][3] == 'O' && board[4][3] == 'O' || board[2][3] == 'O' && board[3][3] == 'O' && board[4][3] == 'O' && board[5][3] == 'O' ||
    board[0][4] == 'O' && board[1][4] == 'O' && board[2][4] == 'O' && board[3][4] == 'O' || board[1][4] == 'O' && board[2][4] == 'O' && board[3][4] == 'O' && board[4][4] == 'O' ||
    board[2][4] == 'O' && board[3][4] == 'O' && board[4][4] == 'O' && board[5][4] == 'O' || board[0][5] == 'O' && board[1][5] == 'O' && board[2][5] == 'O' && board[3][5] == 'O' || 
    board[1][5] == 'O' && board[2][5] == 'O' && board[3][5] == 'O' && board[4][5] == 'O' || board[2][5] == 'O' && board[3][5] == 'O' && board[4][5] == 'O' && board[5][5] == 'O' ||
    board[0][6] == 'O' && board[1][6] == 'O' && board[2][6] == 'O' && board[3][6] == 'O' || board[1][6] == 'O' && board[2][6] == 'O' && board[3][6] == 'O' && board[4][6] == 'O'||
    board[2][6] == 'O' && board[3][6] == 'O' && board[4][6] == 'O' && board[5][6] == 'O'){
        System.out.println("Game over, O won.");
        printBoard();
        doIt();
    }else {
        return;
    }
}

public static void checkHorzO(){
    if (board[0][0] == 'O' && board[0][1] == 'O' && board[0][2] == 'O' && board[0][3] == 'O' || board[0][1] == 'O' && board[0][2] == 'O' && board[0][3] == 'O' && board[0][4] == 'O' ||
    board[0][2] == 'O' && board[0][3] == 'O' && board[0][4] == 'O' && board[0][5] == 'O' || board[0][3] == 'O' && board[0][4] == 'O' && board[0][5] == 'O' && board[0][6] == 'O' ||
    board[1][0] == 'O' && board[1][1] == 'O' && board[1][2] == 'O' && board[1][3] == 'O' || board[1][1] == 'O' && board[1][2] == 'O' && board[1][3] == 'O' && board[1][4] == 'O' ||
    board[1][2] == 'O' && board[1][3] == 'O' && board[1][4] == 'O' && board[1][5] == 'O' || board[1][3] == 'O' && board[1][4] == 'O' && board[1][5] == 'O' && board[1][6] == 'O' ||
    board[2][0] == 'O' && board[2][1] == 'O' && board[2][2] == 'O' && board[2][3] == 'O' || board[2][1] == 'O' && board[2][2] == 'O' && board[2][3] == 'O' && board[2][4] == 'O' ||
    board[2][2] == 'O' && board[2][3] == 'O' && board[2][4] == 'O' && board[2][5] == 'O' || board[2][3] == 'O' && board[2][4] == 'O' && board[2][5] == 'O' && board[2][6] == 'O' ||
    board[3][0] == 'O' && board[3][1] == 'O' && board[3][2] == 'O' && board[3][3] == 'O' || board[3][1] == 'O' && board[3][2] == 'O' && board[3][3] == 'O' && board[3][4] == 'O' ||
    board[3][2] == 'O' && board[3][3] == 'O' && board[3][4] == 'O' && board[3][5] == 'O' || board[3][3] == 'O' && board[3][4] == 'O' && board[3][5] == 'O' && board[3][6] == 'O' ||
    board[4][0] == 'O' && board[4][1] == 'O' && board[4][2] == 'O' && board[4][3] == 'O' || board[4][1] == 'O' && board[4][2] == 'O' && board[4][3] == 'O' && board[4][4] == 'O' ||
    board[4][2] == 'O' && board[4][3] == 'O' && board[4][4] == 'O' && board[4][5] == 'O' || board[4][3] == 'O' && board[4][4] == 'O' && board[4][5] == 'O' && board[4][6] == 'O' ||
    board[5][0] == 'O' && board[5][1] == 'O' && board[5][2] == 'O' && board[5][3] == 'O' || board[5][1] == 'O' && board[5][2] == 'O' && board[5][3] == 'O' && board[5][4] == 'O' ||
    board[5][2] == 'O' && board[5][3] == 'O' && board[5][4] == 'O' && board[5][5] == 'O' || board[5][3] == 'O' && board[5][4] == 'O' && board[5][5] == 'O' && board[5][6] == 'O' ){
        System.out.println("Game over, O won.");
        printBoard();
        doIt();
    }else {
        return;
    }
}

public static void checkHorzX(){
    if (board[0][0] == 'X' && board[0][1] == 'X' && board[0][2] == 'X' && board[0][3] == 'X' || board[0][1] == 'X' && board[0][2] == 'X' && board[0][3] == 'X' && board[0][4] == 'X' ||
    board[0][2] == 'X' && board[0][3] == 'X' && board[0][4] == 'X' && board[0][5] == 'X' || board[0][3] == 'X' && board[0][4] == 'X' && board[0][5] == 'X' && board[0][6] == 'X' ||
    board[1][0] == 'X' && board[1][1] == 'X' && board[1][2] == 'X' && board[1][3] == 'X' || board[1][1] == 'X' && board[1][2] == 'X' && board[1][3] == 'X' && board[1][4] == 'X' ||
    board[1][2] == 'X' && board[1][3] == 'X' && board[1][4] == 'X' && board[1][5] == 'X' || board[1][3] == 'X' && board[1][4] == 'X' && board[1][5] == 'X' && board[1][6] == 'X' ||
    board[2][0] == 'X' && board[2][3] == 'X' && board[2][4] == 'X' && board[2][5] == 'X' || board[2][3] == 'X' && board[2][4] == 'X' && board[2][5] == 'X' && board[2][6] == 'X' ||
    board[3][0] == 'X' && board[3][1] == 'X' && board[3][2] == 'X' && board[3][3] == 'X' || board[3][1] == 'X' && board[3][2] == 'X' && board[3][3] == 'X' && board[3][4] == 'X' ||
    board[3][2] == 'X' && board[3][3] == 'X' && board[3][4] == 'X' && board[3][5] == 'X' || board[3][3] == 'X' && board[3][4] == 'X' && board[3][5] == 'X' && board[3][6] == 'X' ||
    board[4][0] == 'X' && board[4][3] == 'X' && board[4][4] == 'X' && board[4][5] == 'X' || board[4][3] == 'X' && board[4][4] == 'X' && board[4][5] == 'X' && board[4][6] == 'X' ||
    board[5][0] == 'X' && board[5][1] == 'X' && board[5][2] == 'X' && board[5][3] == 'X' || board[5][1] == 'X' && board[5][2] == 'X' && board[5][3] == 'X' && board[5][4] == 'X' ||
    board[5][2] == 'X' && board[5][3] == 'X' && board[5][4] == 'X' && board[5][5] == 'X' || board[5][3] == 'X' && board[5][4] == 'X' && board[5][5] == 'X' && board[5][6] == 'X' ){
        System.out.println("Game over, X won.");
        printBoard();
        doIt();
    }else {
        return;
    }
}

public static void checkDiagX(){
    if (board[2][0] == 'X' && board[3][1] == 'X' && board[4][2] == 'X' && board[5][3] == 'X'|| board[1][0] == 'X' && board[2][1] == 'X' && board[3][2] == 'X' && board[4][3] == 'X'||
    board[0][0] == 'X' && board[1][1] == 'X' && board[2][2] == 'X' && board[3][3] == 'X'|| board[0][1] == 'X' && board[1][2] == 'X' && board[2][3] == 'X' && board[3][4] == 'X'||
    board[1][1] == 'X' && board[2][2] == 'X' && board[3][3] == 'X' && board[4][4] == 'X'|| board[2][1] == 'X' && board[3][2] == 'X' && board[4][3] == 'X' && board[5][4] == 'X'||
    board[0][2] == 'X' && board[1][3] == 'X' && board[2][4] == 'X' && board[3][5] == 'X'|| board[1][2] == 'X' && board[2][3] == 'X' && board[3][4] == 'X' && board[4][5] == 'X'||
    board[2][2] == 'X' && board[3][3] == 'X' && board[4][4] == 'X' && board[5][5] == 'X'|| board[0][3] == 'X' && board[1][4] == 'X' && board[2][5] == 'X' && board[3][6] == 'X'||
    board[1][3] == 'X' && board[2][4] == 'X' && board[3][5] == 'X' && board[4][6] == 'X'|| board[2][3] == 'X' && board[3][4] == 'X' && board[4][5] == 'X' && board[5][6] == 'X'){
        System.out.println("Game over, X won.");
        printBoard();
        doIt();
    }else {
        return;
    }
}

public static void checkDiagO(){
    if (board[2][0] == 'O' && board[3][1] == 'O' && board[4][2] == 'O' && board[5][3] == 'O'|| board[1][0] == 'O' && board[2][1] == 'O' && board[3][2] == 'O' && board[4][3] == 'O'||
    board[0][0] == 'O' && board[1][1] == 'O' && board[2][2] == 'O' && board[3][3] == 'O'|| board[0][1] == 'O' && board[1][2] == 'O' && board[2][3] == 'O' && board[3][4] == 'O'||
    board[1][1] == 'O' && board[2][2] == 'O' && board[3][3] == 'O' && board[4][4] == 'O'|| board[2][1] == 'O' && board[3][2] == 'O' && board[4][3] == 'O' && board[5][4] == 'O'||
    board[0][2] == 'O' && board[1][3] == 'O' && board[2][4] == 'O' && board[3][5] == 'O'|| board[1][2] == 'O' && board[2][3] == 'O' && board[3][4] == 'O' && board[4][5] == 'O'||
    board[2][2] == 'O' && board[3][3] == 'O' && board[4][4] == 'O' && board[5][5] == 'O'|| board[0][3] == 'O' && board[1][4] == 'O' && board[2][5] == 'O' && board[3][6] == 'O'||
    board[1][3] == 'O' && board[2][4] == 'O' && board[3][5] == 'O' && board[4][6] == 'O'|| board[2][3] == 'O' && board[3][4] == 'O' && board[4][5] == 'O' && board[5][6] == 'O'){
        System.out.println("Game over, O won.");
        printBoard();
        doIt();
    }else {
        return;
    }
}

public static void checkAntiDiagX(){
    if (board[3][0] == 'X' && board[2][1] == 'X' && board[1][2] == 'X' && board[0][3] == 'X'|| board[4][0] == 'X' && board[3][1] == 'X' && board[2][2] == 'X' && board[1][3] == 'X'||
    board[3][1] == 'X' && board[2][2] == 'X' && board[1][3] == 'X' && board[0][4] == 'X'|| board[5][0] == 'X' && board[4][1] == 'X' && board[3][2] == 'X' && board[2][3] == 'X'||        
    board[4][1] == 'X' && board[3][2] == 'X' && board[2][3] == 'X' && board[1][4] == 'X'|| board[3][2] == 'X' && board[2][2] == 'X' && board[1][4] == 'X' && board[0][5] == 'X'||
    board[5][1] == 'X' && board[4][2] == 'X' && board[3][3] == 'X' && board[2][4] == 'X'|| board[4][2] == 'X' && board[3][3] == 'X' && board[2][4] == 'X' && board[1][5] == 'X'||
    board[3][3] == 'X' && board[2][4] == 'X' && board[1][5] == 'X' && board[0][6] == 'X'|| board[5][2] == 'X' && board[4][3] == 'X' && board[3][4] == 'X' && board[2][5] == 'X'||
    board[4][3] == 'X' && board[3][4] == 'X' && board[2][5] == 'X' && board[1][6] == 'X'|| board[5][3] == 'X' && board[4][4] == 'X' && board[3][5] == 'X' && board[2][6] == 'X'){
        System.out.println("Game over, X won.");
        printBoard();
        doIt();
    }else {
        return;
    }
}

 public static void checkAntiDiagO(){
    if (board[3][0] == 'O' && board[2][1] == 'O' && board[1][2] == 'O' && board[0][3] == 'O'|| board[4][0] == 'O' && board[3][1] == 'O' && board[2][2] == 'O' && board[1][3] == 'O'||
    board[3][1] == 'O' && board[2][2] == 'O' && board[1][3] == 'O' && board[0][4] == 'O'|| board[5][0] == 'O' && board[4][1] == 'O' && board[3][2] == 'O' && board[2][3] == 'O'||        
    board[4][1] == 'O' && board[3][2] == 'O' && board[2][3] == 'O' && board[1][4] == 'O'|| board[3][2] == 'O' && board[2][2] == 'O' && board[1][4] == 'O' && board[0][5] == 'O'||
    board[5][1] == 'O' && board[4][2] == 'O' && board[3][3] == 'O' && board[2][4] == 'O'|| board[4][2] == 'O' && board[3][3] == 'O' && board[2][4] == 'O' && board[1][5] == 'O'||
    board[3][3] == 'O' && board[2][4] == 'O' && board[1][5] == 'O' && board[0][6] == 'O'|| board[5][2] == 'O' && board[4][3] == 'O' && board[3][4] == 'O' && board[2][5] == 'O'||
    board[4][3] == 'O' && board[3][4] == 'O' && board[2][5] == 'O' && board[1][6] == 'O'|| board[5][3] == 'O' && board[4][4] == 'O' && board[3][5] == 'O' && board[2][6] == 'O'){
        System.out.println("Game over, O won.");
        printBoard();
        doIt();
    }else {
        return;
    }
}

- Daniil German

---

这真的很有趣。 - dcts