ओह, मैं इन खेलों से प्यार करता हूँ!
तो पहली बात यह है कि कंप्यूटर के लिए एक गेम खेलने के लिए, इसकी आवश्यकता है:
- साथ काम करने के लिए एक संरचना
- द्वारा खेलने के लिए नियम
- एक जीत की दिशा में काम करने के लिए
आइए एक बार में इस एक टुकड़े से निपटें।
संरचना
चूंकि बोर्ड एक 8x8 ग्रिड है (लेकिन आसानी से स्केल किया जा सकता है), और प्रत्येक ग्रिड स्थान केवल पांच राज्यों में मौजूद हो सकता है, आइए इन राज्यों को परिभाषित करें:
[EMPTY, WHITE_PIECE, BLACK_PIECE, WHITE_PIECE_PROMOTED, BLACK_PIECE_PROMOTED]
क्रमशः:
[0, 1, 2, 3, 4]
अब जब हम जानते हैं कि प्रत्येक स्थान क्या हो सकता है तो हमें सभी स्थानों या बोर्ड का प्रतिनिधित्व करने के लिए किसी तरह की आवश्यकता हो सकती है। लगभग हर मजबूत भाषा एक बहु-आयामी सरणी (एक सरणी जहां प्रत्येक तत्व डेटा रखने वाली एक सरणी है) का समर्थन करेगी। तो हमारे सरणी को परिभाषित करने के लिए निम्नलिखित सुस्त कोड लें:
BOARD_ARRAY = array(8, 8)
यह हमें एक 8 x 8 एरे देगा जिसमें हम पूर्णांक (पहले से हमारे एनम) स्टोर कर सकते हैं:
(
[0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0],
)
अब आप पहले से ही देख सकते हैं कि यह कैसा बोर्ड जैसा दिखने लगा है! मैंने कभी भी यूट्यूब वीडियो में उल्लिखित संस्करण नहीं खेला है, लेकिन यह नीचे से सफेद पंक्तियों की 2 पंक्तियों और ऊपर से एक पंक्ति में 2 पंक्तियों के साथ शुरू होता है। इसका मतलब यह होगा कि जब हम कोई खेल शुरू करते हैं तो हमारी सरणी इस तरह दिखनी चाहिए:
(
[0, 0, 0, 0, 0, 0, 0, 0],
[2, 2, 2, 2, 2, 2, 2, 2],
[2, 2, 2, 2, 2, 2, 2, 2],
[0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0],
[1, 1, 1, 1, 1, 1, 1, 1],
[1, 1, 1, 1, 1, 1, 1, 1],
[0, 0, 0, 0, 0, 0, 0, 0],
)
(याद रखें 2 'BLACK_PIECE' का प्रतिनिधित्व करता है और 1 'WHITE_PIECE' का प्रतिनिधित्व करता है)
इसलिए अब कंप्यूटर के पास काम करने के लिए एक संरचना है। चरण 1 पूरा!
नियम
आइए कल्पना करें कि आपके सामने एक वास्तविक बोर्ड स्थापित था, जो एक मास्टर खिलाड़ी के खिलाफ खेल रहा था। यदि आपने उसके एक टुकड़े को हिलाने की कोशिश की, तो आपको अपना हाथ थप्पड़ मारना पड़ेगा। यदि आप एक ऐसे टुकड़े को स्थानांतरित करने का प्रयास करते हैं, जो आप नहीं कर सकते, तो आपको अपना हाथ थप्पड़ मारना होगा। अगर आपने अच्छा धोखा देने की कोशिश की ... तो आपको अंदाजा हो जाता है। लेकिन समस्या यह है, कंप्यूटर नहीं है। तो यह हमारा काम है कि भीतर खेलने के लिए सख्त नियम प्रदान करें ।
हमें यह जांचने का एक तरीका बनाने की जरूरत है कि क्या कोई दिया गया कदम 'कानूनी' है। जिसका अर्थ है कि हमें पहले 'चाल' का प्रतिनिधित्व करने के लिए किसी तरह की आवश्यकता है। एक तरीका सरणी पदों का उपयोग करना होगा; उदाहरण के लिए [0, 0] से [0, 1] तक एक टुकड़ा स्थानांतरित करने के लिए, हम एक फ़ंक्शन बना सकते हैं जो उस चाल को दिए गए बोर्ड को अपडेट करेगा। तो वापस करने के लिए सुस्त:
MY_MOVE = array( [0, 0], [0, 1] )
ऊपर एक टुकड़े का प्रतिनिधित्व करता है, बोर्ड के शीर्ष कोने से एक स्थान नीचे ले जाता है (मान 0, 0 शीर्ष बाएँ कोने है)। आप यह भी देख सकते हैं कि मैंने इस कदम के लिए एक बहुआयामी सरणी का उपयोग करने के लिए चुना है। ऐसा इसलिए है क्योंकि टुकड़े सैद्धांतिक रूप से एक बारी में बड़ी संख्या में स्थानांतरित हो सकते हैं (अन्य टुकड़ों को 'कूदने' के लिए)। तो चलो 0 पर दिखावा करते हैं, 1 एक विरोधी टुकड़ा था, जिसका अर्थ है कि हम 0, 2 पर उतरेंगे:
MY_MOVE = array( [0, 0], [0, 2] )
बहुत आसान है एह। कार्यक्रम को समझना चाहिए कि यदि हम एक स्थान छोड़ते हैं तो हम एक और टुकड़ा कूद रहे हैं (या फिर यह एक अवैध कदम है, और एक त्रुटि फेंकनी चाहिए)। अब दो टुकड़े करते हैं:
MY_MOVE = array ( [0, 0], [0, 2], [0, 4] )
यह हमें बोर्ड पर किसी भी कदम का वर्णन करने का एक तरीका देता है। वाह! अब चूंकि मैं प्रश्न में सटीक गेम के नियमों को पूरी तरह से नहीं समझता हूं (हालांकि मैंने अपने दिन में थोड़ा सा कनाडा के चेकर्स को खेला है) सटीक चाल वैधता को आपके द्वारा परिभाषित करने की आवश्यकता होगी। इस बिंदु तक एक अच्छा प्रवाह जैसा दिखेगा:
FUNCTION_FIND_ALL_LEGAL_MOVES( MY_BOARD ) Returns: array ALL_LEGAL_MOVES
FUNCTION_FIND_BEST_MOVE( MY_BOARD, ALL_LEGAL_MOVES ) Returns: array MY_MOVE
FUNCTION_DO_MOVE( MY_BOARD, MY_MOVE ) Throws: error ILLEGAL_MOVE Updates: MY_BOARD
repeat from start for each turn
ऊपर माना जाता है कि आप प्रत्येक टुकड़े के माध्यम से साइकिल चला सकते हैं, यह सब कानूनी चाल को खोजने के लिए है, फिर सभी कानूनी चालों के संग्रह को देखते हुए किसी भी तरह से सबसे अच्छा एक (यहां रणनीति) चुनें। इस कदम को फिर बोर्ड पर लागू किया जाता है, या एक त्रुटि फेंकता है। फिर अगला खिलाड़ी अपनी बारी लेता है। तो हमारे पास एक एआई है जो जानता है कि कैसे खेलना है! जोय! आगे बढ़ते रहना।
जीतना
सरल खेल अद्भुत होते हैं, क्योंकि जीतना बहुत ही सरल अवस्था से परिभाषित होता है। बोर्ड पर सफेद टुकड़े नहीं हैं? वैसे मुझे लगता है कि आप जीत गए हैं! यह चरण 2 में लागू किया जाता है जब हम जीतने की स्थिति के करीब ले जाने के लिए सबसे अच्छा कदम चुनते हैं।
कुछ बहुत ही बुद्धिमान एअर इंडिया बनाने के लिए आप एक डेटाबेस रख सकते हैं जो राज्य के रूप में हर संभव बोर्ड को संग्रहीत करता है, हर संभव राज्य से हर संभव कदम के साथ, जीतने की दिशा में चेन को खोजने के लिए।
आप रणनीतियां भी बना सकते हैं, जैसे: यदि कोई ऐसा टुकड़ा है, जिस पर कूदना होगा, तो उस टुकड़े को बचाएं या यदि एक टुकड़ा एक से अधिक कूदने में सक्षम हो तो उस कूद को करें।
यह आपको एक अच्छा जंपिंग पॉइंट देना चाहिए, यह वस्तुतः असीमित संभावनाओं का केवल एक तरीका है। आप सैद्धांतिक रूप से क्रेयॉन्स के साथ आकर्षित करने के लिए एक विशालकाय रोबोट का निर्माण कर सकते हैं, फिर चाल का चयन करने के लिए ड्राइंग पर वर्णक्रमीय विश्लेषण का संचालन कर सकते हैं ... लेकिन यह बहुत अच्छा, या तेज़ काम नहीं करेगा। इस तरह से अतीत में काम किया है, और अच्छी तरह से काम किया है: (आशा है कि मदद करता है!
कार्यान्वयन पर कुछ शब्द
चेकर्स को एक 'सॉल्व्ड' गेम के रूप में संदर्भित किया जाता है, जिसमें हम बिना किसी अज्ञात के हर कदम की गणना कर सकते हैं। लेकिन यह चाल की एक पूरी अजीब है! तो यह सब मैन्युअल रूप से करने का कोई तरीका नहीं है ... यदि केवल कुछ था ... ओह ठीक है हम प्रोग्रामर हैं। मुट्ठी पंप
एसक्यूएल इन सभी प्रतीत होता है अंतहीन चाल के भंडारण के लिए एक अद्भुत उपकरण है। SQL के साथ कोई अनुभव नहीं रखने वालों के लिए, mySQL एक मुफ्त (उपयोग करने में काफी आसान) और खुला स्रोत SQL सर्वर है। SQL का उपयोग डेटाबेस के प्रबंधन के लिए किया जाता है, स्टेरॉयड पर स्प्रैडशीट की तरह। यह बड़ी मात्रा में डेटा को गंभीरता से रखने में सक्षम है और इसके साथ बहुत जल्दी काम करता है।
तो हम इसका उपयोग कैसे कर सकते हैं? चूंकि हम जानते हैं कि यदि बोर्ड एक सटीक स्थिति में है (एक निश्चित स्थिति में प्रत्येक टुकड़ा) तो हम सभी उपलब्ध चालों की गणना कर सकते हैं, और उन्हें बचा सकते हैं। उदाहरण के लिए:
+Board State+ +All Possible Moves+ +Best Move+
([0,0,1,2,3],[3..) ([0,1],[0,2]), ([7,6],[7,7],[5..) ([7,6],[7,7])
([0,0,2,2,3],[3..) ([0,1],[0,2]), ([7,6],[7,7],[5..) ([5,5],[5,4])
([0,0,1,3,3],[3..) ([0,1],[0,2]), ([7,6],[7,7],[5..) ([4,4],[4,3])
etc...
इसलिए जब कंप्यूटर को एक चाल बनाने की आवश्यकता होती है तो यह डेटाबेस में बोर्ड स्टेट (प्राथमिक कुंजी के रूप में संग्रहीत) को देखता है, और अधिक अनुकूल बनाने के लिए या तो सबसे अच्छा कदम (अपराजेय होना चाहिए) या अन्य चालों में से एक चुन सकता है ऐ।
अब महान इस डेटाबेस का निर्माण करते हैं। पहले हमें प्रत्येक बोर्ड राज्य की गणना करने की आवश्यकता है। जो एक महान बड़े बुरा लूप के साथ किया जा सकता है, अगर कोई व्यक्ति कुछ समय बिताना चाहता है और इसे काम करना चाहता है जो भयानक होगा। सरणी को एक बड़ी संख्या के रूप में देखें, फिर आधार 5, (0, 1, 2, 3, 4) को छोड़कर ऊपर की ओर गिनें और यह शर्त रखें कि प्रत्येक खिलाड़ी के केवल 16 टुकड़े हो सकते हैं।
इस बिंदु पर हमारे पास प्रत्येक बोर्ड स्थिति संग्रहीत होनी चाहिए और सभी संभव चाल की गणना के माध्यम से जा सकते हैं।
एक बार सभी संभावित चालों की गणना करने के बाद सबसे अच्छा संभव चालों को पाथ करने का मजेदार हिस्सा आता है। यहीं से मेरा ज्ञान कम होने लगता है, और मिनीमाक्स या ए * जैसी चीजें चलन में आने लगती हैं। क्षमा करें, मैं उस पर अधिक मदद नहीं कर सकता: /
