Olen kiinnostunut ohjelmoimaan shakkimoottorin ja käyttämään bittilevyjä pelin tilan esittämiseen. Tiedän, että on olemassa muutama avoimen lähdekoodin shakkimoottori, joka käyttää bittilevyjä, mutta se ei ole niin helppoa tarkastella koodia ja ymmärtää, mitä tapahtuu. Etsin hyvää vertailumateriaalia siitä, kuinka edustaa koko valtiota bittilevyissä.
Selkeän selityksen, kuinka pelitila voidaan ylläpitää bittilevyjen avulla, ja erityisesti kuinka luoda luettelo kelvollisista siirroista mistä tahansa annetusta levystä, tai antamalla hyviä viitteitä tällaiseen selitykseen, saat vihreän valintamerkin.
Kommentit
- 1. OP ei osoita aihetta. Toisin sanoen OP ei ole yrittänyt vakavasti kouluttaa itseään. 2. Kyse on ohjelmoinnista, ei shakista
- @TonyEnnis Miksi sinun on toimittava niin epäkohteliaasti toisten ihmisten kanssa ??, kunnioitettava vähän ja näytettävä hänelle, mitä hänen pitäisi parantaa, eikä olla niin hapan
- Tosiseikkojen ilmoittaminen ei ole epäkohteliasta tai hapanta, @AryanParekh
- @Tonny Ennis. Kuvittele, että olet aloittelija, uusi ja kysyit vain toivoen, että ' saat hyvän vastauksen. Ja sitten näet tällaisen kommentin. Käynnistetäänkö muita ihmisiä vastaamaan hänen kysymyksiinsä? Vai tunnetko itsesi liian korkeaksi ottaaksesi sitä huomioon.
Vastaa
Paras resurssi shakkimoottorin ohjelmointiin on shakkiohjelmointikiintiö , jolla on suuri osa bittilevyillä . Kaikki mitä tarvitset kartonkipohjaisen moottorin valmistamiseen, on olemassa, vaikka se onkin levinnyt ja joskus kirjoittanut ihmiset, joille englanti on toinen kieli.
Kommentit
- Nämä kaksi linkkiä ovat virheellisiä nyt.
- Ne toimivat edelleen minulle, kun kirjoitan tätä kommenttia.
Vastaa
Mitä ohjelmointikieliä haluat käyttää?
Jos haluat ottaa bittitaulun käyttöön C #: ssä, käytä System.UInt64 . Tähän mahtuu 64 bittiä, 1 kutakin shakkilaudan neliötä kohti. Tämä arvotyyppi soveltuu monille nopeille bittinopeuksille.
Tämä on hyvä bittitaulun opetusohjelma .
Tässä on joitain esimerkkejä omasta C # -shakkimoottoristani. Kuten koodista näkyy, voi kestää jonkin aikaa päätä kiintolevyjen avulla, mutta ne ovat tyypillisesti erittäin nopeita, etenkin sijainnin arvioimiseksi.
Esimerkki 1 – Bitboardin määrittely:
internal UInt64 WhiteKing; internal UInt64 WhiteQueens; internal UInt64 WhiteRooks; internal UInt64 WhiteBishops; internal UInt64 WhiteKnights; internal UInt64 WhitePawns; internal UInt64 WhitePieces; Esimerkki 2 – Paneelialustus:
// 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; } } Esimerkki 3 – Siirrä sukupolvea:
// 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]; } Esimerkki 4 – Laske materiaalipisteet:
// 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; } Esimerkki 5 – Kappaleen liikkuvuuden laskeminen:
// 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]; } Kommentit
- Voitteko antaa moveList-määritelmän?