Ik “ben geïnteresseerd in het programmeren van een schaakengine en het gebruik van bitboards om de staat van het spel weer te geven. Ik weet dat die er zijn een paar open source schaakengines die bitboards gebruiken, maar het is niet zo eenvoudig om naar de code te kijken en te begrijpen wat er aan de hand is. Ik ben op zoek naar goed referentiemateriaal over hoe de hele staat in bitboards kan worden weergegeven.
Als je duidelijk uitlegt hoe je de staat van het spel kunt behouden met bitboards, en vooral hoe je een lijst met geldige zetten van een bepaald bitboard genereert, of als je goede verwijzingen naar een dergelijke uitleg geeft, krijg je een groen vinkje.
Reacties
- 1. OP toont geen kennis van het onderwerp. Dat wil zeggen, het OP heeft niet serieus geprobeerd zichzelf te onderwijzen. 2. Dit gaat over programmeren, niet over schaken.
- @TonyEnnis Waarom moet je zo grof zijn tegen medemensen ??, een beetje respect hebben en hem laten zien wat ze zou moeten verbeteren in plaats van zo zuur te zijn
- Feiten noemen is niet grof of zuur, @AryanParekh
- @Tonny Ennis. Stel je voor dat je een beginner bent, nieuw bent en alleen maar een vraag stelt in de hoop dat je ' een goed antwoord krijgt. En dan zie je zon opmerking. Worden andere mensen opnieuw gestart om zijn vragen te beantwoorden? Of voel je je te hoog van jezelf om erover na te denken.
Antwoord
De beste bron voor het programmeren van een schaakengine is de Chess Programming Wiki , die een grote sectie op bitboards heeft. Alles wat je nodig hebt om een bitboard-gebaseerde engine te maken, is aanwezig, hoewel het nogal verspreid is en soms is geschreven door mensen voor wie Engels een tweede taal is.
Opmerkingen
- De 2 links zijn nu ongeldig.
- Ze werken nog steeds voor mij vanaf het moment dat ik deze opmerking schrijf.
Antwoord
Welke programmeertaal wil je gebruiken?
Om een bitboard in C # te implementeren, gebruik je System.UInt64 . Dit kan 64 bits bevatten, 1 voor elk vierkant van het schaakbord. Dit waardetype leent zich voor veel snelle bitsgewijze bewerkingen.
Dit is een goede bitboard-tutorial .
Hier zijn enkele voorbeelden van mijn eigen C # -schaakengine. Zoals je kunt zien aan de code, kan het even duren om je ga rond met bitboards, maar ze zijn doorgaans erg snel, vooral voor positie-evaluatie.
Voorbeeld 1 – Bitboard-definitie:
internal UInt64 WhiteKing; internal UInt64 WhiteQueens; internal UInt64 WhiteRooks; internal UInt64 WhiteBishops; internal UInt64 WhiteKnights; internal UInt64 WhitePawns; internal UInt64 WhitePieces; Voorbeeld 2 – Initialisatie van 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; } } Voorbeeld 3 – Genereren van verplaatsingen:
// 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]; } Voorbeeld 4 – Materiaalscore berekenen:
// 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; } Voorbeeld 5 – Stukmobiliteit berekenen:
// 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]; } Reacties
- kun je de definitie van moveList geven?