问Reversi算法检查
EN

Stack Overflow用户

提问于 2015-07-27 02:33:21

回答 1查看 3.3K关注 0票数 1

我目前正在构建一个Reversi游戏，其中的棋盘是一个8x8系列的整数(0表示空白，1表示白色，2表示黑色)。我已经想出了如何让垂直和水平来检查移动和进行移动，但不知道如何让对角线工作。

package OthelloTesting;

public class OthelloGameHandler {
    private int[][] gameBoard = new int[8][8];

    public OthelloGameHandler() {

    }

    public void setBoard(int[][] newBoard) {
        gameBoard = newBoard;
    }

    public int[][] getBoard() {
        return gameBoard;
    }




    private final boolean inBounds(int row, int col) {
        return row >= 0 && col >= 0 && row < gameBoard.length && col < gameBoard.length;
    }

    /*
     * Color is: 0 - Empty | 1 - White | 2 - Black Return Messages: 0 - Okay | 1
     * - Piece in Spot | 2 - Not Valid Placement
     */
    public int move(int color, int row, int col) {
        // Check if spot is full
        int oppColor = (color == 1) ? 2 : 1;
        int returnCode = 2;
        if (gameBoard[row][col] != 0) {
            returnCode = 1;
        }
        if (!inBounds(row, col)) {
            returnCode = 2;
        }
        // Check if move is Valid...

        // Check Right Horizontal
        if (col < 6 && gameBoard[row][col + 1] != 0 &&
            gameBoard[row][col + 1] == oppColor) {
            for (int pos = col + 2; pos < 8; pos++) {
                if (gameBoard[row][pos] == 0) {
                    break;
                }
                if (gameBoard[row][pos] == color) {
                    fill(color, row, col, row, pos);
                    returnCode = 0;
                }
            }
        }

        // Check Left Horizontal
        if (col > 1 && gameBoard[row][col - 1] != 0 &&
            gameBoard[row][col - 1] == oppColor) {
            for (int pos = col - 2; pos > -1; pos--) {
                if (gameBoard[row][pos] == 0) {
                    break;
                }
                if (gameBoard[row][pos] == color) {
                    fill(color, row, pos, row, col);
                    returnCode = 0;
                }
            }
        }

        // Check Bottom Vertical
        if (row < 6 && gameBoard[row + 1][col] != 0 && gameBoard[row + 1][col] == oppColor) {
            for (int pos = row + 2; pos < 8; pos++) {
                System.out.println("did");
                if (gameBoard[pos][col] == 0) {
                    break;
                }
                if (gameBoard[pos][col] == color) {
                    fill(color, row, col, pos, col);
                    returnCode = 0;
                }
            }
        }

        // Check Top Vertical
        if (row > 1 && gameBoard[row - 1][col] != 0 && gameBoard[row - 1][col] == oppColor) {
            for (int pos = row - 2; pos > -1; pos++) {
                System.out.println("did");
                if (gameBoard[pos][col] == 0) {
                    break;
                }
                if (gameBoard[pos][col] == color) {
                    fill(color, pos, col, row, col);
                    returnCode = 0;
                }
            }
        }

        // Check Upper Right Diagonal


        // Check Upper Left Diagonal


        // Check Lower Left Diagonal


        // Check Lower Right Diagonal

        return returnCode;
    }

    private void fill(int color, int r1, int c1, int r2, int c2) {

        // Horizontal Filling
        if (r1 == r2) {
            for (int pos = c1; pos <= c2; pos++) {
                gameBoard[r1][pos] = color;
            }
        }
        if (c1 == c2) {
            for (int pos = r1; pos <= r2; pos++) {
                gameBoard[pos][c1] = color;
            }
        }


    }
}

reversi

java

algorithm

回答 1

Stack Overflow用户

发布于 2017-03-31 08:34:53

我知道这是C++代码，你在做Java。但我认为你可以提炼出大意。

// flips discs in one direction
uint64_t flip_dir(const uint64_t P, const uint64_t O, const uint8_t move, const int dX, const int dY)
{
    uint64_t flips = 0;
    int i = (move % 8) + dX; // Starting index in x direction
    int j = (move / 8) + dY; // Starting index in y direction

    while ((i >= 0) && (i < 8) && (j >= 0) && (j < 8)) // In between boundaries
    {
        const uint64_t bit = 1ULL << (j * 8 + i); // The bit to look at
        if (O & bit) // The bit belongs to the opponent
            flips |= bit; // Add to possible flips
        else if (P & bit) // The bit belongs to the player
            return flips; // All possible flips become real flips
        else // The bit belongs to no player
            return 0; // There are no possible flips
        i += dX; // Advance in direction
        j += dY; // Advance in direction
    }
    return 0;
}

uint64_t flip(const uint64_t P, const uint64_t O, const uint8_t move)
{
    return move == 64 ? 0ULL :
           flip_dir(P, O, move, -1, -1)
         | flip_dir(P, O, move, -1,  0)
         | flip_dir(P, O, move, -1, +1)
         | flip_dir(P, O, move,  0, -1)
         | flip_dir(P, O, move,  0, +1)
         | flip_dir(P, O, move, +1, -1)
         | flip_dir(P, O, move, +1,  0)
         | flip_dir(P, O, move, +1, +1);
}