00 के उत्तरार्ध के बोर्ड गेम की वास्तविक उछाल के बाद, परिवार ने खेलों के साथ कई बक्से छोड़ दिए। उनमें से एक खेल "हरे और हाथी" मूल जर्मन संस्करण में है। कई खिलाड़ियों के लिए एक गेम, जिसमें यादृच्छिकता का तत्व कम से कम है, और कई चरणों में सोबर गणना और खिलाड़ी की क्षमता "आगे देखने" की क्षमता है।

खेल में मेरी लगातार हार ने मुझे सर्वश्रेष्ठ कदम चुनने के लिए कंप्यूटर "खुफिया" लिखने के लिए प्रेरित किया। खुफिया, आदर्श रूप से हरे और हेजहोग के ग्रैंडमास्टर से लड़ने में सक्षम है (और क्या, चाय, शतरंज नहीं, खेल आसान होगा)। बाकी लेख में विकास प्रक्रिया, एआई तर्क और स्रोत के लिए लिंक का वर्णन किया गया है।

खेल के नियम हरे और हाथी

65 कोशिकाओं के खेल मैदान पर 2 से 6 प्रतिभागियों (मेरे ड्राइंग, गैर-विहित, निश्चित रूप से, ऐसा-तो) से कई खिलाड़ी चिप्स हैं:

सूचकांक 0 (शुरू) और 64 (खत्म) के साथ कोशिकाओं के अलावा, प्रत्येक कोशिकाओं में केवल एक खिलाड़ी को रखा जा सकता है। प्रत्येक खिलाड़ी का लक्ष्य प्रतिद्वंद्वियों से आगे फिनिश सेल के लिए आगे बढ़ना है।

"ईंधन" आगे बढ़ने के लिए गाजर है - खेल की " मुद्रा ।" शुरुआत में, प्रत्येक खिलाड़ी को 68 गाजर मिलती हैं, जो वह देता है (और कभी-कभी प्राप्त करता है) जैसे ही वह चलता है।

गाजर के अलावा, शुरुआत में खिलाड़ी को 3 सलाद कार्ड मिलते हैं। सलाद एक विशेष "विरूपण साक्ष्य" है जिसे खत्म होने से पहले एक खिलाड़ी को छुटकारा पाना चाहिए। लेट्यूस से छुटकारा पाना (और यह केवल एक विशेष लेटस पिंजरे पर किया जा सकता है, जैसे:

), खिलाड़ी, सहित, अतिरिक्त गाजर प्राप्त करता है। इससे पहले, अपने कदम को लंघन। कार्ड छोड़ने वाले सलाद के सामने जितने अधिक खिलाड़ी होंगे, उतना ही गाजर उस खिलाड़ी को प्राप्त होगा: 10 x (अन्य खिलाड़ियों के सापेक्ष मैदान पर खिलाड़ी की स्थिति)। यही है, मैदान के दूसरे भाग पर खड़े खिलाड़ी को सलाद के पिंजरे को छोड़कर, 20 गाजर प्राप्त होंगे।

लेटेस सेल के साथ सादृश्य द्वारा, संख्या 1 - 4 के साथ सेल अगर खिलाड़ी की स्थिति सेल (1 - 4, नंबर 1 के साथ सेल भी फ़ील्ड पर 4 वें और 6 ठी स्थिति के लिए उपयुक्त है) के साथ मेल खाती है, तो कई दसियों गाजर ला सकते हैं।

खिलाड़ी इस कदम को गाजर की छवि के साथ पिंजरे पर छोड़ सकता है और इस कार्रवाई के लिए 10 गाजर प्राप्त कर सकता है। एक खिलाड़ी को "ईंधन" क्यों देना चाहिए? तथ्य यह है कि एक खिलाड़ी अपनी अंतिम चाल के बाद केवल 10 गाजर कर सकता है (20 यदि आप दूसरे को समाप्त करते हैं, 30 यदि आप तीसरे स्थान पर हैं, आदि)।

अंत में, खिलाड़ी निकटतम मुक्त हेजहोग पर एन कदम उठाकर 10 x एन गाजर प्राप्त कर सकता है (यदि निकटतम हेजहोग व्यस्त है, तो ऐसा कदम असंभव है)।

आगे बढ़ने की लागत की गणना सूत्र के अनुसार, चाल की संख्या के अनुपात में नहीं की जाती है:

f r a c N + N^{2} 2

$\ frac {N + N ^ 2} {2}$ ।
जहां N आगे की संख्या है।

इसलिए एक सेल को आगे बढ़ाने के लिए, खिलाड़ी 1 गाजर, 2 कोशिकाओं के लिए 3 गाजर, 3 कोशिकाओं के लिए 6 गाजर, 10 के लिए 4, ..., 20 कोशिकाओं को आगे बढ़ने के लिए 210 गाजर देता है।

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

एआई के बिना कार्यान्वयन

पहले कार्यान्वयन में, जो तब खेल "बुद्धि" के विकास का आधार बन जाएगा, मैंने खुद को उस विकल्प तक सीमित कर दिया, जिसमें प्रत्येक खिलाड़ी एक चाल चलता है - एक व्यक्ति।

