Java 象棋比赛无效

我正在写一盘国际象棋，但我总是碰到一只虫子。当我请求有效的移动时，我的程序返回一些不应该有效的点

这是我当前的代码

public enum PieceType {
    PAWN('p', (piece, pieceOnEndTile, board, move) -> {
        PieceTeam team = piece.getTeam();
        int dx = move.getdx();
        int dy = move.getdy();
        final boolean willKill = pieceOnEndTile != null && pieceOnEndTile.getTeam() != team;
        int direction = -1; // to distinguish between the dy of black and white
        if (team == PieceTeam.BLACK) {
            direction = 1; // for black pawns, dy is positive, for white it's
                            // negative
        }
        dy = dy * direction;
        boolean isKilling = willKill && dy == 1 && abs(dx) == 1;
        boolean isMoving1 = dy == 1 && dx == 0 && pieceOnEndTile == null;
        boolean isMoving2 = dy == 2 && dx == 0 && pieceOnEndTile == null && !piece.hasBeenMoved();

        return isKilling || isMoving1 || isMoving2;

    }), BISHOP('b', (piece, pieceOnEndTile, board, move) -> {
        PieceTeam team = piece.getTeam();
        int dx = move.getdx();
        int dy = move.getdy();
        return abs(dy) == abs(dx) && tileIsEmptyOrEnemy(pieceOnEndTile, team) && !pieceInWay(board, move, team);
    }), KNIGHT('k', (piece, pieceOnEndTile, board, move) -> {
        PieceTeam team = piece.getTeam();
        int dx = move.getdx();
        int dy = move.getdy();
        boolean isCorrectMove = (abs(dy) == abs(2 * dx) || (abs(dx) == abs(2 * dy))) && abs(dy) <= 2 && abs(dx) <= 2;

        return isCorrectMove && tileIsEmptyOrEnemy(pieceOnEndTile, team);
    }), ROOK('r', (piece, pieceOnEndTile, board, move) -> {
        PieceTeam team = piece.getTeam();
        int dx = move.getdx();
        int dy = move.getdy();
        return (abs(dy) >= 1 && abs(dx) == 0 || abs(dx) >= 1 && abs(dy) == 0) && tileIsEmptyOrEnemy(pieceOnEndTile, team) && !pieceInWay(board, move, team);
    }), QUEEN('Q', (piece, pieceOnEndTile, board, move) -> {
        PieceTeam team = piece.getTeam();
        int dx = move.getdx();
        int dy = move.getdy();
        return (abs(dy) == abs(dx) || abs(dy) >= 1 && abs(dx) == 0 || abs(dx) >= 1 && abs(dy) == 0) && tileIsEmptyOrEnemy(pieceOnEndTile, team) && !pieceInWay(board, move, team);
    }), KING('K', (piece, pieceOnEndTile, board, move) -> {
        PieceTeam team = piece.getTeam();
        int dx = move.getdx();
        int dy = move.getdy();
        return abs(dy) <= 1 && abs(dx) <= 1 && tileIsEmptyOrEnemy(pieceOnEndTile, team);
    });

    public final IsLegalMove isLegalMove;
    public final char representation;

    private PieceType(final char representation, final IsLegalMove isLegalMove) {
        this.isLegalMove = isLegalMove;
        this.representation = representation;
    }

    private static boolean tileIsEmptyOrEnemy(GamePiece piece, PieceTeam currentTeam) {
        return piece == null || piece.getTeam() != currentTeam;
    }

    private static boolean pieceInWay(GamePiece[][] board, Move move, PieceTeam team) {
        int changerx = (int) Math.signum(move.getdx());
        int changery = (int) Math.signum(move.getdy());
        for (int x = move.start.x + changerx, y = move.start.y + changery; x < move.end.x; x += changerx, y += changery) {
            if (board[y][x] != null) {
                return true;
            }
        }
        return false;
    }

    @FunctionalInterface
    public static interface IsLegalMove {
        public boolean call(GamePiece piece, GamePiece pieceOnEndTile, GamePiece[][] board, Move move);
    }

}

