क्लैश रोयाल में लड़ाई के लिए एक प्रोटोटाइप बॉट बनाना

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



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

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

क्लैश रोयाल में गेम मैकेनिक

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

अभी भी क्षेत्र में कहीं भी खेले जा सकने वाले मंत्र हैं, वे आमतौर पर विभिन्न तरीकों से इकाइयों को नुकसान पहुंचाते हैं। मंत्र एक क्षेत्र में इकाइयों को क्लोन, फ्रीज या गति प्रदान कर सकते हैं।



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

खेल के दौरान, आपको इकाइयों की आवाजाही, मान और वर्तमान दुश्मन कार्डों की संभावित संख्या को ध्यान में रखना होगा। आपको यह भी विचार करने की आवश्यकता है कि इकाई की स्थापना खेल के मैदान को कैसे प्रभावित करती है।

एक समाधान का निर्माण

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

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

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

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

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

उपलब्ध खेल संसाधन

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

मुझे यूनिट एनीमेशन फ्रेम की स्क्रिप्ट्स (हालांकि एकदम सही नहीं) मिलीं - वे मान्यता मॉडल के प्रशिक्षण के लिए उपयोगी थीं।



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

आलसी के लिए कंप्यूटर विजन

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

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

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



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

मार्कअप के समय, मुझे नहीं पता था कि मैं कौन से प्रशिक्षण उपकरण का उपयोग करूंगा, इसलिए मैंने VOC प्रारूप में मार्कअप परिणामों को बचाने का फैसला किया - रूढ़िवादी और प्रतीत होता है सार्वभौमिक में से एक।

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

मैंने YOLO क्यों चुना?

मैंने संभावित छवि पहचान समाधानों का पता लगाना शुरू किया। मैंने विभिन्न एल्गोरिदम के आवेदन को देखा: OpenCV, TensorFlow, Torch। मैं जल्द से जल्द मान्यता देना चाहता था, यहां तक ​​कि सटीकता का बलिदान भी कर रहा था, और जितनी जल्दी हो सके पीओसी प्राप्त कर सकता था।

लेखों को पढ़ने के बाद, मुझे महसूस हुआ कि मेरा कार्य HOG / LBP / SVM / HAAR / ... क्लासिफायर के साथ फिट नहीं है। यद्यपि वे तेज़ हैं, उन्हें कई बार लागू किया जाएगा - प्रत्येक इकाई के लिए क्लासिफायर के अनुसार - और फिर एक-एक करके उन्हें खोज के लिए चित्र पर लागू करने के लिए। इसके अलावा, सिद्धांत में उनके संचालन का सिद्धांत खराब परिणाम देगा: इकाइयों का एक अलग आकार हो सकता है, उदाहरण के लिए, जब बाएं और ऊपर बढ़ते हैं।

सैद्धांतिक रूप से, एक तंत्रिका नेटवर्क का उपयोग करके, आप इसे एक बार एक छवि पर लागू कर सकते हैं और विभिन्न प्रकार की सभी इकाइयों को उनकी स्थिति के साथ प्राप्त कर सकते हैं, इसलिए मैंने तंत्रिका नेटवर्क की ओर खुदाई करना शुरू कर दिया। TensorFlow को कन्वेंशनल न्यूरल नेटवर्क्स (CNN) के लिए समर्थन मिला है। यह पता चला कि तंत्रिका नेटवर्क को खरोंच से प्रशिक्षित करने के लिए आवश्यक नहीं है - आप मौजूदा शक्तिशाली नेटवर्क को पुनः प्राप्त कर सकते हैं।

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

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

TensorFlow, Python में लिखा गया है, वास्तव में एक Python पुस्तकालय है और इसका उपयोग स्व-लिखित लिपियों का उपयोग करने के लिए किया जाता है, जिन्हें आपको अपनी आवश्यकताओं के अनुसार निकालने या उन्हें परिष्कृत करने की आवश्यकता है। संभवतः, कुछ के लिए, TensorFlow का लचीलापन एक प्लस है, लेकिन विवरण में जाने के बिना, इसे जल्दी से लेना और इसका उपयोग करना मुश्किल है। इसलिए, मेरी परियोजना में, विकल्प YOLO पर गिर गया।

मॉडल बिल्डिंग

मॉडल प्रशिक्षण पर काम करने के लिए, मैंने Ubuntu 18.10 स्थापित किया, असेंबली पैकेज वितरित किए, NVIDIA के OpenCL पैकेज और अन्य निर्भरताएं, और डार्कनेट का निर्माण किया।

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

पहले मैं एक साधारण योलो मॉडल को फिर से तैयार करने की कोशिश करना चाहता था, फिर टिनी और उनकी तुलना करना। हालांकि, यह पता चला है कि सरल मॉडल के प्रशिक्षण के लिए, आपको 4 जीबी वीडियो कार्ड मेमोरी की आवश्यकता होती है, और मेरे पास केवल 3 जीबी NVIDIA GeForce GTX 1060 ग्राफिक्स कार्ड गेम के लिए खरीदा गया था। इसलिए, मैं केवल टिनी मॉडल को तुरंत प्रशिक्षित करने में सक्षम था।

मेरे पास मौजूद छवियों पर इकाइयों का मार्कअप VOC प्रारूप में था, और YOLO ने अपने स्वयं के प्रारूप के साथ काम किया, इसलिए मैंने एनोटेशन फ़ाइलों को परिवर्तित करने के लिए Convert2Yolo उपयोगिता का उपयोग किया।

अपने 200 स्क्रीनशॉट में प्रशिक्षण की एक रात के बाद, मुझे पहला परिणाम मिला, और उन्होंने मुझे आश्चर्यचकित किया - मॉडल वास्तव में कुछ सही पहचानने में सक्षम था! मुझे एहसास हुआ कि मैं सही दिशा में आगे बढ़ रहा था, और अधिक शिक्षण उदाहरणों को करने का फैसला किया।



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

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

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



जनरेशन परफेक्ट नहीं थी। अक्सर इकाइयों को इमारतों के ऊपर रखा जाता था, हालांकि खेल में वे उनके पीछे होते थे; यूनिट के अतिव्यापी भागों के कोई उदाहरण नहीं थे, हालांकि यह खेल में एक दुर्लभ स्थिति नहीं है। लेकिन अभी तक मैंने इसे उपेक्षित करने का फैसला किया।



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

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

चलो बॉट के लिए नीचे उतरो

मैंने पायथन में एक बॉट लिखने का फैसला किया - इसमें एमएल के लिए कई उपकरण उपलब्ध हैं। मैंने OpenCV के साथ अपने मॉडल का उपयोग करने का निर्णय लिया, जो 3.5 से तंत्रिका नेटवर्क मॉडल का उपयोग करना सीख गया , और मुझे एक सरल उदाहरण भी मिला। एडीबी के साथ काम करने के लिए कई पुस्तकालयों की कोशिश करने के बाद, मैंने शुद्ध-पायथन-अदब को चुना - मुझे जो कुछ भी चाहिए बस वहां लागू किया जाता है: स्क्रीन कैप्चर फ़ंक्शन और शेल डिवाइस पर ऑपरेशन; मैं 'इनपुट टैप' का उपयोग करके टैप करता हूं।

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

खेल में मान स्तर को प्रगति पट्टी और संख्याओं के रूप में प्रदर्शित किया जाता है। दो बार सोचने के बिना, मैंने नंबर को काटना शुरू कर दिया, उल्टा और pytesseract का उपयोग करके पहचान लिया ।

उपलब्ध कार्ड और उनकी स्थिति का निर्धारण करने के लिए, मैंने OpenCV से keypoint डिटेक्टर KAZE का उपयोग किया। अब तक मैं तंत्रिका नेटवर्क को फिर से सीखने के लिए वापस नहीं लौटना चाहता था, और मैंने एक ऐसा तरीका चुना जो तेज और आसान था, हालांकि अंत में यह मामले में न्यूनतम रूप से सटीक निकला जब आपको कई वस्तुओं की खोज करने की आवश्यकता होती है।

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

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



सभी आवश्यक जानकारी (इकाइयां और उनकी अनुमानित स्थिति, उपलब्ध मान और कार्ड) प्राप्त करने के बाद, आप कुछ निर्णय ले सकते हैं।

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

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

:     =        :         ( )               :         =  ()         =  ()         =  ()         += (, , , ) 

अब तक, बॉट केवल इकाइयों को एक बिंदु पर रख सकता है, लेकिन पहले से ही एक अधिक जटिल रणनीति बनाने के लिए पर्याप्त जानकारी है।

पहली समस्याएं

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

इतना

मेरी परियोजना की स्थिति का गंभीरता से आकलन करने के बाद, मैंने इस मॉडल पर अभी के लिए रहने का फैसला किया। मैंने ऐसा करने के लिए अपने खाली समय के कई हफ्ते बिताए, और यूनिट की मान्यता गेमप्ले का ही हिस्सा है।

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

गीथब प्रोजेक्ट रिपॉजिटरी

मैंने परियोजना पर बहुत समय बिताया है और, स्पष्ट रूप से, मैं इसके बारे में थक गया हूं, लेकिन मुझे इसे थोड़ा पछतावा नहीं है - मुझे एमएल / सीवी में नया अनुभव मिला।

हो सकता है कि मैं बाद में उसके पास लौट आऊं - मुझे खुशी होगी अगर कोई मेरा साथ देगा। यदि आप रुचि रखते हैं, तो टेलीग्राम पर समूह में शामिल हों, और मेरे स्काला पाठ्यक्रम में भी आएं।