मैंने गेम को एक क्लाइंट के रूप में लागू करने का फैसला किया - एक स्थिर एक-पृष्ठ वेबसाइट, जो "तर्क" के सभी जेएस और सर्वर पर लागू होती है - वेब एपीआई एप्लिकेशन। सर्वर .NET कोर 2.1 में लिखा गया है और एक असेंबली विरूपण साक्ष्य का उत्पादन करता है - एक डीएलएल फ़ाइल, जिसे विंडोज / लिनक्स / मैक ओएस के तहत चलाया जा सकता है।

ग्राहक भाग का "तर्क" कम से कम (साथ ही UX, क्योंकि GUI विशुद्ध रूप से उपयोगितावादी है)। उदाहरण के लिए, वेब क्लाइंट यह देखने के लिए स्वयं चेक नहीं करता है कि खिलाड़ी द्वारा अनुरोधित नियम स्वीकार्य हैं या नहीं। यह जाँच सर्वर पर की जाती है। सर्वर क्लाइंट को बताता है कि खिलाड़ी खेल की वर्तमान स्थिति से क्या कदम उठा सकता है।

सर्वर एक क्लासिक मूर मशीन है । सर्वर लॉजिक में "कनेक्टेड क्लाइंट", "गेम सेशन" आदि जैसी अवधारणाओं का अभाव है।

सभी सर्वर प्राप्त (HTTP POST) कमांड को प्रोसेस करते हैं। "कमांड" पैटर्न सर्वर पर लागू किया जाता है। क्लाइंट निम्नलिखित आदेशों में से एक के निष्पादन का अनुरोध कर सकता है:

एक नया गेम शुरू करें, अर्थात "स्वच्छ" बोर्ड पर खिलाड़ियों की निर्दिष्ट संख्या के "प्लेस" चिप्स
कमांड में बताए गए मूव को करें

दूसरी टीम के लिए, क्लाइंट सर्वर को वर्तमान गेम पोजिशन (डिसपोजिशन क्लास का ऑब्जेक्ट), यानी, निम्नलिखित फॉर्म का विवरण भेजता है:

स्थिति, गाजर की संख्या और प्रत्येक घास के लिए लेटस, इसके अलावा एक अतिरिक्त बूलियन फ़ील्ड जो यह दर्शाता है कि हरेक अपनी बारी याद कर रहा है
हरक की चाल।

सर्वर को अतिरिक्त जानकारी भेजने की आवश्यकता नहीं है - उदाहरण के लिए, खेल मैदान के बारे में जानकारी। बस एक शतरंज के स्केच को रिकॉर्ड करने के लिए बोर्ड पर काले और सफेद कोशिकाओं की व्यवस्था को चित्रित करना आवश्यक नहीं है - यह जानकारी एक स्थिर के रूप में ली गई है।

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

यदि टीम सफल होती है, तो प्रतिक्रिया में एक नया गेम पोजिशन होगा , साथ ही उन चालों की एक सूची होगी जो कतार में अगले खिलाड़ी द्वारा बनाई जा सकती है (नई स्थिति के लिए वर्तमान)।

इसके अतिरिक्त, सर्वर प्रतिक्रिया में कुछ सेवा क्षेत्र शामिल हैं। उदाहरण के लिए, एक खिलाड़ी द्वारा संबंधित पिंजरे के एक चरण पर एक खिलाड़ी द्वारा निकाले गए "कार्ड" का एक कार्ड का पाठ।

खिलाड़ी की बारी

खिलाड़ी की बारी एक पूर्णांक के रूप में एन्कोडेड है:

0, यदि खिलाड़ी को वर्तमान सेल में रहने के लिए मजबूर किया जाता है,
1, 2, ... एन 1 के लिए, ... एन कदम आगे,
-1, -2, ... -M को स्थानांतरित करने के लिए 1 ... M कोशिकाएं निकटतम मुक्त हेजहोग पर वापस जाती हैं,
1001, 1002 - उस खिलाड़ी के लिए विशेष कोड, जिसने गाजर सेल पर रहने का फैसला किया और इसके लिए (1001) या (1002) 10 गाजर प्राप्त किए।

सॉफ्टवेयर कार्यान्वयन

सर्वर अनुरोधित कमांड का JSON प्राप्त करता है, इसे संबंधित अनुरोध वर्गों में से एक में दर्ज करता है, और अनुरोधित कार्रवाई करता है।

यदि क्लाइंट (खिलाड़ी) ने टीम से स्थानांतरित स्थिति (पीओएस) से सीएमडी कोड के साथ एक चाल बनाने का अनुरोध किया, तो सर्वर निम्नलिखित क्रियाएं करता है:

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

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

चेक / निष्पादित विधियों के इनपुट पर, TurnChecker गेम स्थिति (डिस्पोजल) के वर्ग का एक ऑब्जेक्ट प्राप्त करता है। डिस्पोज़न ऑब्जेक्ट में प्लेयर डेटा (हेज़ [] हेज़) का एक सरणी होता है, जो खिलाड़ी के मूव + को कुछ सर्विस की जानकारी देता है जो टर्नचैकर ऑब्जेक्ट के संचालन के दौरान भरा जाता है।

खेल का मैदान फ़ील्ड मैप क्लास का वर्णन करता है, जिसे एक सिंगलटन के रूप में कार्यान्वित किया जाता है। कक्षा में कोशिकाओं की एक सरणी होती है + बाद की गणना को सरल / तेज़ करने के लिए उपयोग की जाने वाली कुछ ओवरहेड जानकारी।

