Cách biểu diễn trạng thái cờ vua bằng bảng bit

Tôi quan tâm đến việc lập trình một công cụ cờ vua và sử dụng bảng bitcoin để thể hiện trạng thái của trò chơi. Tôi biết có một vài công cụ cờ vua mã nguồn mở sử dụng bitboard, nhưng không dễ để xem mã và hiểu những gì đang diễn ra. Tôi đang tìm tài liệu tham khảo tốt về cách thể hiện tất cả trạng thái trong bảng bit.

Giải thích rõ ràng cách duy trì trạng thái của trò chơi bằng cách sử dụng bảng điều khiển và đặc biệt là cách tạo danh sách các bước di chuyển hợp lệ từ bất kỳ bảng bit cụ thể nào hoặc cung cấp tài liệu tham khảo tốt cho lời giải thích như vậy sẽ giúp bạn có được dấu kiểm màu xanh lục.

Tài nguyên tốt nhất để lập trình động cơ cờ vua là Wiki Lập trình Cờ vua , có một phần lớn trên các bảng bitcoin . Tất cả mọi thứ bạn cần để tạo ra một công cụ dựa trên bitboard đều ở đó, mặc dù nó khá phổ biến và đôi khi được viết bởi những người mà tiếng Anh là ngôn ngữ thứ hai.

Bạn muốn sử dụng ngôn ngữ lập trình nào?

Để triển khai bảng bit trong C #, hãy sử dụng System.UInt64 . Điều này có thể chứa 64 bit, 1 cho mỗi ô vuông của bàn cờ. Loại giá trị này cho vay nhiều hoạt động bitwise nhanh.

Đây là một hướng dẫn bitboard tốt .

Dưới đây là một số ví dụ từ công cụ cờ vua C # của riêng tôi. Như bạn có thể thấy từ mã, có thể mất một chút thời gian để sử dụng bitboard, nhưng chúng thường rất nhanh, đặc biệt là để đánh giá vị trí.

Ví dụ 1 - Định nghĩa Bitboard:

internal UInt64 WhiteKing;
internal UInt64 WhiteQueens;
internal UInt64 WhiteRooks;
internal UInt64 WhiteBishops;
internal UInt64 WhiteKnights;
internal UInt64 WhitePawns;
internal UInt64 WhitePieces;

Ví dụ 2 - Khởi tạo Bitboard:

// Initialise piece bitboards using square contents.
private void InitPieceBitboards()
{
    this.WhiteKing = 0; 
    this.WhiteQueens = 0; 
    this.WhiteRooks = 0; 
    this.WhiteBishops = 0; 
    this.WhiteKnights = 0; 
    this.WhitePawns = 0;

    for (Int16 i = 0; i < 64; i++)
    {
        if (this.Squares[i] == Constants.WHITE_KING)
        {
            this.WhiteKing = this.WhiteKing | Constants.BITSET[i];
        }
        if (this.Squares[i] == Constants.WHITE_QUEEN)
        {
            this.WhiteQueens = this.WhiteQueens | Constants.BITSET[i];
        } 
        if (this.Squares[i] == Constants.WHITE_ROOK) 
        {
            this.WhiteRooks = this.WhiteRooks | Constants.BITSET[i];
        }
        if (this.Squares[i] == Constants.WHITE_BISHOP) 
        {
            this.WhiteBishops = this.WhiteBishops | Constants.BITSET[i];
        }
        if (this.Squares[i] == Constants.WHITE_KNIGHT) 
        {
            this.WhiteKnights = this.WhiteKnights | Constants.BITSET[i];
        }
        if (this.Squares[i] == Constants.WHITE_PAWN) 
        {
            this.WhitePawns = this.WhitePawns | Constants.BITSET[i];
        }

        this.WhitePieces = this.WhiteKing | this.WhiteQueens | 
                           this.WhiteRooks | this.WhiteBishops | 
                           this.WhiteKnights | this.WhitePawns;
        this.BlackPieces = this.BlackKing | this.BlackQueens | 
                           this.BlackRooks | this.BlackBishops | 
                           this.BlackKnights | this.BlackPawns;
        this.SquaresOccupied = this.WhitePieces | this.BlackPieces;
    }
}

Ví dụ 3 - Tạo thế hệ:

// We can't capture one of our own pieces.
eligibleSquares = ~this.WhitePieces;

// Generate moves for white knights.
remainingKnights = this.WhiteKnights;

// Generate the moves for each knight...
while (remainingKnights != 0)
{
    squareFrom = BitOps.BitScanForward(remainingKnights);
    generatedMoves = Constants.ATTACKS_KNIGHT[squareFrom] & eligibleSquares;
    while (generatedMoves != 0)
    {
        squareTo = BitOps.BitScanForward(generatedMoves);
        moveList.Add(new Move(squareFrom, squareTo, Constants.WHITE_KNIGHT, 
                              this.Squares[squareTo], Constants.EMPTY));
        generatedMoves ^= Constants.BITSET[squareTo];
    }
    // Finished with this knight - move on to the next one.
    remainingKnights ^= Constants.BITSET[squareFrom];
}    

Ví dụ 4 - Tính điểm vật liệu:

// Material score from scratch, in centipawns from White's perspective.
internal static Int32 ScoreMaterial(Board position)
{
    return BitOps.BitCountWegner(position.WhitePawns)   * Constants.VALUE_PAWN +
           BitOps.BitCountWegner(position.WhiteKnights) * Constants.VALUE_KNIGHT +
           BitOps.BitCountWegner(position.WhiteBishops) * Constants.VALUE_BISHOP +
           BitOps.BitCountWegner(position.WhiteRooks)   * Constants.VALUE_ROOK   +
           BitOps.BitCountWegner(position.WhiteQueens)  * Constants.VALUE_QUEEN  -
           BitOps.BitCountWegner(position.BlackPawns)   * Constants.VALUE_PAWN   -
           BitOps.BitCountWegner(position.BlackKnights) * Constants.VALUE_KNIGHT -
           BitOps.BitCountWegner(position.BlackBishops) * Constants.VALUE_BISHOP -
           BitOps.BitCountWegner(position.BlackRooks)   * Constants.VALUE_ROOK   -
           BitOps.BitCountWegner(position.BlackQueens)  * Constants.VALUE_QUEEN;
}

Ví dụ 5 - Tính di động mảnh:

// Calculate mobility score for white knights.
remainingPieces = position.WhiteKnights;
while (remainingPieces != 0)
{
    squareFrom = BitOps.BitScanForward(remainingPieces);
    mobilityKnight += BitOps.BitCountWegner(Constants.ATTACKS_KNIGHT[squareFrom]
                                            & unoccupiedSquares);
    remainingPieces ^= Constants.BITSET[squareFrom];
 }