Jag är intresserad av att programmera en schackmotor och använda bitbrädor för att representera spelet. Jag vet att det finns några schackmotorer med öppen källkod som använder bitboards, men det är inte så lätt att titta på koden och förstå vad som händer. Jag letar efter bra referensmaterial om hur man representerar hela tillståndet i bitboards.
Att tydligt förklara hur man bibehåller spelets tillstånd med hjälp av bitboards, och speciellt hur man skapar en lista med giltiga drag från ett visst bitboard, eller tillhandahåller goda referenser till en sådan förklaring ger dig den gröna bocken.
Kommentarer
- 1. OP visar ingen kunskap om ämnet. Det vill säga, OP har inte försökt på allvar att utbilda sig själv. 2. Det här handlar om programmering, inte schack
- @TonyEnnis Varför måste du agera så oförskämd mot medmänniskor ??, ha lite respekt och visa honom vad hon ska förbättra snarare än att vara så sur
- Att säga fakta är inte att vara oförskämd eller sur, @AryanParekh
- @Tonny Ennis. Tänk dig att du var nybörjare, ny och bara ställde en fråga i hopp om att du ' får ett bra svar. Och då ser du en sådan kommentar. Kommer andra personer på nytt för att svara på hans frågor? Eller känner du dig för hög av dig själv att överväga det.
Svar
Den bästa resursen för schackmotorprogrammering är Schackprogrammeringswiki , som har ett stort -avsnitt på bitbrädor . Allt du behöver för att skapa en bitboardbaserad motor finns där, även om den är ganska utspridd och ibland skriven av personer för vilka engelska är andraspråk.
Kommentarer
- De två länkarna är ogiltiga nu.
- De fungerar fortfarande för mig när jag skriver den här kommentaren.
Svar
Vilket programmeringsspråk vill du använda?
För att implementera en bitboard i C #, använd System.UInt64 . Detta kan innehålla 64 bitar, 1 för varje kvadrat på schackbrädet. Denna värdetyp lämpar sig för många snabba bitvisa operationer.
Detta är en bra bitboard-handledning .
Här är några exempel från min egen C # schackmotor. Som du ser i koden kan det ta en stund att packa in din gå runt med hjälp av bitbrädor, men de är vanligtvis väldigt snabba, särskilt för positionsvärdering.
Exempel 1 – Bitboarddefinition:
internal UInt64 WhiteKing; internal UInt64 WhiteQueens; internal UInt64 WhiteRooks; internal UInt64 WhiteBishops; internal UInt64 WhiteKnights; internal UInt64 WhitePawns; internal UInt64 WhitePieces; Exempel 2 – Initiering av bitbräda:
// 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; } } Exempel 3 – Flytta generation:
// 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]; } Exempel 4 – Beräkna materialpoäng:
// 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; } Exempel 5 – Beräkna bitmobilitet:
// 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]; } Kommentarer
- kan du tillhandahålla definitionen av moveList?