प्रदर्शन के विचार

टर्नकैचर वर्ग के कार्यान्वयन में, मैंने जितना संभव हो सके छोरों से बचने की कोशिश की। तथ्य यह है कि किसी चाल की अनुमेय चाल / निष्पादन के सेट को प्राप्त करने के तरीकों को बाद में एक अर्ध-इष्टतम चाल के लिए खोज प्रक्रिया के दौरान हजारों (दसियों हजारों) बार कहा जाएगा।

इसलिए, उदाहरण के लिए, मैं गणना करता हूं कि सूत्र का उपयोग करके एक खिलाड़ी एन गाजर के साथ कितने सेल आगे बढ़ सकता है:

return ((int)Math.Pow(8 * N + 1, 0.5) - 1) / 2;

यह जाँच करना कि क्या सेल में से किसी एक खिलाड़ी के कब्जे में है, मैं खिलाड़ियों की सूची से नहीं गुजरता (क्योंकि यह क्रिया संभवतः कई बार करनी होगी), लेकिन मैं फॉर्म के कोश [सेल_इंडेक्स, बिजी_केज और फ्लैग] की ओर मुड़ जाता हूं ।

यह जाँचने पर कि क्या खिलाड़ी द्वारा कब्जे वाली वर्तमान सेल के लिए निर्दिष्ट हेजहोग सेल सबसे नज़दीकी (पीछे) है, मैं फॉर्म [सेल_इंडेक्स, निकटतम_बैक_डेझ] _index के एक शब्दकोश के मूल्य के साथ अनुरोधित स्थिति की तुलना करता हूं - स्थिर जानकारी।

एआई के साथ कार्यान्वयन

एक आदेश सर्वर द्वारा संसाधित कमांड की सूची में जोड़ा जाता है: प्रोग्राम द्वारा चयनित एक अर्ध-इष्टतम चाल को निष्पादित करें। यह टीम "खिलाड़ी की चाल" कमांड का एक छोटा संशोधन है, जिससे वास्तव में, चाल क्षेत्र ( CMD ) को हटा दिया गया है।

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

अनुमानी स्थिति का मूल्यांकन

उदाहरण के लिए, शतरंज में, मूल्यांकन करने के लिए (बिना खुलने के विकलों में रेंगने के बिना) काफी सरल है: कम से कम, आप 3 प्यादों के लिए शूरवीर / बिशप मूल्य ले कर टुकड़ों की कुल "लागत" की गणना कर सकते हैं, एक पंजे का मूल्य 5 पंजे, रानी से 9 और इंट का राजा .MaxValue प्यादे उदाहरण के लिए, अनुमान में सुधार करना आसान है, इसे जोड़ना (एक सुधार कारक के साथ - कारक / प्रतिपादक या अन्य फ़ंक्शन):

वर्तमान स्थिति से संभावित चालों की संख्या,
दुश्मन के आंकड़ों के खतरे / दुश्मन से खतरे का अनुपात।

चटाई की स्थिति के लिए एक विशेष मूल्यांकन दिया जाता है: int.MaxValue , अगर चेकमेट कंप्यूटर डालता है , तो int .inValue अगर चेकमेट व्यक्ति को डालता है।

यदि आप शतरंज प्रोसेसर को अगली चाल का चयन करने का आदेश देते हैं, तो केवल इस तरह के आकलन से निर्देशित, प्रोसेसर शायद सबसे खराब चालों का चयन नहीं करेगा। विशेष रूप से:

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

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

फिर भी, शतरंज में वर्तमान खेल की स्थिति के अनुमानी मूल्यांकन के लिए एल्गोरिथ्म (चैंपियन कार्यक्रम की प्रशंसा का दावा किए बिना) काफी पारदर्शी है। आप खेल हरे और हेजहोग के बारे में नहीं कह सकते।

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

मैंने एक समारोह के रूप में अंतिम ग्रेड काटा:

ई = केएस * एस + केसी * सी + केपी * पी,

जहां S, C, P ग्रेड की गणना सलाद कार्ड (S) और गाजर का उपयोग करके की जाती है। खिलाड़ी के हाथों में P, ग्रेड है, जो खिलाड़ी द्वारा तय की गई दूरी के लिए खिलाड़ी को दिया गया ग्रेड है।

Ks, Kc, Kp इसी सुधार कारक हैं (बाद में उनकी चर्चा की जाएगी)।

सबसे आसान तरीका है कि मैंने तय किए गए मार्ग के लिए चिह्न निर्धारित किया है:
P = i * 3, जहां मैं उस सेल का सूचकांक है, जिस पर खिलाड़ी स्थित है।

ग्रेडिंग सी (गाजर) पहले से अधिक कठिन है।

एक विशिष्ट C मान प्राप्त करने के लिए, मैं 3 कार्यों में से एक का चयन करता हूं

C_{0}, C_{1}, C_{2}

$C_0, C_1, C_2$ एक तर्क से (हाथों पर गाजर की संख्या)। फ़ंक्शन सी ([0, 1, 2]) का सूचकांक खेल के मैदान पर खिलाड़ी की सापेक्ष स्थिति से निर्धारित होता है:

