Chequers极小极大混淆（Java）

我正在写一个棋盘游戏，用极大极小算法作为人工智能。当我手动移动chequer（player对player）时，一切都很好，但是每当我调用MiniMax方法时，我都会遇到一个空指针错误

这是因为当我调用“多跳”时，在某个点上它试图移动一个不再存在的棋盘格。代码尝试从[2][2]移动一个方格，该方格在创建子节点时已被递归移动。我找不到它执行此操作的位置或原因-当我完成调试过程时，会执行正确的多跳移动，但不会在正确的位置退出，而是会抛出此空指针错误

如果有人能看看我的代码，让我知道他们是否能找到算法试图移动它已经移动的东西的原因，那就太好了

如果有什么我可以帮忙的，或者有什么我可以回答的，请随时告诉我：）

下面我将复制并粘贴MiniMax方法和MultiJump方法。再一次，请参阅文章顶部，了解我的全部代码

我的MiniMax控制方法是：

public double miniMax(String side, int depth, PlaySpace board)
{
    this.board = board;
    this.side = side;
    this.depth = depth;
    double a = 0;

    if(depth==0){
        a = evaluateState(board);
        return a;
    }

    if (side.equals("A")){
        a = Double.MIN_VALUE;
        for(ChequersMove move : board.getLegalMoves(side)){ 

            PlaySpace child = new PlaySpace(board.returnState());
            child.setState(board.returnState());

            for(int x=0;x<move.multiJumpCount(board,move,side,0);x++){ 
                child.moveChequer(move.multiJump(board,move,side,0)[x].returnCurrentX(),move.multiJump(board,move,side,0)[x].returnCurrentY(),move.multiJump(board,move,side,0)[x].returnDestX(),move.multiJump(board,move,side,0)[x].returnDestY());
            }

            Tree tree = new Tree();
            double eval = tree.miniMax("B",depth-1,child);
            if(eval > a){
                System.out.println(eval);
                a = eval;
            }
        }
        return a;
    }
    if(side.equals("B")){
        a = Double.MAX_VALUE;
        for(ChequersMove move : board.getLegalMoves(side)){ through all of the possible resulting moves
            PlaySpace child = new PlaySpace(board.returnState()); 
            child.setState(board.returnState());
            for(int x=0;x<move.multiJumpCount(board,move,side,0);x++){
                child.moveChequer(move.multiJump(board,move,side,0)[x].returnCurrentX(),move.multiJump(board,move,side,0)[x].returnCurrentY(),move.multiJump(board,move,side,0)[x].returnDestX(),move.multiJump(board,move,side,0)[x].returnDestY());
            }
            Tree tree = new Tree();
            double eval = tree.miniMax("A",depth-1,child);
            if(eval > a){
                a = eval;
            }
        }
        return a;
    }
    return a;
}

public double miniMax（字符串侧、整数深度、播放空间板）
{
this.board=董事会；
这个边=边；
这个。深度=深度；
双a=0；
如果（深度==0）{
a=测试（董事会）；
返回a；
}
如果（等于（“A”）侧）{
a=双最小值；
对于（ChequersMove移动：board.getLegalMoves（side））{
PlaySpace child=新的PlaySpace（board.returnState（））；
child.setState（board.returnState（））；
对于（int x=0；x a）{
系统输出打印项次（eval）；
a=评估；
}
}
返回a；
}
如果（等于（“B”）侧）{
a=双倍最大值；
对于（ChequersMove move:board.getLegalMoves（side））{通过所有可能的结果移动
PlaySpace child=新的PlaySpace（board.returnState（））；
child.setState（board.returnState（））；
对于（int x=0；x a）{
a=评估；
}
}
返回a；
}
返回a；
}

我的多跳方法是：

ChequersMove[] multiJump(PlaySpace board, ChequersMove move, String side, int jumpCount)
{

    jumpPath.addElement(move);

    if(move.isJump()==true){
        PlaySpace child = new PlaySpace(board.returnState());
        child.setState(board.returnState());
        child.moveChequer(move.returnCurrentX(),move.returnCurrentY(),move.returnDestX(),move.returnDestY());
        jumpCount++;

        if(child.getLegalMoves(side)!=null){
            for(ChequersMove path : child.getLegalMoves(side)){
                if(path.returnCurrentX() == move.returnDestX() && path.returnCurrentY() == move.returnDestY() && path.isJump() == true){
                    multiJump(child,path,side,jumpCount);
                }
            }
        }
    }

    multiJump = new ChequersMove[jumpPath.size()];

    System.out.println("MultiJump length = " + multiJump.length);

    for(int i = 0; i < jumpPath.size(); i++){
        System.out.println(i);
        multiJump[i] = (ChequersMove)jumpPath.elementAt(i);
    }

    return multiJump; 

}

ChequersMove[]多跳（游戏空间板、ChequersMove移动、字符串侧、整数跳数）
{
跳线路径。添加元素（移动）；
if（move.isJump（）==true）{
PlaySpace child=新的PlaySpace（board.returnState（））；
child.setState（board.returnState（））；
move chequer（move.returnCurrentX（），move.returnCurrentY（），move.returnDestX（），move.returnDestY（））；
跳跃计数++；
if（child.getLegalMoves（side）！=null）{
for（ChequersMove路径：child.getLegalMoves（侧））{
if（path.returnCurrentX（）==move.returnDestX（）&&path.returnCurrentY（）==move.returnDestY（）&&path.isJump（）==true）{
多跳（子跳、路径跳、侧跳、跳跃计数）；
}
}
}
}
multiJump=newchequersmove[jumpPath.size（）]；
System.out.println（“MultiJump length=“+MultiJump.length”）；
对于（int i=0；i

---

提前谢谢

您确定此行正确吗：

child.moveChequer（move.multiJump（board，move，side，0）[x]。returnCurrentX（），move.multiJump（board，move，side，0）[x]。returnCurrentY（），move.multiJump（board，move，side，0）[x]。returnDestX（），move.multiJump（board，move，side，0）[x]。returnDestY（）？我期望一个调用
someObj=move.multiJump（board，move，side，0），根据需要使用
someObj
。请尝试提供更详细的错误描述。只有忠实的发烧友才会筛选30k的未注释源。嗨，首先感谢你这么快的回答！在这个棋盘游戏中，如果你能拿，你必须拿&你可以在一个“移动”中进行多个链式跳跃。这条线的目的是允许在不绊倒游戏逻辑约束的情况下进行多个链式跳跃。MultiJump返回一个移动数组，在返回下一个状态（极小极大树中的下一个游戏板）之前，所有移动都需要在棋盘上移动真的很抱歉，但我不确定someObj是什么/我如何使用它来改进我的代码。再次感谢
someObj
将是包含移动列表的支持变量。目前，您的代码为涉及的4个移动坐标（从X/Y到X/Y）中的每一个生成相同的移动列表。除了效率极低之外，我怀疑您的移动生成器没有处理重复调用以正确生成相同的移动数组（我必须承认，我没有查看生成器，所以这只是一种预感）。