💿 😏 🤷🏽 ब्राउज़र गेम के लिए मैक्रो बॉट लिखना 🤨 👨‍👩‍👧 🌲

परिचय

बहुत पहले नहीं, खेल Google+ पर दिखाई देते थे। इसके बारे में विषय पढ़ने के बाद, मैंने कुछ खेलने का फैसला किया। पसंद खेल डायमंड डैश पर गिर गया। खेल के दौरान कुछ समय बाद, प्रोग्रामर ने मुझसे बात करना शुरू किया कि स्वचालित होने के लिए उसी प्रकार के कार्यों की आवश्यकता है। और इसलिए यह क्या आया ...

* नोट: एक अनुभवी खिलाड़ी के लिए अपने "हाथों" का उपयोग करके 400k से अधिक प्राप्त करना कठिन है

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

खेल सारांश

खेल एक सरल "क्लिक-ऑन-एरिया-अधिक-तीन-वर्ग-एक-रंग" पहेली है।

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

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

परिभाषित विंडो निर्देशांक

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

रंगों को पहचानो और स्क्रीनशॉट को बचाओ

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

फंक _GetField ( ByRef $ aiField ) ; फ़ील्ड रंगों की एक सरणी प्राप्त करना
; WinAPI का उपयोग करके BitMap स्क्रीनशॉट कैप्चर करना
स्थानीय $ hWnd = WinGetHandle ( "Google+ गेम्स - Google Chrome" )
स्थानीय $ आकार = WinGetClientSize ( $ hWnd )
स्थानीय $ hDC = _WAPAPI_GetDC ( $ hWnd )
स्थानीय $ hMemDC = _WAPAPI_CreateCompatibleDC ( $ hDC )
स्थानीय $ hBitmap = _WinAPI_CreateCompatibleBitmap ( $ hDC , $ आकार [ 0 ] , $ आकार [ 1 ]
स्थानीय $ hSv = _WinAPI_SelectObject ( $ hMemDC , $ hBitmap )
_WAPAP_BitBlt ( $ hMemDC , 0 , 0 , $ आकार [ 0 ] , $ आकार [ 1 ] , $ hDC , 0 , 0 , $ SRCCOPY )
_WAPI_SelectObject ( $ hMemDC , $ hSv )
_WAPAP_DeleteDC ( $ hMemDC )
_WAPAPI_ReleaseDC ( $ hWnd , $ hDC )
स्थानीय $ L = $ आकार [ 0 ] * $ आकार [ 1 ]
स्थानीय $ tBits = DllStructCreate ( 'dword [' और $ L & ']' )
_WAPAPI_GetBitmapBits ( $ hBitmap , 4 * $ L , DllStructGetPtr ( $ tBits ) )
; सेल रंग निर्धारण
$ ICol = 0 से $ iNumCols के लिए - 1
$ IRow = $ iNumRows के लिए - 1 से 0 चरण - 1
; वर्ग पैमाइश
$ iX = $ iCornerX + ( $ iCol * 40 ) + $ iDeltaX
$ iY = $ iCornerY + ( $ iRow * 40 ) + $ iDeltaY
$ iPixelColor = मॉड ( DllStructGetData ( $ tBits , 1 , $ iY * $ आकार [ 0 ] + $ iX ) , 0x1000000 )
$ aiField [ $ iRow ] [ $ iCol ] = _GetCheckColor ( $ iPixCCC )
अगला
अगला
; स्मृति रिसाव से बचने के लिए डेटा विलोपन
_WAPAP_DeleteObject ( $ hBitmap )
_WAPAP_DeleteObject ( $ hMemDC )
_WAPAP_DeleteObject ( $ tBits )
EndFunc

यहां यह ध्यान देने योग्य है कि माप केवल 1 बिंदु पर क्यों होता है। यह विधि पहले मेरे द्वारा की गई थी, और अंतिम संस्करण में बनी रही। इन दो बिंदुओं के बीच, बड़ी संख्या में वैकल्पिक तरीकों की कोशिश की गई, जिनमें से थे: प्रति वर्ग 64 अंक (8 8 जाली) और विभिन्न प्राप्त मानों का औसत, माप के लिए निर्देशांक का यादृच्छिक चयन, बेहतर सटीकता के लिए कई हालिया मापों के इतिहास को संग्रहीत करते हुए ... लेकिन वे सभी पहले तरीके से कम सटीक या सुविधाजनक निकले।
यह संभव है कि चूंकि मैं छवि पहचान के विषय से बहुत दूर हूं, इसलिए मुझे कुछ सरल नहीं पता है जो इस मामले में मेरी मदद कर सकता है। इस मामले में, मुझे किसी भी सुझाव पर खुशी होगी। =)

एक रंग तालिका से एकल-रंग क्षेत्र को परिभाषित करना

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

फंक _DfsAreaSize ( ByRef $ aiField , $ iStartX , $ iStartY ) ; गैर-पुनरावर्ती एकल रंग क्षेत्र आकार खोज एल्गोरिथ्म
; गहराई खोज विधि
स्थानीय $ aiResult [ $ iNumCols * $ iNumRows ] [ 2 ] ; क्षेत्र में शामिल कोशिकाओं की सूची
स्थानीय $ iResultSize = 0
स्थानीय $ afMap [ $ iNumRows ] [ $ iNumCols ] ; प्रगति के झंडे
$ IRow = 0 से $ iNumRows के लिए - 1
$ ICol = 0 से $ iNumCols के लिए - 1
$ afMap [ $ iRow ] [ $ iCol ] = गलत
अगला
अगला
$ afMap [ $ iStartX ] [ $ iStartY ] = सच
स्थानीय $ aiStack [ $ iNumRows * $ iNumCols ] [ 2 ] ; सक्रिय स्टैक
स्थानीय $ iStackSize = 1
$ aiStack [ 0 ] [ 0 ] = $ iStartX
$ aiStack [ 0 ] [ 1 ] = $ iStartY
जबकि $ iStackSize > 0
$ iStackSize - = 1
$ iX = $ aiStack [ $ iStackSize ] [ 0 ]
$ iY = $ aiStack [ $ iStackSize ] [ 1 ]
$ aiResult [ $ iResultSize ] [ 0 ] = $ iX
$ aiResult [ $ iResultSize ] [ 1 ] = $ iY
$ iResultSize + = 1
$ IDirection = 0 से 3 के लिए ; 4 पास की कोशिकाओं की गणना
स्थानीय $ iNewX = $ iX
स्थानीय $ iNewY = $ iY
$ IDirection स्विच करें
केस 0
$ iNewY + = 1
केस 1
$ iNewY - = 1
केस 2
$ iNewX + = 1
केस 3
$ iNewX - = 1
EndSwitch
यदि ( $ iNewX > = 0 और $ iNewX < $ iNumRows और _
$ iNewY > = 0 और $ iNewY < $ iNumCols और _
नहीं ( $ afMap [ $ iNewX ] [ $ iNewY ] ) और $ aiField [ $ iNewX ] [ $ iNewY ] = $ aiField [ $ iStartX ] [ $ iNewY ]] फिर
$ afMap [ $ iNewX ] [ $ iNewY ] = सच
$ aiStack [ $ iStackSize ] [ 0 ] = $ iNewX
$ aiStack [ $ iStackSize ] [ 1 ] = $ iNewY
$ iStackSize + = 1
endif
अगला
बीतना
$ IResultSize लौटें
EndFunc

अनुकूलन

अनुकूलन 1. हीरे

उपरोक्त एक मिलियन प्राप्त करने के लिए पहले से ही पर्याप्त है। लेकिन मुझे और चाहिए था। उपरोक्त एल्गोरिथ्म का सबसे बड़ा दोष, हीरे को निर्धारित करने में असमर्थता था। इसलिए, मिनट के अंत में, फ़ील्ड कुछ इस तरह दिखती थी:

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

$ IRow = $ iNumRows के लिए - 1 से $ iNumRows - 3 चरण - 1
$ ICol = 0 से $ iNumCols के लिए - 1
यदि $ aiField [ $ iRow ] [ $ iCol ] <> 0 तब
$ aiDiams [ $ iRow ] [ $ iCol ] = 0
अन्यथा
$ aiDiams [ $ iRow ] [ $ iCol ] + = 1
यदि $ aiDiams [ $ iRow ] [ $ iCol ] > 15 तब
माउसक्लिक ( "वाम" , $ iCornerX + 30 + ( $ iCol * 40 ) , $ iCornerY + 10 + ( $ iRow * 40 ) , 1 , $ iMouseSpeed )
$ aiDiams [ $ iRow ] [ $ iCol ] = 0
नींद ( 500 )
वापसी ०
endif
endif
अगला
अगला

अनुकूलन 2. धमाका

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

अनुकूलन 3. अंतिम क्लिक क्षेत्र

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

परिणाम

उपरोक्त सभी के बाद, मेरा रिकॉर्ड कुछ इस तरह था:

मुझे वास्तव में 2 मिलियन चाहिए थे, लेकिन 4 दिन की कोशिश, प्रयोगात्मक कोड की एक हजार लाइनें (स्व-लॉगिंग और स्क्रीनशॉट को सहेजने के साथ), लॉग के सावधानीपूर्वक धूम्रपान और स्क्रीनशॉट के साथ सामंजस्य, काम नहीं किया। = (
गिथब रिपॉजिटरी लिंक: github.com/EvilTosha/DiamondDash

पोस्टस्क्रिप्ट के बजाय। AutoIt के बारे में कुछ शब्द

मुझे बहुत आश्चर्य हुआ कि यह भाषा लगभग केंद्र में नहीं है दरअसल, इस अन्याय को ठीक करने की इच्छा ने मुझे इस विषय को लिखने के लिए प्रेरित किया।
इसी समय, भाषा काफी कुछ कर सकती है, और सीखने की अद्भुत सरलता है। इसके अस्तित्व के बारे में जानने के कुछ घंटे बाद, मुझे पहले से ही इस मैक्रो को लिखने के लिए आवश्यक सभी ज्ञान था।
AutoIt का उपयोग करते हुए, आप लगभग किसी भी नियमित क्रिया को स्वचालित कर सकते हैं: एक स्क्रीनशॉट को सहेजना, एक प्रोग्राम स्थापित करना (यदि आपको इसे कई कंप्यूटरों पर स्थापित करने की आवश्यकता है), तो कई लॉगिन कहीं ... आप इसे exe-shnik में संकलित कर सकते हैं, DLL कनेक्ट कर सकते हैं।
लेकिन कुछ, एक प्रचारक के रूप में, मैंने बात की। =)

UPD वीडियो का काम

आपका ध्यान देने के लिए धन्यवाद, मुझे किसी भी टिप्पणी पर खुशी होगी।

ब्राउज़र गेम के लिए मैक्रो बॉट लिखना