[०] यदि खिलाड़ी ने खेल के आधे से कम क्षेत्र पूरे कर लिए हैं,
[२] अगर किसी खिलाड़ी के पास पर्याप्त (mb, यहां तक कि प्रचुर मात्रा में) गाजर खत्म करने के लिए है,
[१] अन्य मामलों में।

फ़ंक्शंस 0 और 1 समान हैं: खिलाड़ी के हाथों में प्रत्येक गाजर का "मूल्य" धीरे-धीरे हाथों में गाजर की बढ़ती संख्या के साथ घट जाता है। खेल शायद ही कभी Plyushkins को प्रोत्साहित करता है। 1 (क्षेत्र का आधा हिस्सा बीत जाने पर), गाजर का मूल्य थोड़ा तेज हो जाता है।

फ़ंक्शन 2 (खिलाड़ी समाप्त कर सकता है), इसके विपरीत, खिलाड़ी के हाथों में प्रत्येक गाजर पर एक बड़ा जुर्माना (नकारात्मक गुणांक मूल्य) लगाया जाता है - अधिक गाजर, अधिक से अधिक दंड गुणांक। चूंकि गाजर की अधिकता के साथ खेल के नियमों के अनुसार फिनिश निषिद्ध है।

खिलाड़ी के हाथों पर गाजर की मात्रा की गणना करने से पहले, लेटस सेल / सेल नंबर 1 ... 4 से प्रति गाजर खाते में ले जाना निर्दिष्ट है।

एक " लेटेस " ग्रेड एस को इसी तरह से घटाया जाता है। खिलाड़ी के हाथों (0 ... 3) पर सलाद की मात्रा के आधार पर, एक फ़ंक्शन का चयन किया जाता है

S_{0}, S_{1}, S_{2}

$S_0, S_1, S_2$ या

S_{3}

$S_3$ । समारोह तर्क

S_{0} - S_{3}

$S_0 - S_3$ । - फिर से, "रिश्तेदार" पथ खिलाड़ी द्वारा यात्रा की। अर्थात्, सलाद के साथ कोशिकाओं की संख्या शेष है (खिलाड़ी द्वारा कब्जा की गई सेल के सापेक्ष):

वक्र

S_{0}

$S_0$ - खिलाड़ी (0 ... 5) के सामने लेटेस कोशिकाओं की संख्या पर मूल्यांकन फ़ंक्शन (एस), हाथ पर लेटस के 0 कार्ड के साथ एक खिलाड़ी के लिए,
वक्र

S_{1}

$S_1$ - हाथ में एक सलाद कार्ड के साथ एक खिलाड़ी के लिए एक ही कार्य, आदि।

अंतिम ग्रेड (E = Ks * S + Kc * C + Kp * P) इस प्रकार ध्यान में रखता है:

गाजर की अतिरिक्त मात्रा जो खिलाड़ी को अपनी चाल से तुरंत पहले प्राप्त होगी,
खिलाड़ी का रास्ता
गाजर की मात्रा और लेटिष हाथों पर कि nonlinearly स्कोर को प्रभावित करते हैं।

और यहां बताया गया है कि कंप्यूटर कैसे चलता है, अधिकतम हेयूरिस्टिक स्कोर के साथ अगला कदम चुनने पर:

सिद्धांत रूप में, पहली फिल्म इतनी बुरी नहीं है। हालांकि, किसी को ऐसे AI से अच्छे खेल की उम्मीद नहीं करनी चाहिए: खेल के मध्य तक, हरे रंग का "रोबोट" बार-बार चलना शुरू कर देता है, और अंत तक यह आगे बढ़ने के कई पुनरावृत्तियों बनाता है - पिछवाड़े से हेजहोग तक, अंत में खत्म होने तक। आंशिक रूप से मौका के कारण, वह खिलाड़ी को पीछे छोड़ देगा - एक दर्जन चालों वाला व्यक्ति।

कार्यान्वयन नोट्स

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

निर्णय ट्री और मिनिमैक्स एल्गोरिथम

हम विरोधी मिनीमैक्स गेम में निर्णय लेने वाले एल्गोरिदम का उपयोग करते हैं। बहुत अच्छा, मेरी राय में, एल्गोरिथ्म का वर्णन इस पोस्ट (अनुवाद) में किया गया है ।

हम प्रोग्राम को कुछ आगे बढ़ने के लिए "देखना" सिखाते हैं। मान लीजिए, वर्तमान स्थिति से (और पृष्ठभूमि एल्गोरिदम के लिए महत्वपूर्ण नहीं है - जैसा कि हम याद करते हैं, कार्यक्रम एक मूर मशीन के रूप में कार्य करता है ), नंबर 1 द्वारा गिना गया, कार्यक्रम दो चाल बना सकता है। हमें दो संभावित स्थान मिलते हैं, 2 और 3. इसके बाद खिलाड़ी की बारी आती है - व्यक्ति (सामान्य स्थिति में - दुश्मन)। दूसरे स्थान से, प्रतिद्वंद्वी के पास 3 चालें हैं, तीसरे से - केवल दो चालें। अगला, फिर से एक चाल बनाने की बारी कार्यक्रम में आती है, जो कुल मिलाकर, 5 संभावित पदों से 10 चालें बना सकती है:

मान लीजिए, कंप्यूटर की दूसरी चाल के बाद, खेल समाप्त हो जाता है और प्रत्येक प्राप्त पदों का मूल्यांकन पहले और दूसरे खिलाड़ियों के दृष्टिकोण से किया जाता है। और हमने मूल्यांकन एल्गोरिथम पहले ही लागू कर दिया है। आइए हम वेक्टर के रूप में प्रत्येक अंतिम स्थिति (पेड़ के पत्ते 9 ... 18) का मूल्यांकन करें

[v_{0}, v_{1}]

$[v_0, v_1]$ ।
जहाँ

v_{0}

$v_0$ - पहले खिलाड़ी के लिए गणना स्कोर,

v_{1}

$v_1$ - दूसरे खिलाड़ी का स्कोर:

चूंकि कंप्यूटर अंतिम चाल बनाता है, इसलिए यह स्पष्ट रूप से प्रत्येक उपप्रकार ([9, 10], [11], [12, 13], [14, 15, 16], [17, 18] में विकल्प का चयन करेगा। जो उसे एक बेहतर रेटिंग देता है। प्रश्न तुरंत उठता है: किस सिद्धांत से किसी को "सर्वश्रेष्ठ" स्थिति चुननी चाहिए?

उदाहरण के लिए, दो चालें हैं, जिसके बाद हम रेटिंग के साथ स्थिति रखते हैं [5; 5] और [2; 1]। पहले खिलाड़ी का मूल्यांकन करता है। दो विकल्प स्पष्ट हैं:

i-th खिलाड़ी के लिए i-th स्कोर के अधिकतम निरपेक्ष मान के साथ स्थिति चयन। दूसरे शब्दों में, महान रेसर लेस्ली, प्रतियोगियों की परवाह किए बिना, जीत के लिए उत्सुक। इस स्थिति में, [5 के अनुमान के साथ एक स्थिति; 5]।
प्रतियोगियों के अनुमानों के सापेक्ष अधिकतम रेटिंग के साथ एक स्थिति का विकल्प चालाक प्रोफेसर विश्वास है, जो दुश्मन पर गंदी चालें चलाने का मौका नहीं छोड़ता है। उदाहरण के लिए, जानबूझकर दूसरे स्थान से शुरू करने की योजना बनाने वाले खिलाड़ी से पिछड़ जाते हैं। रेटिंग के साथ एक आइटम [2; 1]।

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

v_{i}

$v_i$ ।

सॉफ्टवेयर कार्यान्वयन की विशेषताएं

यदि एआई (टर्नरमेकर क्लास) की सेटिंग में सबसे अच्छा ग्रेड चुनने का पहला विकल्प निर्दिष्ट है, तो संबंधित विधि का कोड फॉर्म लेगा:

  int ContractEstimateByAbsMax(int[] estimationVector, int playerIndex) { return estimationVector[playerIndex]; }

दूसरी विधि - प्रतियोगियों के पदों के सापेक्ष अधिकतम - थोड़ा और अधिक जटिल है:

  int ContractEstimateByRelativeNumber(int[]eVector, int player) { int? min = null; var pVal = eVector[player]; for (var i = 0; i < eVector.Length; i++) { if (i == player) continue; var val = pVal - eVector[i]; if (!min.HasValue || min.Value > val) min = val; } return min.Value; }

चयनित अनुमान (आंकड़े में रेखांकित) को स्तर तक स्थानांतरित किया जाता है। अब दुश्मन को एक स्थिति चुननी होगी, यह जानने के बाद कि एल्गोरिथम किस स्थिति को चुनेगा:

प्रतिकूल, जाहिर है, खुद के लिए सबसे अच्छी रेटिंग के साथ स्थिति का चयन करेगा (एक जहां वेक्टर का दूसरा समन्वय सबसे बड़ा मूल्य लेता है)। इन अनुमानों को फिर से ग्राफ में रेखांकित किया गया है।

अंत में, हम पहले कदम पर लौटते हैं। कंप्यूटर का चयन करता है, और वह वेक्टर के सबसे बड़े पहले समन्वय के साथ इस कदम को प्राथमिकता देता है:

इस प्रकार, समस्या हल हो गई है - एक अर्ध-इष्टतम चाल पाई जाती है। मान लीजिए कि एक पेड़ पर पत्ती की स्थिति में 100% का एक अनुमानी स्कोर भविष्य के विजेता को इंगित करता है। तब हमारा एल्गोरिथ्म असमान रूप से सर्वोत्तम संभव कदम का चयन करेगा।

हालांकि, हेयुरिस्टिक स्कोर केवल 100% सटीक होता है जब खेल की अंतिम स्थिति का मूल्यांकन किया जाता है - एक (या कई) खिलाड़ी समाप्त हो जाते हैं, विजेता निर्धारित होता है। इसलिए, आगे की चालों को देखने का अवसर मिलता है - प्रतिद्वंद्वियों को ताकत में बराबर जीतने में जितना समय लगता है, आप इष्टतम चाल का चयन कर सकते हैं।

लेकिन 2 खिलाड़ियों के लिए एक विशिष्ट गेम औसतन 30 - 40 चाल (तीन खिलाड़ियों के लिए - लगभग 60 चाल, आदि) पर रहता है। प्रत्येक स्थिति से, एक खिलाड़ी आमतौर पर लगभग 8 चालें बना सकता है। नतीजतन, 30 चालों के लिए संभावित पदों का एक पूरा पेड़ लगभग शामिल होगा

8^{30}

$8 ^ {30}$ = 1237940039285380274899124224 चोटियाँ!

व्यवहार में, मेरे पीसी पर ~ 100,000 पदों के एक पेड़ के निर्माण और "पार्सिंग" में लगभग 300 मिलीसेकंड लगते हैं। यदि हमें 7 - 8 स्तरों (चालों) में पेड़ की गहराई पर एक सीमा मिलती है, अगर हम एक सेकंड से अधिक नहीं की कंप्यूटर प्रतिक्रिया की अपेक्षा करना चाहते हैं।

सॉफ्टवेयर कार्यान्वयन की विशेषताएं

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

एक महत्वपूर्ण अतिरिक्त : वर्तमान खिलाड़ी के समाप्त होने पर पेड़ के नीचे के वंश को भी रोक दिया जाना चाहिए। अन्यथा (यदि अन्य खिलाड़ियों के पदों के सापेक्ष सर्वश्रेष्ठ स्थिति का चयन करने के लिए एल्गोरिथ्म चुना गया है), तो कार्यक्रम लंबे समय तक प्रतिद्वंद्वी को "स्टॉम्प" कर सकता है, प्रतिद्वंद्वी को "मॉकिंग" कर सकता है। इसके अलावा, इस तरह हम एंडगेम में पेड़ के आकार को थोड़ा कम कर देंगे।

यदि हम अभी तक पुनरावृत्ति के अंतिम स्तर पर नहीं हैं, तो हम संभव चालों का चयन करते हैं, प्रत्येक चाल के लिए एक नई स्थिति बनाते हैं और इसे वर्तमान विधि के पुनरावर्ती कॉल में पास करते हैं।

मिनिमैक्स क्यों है?

खिलाड़ियों की मूल व्याख्या में हमेशा दो होते हैं। कार्यक्रम विशेष रूप से पहले खिलाड़ी की स्थिति से स्कोर की गणना करता है। तदनुसार, जब "सर्वश्रेष्ठ" स्थिति चुनते हैं, तो इंडेक्स 0 वाला खिलाड़ी अधिकतम रेटिंग के साथ स्थिति की खोज करता है, इंडेक्स 1 वाला खिलाड़ी न्यूनतम खोजता है।

हमारे मामले में, रेटिंग एक वेक्टर होनी चाहिए ताकि प्रत्येक एन खिलाड़ी अपने "दृष्टिकोण" से इसका मूल्यांकन कर सकें, क्योंकि रेटिंग पेड़ से ऊपर उठती है।

ट्यूनिंग ऐ

कंप्यूटर के खिलाफ खेलने के मेरे अभ्यास से पता चला है कि एल्गोरिथ्म इतना बुरा नहीं है, लेकिन अभी भी मनुष्यों से नीच है। मैंने एआई को दो तरीकों से सुधारने का फैसला किया:

निर्णय पेड़ के निर्माण / ट्रैवर्सल का अनुकूलन करें,
सुधार के आंकड़े।

मिनिमैक्स एल्गोरिथम ऑप्टिमाइज़ेशन

उपरोक्त उदाहरण में, हम स्थिति 8 पर विचार करने से इनकार कर सकते हैं और पेड़ के 2 - 3 कोने को बचा सकते हैं:

हम पेड़ के चारों ओर ऊपर से नीचे, बाएँ से दाएँ घूमते हैं। स्थिति 2 पर शुरू होने वाले उप-केंद्र को दरकिनार करते हुए, हमने 1 -> 2: [3, 2] चाल के लिए सबसे अच्छा अनुमान लगाया। स्थिति 7 में मूल के साथ सबट्री को दरकिनार करते हुए, हमने वर्तमान (चाल 3 के लिए सबसे अच्छा निर्धारित किया -> 7) रेटिंग: [2, 4]। कंप्यूटर (पहले खिलाड़ी) के दृष्टिकोण से, स्कोर [2, 4] स्कोर [3, 2] से भी बदतर है। और जब से कंप्यूटर का प्रतिद्वंद्वी स्थिति 3 से कदम चुनता है, तो स्थिति 8 के लिए जो भी स्कोर होता है, स्थिति 3 के लिए अंतिम स्कोर तीसरे स्थान के लिए प्राप्त स्कोर की तुलना में एक प्राथमिकता है। तदनुसार, स्थिति 8 में रूट के साथ सबट्री का निर्माण और मूल्यांकन नहीं किया जा सकता है।

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

सॉफ्टवेयर कार्यान्वयन की विशेषताएं

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

  e = _[0] //        (  )  (e > alpha) alpha = e   (e < beta) beta = e  (beta <= alpha)

सॉफ्टवेयर कार्यान्वयन की एक महत्वपूर्ण विशेषता

अल्फा-बीटा क्लिपिंग विधि, परिभाषा के अनुसार, "क्लीन" मिनिमैक्स एल्गोरिथ्म के समान समाधान की ओर जाता है। यह जांचने के लिए कि क्या निर्णय लेने का तर्क बदल गया है (या इसके बजाय, परिणाम चालें हैं), मैंने एक इकाई परीक्षण लिखा जिसमें रोबोट ने प्रत्येक 2 विरोधियों के लिए 8 चालें बनाईं (कुल 16 चालें) और परिणामी श्रृंखला की चाल को बचाया - के साथ विकलांग कतरन विकल्प।

फिर, उसी परीक्षण में, प्रक्रिया को क्लिपिंग विकल्प को चालू करने के साथ दोहराया गया । उसके बाद, चालों के अनुक्रम की तुलना की गई। चाल में विसंगति अल्फा-बीटा क्लिपिंग एल्गोरिदम (परीक्षण विफल) के कार्यान्वयन में एक त्रुटि को इंगित करता है।

मामूली अल्फा-बीटा कतरन अनुकूलन

AI सेटिंग्स में क्लिपिंग विकल्प सक्षम होने के साथ, स्थिति ट्री में वर्टिस की संख्या औसत 3 गुना कम हो गई थी। इस परिणाम में कुछ सुधार किया जा सकता है।

उपरोक्त उदाहरण में:

इतनी सफलतापूर्वक "संयोग" कि, स्थिति 3 में शीर्ष के साथ उपशीर्षक से पहले, हमने स्थिति 2 में शीर्ष के साथ उपशीर्षक की जांच की। यदि अनुक्रम अलग था, तो हम "सबसे खराब" उपशीर्षक के साथ शुरू कर सकते हैं और यह निष्कर्ष नहीं निकाल सकते कि अगली स्थिति पर विचार करने का कोई मतलब नहीं था। ।

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

वर्तमान स्थिति का आकलन एक महंगी प्रक्रिया है। यदि पहले हमारे लिए केवल टर्मिनल पदों (पत्तियों) का मूल्यांकन करना पर्याप्त था, तो अब मूल्यांकन पेड़ के सभी कोने के लिए किया जाता है। हालाँकि, जैसा कि परीक्षणों से पता चला है, किए गए अनुमानों की कुल संख्या संभावित चालों की प्रारंभिक छंटाई के बिना संस्करण में थोड़ी कम थी।

सॉफ्टवेयर कार्यान्वयन की विशेषताएं

अल्फा-बीटा क्लिपिंग एल्गोरिदम मूल मिनीमैक्स एल्गोरिथ्म के समान चाल देता है। यह हमारे द्वारा लिखे गए इकाई परीक्षण की जांच करता है, चाल के दो अनुक्रमों की तुलना करता है (कतरन के साथ एक एल्गोरिथ्म के लिए और बिना)। सामान्य मामले में, छंटनी के साथ अल्फा-बीटा कतरन, अर्ध-इष्टतम के रूप में एक अलग चाल का संकेत दे सकता है।

संशोधित एल्गोरिथ्म के सही संचालन का परीक्षण करने के लिए, आपको एक नई परीक्षा की आवश्यकता है। संशोधन के बावजूद, सॉर्ट किए गए एल्गोरिथ्म को मूल मिनिमैक्स एल्गोरिथ्म के रूप में गैर-सॉर्ट किए गए एल्गोरिदम के रूप में बिल्कुल उसी अंतिम अनुमान वेक्टर ([3, 2 उदाहरण में उदाहरण में) का उत्पादन करना चाहिए।

परीक्षण में, मैंने परीक्षण पदों की एक श्रृंखला बनाई और "सर्वश्रेष्ठ" चाल के अनुसार हर एक से चुना, छँटाई विकल्प को चालू और बंद किया। फिर उन्होंने दो तरीकों से प्राप्त मूल्यांकन वेक्टर की तुलना की।

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

ऐ सेटिंग्स में, मैं "सबसे खराब विकल्पों की कतरन" वेक्टर सेट करता हूं। उदाहरण के लिए, फ़ॉर्म का वेक्टर [0, 0, 8, 8, 4] का अर्थ है:

एक [0] और दो [0] चरणों को देखते हुए, कार्यक्रम सभी संभावित कदमों पर विचार करेगा, क्योंकि 0 ,
[8] [8] , 8 “” , , ,
पांच या अधिक चरणों को देखते हुए [4], कार्यक्रम 4 से अधिक "सर्वश्रेष्ठ" चालों का मूल्यांकन नहीं करेगा।

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

हेयुरिस्टिक ऑप्टिमाइज़ेशन

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

हरे का जाल

. ( 8 — 10 15), . “” ( !):

7,
, , . , , , .

. :

54 (43), — 10 55 . AI, , (61), 28 . , 6 9 ( 10 ).

, ( ), , 4 — 6 . , , , AI ?

, , . AI . , , . “ ” :

65 — “” , , . , , , () .

सुधार कारक

इससे पहले, वर्तमान स्थिति
E = Ks * S + Kc * C + Kp * P के अनुमानी अनुमान के लिए एक सूत्र देते हुए ,
मैंने उल्लेख किया, लेकिन वर्णन नहीं किया, सुधार कारक।

तथ्य यह है कि दोनों सूत्र और कार्यों के सेट

, तथाकथित रूप से मेरे द्वारा सहज रूप से काटे गए थे "सामान्य ज्ञान।" कम से कम, मैं ऐसे गुणांक Ks, Kc और Kp का चयन करना चाहूंगा ताकि अनुमान यथासंभव पर्याप्त हो। मूल्यांकन की "पर्याप्तता" का मूल्यांकन कैसे करें? मूल्यांकन एक आयाम रहित मात्रा है, और इसकी तुलना केवल दूसरे अनुमान से की जा सकती है। मैं सुधार गुणांक को परिष्कृत करने के लिए केवल एक ही तरीका के साथ आने में सक्षम था: मैंनेप्रोग्राम में "अध्ययन" के एक नंबर को एक सीएसवी फ़ाइल में संग्रहीत किया है जो फॉर्म के डेटा के साथ है।

C_{0} . . C_{2}, S_{0} . . S_{5}

$C_0 .. C_2, S_0 .. S_5$

  45;26;2;f;29;19;0;f;2 ...

इस पंक्ति का शाब्दिक अर्थ है निम्नलिखित:

पहला खिलाड़ी वर्ग 45 पर है, उसके हाथों में गाजर के 26 पत्ते और 2 सलाद कार्ड हैं, खिलाड़ी एक चाल (f = गलत) को याद नहीं करता है। स्थानांतरित करने का अधिकार हमेशा पहला खिलाड़ी होता है।
सेल 29 के दूसरे खिलाड़ी ने गाजर के 19 कार्ड और बिना सलाद कार्ड के एक कदम भी नहीं छोड़ा।
आंकड़ा दो का अर्थ है कि, "निर्णय" अध्ययन, मैंने मान लिया कि दूसरा खिलाड़ी जीतने की स्थिति में है।

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

20 एट्यूड्स का मूल्यांकन करने के बाद (निश्चित रूप से, उनमें से अधिक का विश्लेषण करना सार्थक होगा), मैंने कार्यक्रम द्वारा प्रत्येक एटिकेट्स का मूल्यांकन किया। मूल्यांकन में, सुधार के कारकों में से प्रत्येक के मान, 0.5 से 2 से 0.1 के कुल वेतन वृद्धि में हैं

गुणांक के तीनों के

= 4096 प्रकार। यदि पहले खिलाड़ी के लिए स्कोर दूसरे खिलाड़ी के स्कोर से अधिक हो गया है, और इसी तरह के निर्देश को एटूड रिकॉर्ड की पंक्ति में संग्रहीत किया गया था (लाइन का अंतिम मूल्य 1 है), "हिट" गिना गया था। इसी तरह दर्पण की स्थिति के लिए। अन्यथा, एक पर्ची गिना जाता था। परिणामस्वरूप, मैंने उन त्रिगुणों को चुना जिनके लिए "हिट" का प्रतिशत अधिकतम था (20 में से 16)। लगभग 4096 वैक्टर में से 250 सामने आए, जिनमें से मैंने "सबसे अच्छा", फिर से, "आंख से" चुना, और इसे एआई सेटिंग्स में स्थापित किया।

16^{3}

$16^3$

परिणाम

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

उदाहरण के लिए, रेटिंग्स चुनने के तर्क में (अन्य खिलाड़ियों के सापेक्ष अधिकतम या अधिकतम), मैं निश्चित रूप से एक मध्यवर्ती विकल्प की कोशिश करूंगा। कम से कम, अगर ith खिलाड़ी के स्कोर का पूर्ण मूल्य बराबर है, तो यह एक उच्च स्तर के स्कोर (उच्च स्तर वाले लेसली और विश्वासघाती Feith के संकर) के सापेक्ष मूल्य के साथ एक चाल का चयन करने के लिए उचित है।

कार्यक्रम 3 खिलाड़ियों के साथ संस्करण के लिए पूरी तरह कार्यात्मक है। हालांकि, इसमें संदेह है कि 3 खिलाड़ियों के साथ खेलने के लिए AI की "गुणवत्ता" दो खिलाड़ियों के साथ खेलने की तुलना में कम है। हालांकि, आखिरी परीक्षण के दौरान मैं कंप्यूटर से हार गया - शायद लापरवाही के माध्यम से, लापरवाही से मेरे हाथों पर गाजर की मात्रा का मूल्यांकन किया गया और "ईंधन" की अधिकता के साथ फिनिश लाइन पर आ गया।

अब तक, एआई का आगे विकास एक व्यक्ति की कमी से बाधित है - एक "परीक्षक", अर्थात्, एक कंप्यूटर "जीनियस" का एक जीवित प्रतिद्वंद्वी। मैंने खुद हरे और हेजहोग को मतली के लिए पर्याप्त खेला और मौजूदा स्तर पर बाधित होने के लिए मजबूर किया।

→ स्रोत के साथ भंडार का लिंक

ऐज़ इन हसेड इगेल: मिनिमैक्स फॉर थ्री

खेल के नियम हरे और हाथी

एआई के बिना कार्यान्वयन

खिलाड़ी की बारी

सॉफ्टवेयर कार्यान्वयन

एआई के साथ कार्यान्वयन

अनुमानी स्थिति का मूल्यांकन

निर्णय ट्री और मिनिमैक्स एल्गोरिथम

ट्यूनिंग ऐ

मिनिमैक्स एल्गोरिथम ऑप्टिमाइज़ेशन

मामूली अल्फा-बीटा कतरन अनुकूलन

हेयुरिस्टिक ऑप्टिमाइज़ेशन

सुधार कारक

परिणाम

More articles: