这个问题相当大，不看我的代码就很难解决，如果非常大，那么范围可能太大了，我会删除这个问题。基本上我有一个有效的国际象棋游戏，其中包含国际象棋的所有规则 except Check (和 因此也不是将死，僵局等.) 实现。

我通过为我的 ChessBoard 的 Squares 分配两个 boolean 值来实现 Check:protectedByWhite和 protectedByBlack .有两个主要的检查逻辑:

• 如果白方下棋导致他的王在方格上 那是 protectedByBlack ，反之亦然，黑棋是 “撤消”。
• 如果白方下棋导致黑方王位于protectedByWhite的格子上，反之亦然，黑方下一步必须将王放在不是protectedByWhite的格子上。 .

因此逻辑相当简单。在我的 ChessBoard类，我有testCheckWhite和 testCheckBlack每次移动后调用的函数。在我的 Square 中调用了移动类(一个简单的鼠标点击功能)。

主要问题是代码有问题...我不确定原因/位置。主要错误是:

• 当黑色或白色处于 Check 状态时，如果他们在仍处于 Check 状态的位置移动，则该移动不会撤消。我知道撤消功能工作正常，所以我的逻辑有些错误。

例如，当黑色/白色处于检查状态时，我在侧面有标签提醒。当我最初“检查”对手时，标签会通知我检查。但是，当我尝试将国王移动到我仍处于检查状态的方格时，标签错误地表示没有检查。我已经工作了一段时间，试图找出我哪里出错了，我可以使用一些指导。

相关代码:

ChessBoard.Java

public static void setProtectedSquares() {
        // Reset
        for(Square s : BOARD_SQUARES) {
            s.protectedByWhite = false;
            s.protectedByBlack = false;
        }

        // Now set protections
        for(Square s : BOARD_SQUARES) {
            if(s.hasPiece() && s.getPiece().getTeamColor().equals(TeamColor.WHITE)) {
                Piece p = s.getPiece();
                for(int[] position : p.getLegalMoves(p.getPosition())) {
                    if(hasSquare(position)) {
                        getSquare(position).protectedByWhite = true;
                    }
                }
            }
        }
        for(Square s : BOARD_SQUARES) {
            if(s.hasPiece() && s.getPiece().getTeamColor().equals(TeamColor.BLACK)) {
                Piece p = s.getPiece();
                for(int[] position : p.getLegalMoves(p.getPosition())) {
                    if(hasSquare(position)) {
                        getSquare(position).protectedByBlack = true;
                    }
                }
            }
        }
}

public static boolean testCheckWhite() {

        // Get king position
        int[] whiteKingPosition = new int[]{};
        for(Square s : BOARD_SQUARES) {
            Piece p = s.getPiece();
            if(s.hasPiece() && (p.getPieceType()).equals(PieceType.KING)) {
                if((p.getTeamColor()).equals(TeamColor.WHITE)) {
                    whiteKingPosition = p.getPosition();
                }
            }
        }

        if(hasSquare(whiteKingPosition) && getSquare(whiteKingPosition).protectedByBlack) {
            GameInfoPanel.inCheckWhite.setText("White is in check");
            return true;
        } else {
            GameInfoPanel.inCheckWhite.setText("White is not in check");
            return false;
        }
    }

    public static boolean testCheckBlack() {

        // Get king position
        int[] blackKingPosition = new int[]{};
        for(Square s : BOARD_SQUARES) {
            Piece p = s.getPiece();
            if(s.hasPiece() && (p.getPieceType()).equals(PieceType.KING)) {
                if((p.getTeamColor()).equals(TeamColor.BLACK)) {
                    blackKingPosition = p.getPosition();
                }
            }
        }

        if(hasSquare(blackKingPosition) && getSquare(blackKingPosition).protectedByWhite) {
            GameInfoPanel.inCheckBlack.setText("Black is in check");
            return true;
        } else {
            GameInfoPanel.inCheckBlack.setText("Black is not in check");
            return false;
        }
    }

Square.java

.... // If a square is clicked that IS colored...
        } else {
            for(Square s : ChessBoard.BOARD_SQUARES) {
                if(s.hasPiece() && (s.getPiece()).getFocus()) {

                    // Check to make sure that the target square and current
                    // square are not the same
                    if(!this.equals(s)) {
                        movePiece(s);

                        ChessBoard.setProtectedSquares();

                        // Test for check
                        // 1) Find out what color the moved piece is
                        if((ChessBoard.getTurn()) == TeamColor.WHITE) {
                            if(ChessBoard.testCheckWhite()) {
                                // Undo move
                                s.movePiece(ChessBoard.getSquare(STORED_POSITION));
                                GameInfoPanel.gameStatus.setText("Illegal move, white in check");
                            } else if(ChessBoard.testCheckBlack()) {
                                // Move is okay, black is now in check
                                GameInfoPanel.gameStatus.setText("Okay move, black in check");
                                // Switch players' turn
                                ChessBoard.switchTurn();
                            } else {
                                // Move is okay, nothing happened
                                GameInfoPanel.gameStatus.setText("No one in check");
                                // Switch players' turn
                                ChessBoard.switchTurn();
                            }

                        } else {
                            if(ChessBoard.testCheckBlack()) {
                                // Undo move
                                s.movePiece(ChessBoard.getSquare(STORED_POSITION));
                                GameInfoPanel.gameStatus.setText("Illegal move, black in check");
                            } else if(ChessBoard.testCheckWhite()) {
                                // Move is okay, white is now in check
                                GameInfoPanel.gameStatus.setText("Okay move, white in check");
                                // Switch players' turn
                                ChessBoard.switchTurn();
                            } else {
                                // Move is okay, nothing happened
                                GameInfoPanel.gameStatus.setText("No one in check");
                                // Switch players' turn
                                ChessBoard.switchTurn();
                            }
                        }
                    }
                }
            }

            // Clear all color and focus
            ChessBoard.clearFocus();

            ChessBoard.setProtectedSquares();
        }

最佳答案

我很理解你代码的算法。不幸的是，我没有发现您发布的代码段有任何问题。

这就是为什么在编写代码时应始终使用单元测试的原因。 :)

1. 对 setProtectedSquares() 进行单元测试
2. 对 testCheckWhite() 进行单元测试
3. 对 testcCheckBlack() 进行单元测试
4. 单元测试然后重构 for(Square s : ChessBoard.BOARD_SQUARES) {...}

从长远来看，这些将对您有所帮助。

但是，如果您想(希望)更快地解决问题，请使用 IDE 中的调试器 模式。

关于java - 在国际象棋游戏中实现 "Check"，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/23380770/