Question

所以，我正在用Java制作一个国际象棋引擎。给定当前的板配置，AI应该找出它可以进行的每个可能的移动，将其添加到所有可能移动的链接列表中，并返回该列表。目前我正在测试以下电路板配置：

/*bRbNbBbQbKbBbNbR
  bPbPbPbPbPbPbPbP
  NuNuNuNuNuNuNuNu
  NuNuNuwRNuNuNuNu
  NuNuNuNuNuNuNuNu
  NuNuNuNuNuNuNuNu
  wPwPwPwPwPwPwPwP
  NuwNwBwQwKwBwNwR*/

“bR”表示黑车，“bN”表示黑骑士等。“Nu”表示无效或无效。在这种配置中，我将左下角的白色车道移动到了车板的中间位置。

我的possibleMoves()类中的以下方法Mobility应生成并返回所有可能的板配置的链接列表。每个索引i对应于从左侧开始的棋盘上的棋子。在这种情况下，AI是白色的，所以0是最左边的白色棋子，7是最右边的白色棋子，8是现在在棋盘中央的白色车，9是另一个白色车，等等。现在我我只测试车，所以其他条件都是空的。 nonPawnBoardGen()返回可能的电路板配置的子列表。

public LL possibleMoves(){
    LL children = new LL();
    /*
     * check each piece
     */
    for(int i = 0; i < 16; i++){
        if(i < 8){//pawns

        }
        else if(i < 10){//rooks
            children.joinWith(nonPawnBoardGen(i, 0, -1)); //positions to the left
            children.joinWith(nonPawnBoardGen(i, 0, 1)); //right
            children.joinWith(nonPawnBoardGen(i, -1, 0)); //up
            children.joinWith(nonPawnBoardGen(i, 1, 0)); //down
        }
        else if(i < 12){
        //  checkKnight(r, c, int dR, int dC)
        }
        else if(i < 14){//bishops

        }
        else{ //king, queen

        }
    }
    return children;
}

joinWith()，在我的LL课程中，加入一个子列表和子项链接列表。

public void joinWith(LL newList){
    if(newList.isEmpty())
        return;
    if(this.isEmpty()){
        first = newList.getFirst();
        last = newList.getLast();
    }
    else{
        last.next = newList.getFirst();
        last = newList.getLast();
    }
}

以下函数nonPawnBoardGen()是我的Mobility中的另一个函数，它传递了一个index和一个单位向量。所以，如果我想在棋盘中心检查车的所有可能的左移动，我会调用nonPawnBoardGen(8, 0, -1)，因为车是索引8，它将保持在同一行，它将迭代通过左侧的列。该函数调用应该返回涉及此车的所有可能的板配置的子列表，因为我仍然需要从车辆当前位置向右，向上和向下检查所有内容。

private LL nonPawnBoardGen(int index, int vecR, int vecC){
    LL boardSubLst = new LL();
    int sR, sC; //source row and col
    if(turn == true){//white
        //last 16 coords are white pieces
        if(coords[index + 16] == null){//if piece does not exist, return
            return null;
        }
        sR = coords[index + 16].getRow(); //each coord is an object containing a row and col value
        sC = coords[index + 16].getCol();
    }
    else{//black
        //first 16 coords are black pieces
        if(coords[index] == null){
            return null;
        }
        sR = coords[index].getRow();
        sC = coords[index].getCol();
    }
    int curR = sR; //current row
    int curC = sC; //current col
    curR+=vecR; //iterate by unit vector
    curC+=vecC;
    while(curR > -1 && curR < 8 && curC > -1 && curC < 8){ //while in range of board
        if(turn == true){//white
            if(board[curR][curC].charAt(0) != 'w'){ //if space is free or opposite color, valid move
                coords[index + 16].setRow(curR); //move rook to new position
                coords[index + 16].setCol(curC);
                if(board[curR][curC].charAt(0) == 'b'){ //if space contains piece of opposite color,
                    int r, c;                           //piece needs to be removed
                    for(int j = 0; j < 16; j++){ //iterate through 16 opponent pieces
                        r = coords[j].getRow();
                        c = coords[j].getCol();
                        if(curR == r && curC == c){ //check which opponent's piece's coords match
                            coords[j] = null;       //the rook's current coords, then remove opp's piece
                            boardSubLst.insert(coords); //add board config to sublist
                            break;
                        }
                    }
                    break;
                }
                else{ //if the space is null, simply add board config to sublist
                    boardSubLst.insert(coords);
                }
            }
            else{ //if space is same color, break
                break;
            }
        }
        else{//black
            if(board[curR][curC].charAt(0) != 'b'){
                coords[index].setRow(curR);
                coords[index].setCol(curC);
                if(board[curR][curC].charAt(0) == 'w'){
                    int r, c;
                    for(int j = 0; j < 16; j++){
                        r = coords[j + 16].getRow();
                        c = coords[j + 16].getCol();
                        if(curR == r && curC == c){
                            coords[j + 16] = null;
                            boardSubLst.insert(coords);
                            break;
                        }
                    }
                    break;
                }
                else{
                    boardSubLst.insert(coords);
                }
            }
            else{
                break;
            }
        }
        curR+=vecR;
        curC+=vecC;
    }
    return boardSubLst;
}

简而言之，在nonPawnBoardGen()中，每当我获得新的有效电路板配置时，我都会编辑电路板坐标（在这种情况下为白色）：

coords[index + 16].setRow(curR);
coords[index + 16].setCol(curC);

并将它们添加到电路板配置列表中：

boardSubLst.insert(coords);

但是，每次我修改coords时，boardSubList链接列表中的每个值都会更改为coords的当前值。为什么会这样？

编辑：我想我只能通过nonPawnBoardGen()生成并返回一组坐标来避免这个问题。迭代器可以保存在类中，而不是本地保存在函数中。返回的每组坐标可以直接添加到possibleMoves()中的子项列表中。我会尝试这个，看看会发生什么......

Answer 1

致电时

boardSubLst.insert(coords);

您将相同的引用传递给coords数组。我认为您会发现最简单的解决方案是复制数组，例如使用Arrays.copyOf(T[] original, int newLength)

boardSubLst.insert(Arrays.copyOf(coords, coords.length));

或者，假设coords的类型为Coord[]，您可以使用System.arraycopy(Object src, int srcPos, Object dest, int destPos, int length)

Coord[] coords2 = new Coord[coords.length];   
System.arraycopy(coords, 0, coords2, 0, coords.length);
boardSubLst.insert(coords2);

Answer 2

我停止了我的代码工作一段时间，只是回到它并解决了问题。谢谢Elliott和Anantha。你们都是对的。我的棋子坐标数组实际上是一个对象数组，每个对象都是一组坐标。最初，我改变了我的代码，以便每次在编辑坐标并将数组添加到我的列表之前制作数组的副本，但这只是对数组对象的同一组进行了新的引用。解决方案不仅要创建新的数组引用，还要在每次更改坐标时在数组中分配新的坐标对象。我认为我的声音比它实际上要复杂得多，但是这是一个不断引用内存中同一区域的问题。这不太明显。非常感谢！

只是更改变量的值会更改链接列表中节点的值？这不应该发生

2 个答案: