🚜 🚾 💘 टिक टीएसी को पैर की अंगुली "बिना सीमाओं" 🖖 👈🏼 🤞🏾

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

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

फ़ील्ड मनमाने ढंग से बड़ी हो सकती है (नोटबुक कितनी देर तक चलेगी)
विजेता वह है जो एक पंक्ति में 5 टुकड़े डालता है (यदि आप उन्हें कॉल कर सकते हैं)।

सब कुछ सरल है ... और एक ही समय में जटिल: खेल के परिणाम की गणना अग्रिम में नहीं की जा सकती, जैसा कि क्लासिक एनालॉग में है। इस "छोटे प्रक्षेपण" ने मेरा बहुत समय और नसों को छीन लिया। आशा है आपको यह दिलचस्प लगेगा।

इससे पहले कि हम शुरू करें

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

हॉटकी और कमांड:

D - AI आपके लिए एक कदम बनाएगा
टी - सेल वजन देखें
सभी विश्लेषण कोशिकाओं के वजन को देखने के लिए कंसोल में SHOW_WEIGHTS = सही लिखें।

चलिए शुरू करते हैं

आपको खेल के कार्यान्वयन के साथ ही शुरू करने की आवश्यकता है, अर्थात्। दो खिलाड़ियों के लिए एक आवेदन लिखें, अब तक बिना बॉट के। अपने उद्देश्यों के लिए, मैंने जावास्क्रिप्ट + jquery + bootstrap4 का उपयोग करने का फैसला किया, हालांकि यह व्यावहारिक रूप से वहां उपयोग नहीं किया जाता है, लेकिन इसे छोड़ना बेहतर है - या तालिका तैर जाएगी। यह बताने के लिए कुछ विशेष नहीं है कि, js, jquery और बूटस्ट्रैप पर बहुत सारी सामग्री है। मैं केवल यह कह सकता हूं कि मैंने एमवीसी का उपयोग किया है। वैसे भी, मैं बिल्कुल सभी कोड नहीं समझाऊंगा - पहले से ही बहुत सारी सामग्री है।

इसलिए, खेल का मैदान तैयार था। आप कोशिकाओं में आकार निर्धारित कर सकते हैं। लेकिन किसी भी खिलाड़ी की जीत किसी भी तरह से तय नहीं थी।

खेल स्कैन का अंत

खेल तब समाप्त होता है जब खिलाड़ियों में से एक पंक्ति में 5 टुकड़े डालता है। "यह आसान है!" मैंने सोचा। और उसने क्षेत्र की सभी कोशिकाओं को स्कैन करना शुरू कर दिया: पहले सभी क्षैतिज, फिर ऊर्ध्वाधर, और अंत में विकर्ण।

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

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

कोड देखें

checkWin( cellX, cellY ){ var res = null; var newFig = getFig(cellX,cellY); if( ! newFig ) return false; var res; res = res || checkLine( cellX, cellY, 1, 0 ); //horizontal res = res || checkLine( cellX, cellY, 0, 1 ); //vertical res = res || checkLine( cellX, cellY, 1, 1 ); //diagonal 45 res = res || checkLine( cellX, cellY, 1, -1 ); //diagonal 135 return res; function getFig( x, y ){ return Model.Field[x] && Model.Field[x][y] ? Model.Field[x][y] : 'b'; } function checkLine( x, y, dx, dy ){ x = +x; y = +y; var score = 0; while( getFig( x - dx, y - dy ) == newFig ){ x -= dx; y -= dy; } while( getFig( x, y ) == newFig ){ x += dx; y += dy; score++; } if( score >= 5 ) return true; return false; } }

चलो बॉट में ही उतर जाते हैं

इसलिए, हमने पहले ही टिक-टैक-टो के साथ एक पेज लिखा है। हम मुख्य कार्य को पास करते हैं - एआई।
अगर आपको पता नहीं है कि आप कैसे सिर्फ कोड ले सकते हैं और लिख सकते हैं: आपको बॉट के तर्क पर विचार करने की आवश्यकता है।

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

शब्दावली

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

आसन्न हमले की कोशिकाओं (सिरों पर) में खाली कोशिकाएं या दुश्मन के टुकड़े हो सकते हैं। यह सोचना तर्कसंगत है कि "सिरों" पर दो खाली कोशिकाओं के साथ एक हमला दो दिशाओं में विकसित किया जा सकता है, जो इसे और अधिक आशाजनक बनाता है। हमले के "सिरों" पर खाली कोशिकाओं की संख्या को इसकी क्षमता कहा जाएगा। क्षमता 0, 1 या 2 हो सकती है।
हम हमलों को निम्नानुसार दर्शाते हैं: [हमले की शक्ति, क्षमता] । उदाहरण के लिए, एक हमला [४: १] ।

चित्र 1. हमला [4: 1]

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

विश्लेषण का सार

कल्पना कीजिए कि खेल के मैदान पर पहले से ही एक और दूसरे खिलाड़ी के कई हमले हैं। खिलाड़ियों में से एक एक चाल बनाता है (क्रॉस को छोड़ दें)। स्वाभाविक रूप से, वह एक खाली सेल में कदम रखता है - और इस तरह वह:

अपने हमले को विकसित करें, और शायद एक से अधिक, अपनी शक्ति बढ़ाते हुए। एक नया हमला शुरू कर सकते हैं, आदि।
दुश्मन के हमले के विकास को रोकें या इसे पूरी तरह से अवरुद्ध करें।

यानी हमारा नायक हमला और बचाव कर सकता है। या हो सकता है कि एक बार में सभी एक बार में। उसके लिए, पहला और दूसरा दोनों महत्वपूर्ण हैं।

विश्लेषण का सार इस प्रकार है:

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

वास्तव में, हम इस तरह के एक एल्गोरिथ्म के साथ जांच करते हैं कि अगर हम इस तरह से जाते हैं तो क्या होगा ... और अगर प्रतिद्वंद्वी इस तरह से चला जाता है तो क्या होगा। हम एक कदम आगे देखते हैं और सबसे उपयुक्त सेल का चयन करते हैं - उच्चतम वजन के साथ।

यदि किसी सेल में दूसरे की तुलना में अधिक वजन है, तो यह अधिक खतरनाक हमलों के निर्माण की ओर जाता है, या मजबूत दुश्मन के हमलों को रोकता है। सब कुछ तार्किक है ... यह मुझे लगता है।
यदि आप पृष्ठ पर जाते हैं और कंसोल SHOW_WEIGHTS = true में लिखते हैं, तो आप नेत्रहीन एल्गोरिथ्म के संचालन को महसूस कर सकते हैं (सेल वजन दिखाया जाएगा)।

हमला वजन

मैं अपने दिमाग पर चला गया और हमलों और वजन के ऐसे पत्राचार लाया:

 ATTACK_WEIGHT = [[],[],[],[],[],[]]; ATTACK_WEIGHT[1][1] = 0.1; ATTACK_WEIGHT[2][1] = 2; ATTACK_WEIGHT[3][1] = 4; ATTACK_WEIGHT[4][1] = 6; ATTACK_WEIGHT[5][1] = 200; ATTACK_WEIGHT[1][2] = 0.25; ATTACK_WEIGHT[2][2] = 5; ATTACK_WEIGHT[3][2] = 7; ATTACK_WEIGHT[4][2] = 100; ATTACK_WEIGHT[5][2] = 200; ATTACK_WEIGHT[5][0] = 200;

अनुभवजन्य रूप से चयनित - शायद यह सबसे अच्छा विकल्प नहीं है।

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

उच्च क्षमता वाले हमलों को अधिक महत्व दिया जाता है।

हमले [4: 2] ज्यादातर मामलों में खेल के परिणाम का फैसला करता है। यदि खिलाड़ी इस तरह का हमला करने में कामयाब रहा, तो प्रतिद्वंद्वी अब इसे ब्लॉक नहीं कर पाएगा। हालाँकि, यह कोई जीत नहीं है। दुश्मन खेल को तेजी से खत्म कर सकता है, भले ही हमारे पास मैदान पर हमला हो [4: 2], इसलिए इसका वजन 5. की शक्ति के साथ हमलों से कम है। नीचे एक उदाहरण देखें।

चित्रा 2. हमला [4: 2]

फटे अटैक

इस अनुच्छेद में कोड प्रस्तुत नहीं किया गया है। यहाँ हम एक हमले विभक्त की अवधारणा को पेश करते हैं और "फटे हुए हमलों" का सार समझाते हैं।

निम्नलिखित स्थिति पर विचार करें: जब कई खाली कोशिकाओं को हटाने के लिए एक आंकड़ा प्रतिस्थापित किया जाता है, लेकिन 5 से अधिक नहीं, एक और स्थित है।

और, ऐसा लगता है, दो समान आंकड़े, एक ही पंक्ति पर ... नेत्रहीन यह एक हमले की तरह दिखता है, लेकिन वास्तव में नहीं। आदेश नहीं, क्योंकि इस तरह के "फटे" हमले संभावित खतरे को भी बढ़ाते हैं।

विशेष रूप से ऐसे मामलों के लिए, प्रत्येक हमले के लिए हम भाजक की गणना करेंगे। प्रारंभ में, इसका मूल्य 1 है।

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

अंजीर 3. "फटे हुए हमले" का विश्लेषण। पीले क्रॉस के साथ एक सेल स्कैन किया जाता है।

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

हमला खोज एल्गोरिथ्म

सबसे पहले, एक हमले वर्ग बनाएँ। हमले में 3 विशेषताएँ होंगी, जो मैंने पहले लिखी थीं:

 class Attack{ constructor( cap = 0, pot = 0, div = 1 ){ this.capability = cap; // this.potential = pot; // this.divider = div; // }

और एक विधि जो किसी दिए गए हमले का वजन लौटाएगी:

 countWeigth(){ return ATTACK_WEIGHT[ this.capability, this.potential ] / this.divider } }

अगला। हम एक सेल में सभी हमलों के लिए खोज को विभाजित करेंगे:

क्षैतिज खोज
ऊर्ध्वाधर खोज
45 डिग्री विकर्ण खोज
135 डिग्री विकर्ण खोज

ये सभी लाइनें हैं , और इन लाइनों पर हमलों की खोज के लिए एल्गोरिदम को सामान्यीकृत किया जा सकता है: चेकलाइन क्लास ।

हालाँकि, हमें पूरी लाइन की जाँच करने की आवश्यकता नहीं है। अधिकतम हमले की शक्ति जो हमारे हित में है, 5. बेशक, 6 की शक्ति के साथ हमला करना संभव है। लेकिन एक एआई के लिए जो अगले कदम की खेल स्थिति का विश्लेषण करता है, यह 6 या 5 के समान है। इनमें से किसी एक हमले की संभावना अगले कदम पर गेम के अंत का संकेत देती है। तदनुसार, विश्लेषण किए गए सेल का वजन दोनों मामलों में समान होगा।

वर्ग विशेषताएं:

 class checkLine{ constructor(){ //,        this.subFig = "×"; //     .    «0» - . this.Attacks = []; //  this.curAttack = new Attack; // (      ) this.iter = 1; //,     this.checkEdge = false;

यहां रोकना आवश्यक है, जैसा कि सवाल उठ सकता है: 6 वें सेल की जांच क्यों करें यदि अधिकतम हमले की शक्ति 5. है इसका जवाब हमले के केंद्र से संभावित रिमोट को निर्धारित करना है।

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

अंजीर। 3. 6 वीं कोशिकाओं को स्कैन करना। यदि आप 6 वें सेल को स्कैन नहीं करते हैं, तो आप हमले की क्षमता को गलत तरीके से निर्धारित कर सकते हैं।

  //   this.attackplace = 1; }

कुछ हमलों को पूरा करने के लिए बस पर्याप्त जगह नहीं हो सकती है। हमलावर को गिना जाने पर, हम पहले से समझ सकते हैं कि कौन सा हमला अप्रमाणिक है।

अंजीर। 4. हमला करने का स्थान

एल्गोरिथ्म इस प्रकार है:

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

इसकी शक्ति 1 से कम नहीं होगी (केंद्रीय सेल में एक आंकड़ा)
विभक्त - १, क्योंकि यह एक केंद्रीय हमला है (यह स्कैन सेल का है);
क्षमता अभी तक ज्ञात नहीं है - डिफ़ॉल्ट 0 है;

हमने इन सभी बिंदुओं को डिफ़ॉल्ट कंस्ट्रक्टर मानों में प्रदर्शित किया - ऊपर कोड देखें।

2) अगला, पुनरावृत्ति को कम करने, स्कैन किए गए एक तरफ 5 से अधिक कोशिकाओं को पुनरावृत्त करता है। GetAttacks फ़ंक्शन (सेलएक्स, सेल, सबफ़िग, डीएक्स, डाई) इसके लिए जिम्मेदार है, जहां:

cellX, cellY - चेक किए गए सेल के निर्देशांक
सबफिग - वह आंकड़ा जिसे हम चेक किए गए सेल में स्थानापन्न करते हैं
dx, dy - चक्रों में x और y निर्देशांक में परिवर्तन - इस तरह से हम खोज दिशा निर्धारित करते हैं:

क्षैतिज (dx = 1, डाई = 0)
कार्यक्षेत्र (dx = 0, dy = 1)
विकर्ण 45 (डीएक्स = 1, डाई = -1)
विकर्ण 135 (डीएक्स = 1, डाई = 1)

एक अर्थ में, यह खोज लाइन के समानांतर एक वेक्टर है। इस प्रकार, एक फ़ंक्शन 4 दिशाओं में खोज करने में सक्षम होगा और हम DRY सिद्धांत का एक बार फिर उल्लंघन नहीं करेंगे।

समारोह कोड:

 getAttacks( cellX, cellY, subFig, dx, dy ){ this.substitudeFigure( subFig ); //  –  ... for( var x = cellX - dx, y = cellY - dy; Math.abs( x - cellX ) <= 5 && Math.abs( y - cellY ) <= 5; x -= dx, y -= dy ) if( this.checkCell( x, y ) ) break; //: //    (  ) this.turnAround(); //  -    ... for( var x = cellX + dx, y = cellY + dy; Math.abs( x - cellX ) <= 5 && Math.abs( y - cellY ) <= 5; x += dx, y += dy ) if( this.checkCell( x, y ) ) break; return this.Attacks; }

कृपया ध्यान दें कि अगर चेकसेल () कुछ वापस करता है, तो लूप बंद हो जाता है।

3) हम इन कोशिकाओं के आंकड़ों की जांच करते हैं।
चेकसेल (x, y) फ़ंक्शन इसके लिए जिम्मेदार है:

सबसे पहले, आकृति को अंजीर चर पर लिखें:
Model.Field हमारे खेल का मैदान है।

 checkCell( x, y ){ var fig = Model.Field[x] && Model.Field[x][y] !== undefined ? Model.Field[x][y] : 'b';

अंजीर 'x', 'o', 'b' (बॉर्डर), 0 (खाली सेल) हो सकता है।

यदि ऐसा आंकड़ा केंद्रीय सेल ( this.subFig ) के आंकड़े के साथ मेल खाता है, तो हम एल्गोरिदम जारी रखते हैं - फिर हम हमले को स्कैन करना जारी रखते हैं, सब कुछ ठीक है, हम उसी भावना में जारी रखते हैं। हमले में एक अतिरिक्त टुकड़ा इसकी शक्ति ( this.curAttack.capability ) और जगह ( this.attackplace ) के लिए एक प्लस है।

(अगले पैराग्राफ में कोड देखें)
यदि यह एक अलग आकृति है, तो इस हमले से पहले हमने स्कैन किया था (इस.curAttack) को इस तरफ से अवरुद्ध किया गया है। हम हमले के मापदंडों में कुछ भी नहीं बदलते हैं, इसे हमलों के सरणी में लिखते हैं और लूप से बाहर आते हैं।
```
 if( fig == '○' || fig == '×' ){ if( this.subFig != fig ){ //  this.Attacks.push( this.curAttack ); //  return fig; //      } else{ //    this.curAttack.capability++; // +   this.attackplace++; // +   } } 
```
यदि ऐसी कोई सेल नहीं है, तो इसका मतलब है कि वे क्षेत्र की सीमा से बाहर गिर गए हैं, जिसका मतलब है कि हमला अवरुद्ध है। हम इसे सभी हमलों की एक सरणी में लिखते हैं और लूप से बाहर निकलते हैं।
```
 else if( fig == 'b' ){ // this.Attacks.push( this.curAttack ); return 'b'; } 
```
यदि आप एक खाली पिंजरे को पकड़ते हैं, तो इसका मतलब है कि वर्तमान हमला खत्म हो गया है या हम "फटे हुए हमले" से निपट रहे हैं। प्लस पर हमला करने की क्षमता और जगह (क्योंकि हमला अवरुद्ध नहीं है)। हालांकि, हम लूप से बाहर नहीं निकलते हैं - शायद यह एक "फाड़ा हुआ हमला" है - हम इस लाइन के सभी हमलों के सरणी में इस.curAttack को लिखते हैं। एक नया "करंट" हमला बनाएँ और 1 से इसका भाजक बढ़ाएँ (यह एक साइड अटैक है)।
```
 else{ //  if( this.curAttack.capability ){ this.curAttack.potential++; this.Attacks.push( this.curAttack ); this.curAttack = new Attack; this.curAttack.potential++; } this.curAttack.divider++; this.attackplace++; } 
```

4) यदि 5 वीं सेल में केंद्रीय सेल के साथ आंकड़ा मेल खाता है, तो सीमा के खिलाफ "आराम" किया गया है और हमले की क्षमता निर्धारित करने के लिए आपको "सीमा की जांच" ( यह सही है । = सही )।

 if( this.iter == 4 && fig == this.subFig ) // 5-  this.checkEdge = true; else if( this.iter == 5 ){ if( this.checkEdge ){ if( fig == this.curFig || fig == 0 ) this.curAttack.potential++; this.Attacks.push( this.curAttack ) } return 0; } this.iter++

CheckCell फ़ंक्शन तैयार है। हालाँकि, हम चेकलाइन क्लास पर काम करना जारी रखते हैं।

5) पहला चक्र पूरा करने के बाद, आपको "चारों ओर मुड़ना" चाहिए। हम सूचक को केंद्र और केंद्रीय हमले में अनुवाद करते हैं, सूचकांक 0 के साथ, इसे हमलों के सरणी से हटा दें और इसे वर्तमान के रूप में सेट करें।

 turnAround(){ this.iter = 1; this.checkEdge = false; this.curAttack = this.Attacks[0]; this.Attacks.splice(0,1) }

6) अगला, पुनरावृत्ति को बढ़ाते हुए, वर्तमान सेल के दूसरी तरफ जाएं।
बिल्कुल आंकड़ों की एक ही जाँच। (पहले से लिखा हुआ कोड - getAttacks फ़ंक्शन)

7) सब कुछ, हमने उन सभी हमलों को एकत्र किया जो एक सरणी में लाइन पर थे।
चेकलाइन क्लास के साथ ऐसा ही है ... सब कुछ किया जाता है।

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

