आकस्मिक खेल के लिए आरामदायक बॉट।

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

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



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



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



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



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

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

C # कोड

//""  //detail -    . private Color getMidColor(Bitmap inpBit, int x, int y, int w, int h, int detail) { double r = 0, g = 0, b = 0; for (var ii = x; ii < x + w; ii += detail) for (var jj = y; jj < y + h; jj += detail) { var pix = inpBit.GetPixel(ii, jj); r += pix.R; g += pix.G; b += pix.B; } r /= (w * h / detail / detail);// :-( g /= (w * h / detail / detail); b /= (w * h / detail / detail); return Color.FromArgb((int)r, (int)g, (int)b); } //  //   //blcColors -  ""  . private int colorCompare(Color c) { int max=255; int cur = -1; int imax; for(var i=0;i<blcColors.Count;i++) { imax=Math.Abs(cR - blcColors[i].R) + Math.Abs(cG - blcColors[i].G) + Math.Abs(cB - blcColors[i].B) / 3; if (imax < max) { max=imax; cur = i; } } if (max > 50)//    return -1;//     return cur; } 

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

 //..... for (var i = 0; i < 10; i++) for (var j = 0; j < 9; j++) { if (nots[i, j])//    count[i, j] = //   "" searching(i, j, 0); // ""     if(count[i, j]>max) { x=i; y=j; max = count[i, j]; } } //..... //     private int searching(int i, int j, int c) { nots[i, j] = false; //    for (var di = -1; di <= 1; di++) for (var dj = -1; dj <= 1; dj++) if (di+i >= 0 && di+i < 10 && dj+j >= 0 && dj+j < 9) //   ? if (Math.Abs(di) != Math.Abs(dj)) //     ? if (cube[i, j] == cube[i + di, j + dj]) // ? if (nots[i + di, j + dj]) // ? { c = searching(i + di, j + dj, c+1); //  ! } return c; } } 

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

बॉट का एक उदाहरण। इसके अलावा, भले ही यह कार्यक्रम ब्लॉक की मान्यता और निर्णय लेने पर 15-20 एमएस खर्च करता है, लेकिन इससे बहुत अधिक समझदारी नहीं है मेरी खिड़की पर, एक फ्लैश ड्राइव पहले से ही 10-20 एफपीएस का उत्पादन करता है, और वीडियो के फिल्मांकन के साथ यह एक स्लाइड शो है। अधिकतम मेरा बॉट 300k भरने में सक्षम था।


____
* वास्तव में, उनमें से 6 थे। मुझे बॉट को जोड़ने के बाद ही इस बारे में पता चला, क्योंकि जब उन्होंने खुद को (बुरी तरह से) खेला, तो यह ब्लॉक दिखाई नहीं दिया।
** 2, 4 या अधिक ब्लॉकों में विभाजन करना संभव था, लेकिन यहां यह बहुत ही शानदार था।