Jak reprezentować stan szachowy za pomocą płyty głównej

11

Interesuje mnie programowanie silnika szachowego i używanie bitboardów do reprezentowania stanu gry. Wiem, że istnieje kilka silników szachowych o otwartym kodzie źródłowym, które używają bitboardów, ale nie jest tak łatwo spojrzeć na kod i zrozumieć, co się dzieje. Szukam dobrego materiału referencyjnego na temat tego, jak reprezentować cały stan na bitboardach.

Jasne wyjaśnienie, w jaki sposób utrzymywać stan gry za pomocą bitboardów, a zwłaszcza jak wygenerować listę prawidłowych ruchów z dowolnej tablicy lub dostarczenie dobrych odniesień do takiego wyjaśnienia, zapewni ci zielony znacznik wyboru.

aksiopisty
źródło
3
1. PO pokazuje brak znajomości tematu. Oznacza to, że PO nie próbował poważnie się kształcić. 2. Chodzi o programowanie, a nie szachy
Tony Ennis,

Odpowiedzi:

10

Najlepszym źródłem do programowania silnika szachowego jest Wiki programowania szachowego , które ma duży sekcję na bitboardach . Wszystko, czego potrzebujesz, aby stworzyć silnik oparty na płycie głównej, jest tam, choć jest on dość rozproszony i czasami pisany przez ludzi, dla których angielski jest drugim językiem.

dfan
źródło
2 linki są teraz nieprawidłowe.
Jackson Tale
1
Nadal działają dla mnie od chwili, gdy piszę ten komentarz.
dfan
8

Jakiego języka programowania chcesz używać?

Aby zaimplementować bitboard w C #, użyj System.UInt64 . Może pomieścić 64 bity, 1 na każdy kwadrat szachownicy. Ten typ wartości nadaje się do wielu szybkich operacji bitowych.

To jest dobry samouczek na płycie .

Oto kilka przykładów z mojego własnego silnika szachowego C #. Jak widać z kodu, może zająć trochę czasu, aby owinąć głowę za pomocą bitboardów, ale zazwyczaj są one bardzo szybkie, szczególnie w przypadku oceny pozycji.

Przykład 1 - Definicja płyty głównej:

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

Przykład 2 - inicjalizacja płyty głównej:

// 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;
    }
}

Przykład 3 - Generowanie ruchu:

// 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];
}    

Przykład 4 - Oblicz wynik materiałowy:

// 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;
}

Przykład 5 - Obliczanie mobilności sztuk:

// 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];
 }
HTTP 410
źródło
czy możesz podać definicję moveList?
Carlos