Jeg er interesseret i at programmere en skakmotor og bruge bitboards til at repræsentere spillets tilstand. Jeg ved, at der er et par open source-skakmotorer, der bruger bitboards, men det er ikke så let at se på koden og forstå, hvad der foregår. Jeg leder efter godt referencemateriale om, hvordan man repræsenterer hele tilstanden i bitboards.
At tydeligt forklare, hvordan man opretholder tilstanden af spillet ved hjælp af bitboards, og især hvordan man genererer en liste over gyldige træk fra et givet bitboard, eller ved at levere gode referencer til en sådan forklaring giver dig det grønne flueben.
Kommentarer
- 1. OP viser ingen viden om emnet. Det vil sige, at OP ikke har prøvet seriøst at uddanne sig selv. 2. Dette handler om programmering, ikke skak
- @TonyEnnis Hvorfor skal du handle så uhøfligt overfor kolleger ??, have lidt respekt og vise ham hvad hun skal forbedre i stedet for at være så sur
- At sige fakta er ikke uhøfligt eller surt, @AryanParekh
- @Tonny Ennis. Forestil dig, at du var nybegynder, ny og blot stillede et spørgsmål i håb om, at du ' får et godt svar. Og så ser du en sådan kommentar. Er andre mennesker begyndt igen for at besvare hans spørgsmål? Eller føler du dig for høj af dig selv til at overveje det.
Svar
Den bedste ressource til programmering af skakmotorer er Skakprogrammeringswiki , som har et stort -snit på bitboards . Alt hvad du behøver for at lave en bitboard-baseret motor, er der, selvom den snarere er spredt og undertiden skrevet af folk, for hvem engelsk er andetsprog.
Kommentarer
- De 2 links er ugyldige nu.
- De fungerer stadig for mig fra det tidspunkt, hvor jeg skriver denne kommentar.
Svar
Hvilket programmeringssprog vil du bruge?
For at implementere et bitboard i C # skal du bruge System.UInt64 . Dette kan rumme 64 bit, 1 for hver firkant på skakbrættet. Denne værditype egner sig til mange hurtige bitvise operationer.
Dette er en god bitboard tutorial .
Her er nogle eksempler fra min egen C # skakmotor. Som du kan se i koden, kan det tage et stykke tid at pakke din gå rundt ved hjælp af bitboards, men de er typisk meget hurtige, især til positionsvurdering.
Eksempel 1 – Bitboarddefinition:
internal UInt64 WhiteKing; internal UInt64 WhiteQueens; internal UInt64 WhiteRooks; internal UInt64 WhiteBishops; internal UInt64 WhiteKnights; internal UInt64 WhitePawns; internal UInt64 WhitePieces; Eksempel 2 – Bitboardinitialisering:
// 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; } } Eksempel 3 – Generering af flytning:
// 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]; } Eksempel 4 – Beregn materialescore:
// 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; } Eksempel 5 – Beregning af stykkemobilitet:
// 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 angive definitionen af moveList?