GetAllAttacks () फ़ंक्शन इस सब के लिए जिम्मेदार है - पहले से ही ऊपर वर्णित वर्गों से अलग;

 getAllAttacks( cellX, cellY ){ // ,  , //       if( Model.Field[ cellX ][ cellY ] ) return false var cX = []; var cO = []; //   ... cX['0'] = this.getAttacksLine( cellX, cellY, '×', 1, 0 ); cX['90'] = this.getAttacksLine( cellX, cellY, '×', 0, 1 ); cX['45'] = this.getAttacksLine( cellX, cellY, '×', 1, -1 ); cX['135'] = this.getAttacksLine( cellX, cellY, '×', 1, 1 ); //  ... cO['0'] = this.getAttacksLine( cellX, cellY, '○', 1, 0 ); cO['90'] = this.getAttacksLine( cellX, cellY, '○', 0, 1 ); cO['45'] = this.getAttacksLine( cellX, cellY, '○', 1, -1 ); cO['135'] = this.getAttacksLine( cellX, cellY, '○', 1, 1 ); return { //     'x': cX, 'o': cO } } getAttacksLine( cellX, cellY, subFig, dx, dy ){ //      var C = new checkLine; C.getAttacks( cellX, cellY, subFig, dx, dy ); return this.filterAttacks( C ) //   }

आउटपुट में, हमारे पास परीक्षणित सेल के लिए सभी हमलों के साथ एक ऑब्जेक्ट है

हालाँकि, आपने किसी प्रकार के फ़िल्टर फ़ंक्शन को देखा होगा। इसका काम "निरर्थक" हमलों को सुलझाना है:

शून्य शक्ति के साथ (आप कभी नहीं जानते कि वे सरणी में आते हैं)
अंतरिक्ष की कमी वाले हमले (आक्रमण 5 <)
शून्य क्षमता के साथ।

हालांकि, अगर हमले में 5 से अधिक की शक्ति है, तो फ़िल्टर इसे छोड़ देगा। बॉट को ऐसे हमलों को देखना होगा, उनकी स्क्रीनिंग से खेल के अंत में जाम हो जाएगा।

 filterAttacks( attackLine ){ var res = [] if( attackLine.attackplace >= 5 ) attackLine.Attacks.forEach( ( a )=>{ if( a.capability && a.potential || a.capability >= 5 ) res.push( a ) }) attackLine.Attacks = res; return res }

breakpoints

हाँ ... फिर से, क्षमा करें! इसलिए हम गेम में स्थिति को कॉल करेंगे, जब कोई गलत कदम गेम के परिणाम को तय करेगा।

उदाहरण के लिए, एक हमला [3: 2] एक विराम बिंदु है। यदि प्रतिद्वंद्वी उसके बगल में एक टुकड़ा रखकर इसे अवरुद्ध नहीं करता है, तो अगली चाल, हमारे पास पहले से ही खेल मैदान पर एक हमले [4: 2] है - ठीक है, खेल का परिणाम तय किया जाता है, जो भी कह सकता है (अधिकांश मामलों में)।

या एक हमला [४: १]। एक जम्हाई - और खेल को आसानी से पूरा किया जा सकता है।

चित्रा 5. ब्रेकपॉइंट

सब कुछ स्पष्ट और समझ में आता है, और ऊपर वर्णित एल्गोरिदम पहले से ही ब्रेकपॉइंट्स को ध्यान में रखने और उन्हें समय पर ढंग से ब्लॉक करने में सक्षम है। बॉट आगे दिखता है। वह देखेंगे कि अगले मोड़ पर प्रतिद्वंद्वी एक हमला करने में सक्षम है [5: 1], उदाहरण के लिए, जिसका वजन 200 है - जिसका अर्थ है कि चालाक नीर यहां जाएगा।

हालाँकि, ऐसी स्थिति की कल्पना करें जब खिलाड़ियों में से एक मैदान पर 2 ब्रेकप्वाइंट प्राप्त करने का प्रबंधन करता है। और यह, जाहिर है, प्रतिद्वंद्वी को कोई मौका नहीं छोड़ता है, क्योंकि एक चाल में हम केवल एक ब्रेकपॉइंट को ब्लॉक कर सकते हैं। ऐसे हमलों को रोकने के लिए हमारे एआई को कैसे सिखाना है?

चित्रा 6. 2 ब्रेकप्वाइंट

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

और अब, बॉट न केवल इस तरह की खेल स्थितियों को रोकेगा, बल्कि उन्हें बनाने में भी सक्षम होगा, जो अब इसे अधिक दुर्जेय प्रतिद्वंद्वी बनाता है।

कैसे समझें कि एक हमला एक विराम बिंदु है

आइए स्पष्ट से शुरू करें: 4 की शक्ति के साथ कोई भी हमला एक ब्रेकपॉइंट है। बस एक चूक से हमें खेल को पूरा करने का अवसर मिलता है, अर्थात्। एक पंक्ति में 5 टुकड़े रखें।

इसके अलावा, अगर हमला करने की क्षमता 2 है, तो हम इस तरह के हमले को रोकने के लिए 1 बारी और खर्च करेंगे, जिसका मतलब है कि 3. की शक्ति के साथ एक ब्रेकपॉइंट है। लेकिन इस तरह का केवल एक ब्रेकपॉइंट है - यह एक हमला है [3: 2]।

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

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

ब्रेकपॉइंट खोजने के लिए एल्गोरिदम (आसान, नीचे पढ़ें):

हम चर अंक का परिचय देते हैं
हम केंद्रीय हमला करते हैं, हम शक्ति पर विचार करते हैं
हम एक पक्ष लेते हैं यदि इसका भाजक 2x से अधिक नहीं है।
स्कोर - केंद्रीय और साइड हमलों की शक्ति का योग
यदि केंद्रीय और साइड हमलों की क्षमता 2 हैं, तो इस तरह के हमले को अवरुद्ध करने के लिए आपको एक और मोड़ खर्च करने की आवश्यकता है। इसलिए, स्कोर 1 से बढ़ा है
यदि स्कोर > = 4 है, तो यह एक विराम बिंदु है
वास्तव में, ब्रेकपॉइंट्स को केवल गणना की जा सकती है, उनमें से कई नहीं हैं, लेकिन मुझे तुरंत यह समझ नहीं आया।

 isBreakPoint( attackLine ){ if( ! attackLine || ! attackLine.length ) return false; var centAtk; attackLine.forEach( ( a )=>{ if( a.divider == 1 ) centAtk = a; }) if( centAtk.capability >= 4 ) return true if( centAtk.potential == 2 && centAtk.capability >= 3 ) return true; var res = false; attackLine.forEach( ( a )=>{ var score = centAtk.capability; if( a.divider == 2 ){ //side attack if( centAtk.potential == 2 && a.potential == 2 ) score++; if( score + a.capability >= 4 ){ res = true; return; } } }) return res; }

हां, हम अंत में सब कुछ एक साथ लाएंगे

तो, पीछे मुख्य नरक ऊपर वर्णित है। इससे काम करने के लिए कुछ करने का समय है। फ़ंक्शन काउंटाइट (x, y) - सेल के निर्देशांक को एक इनपुट के रूप में लेता है, और उसका वजन लौटाता है। उसके हुड के नीचे क्या है?

सबसे पहले, हमें उन सभी हमलों की एक सरणी मिलती है, जिनसे सेल संबंधित है। ( getAllAttacks (x, y) )। सभी लाइनों से गुजरते हुए, हम ब्रेकपॉइंट की संख्या की गणना करते हैं। यदि 2 ब्रेकप्वाइंट हैं, तो हम याद करते हैं कि ऐसी स्थिति खेल के परिणाम को तय कर सकती है, और सेल वजन में 100 की वृद्धि कर सकती है।
हालांकि, सभी ब्रेकप्वाइंट एक खिलाड़ी से संबंधित होने चाहिए, इसलिए मुझे 2 चरणों में एक चेक लागू करना पड़ा: पहले क्रॉस, फिर शून्य।

चूँकि अटैक वेट ( ATTACK_WEIGHTS [] ) के सरणी में मैंने 6 या अधिक की शक्ति के साथ हमले प्रदान नहीं किए हैं, मुझे उन्हें 5. की शक्ति के साथ हमलों से बदलना पड़ा। इससे कोई फर्क नहीं पड़ता - वे सभी खेल के अंत तक ले जाते हैं।

खैर, हम हमले के वज़न को संक्षेप में प्रस्तुत करते हैं - यह सब।

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

 countWeight( x, y ){ var attacks = this.getAttacks( x, y ) if( ! attacks ) return; var sum = 0; sum += count.call( this, attacks.x, '×' ); sum += count.call( this, attacks.o, '○' ); return sum function count( atks, curFig ){ var weight = 0; var breakPoints = 0; [ "0", "45", "90", "135" ].forEach( ( p )=>{ if( this.isBreakPoint( atks[p] ) ){ debug( "Break point" ) if( ++breakPoints == 2 ){ weight += 100; debug( "Good cell" ) return; } } atks[p].forEach( ( a )=>{ if( a.capability > 5 ) a.capability = 5; if( a.capability == 5 && curFig == Model.whoPlays.char ) weight += 100; weight += a.getWeight(); }); }) return weight } }

अब जब एक विशिष्ट सेल के लिए इस फ़ंक्शन को कॉल किया जाता है, तो हम इसका वजन प्राप्त करेंगे। हम सभी कोशिकाओं के लिए यह ऑपरेशन करते हैं और सबसे अच्छे (उच्चतम वजन के साथ) का चयन करते हैं। वहाँ और जाना)

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

परिणाम पर मेरी राय

नीचे आओ! हां, आप उसे हरा सकते हैं, लेकिन ऐसा करना मेरे लिए व्यक्तिगत रूप से थोड़ा समस्याजनक है। शायद मैं अभी पर्याप्त सावधान नहीं हूं। अपनी ताकत भी आजमाएं।

मुझे पता है कि यह आसान है, लेकिन मुझे नहीं पता कि कैसे। मैं ऐसे लोगों के बारे में सुनना चाहूंगा जो ऐसे बॉट के अन्य कार्यान्वयनों को जानते हैं या देखते हैं।

मुझे पता है कि क्या बेहतर हो सकता है। हां ... आप मिनिमैक्स जैसे जाने-माने एल्गोरिदम का उपयोग कर सकते हैं, लेकिन इसके लिए आपको गेम थ्योरी के क्षेत्र में कुछ ज्ञान का आधार होना चाहिए, जो दुर्भाग्यवश मैं इसका घमंड नहीं कर सकता।

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

अंत तक पढ़े तो धन्यवाद।

टिक टीएसी को पैर की अंगुली "बिना सीमाओं"