Estou interessado em programar um mecanismo de xadrez e usar bitboards para representar o estado do jogo. Sei que existem alguns mecanismos de xadrez de código aberto que usam quadros de bits, mas não é tão fácil olhar o código e entender o que está acontecendo. Estou procurando um bom material de referência sobre como representar todo o estado em quadros de bits.
Explicar claramente como manter o estado do jogo usando quadros de bits e, especialmente, como gerar uma lista de movimentos válidos de qualquer quadro de bits, ou fornecer boas referências para tal explicação, você receberá a marca de seleção verde.
Comentários
- 1. OP não mostra nenhum conhecimento do assunto. Ou seja, o OP não tentou se educar seriamente. 2. Trata-se de programação, não de xadrez
- @TonyEnnis Por que você tem que ser tão rude com os outros ??, tenha um pouco de respeito e mostre a ele o que ela deve melhorar em vez de ser tão azeda
- Declarar fatos não é ser rude ou azedo, @AryanParekh
- @Tonny Ennis. Imagine que você é um iniciante, novo e está apenas fazendo uma pergunta na esperança de ' obter uma boa resposta. E então você vê um comentário como esse. Outras pessoas voltaram a responder às suas perguntas? Ou você se sente muito animado para pensar nisso.
Resposta
O melhor recurso para programação de mecanismo de xadrez é o Wiki de programação de xadrez , que tem uma grande seção em quadros de bits . Tudo que você precisa para fazer um mecanismo baseado em bitboard está lá, embora seja bastante espalhado e às vezes escrito por pessoas para quem o inglês é uma segunda língua.
Comentários
- Os 2 links são inválidos agora.
- Eles ainda funcionam para mim no momento em que estou escrevendo este comentário.
Resposta
Qual linguagem de programação você deseja usar?
Para implementar um bitboard em C #, use System.UInt64 . Pode conter 64 bits, 1 para cada casa do tabuleiro de xadrez. Este tipo de valor se presta a muitas operações bit a bit rápidas.
Este é um bom tutorial de bitboard .
Aqui estão alguns exemplos de meu próprio mecanismo de xadrez C #. Como você pode ver no código, pode demorar um pouco para envolver seu comece usando bitboards, mas eles são normalmente muito rápidos, especialmente para avaliação de posição.
Exemplo 1 – Definição de Bitboard:
internal UInt64 WhiteKing; internal UInt64 WhiteQueens; internal UInt64 WhiteRooks; internal UInt64 WhiteBishops; internal UInt64 WhiteKnights; internal UInt64 WhitePawns; internal UInt64 WhitePieces; Exemplo 2 – Inicialização do 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; } } Exemplo 3 – Geração de movimentação:
// 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]; } Exemplo 4 – Calcular pontuação do material:
// 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; } Exemplo 5 – Calculando a mobilidade da peça:
// 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]; } Comentários
- você pode fornecer a definição de moveList?