मैं एक संभव कदम को बिटबोर्ड में वास्तविक चाल में कैसे बदल सकता हूं?
अगर मेरे पास एक बिटबोर्ड है (जैसे नाइट स्क्वायर के लिए वह इस ओर जा सकता है):
00000000
00000000
00000000
00000000
00000000
01000000
00100000
N0000000
मैं इसे "चाल" में कैसे बदल सकता हूं या उस चाल को "लागू" कर सकता हूं?
जवाब
आपकी पोस्ट में वास्तव में दो प्रश्न हैं
बिटकॉइन में अटैक्स को मूव्स की सूची में कैसे बदलें?
उन चालों का प्रतिनिधित्व कैसे करें?
- उन चालों का प्रतिनिधित्व कैसे करें?
इस सवाल पर यहाँ और यहाँ पूरी तरह से चर्चा की गई है । लेकिन इस पोस्ट के पाठकों को कुछ संदर्भ प्रदान करने के लिए, एक बहुत ही सरल तरीका यह हो सकता है कि आप इस कदम का प्रतिनिधित्व करने के लिए एक वर्ग / संरचना का उपयोग कर सकें।
- जहां से (जहां चल रहा टुकड़ा था)
- करने के लिए (जहां चलती टुकड़ा होगा)
- स्पेशल मूव फ़्लैग (चाहे वह चाल विशेष चाल हो, यानी एनरजेंट, कास्टिंग, प्रमोशन)
- प्रचारित टुकड़ा (यदि चाल एक पदोन्नति कदम था, तो किस टुकड़े ने इसे बढ़ावा दिया)
आपके पास अतिरिक्त गुण भी हो सकते हैं जैसे कि कब्जा कर लिया गया टुकड़ा, महल का प्रकार आदि। लेकिन उस जानकारी का उपयोग करके From
और To
चौकों का उपयोग करके भी कटौती की जा सकती है।
तो ऊपर विचार करते हुए, हम इस प्रकार इस कदम का प्रतिनिधित्व कर सकते हैं
struct Move {
char from;
char to;
char spMoveFlag;
char promotedPiece;
};
हालांकि, शतरंज सहित बहुत सारे इंजन, एक अन्य विधि का उपयोग करते हैं जो इस कदम को बस 16
बिट्स में संपीड़ित कर सकता है । इसके बारे में यहाँ और पढ़ें ।
एक बार जब हम जानते हैं कि एक चाल क्या है, तो हम अगले प्रश्न का उत्तर दे सकते हैं
- बिटकॉइन में अटैक्स को मूव्स की सूची में कैसे बदलें?
आइए विचार करें कि हमारे पास वर्ग d4 पर एक नाइट है । हमारे पास एक फ़ंक्शन भी है जो स्क्वायर दिए गए एक नाइट के हमलों को वापस करता है।
. . . . . . . .
. . . . . . . .
. . 1 . 1 . . .
. 1 . . . 1 . .
. . . n . . . . = knightattacks(SQ_D4)
. 1 . . . 1 . .
. . 1 . 1 . . .
. . . . . . . .
तो चलिए इसे एक वेरिएबल के अंदर स्टोर करते हैं knightAttacks
uint64_t knightAttacks = getKnightAttacksBB(SQ_D4);
यदि आप ध्यान से देखें तो हमारे पास पहले से ही 4 विशेषताओं में से 1 है जो हमें इस कदम का प्रतिनिधित्व करने की आवश्यकता है, जो कि From
वर्ग है - D4
। अब हम सभी को यह करने की आवश्यकता है कि किसी To
तरह इसे पूरा करने के लिए वर्ग प्राप्त करें क्योंकि नाइट किसी भी प्रकार की विशेष चाल नहीं कर सकता है।
एक बहुत ही सामान्य तरीका है कि कम से कम महत्वपूर्ण बिट को पॉप करें जब तक कि आपके पास knightAttacks
कुछ भी नहीं बचा हो 0
।
0000011100001000
^
Least significant bit (lsb)
आप मेरे द्वारा प्रदान किए गए लिंक का अनुसरण कर सकते हैं यह जानने के लिए कि आप यह कैसे कर सकते हैं, या एक मौका है कि आपका कंपाइलर आपको पहले से ही यह प्रदान कर सकता है।
आपको बस एक फ़ंक्शन बनाने की ज़रूरत है जो एक बिटबोर्ड के lsb को साफ करता है और इसके सूचकांक को वापस करता है। चलो बुलावा आया poplsb()
।
कुल मिलाकर, आपका कोड इस तरह दिख सकता है
int from = SQ_D4;
uint16_t knightAttacks = getknightAttacks(from);
while (knightAttacks) {
int to = poplsb(knightAttacks);
MyMoveList.Add( NewMove(from, to, 0, 0) ); // The last two 0's denote that there is no special move
}
यह काम करता है क्योंकि हर बार जब आप lsb को पॉप करते हैं, तो नंबर == 0. तब तक क्लियर हो जाता है, जब लूप बंद हो जाता है और आपके पास मूव्स की अच्छी सूची होती है। बिटबोर्ड का उपयोग करके आपके द्वारा बनाई गई किसी भी तरह की चाल पर एक ही विचार लागू होता है।