公共枚举片段类型{
典当（'p'，（分块、分块、棋盘、移动）->{
PieceTeam=piece.getTeam（）；
int dx=move.getdx（）；
int dy=move.getdy（）；
最终布尔值willKill=pieceOnEndTile！=null&&pieceOnEndTile.getTeam（）！=team；
int direction=-1；//用于区分黑色和白色的dy
if（team==PieceTeam.BLACK）{
方向=1；//对于黑色棋子，dy为正，对于白色棋子，dy为正
//否定的
}
dy=dy*方向；
布尔值iskill=willKill&&dy==1&&abs（dx）==1；
布尔值isMoving1=dy==1&&dx==0&&PieceOnEndFile==null；
布尔值isMoving2=dy==2&&dx==0&&PieceOnEndFile==null&&！piece.hasBeenMoved（）；
返回正在杀死| |正在移动1 | |正在移动2；
})，BISHOP（'b'，（片，片，板，移动）->{
PieceTeam=piece.getTeam（）；
int dx=move.getdx（）；
int dy=move.getdy（）；
返回abs（dy）=abs（dx）&&tileisemptyorfriend（pieconendtile，team）&&pieceeinway（board，move，team）；
})，骑士（'k'，（棋子，棋子，棋盘，移动）->{
PieceTeam=piece.getTeam（）；
int dx=move.getdx（）；
int dy=move.getdy（）；
布尔值isCorrectMove=（abs（dy）=abs（2*dx）| |（abs（dx）=abs（2*dy））&&abs（dy）=1&&abs（dx）=0 | | abs（dx）>=1&&abs（dy）==0&&tileisemptyTorOwner敌人（拼块文件，团队）和拼块（棋盘，移动，团队）；
})，皇后（'Q'，（片，片，板，移动）->{
PieceTeam=piece.getTeam（）；
int dx=move.getdx（）；
int dy=move.getdy（）；
返回（abs（dy）=abs（dx）| | abs（dy）>=1和abs（dx）==0和abs（dx）>=1和abs（dy）==0）和tileispentyortofriend（pieceOnEndTile，team）和&！pieceInWay（board，move，team）；
})，国王（'K'，（片，片，板，移动）->{
PieceTeam=piece.getTeam（）；
int dx=move.getdx（）；
int dy=move.getdy（）；
return abs（dy）我通过为8个方向中的每一个写出实际案例来修复它，现在它似乎可以工作了

public static boolean pieceInWay(final GamePiece[][] board, final Move move) {
        final int changerx = (int) Math.signum(move.getdx());
        final int changery = (int) Math.signum(move.getdy());
        switch (Direction.getFromDelta(changerx, changery)) {
        case DOWN:
            for (int y = move.start.y + 1; y < move.end.y; y++) {
                if (board[y][move.start.x] != null) {
                    return true;
                }
            }
            break;
        case DOWN_LEFT:
            for (int y = move.start.y + 1, x = move.start.x - 1; y < move.end.y; y++, x--) {
                if (board[y][x] != null) {
                    return true;
                }
            }
            break;
        case DOWN_RIGHT:
            for (int y = move.start.y + 1, x = move.start.x + 1; y < move.end.y; y++, x++) {
                if (board[y][x] != null) {
                    return true;
                }
            }
            break;
        case LEFT:
            for (int x = move.start.x - 1; x > move.end.x; x--) {
                if (board[move.start.y][x] != null) {
                    return true;
                }
            }
            break;
        case RIGHT:
            for (int x = move.start.x + 1; x < move.end.x; x++) {
                if (board[move.start.y][x] != null) {
                    return true;
                }
            }
            break;
        case UP:
            for (int y = move.start.y - 1; y > move.end.y; y--) {
                if (board[y][move.start.x] != null) {
                    return true;
                }
            }
            break;
        case UP_LEFT:
            for (int y = move.start.y - 1, x = move.start.x - 1; y > move.end.y; y--, x--) {
                if (board[y][x] != null) {
                    return true;
                }
            }
            break;
        case UP_RIGHT:
            for (int y = move.start.y - 1, x = move.start.x + 1; y > move.end.y; y--, x++) {
                if (board[y][x] != null) {
                    return true;
                }
            }
            break;
        }
        return false;
    }

    @FunctionalInterface
    public static interface IsLegalMove {
        public boolean call(GamePiece piece, GamePiece pieceOnEndTile, GamePiece[][] board, Move move);
    }

    private static enum Direction {
        UP(0, -1),
        UP_RIGHT(1, -1),
        RIGHT(1, 0),
        DOWN_RIGHT(1, 1),
        DOWN(0, 1),
        DOWN_LEFT(-1, 1),
        LEFT(-1, 0),
        UP_LEFT(-1, -1);

        public final int dx;
        public final int dy;

        private Direction(final int dx, final int dy) {
            this.dx = dx;
            this.dy = dy;
        }

        public static Direction getFromDelta(final int dx, final int dy) {
            for (final Direction d : values()) {
                if (d.dx == dx && d.dy == dy) {
                    return d;
                }
            }
            return null;
        }
    }

publicstaticbooleanpoigeinway（最终游戏片[][]棋盘，最终移动）{
final int changerx=（int）Math.signum（move.getdx（））；
final int changery=（int）Math.signum（move.getdy（））；
开关（方向：getFromDelta（changerx，changery））{
按大小写：
for（int y=move.start.y+1；ymove.end.x；x--）{
如果（板[move.start.y][x]！=null）{
返回true；
}
}
打破
案例权利：
for（int x=move.start.x+1；xmove.end.y；y--）{
如果（线路板[y][move.start.x]！=null）{
返回true；
}
}
打破
左起右起：
对于（int y=move.start.y-1，x=move.start.x-1；y>move.end.y；y--，x--）{
如果（线路板[y][x]！=null）{
返回true；
}
}
打破
案例右起：
对于（int y=move.start.y-1，x=move.start.x+1；y>move.end.y；y--，x++）{
如果（线路板[y][x]！=null）{
返回true；
}
}
打破
}
返回false；
}
@功能接口
公共静态接口IsLegalMove{
公共布尔调用（GamePiece，GamePiece PieceOnEndFile，GamePiece[]]板，移动）；
}
私有静态枚举方向{
向上（0，-1），
右上（1，-1），
右（1,0），
右下（1，1），
向下（0，1），
左下角（-1，1），
左（-1,0），
左上角（-1，-1）；
公共最终int dx；
公开决赛；
专用方向（最终整数dx、最终整数dy）{
this.dx=dx；
this.dy=dy；
}
公共静态方向getFromDelta（最终整数dx，最终整数dy）{
对于（最终方向d:values（））{
如果（d.dx==dx&&d.dy==dy）{
返回d；
}
}
返回null；
}
}
可能是
y=move.start.y+changery
，y没有声明为int。你会得到什么样的错误？一旦程序变得复杂，你真的需要一个测试工具来保持一切正常。简单的方法，如
testPawn（）
，
testBishop（）
和
testPieceInWay（）
将帮助您隔离错误并避免复杂的调试。哪些点？针对哪些块？处于哪些板状态？@JamesBuck这不是错误，某些块（例如皇后）仅在某些方向正确停止。在皇后类中，它仅在右上角和右下角方向工作