बिटबोर्ड के साथ शतरंज की स्थिति का प्रतिनिधित्व कैसे करें

Question

मुझे शतरंज इंजन की प्रोग्रामिंग करने और गेम की स्थिति का प्रतिनिधित्व करने के लिए बिटबोर्ड का उपयोग करने में दिलचस्पी है। मुझे पता है कि कुछ खुले स्रोत शतरंज इंजन हैं जो बिटबोर्ड का उपयोग करते हैं, लेकिन इसका इतना आसान नहीं है कि कोड को देखें और समझें कि क्या चल रहा है। मैं बिटबोर्ड में सभी राज्य का प्रतिनिधित्व करने के तरीके पर अच्छी संदर्भ सामग्री की तलाश कर रहा हूं।

स्पष्ट रूप से यह समझाते हुए कि बिटबोर्ड का उपयोग करके खेल की स्थिति को कैसे बनाए रखा जाए, और विशेष रूप से किसी भी दिए गए बिटबोर्ड से वैध चालों की सूची कैसे उत्पन्न की जाए, या इस तरह के स्पष्टीकरण के लिए अच्छे संदर्भों की आपूर्ति करने से आपको ग्रीन चेक मार्क प्राप्त होगा।

Comments

1. ओपी विषय का कोई ज्ञान नहीं दिखाता है। अर्थात्, ओपी ने खुद को शिक्षित करने के लिए गंभीरता से प्रयास नहीं किया है। 2. यह प्रोग्रामिंग के बारे में है, शतरंज नहीं

— टोनी एननिस

Answer 1

शतरंज इंजन प्रोग्रामिंग के लिए सबसे अच्छा संसाधन शतरंज प्रोग्रामिंग विकी है , जिसमें बिटबोर्ड पर एक बड़ा खंड है । एक बिटबोर्ड-आधारित इंजन बनाने के लिए आपको जो कुछ भी चाहिए, वह है, हालांकि यह बाहर फैला हुआ है और कभी-कभी लोगों द्वारा लिखा जाता है जिनके लिए अंग्रेजी दूसरी भाषा है।

Comments

2 लिंक अब अमान्य हैं।

— जैक्सन टेल

वे अभी भी मेरे लिए काम करते हैं क्योंकि मैं यह टिप्पणी लिख रहा हूं।

— dfan

Answer 2

आप किस प्रोग्रामिंग भाषा का उपयोग करना चाहते हैं?

C # में एक बिटबोर्ड लागू करने के लिए, System.UInt64 का उपयोग करें । यह शतरंज बोर्ड के प्रत्येक वर्ग के लिए 64 बिट्स, 1 को पकड़ सकता है। यह मान प्रकार कई तेज़ बिटवाइज़ ऑपरेशनों के लिए उधार देता है।

यह एक अच्छा बिटबोर्ड ट्यूटोरियल है ।

यहाँ मेरे अपने C # शतरंज इंजन के कुछ उदाहरण दिए गए हैं। जैसा कि आप कोड से देख सकते हैं, बिटबोर्ड का उपयोग करते हुए आपके सिर को लपेटने में कुछ समय लग सकता है, लेकिन वे आम तौर पर बहुत तेज़ होते हैं, खासकर स्थिति मूल्यांकन के लिए।

उदाहरण 1 - बिटबोर्ड परिभाषा:

internal UInt64 WhiteKing;
internal UInt64 WhiteQueens;
internal UInt64 WhiteRooks;
internal UInt64 WhiteBishops;
internal UInt64 WhiteKnights;
internal UInt64 WhitePawns;
internal UInt64 WhitePieces;

उदाहरण 2 - बिटबोर्ड आरंभीकरण:

// 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;
    }
}

उदाहरण 3 - हटो पीढ़ी:

// 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];
}    

उदाहरण 4 - गणना सामग्री स्कोर:

// 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;
}

उदाहरण 5 - गणना की गतिशीलता:

// 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];
 }

Comments

क्या आप मूवमेंट की परिभाषा प्रदान कर सकते हैं?

— कार्लोस