Method attackingKing

src/main/java/game/Board.java:354–396

(Piece king)

    }

    private Set<Piece> attackingKing(Piece king) {
        final HashSet<Piece> attackers = new HashSet<>();
        final int kingRow = king.position.row, kingCol = king.position.col;
        final Color color = king.color;
        for (int rowDiff = -1; rowDiff <= 1; rowDiff++) {
            for (int colDiff = -1; colDiff <= 1; colDiff++) {
                if (!(rowDiff == 0 && colDiff == 0) && attackers.size() < 2) {
                    final PieceType type = rowDiff == 0 || colDiff == 0 ? PieceType.ROOK : PieceType.BISHOP;
                    for (int row = kingRow + rowDiff, col = kingCol + colDiff; Utils.withinBoardLimits(row, col); row = row + rowDiff, col = col + colDiff) {
                        if (!isEmpty(row, col)) {
                            final Piece piece = getPiece(row, col);
                            if (piece.color != color && (piece.sameType(PieceType.QUEEN) || piece.sameType(type))) {
                                attackers.add(piece);
                            }
                            break;
                        }
                    }
                }
            }
        }
        if (attackers.size() < 2) {
            final int pawnAttackRow = color == Color.BLACK ? kingRow - 1 : kingRow + 1;
            if (pawnAttackRow >= 0 && pawnAttackRow < 8) {
                final Piece leftPawn = kingCol > 0 ? getPiece(pawnAttackRow, kingCol - 1) : null;
                final Piece rightPawn = kingCol < 7 ? getPiece(pawnAttackRow, kingCol + 1) : null;
                if (rightPawn != null && rightPawn.sameType(PieceType.PAWN) && rightPawn.color != king.color) {
                    attackers.add(rightPawn);
                } else if (leftPawn != null && leftPawn.sameType(PieceType.PAWN) && leftPawn.color != king.color) {
                    attackers.add(leftPawn);
                }
            }
            for (int i = 0; i < Knight.diff.length && attackers.size() < 2; i++) {
                final int row = kingRow + Knight.diff[i][0], col = kingCol + Knight.diff[i][1];
                if (Utils.withinBoardLimits(row, col)) {
                    final Piece piece = getPiece(row, col);
                    if (piece != null && piece.sameType(PieceType.KNIGHT) && piece.color != king.color) {
                        attackers.add(piece);
                    }
                }
            }
        }
        return attackers;
    }

    private void updateHashForRemove(Piece piece) {
        zobristHash ^= zobrist[piece.pieceType.ordinal()][piece.color.ordinal()][(piece.position.row << 3) + piece.position.col];