Java 国际象棋，防止棋子在斜行时跳过棋子

希望你们做得很好

在过去的两天里，我一直在尝试编写一个国际象棋引擎的代码，我有一个似乎无法解决的问题，下面的代码工作得非常好，棋子在棋盘上所有有限的2D空间中呈对角线移动（请注意，棋盘是一个8*8 2D数组），问题是，我不知道如何防止一个棋子在斜行时跳过其他棋子

方法如下：

    /**
 * y = abs(x)
 * y = -abs(x)
 * programming these 2 functions will let the piece go diagonally in all directions.
 *@param pieceX: current X coordinates of the piece
 * @param pieceY : current Y Coordinates of the piece
 * @param board: Board instance to get the locations of all the pieces
 * @return legal movements
 */
protected int[][] diagonalMove(int pieceX, int pieceY, Board board)
{
    ArrayList<Integer> legalXMovements = new ArrayList<>();
    ArrayList<Integer> legalYMovements = new ArrayList<>();

    //cartesian plane with a size of 8*8.
    for (int x = 7; x > -8; x--)
    {
        for (int y = 7; y > -8; y--)
        {
            //function 1: y = abs(x) and y > 0: Math.abs(x) == Math.abs(y)
            //function 2: y = -abs(x) : y == -Math.abs(x)
            if (Math.abs(x) == Math.abs(y) || y == -Math.abs(x))
            {
                //prevent OutOfBounds at any case.
                if (pieceX + x >= 0 && pieceX + x < 8)
                {
                    if (pieceY + y >= 0 && pieceY + y < 8)
                    {
                        //make sure that the piece doesn't eat his allies

                        //if Tile is empty.
                        if (board.getTile(pieceX + x, pieceY + y).checkIsEmpty())
                        {
                            legalXMovements.add(pieceX + x);
                            legalYMovements.add(pieceY + y);
                        }
                        else
                        {
                            //if enemy.
                            if (color != board.getTile(pieceX + x, pieceY + y).getPiece().getColor())
                            {
                                legalXMovements.add(pieceX + x);
                                legalYMovements.add(pieceY + y);
                            }
                        }

                    }
                }
            }
        }
    }
    //Chess, preventing a piece from jumping over pieces when going diagonally
    int[][] finalLegalMovements = new int[legalXMovements.size()][2];
    for (int x = 0; x < legalXMovements.size(); x++)
    {
        finalLegalMovements[x][0] = legalXMovements.get(x);
        finalLegalMovements[x][1] = legalYMovements.get(x);
    }


    return finalLegalMovements;
}

/**
*y=abs（x）
*y=-abs（x）
*编程这两个函数将使工件在所有方向上呈对角线移动。
*@param pieceX：工件的当前X坐标
*@param pieceY：工件的当前Y坐标
*@param board:board实例获取所有棋子的位置
*@返回法律运动
*/
受保护的int[][]对角线移动（int-pieceX，int-pieceY，Board）
{
ArrayList legalXMovements=新的ArrayList（）；
ArrayList legalYMovements=新的ArrayList（）；
//大小为8*8的笛卡尔平面。
对于（int x=7；x>-8；x--）
{
对于（int y=7；y>-8；y--）
{
//函数1:y=abs（x）和y>0:Math.abs（x）==Math.abs（y）
//函数2:y=-abs（x）：y==-Math.abs（x）
if（Math.abs（x）=Math.abs（y）| | y==-Math.abs（x））
{
//在任何情况下都要防止越界。
如果（pieceX+x>=0&&pieceX+x<8）
{
如果（分段+y>=0&&pieceY+y<8）
{
//确保这一块不会吃掉他的盟友
//如果瓷砖是空的。
if（board.getTile（pieceX+x，pieceY+y）.checkIsEmpty（））
{
法律动议。添加（计件x+x）；
法律动议。添加（分段+y）；
}
其他的
{
//如果是敌人。
if（color！=board.getTile（pieceX+x，pieceY+y）.getPiece（）.getColor（））
{
法律动议。添加（计件x+x）；
法律动议。添加（分段+y）；
}
}
}
}
}
}
}
//国际象棋，防止棋子在斜行时跳过棋子
int[][]finalLegalMovements=new int[legalXMovements.size（）][2]；
对于（int x=0；x

谢谢你的帮助

输出：

---

这里是我曾经编写的一段代码，它工作得很好，但使用了与您不同的体系结构。无论如何，它可能会帮助你想出自己的解决方案

    else if((piece == 'B') || (piece == 'b')){
        
        //Check if deltaX and deltaY are equal
        if(Math.abs(move.getFromX()-move.getToX()) == Math.abs(move.getFromY() - move.getToY())){
            //check the directions
            int directionX = 1;
            if(move.getToX() < move.getFromX())
                directionX = -1;
            
            int directionY = 1;
            if(move.getToY() < move.getFromY())
                directionY = -1;
            
            // Check if everything is free
            int y = move.getFromY();
            for(int x = move.getFromX() + directionX; x != move.getToX(); x += directionX){
                y += directionY;
                
                if(position.getPieceAt(x, y) != ' ')
                    //A piece is in the way -> move illegal!
                    return false;
                
            }
            
        }
        else{
            return false;
        }
    }

else if（（工件='B'）| |（工件='B'））{
//检查deltaX和deltaY是否相等
if（Math.abs（move.getFromX（）-move.getToX（））==Math.abs（move.getFromY（）-move.getToY（））{
//检查一下方向
int方向x=1；
if（move.getToX（）移动非法！
返回false；
}
}
否则{
返回false；
}
}

---

请注意，我在2009年写了这篇文章，它不是很好的代码，它的结构可能要好得多，并且有风格上的问题。但是数学是可靠的。

如果路径中的每个磁贴都是空的，则必须检查它。就这么简单。谢谢回复！，我知道我需要检查每个磁贴，但问题是如何在上面的代码中实现解决方案？再次感谢您构建一个从起始空间到目标空间的循环，忽略这两个空间，并检查所有空间是否为空。但是tbh我会以不同的方式编写整个代码（事实上，我以前也这么做过）。谢谢你的时间！，是的，你下面的代码非常有帮助（而且比我的xD要少得多），如果有必要的话，我正在考虑重构这个方法，你的代码给了我一些想法，再次感谢！嗯，我基本上放弃了前五次尝试实施国际象棋规则，因为它们比这更混乱，我的第一稿肯定非常血腥，但它确实帮助我学到了很多。