खेल बाढ़ के लिए यूनिवर्सल बॉट

चित्र 1. खेल का मैदान।

एक बार, एक लेख ने मेरी आंख पकड़ ली। हेडलाइन पढ़ने के तुरंत बाद, इस तरह के दर्जनों विचार मेरे सिर में दिखाई दिए, जिनमें से एक ही था - इस खेल के लिए एक सार्वभौमिक बॉट बनाने का विचार।

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

के विश्लेषण

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

• खेल के मैदान और उसके मापदंडों को पहचानें;
• खेल में कोशिकाओं के रंगों पर डेटा प्राप्त करें;
• भरण विकल्पों का इष्टतम अनुक्रम खोजें;
• प्रत्येक रंग के लिए भरण बटन की स्थिति ज्ञात करें;
• खेल प्रक्रिया को स्वचालित करें।

खेल के मैदान और इसके मापदंडों की मान्यता

पहला कदम किसी तरह स्क्रीन पर खेल मैदान की स्थिति का पता लगाना था। लेकिन पहले, यह एक स्क्रीनशॉट पाने के लिए चोट नहीं होगा। ऐसा करने के लिए, मुझे इसकी विधि के साथ java.awt.Robot क्लास की आवश्यकता थी: BufferedImage createScreenCapture (आयत स्क्रीनरेक्ट)।
और फिर क्या? और फिर खेल मैदान की स्थिति का पता लगाने के लिए कई प्रयास किए गए थे, बफ़रडाइमैज क्लास की गेटआरजीबी विधि के लिए दसियों हजार कॉल, टेम्पलेट से खेल मैदान की स्थिति का पता लगाने का प्रयास आदि। ये सभी परिणाम असफल रहे। एक खेल के लिए जो काम किया वह दूसरे के काम नहीं आया। और एक बार, इस तरह की योजना मेरे सिर में आ गई:

• छवि को दूर करना;
• यदि आवश्यक हो, तो इसे उल्टा कर दें ताकि महत्वपूर्ण बिंदु सफेद हो और पृष्ठभूमि काली हो;
• क्षैतिज और लंबवत रूप से सफेद डॉट्स की घटनाओं की संख्या की गणना करें;
• अनावश्यक प्रविष्टियों को फ़िल्टर करें;
• नॉनजेरो वैल्यू का सबसे लंबा क्रम ज्ञात करें। जिस स्थिति पर यह लंबा अनुक्रम शुरू होता है वह खेल के मैदान का शुरुआती बिंदु होगा, और इस क्रम की लंबाई पिक्सेल में आकार होगी।

स्क्रीनशॉट प्राप्त करने के बाद, इसे ARGB सरणी में अनुवाद करना अच्छा होगा:

int[] pixels = new int[w * h]; image.getRGB(0, 0, w, h, pixels, 0, w); 

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

 int red = (color >> 16) & 0xff; int green = (color >> 8) & 0xff; int blue = color & 0xff; int mean = (qr + qg + qb) / 3; if (mean > thresholdValue) color = 0xFFFFFFFF; else color = 0xFF000000; 

पहले आपको वर्तमान रंग की चमक प्राप्त करने की आवश्यकता है, और इसे या तो आरजीबी घटकों के योग के औसत के रूप में लिया जाता है, या सूत्र के अनुसार: चमक = 0.3 * लाल + 0.59 * हरा + 0.11 * नीला। गुणांक को एक कारण के लिए लिया जाता है, उनका मतलब है किसी विशेष रंग घटक की मानव आंख द्वारा धारणा।

अब आपको थ्रेशोल्ड वैल्यू (थ्रेशोल्डवैल्यू) का चयन करने की आवश्यकता है, 191 काफी उपयुक्त है - खेल के साथ उन सभी साइटों पर जहां एक हल्की पृष्ठभूमि थी, बिनाराइजेशन ने ऐसी छवि का उत्पादन किया:

चित्रा 2. मोनोक्रोम छवि।
और एक अंधेरे पृष्ठभूमि वाली साइटों पर, 64 के मूल्य ने एक समान तस्वीर दी, लेकिन उलटा। वैसे, मैंने 191 को न केवल ऐसा चुना, बल्कि कानून के अनुसार 255-64।

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

 private boolean[] threshold(int[] pixels, int value) { boolean inverse = isBackgroundLight(MAX_COLOR_POINTS); if (inverse) value = 255 - value; boolean[] bw = new boolean[pixels.length]; for (int i = 0; i < pixels.length; i++) { int brightness = getBrightness(pixels[i]); bw[i] = (brightNess >= value) ^ inverse; } return bw; } 

isBackgroundLight उन बिंदुओं की संख्या को स्वीकार करता है, जिन्हें समझने की जरूरत है कि पृष्ठभूमि हल्की है या अंधेरा है। हम रंगीन छवि से MAX_COLOR_POINTS प्राप्त करते हैं और औसत चमक पाते हैं। यदि यह 128 से अधिक है, तो पृष्ठभूमि हल्की है, यदि कम है - अंधेरे।

इसके अलावा, प्राप्त मोनोक्रोम छवि में, हमें क्षैतिज और लंबवत रूप से सफेद डॉट्स की संख्या की गणना करने की आवश्यकता है। यह छवि पर दो पास में किया जाता है। नतीजतन, हमें फॉर्म के मूल्यों के साथ दो सरणियां मिलती हैं: 1440, 1440, 410, 23, 119, 838 ... औसत से नीचे के मूल्यों को फ़िल्टर करें और एक सरणी प्राप्त करें: 1, 1, 0, 0, 0, 1 ... और अंत में, आपको सबसे लंबे अनुक्रम को निर्धारित करने की आवश्यकता है। यहां वे इकाइयाँ हैं जो शून्य से टूटी नहीं हैं। यह भी एक बहुत ही मामूली काम है।

अंत में, हमें 4 मान मिलते हैं: खेल के मैदान की स्थिति क्षैतिज रूप से, लंबवत, खेल मैदान की चौड़ाई और ऊंचाई। चूँकि यह वर्गाकार है, इसलिए अंतिम दो मूल्यों का मेल होना चाहिए। प्रत्येक सेल के आकार का पता लगाने के लिए, आपको इसके आयाम द्वारा खेल मैदान के आकार को विभाजित करने की आवश्यकता है। आयाम उपयोगकर्ता द्वारा निर्धारित किया गया है, क्योंकि फ़ील्ड केवल 14x14 नहीं है, बल्कि 10x10, 20x20, आदि भी है।

सेल रंग डेटा पुनर्प्राप्त कर रहा है

अब जब हमने खेल मैदान के मापदंडों को निर्धारित कर लिया है, तो हम कोशिकाओं के रंगों को पढ़ सकते हैं:

 int[][] table = new int[boardSize][boardSize]; int offset = cellSize / 2; for (int i = 0; i < boardSize; i++) { for (int j = 0; j < boardSize; j++) { table[i][j] = detectImage.getRGB(j*cellSize + offset, i*cellSize + offset); } } 

त्रुटियों से बचने के लिए, हम सेल के केंद्र में सख्ती से रंग लेंगे।

इसके अलावा, डेटा के साथ काम करना आसान बनाने के लिए, आपको इन रंगों को पहचानकर्ताओं में अनुवाद करने की आवश्यकता है: 0, 1, 2, 3 ... लेकिन आप यह सरल नहीं कर सकते हैं यदि (रंग == 0xFF46B1E2), जैसा कि पैलेट गेम के विभिन्न संस्करणों में होता है। उदाहरण के लिए, एक में एक नारंगी रंग है, और दूसरे में, इसके बजाय बकाइन का उपयोग किया जाता है ... लेकिन यह ठीक है, चलो इसके चारों ओर चलते हैं - हम प्रत्येक सूचकांक के रंगों को याद करेंगे:

 private byte[][] colorsToIds(int[][] tableColor) { int size = tableColor.length; byte[][] out = new byte[size][size]; int colorsReaded = 1; //    for (int i = 0; i < size; i++) { for (int j = 0; j < size; j++) { int color = tableColor[i][j]; for (byte k = 0; k < colorsReaded; k++) { //     if (colors[k] == -1) { colors[k] = color; colorsReaded++; if (colorsReaded > MAX_COLORS) colorsReaded = MAX_COLORS; } //     ,    ID if (color == colors[k]) { out[i][j] = k; break; } } } } return out; } 

MAX_COLORS यहां 6 के बराबर है, क्योंकि फ्लड-इट गेम में पैलेट में बिल्कुल कई रंग हैं। लेकिन अगर अचानक कोई पैलेट में दस अलग-अलग रंगों के साथ एक गेम बनाने का फैसला करता है, तो कार्यक्रम उन्हें पहचानने में सक्षम होगा।

अब आप कोड के इस टुकड़े की कार्यक्षमता की जांच कर सकते हैं। कार्यक्रम को चित्र 1 में खेल के मैदान की छवि खिलाने के बाद, परिणाम आने में लंबा नहीं था:

0 1 2 2 3 3 0 0 1 4 2 3 5 3
2 4 1 1 5 4 5 0 2 4 5 3 4 4
3 1 1 5 2 1 3 5 5 2 1 0 4 2
0 3 1 0 5 4 4 1 4 1 4 5 3 5
4 5 0 4 4 4 3 2 0 3 1 0 0 5
0 4 3 4 1 1 2 2 3 2 4 3 1 2
3 2 0 0 5 2 1 5 3 0 2 1 4 4
3 3 5 3 1 5 3 0 3 5 2 4 1 1
3 3 3 3 0 5 0 3 5 0 1 4 2 4
4 2 3 0 2 1 0 3 1 3 2 5 2 3
5 5 1 4 2 3 5 4 1 2 5 0 4 0
5 2 0 2 2 3 2 5 4 1 1 5 0 5
1 0 0 5 5 5 4 1 2 2 3 2 2 0
3 2 2 3 4 3 0 3 2 2 4 3 5 5

भरण विकल्पों के इष्टतम अनुक्रम का पता लगाना

कोई फर्क नहीं पड़ता कि मैंने कैसे प्रयास किया, लेख के लेखक की तुलना में बेहतर एल्गोरिथ्म के साथ आना संभव नहीं था। इसलिए मैंने उनका एल्गोरिथ्म लिया और इसे अधिक सार्वभौमिक तरीके से फिर से लिखा। मुझे लगता है कि वह बुरा नहीं मानेगा।

 private byte getNextFillColor(byte[][] table) { //    int fillSize = (int) Math.pow(MAX_COLORS, FILL_STEPS); int[] fillRate = new int[fillSize]; //     int[] fillPow = new int[FILL_STEPS]; for (int i = 0; i < FILL_STEPS; i++) { fillPow[i] = (int) Math.pow(MAX_COLORS, i); } //  FILL_STEPS  MAX_COLORS  for (int i = 0; i < fillSize; i++) { byte[][] iteration = copyTable(table); for (int j = 0; j < FILL_STEPS; j++) { byte fillColor = (byte) (i / fillPow[j] % MAX_COLORS); fillTable(iteration, fillColor); } //     fillRate[i] = getFillCount(iteration); } //       FILL_STEPS   int maxArea = fillRate[0]; int maxColor = 0; for (int i = 1; i < fillSize; i++) { if (fillRate[i] > maxArea) { maxColor = i; maxArea = fillRate[i]; } } //        byte colorID = (byte) (maxColor % MAX_COLORS); fillTable(table, colorID); return colorID; } 

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

 ArrayList<Byte> seq = new ArrayList<Byte>(); while(!gameCompleted(copyTable)) { seq.add(getNextFillColor(copyTable)); } 

gameCompleted जांचें कि क्या सभी सेल किसी एक रंग से भरे हुए हैं, और यदि ऐसा है, तो गेम पूरा हो गया है।

एप्लिकेशन लॉन्च करके, हम उसे अपना चित्र 1 खाने के लिए देंगे, जिसके परिणामस्वरूप हमें मिलेगा:
1 2 1 3 0 5 4 0 3 1 0 5 3 1 4 1 5 2 4 0 5
लेकिन इस तरह का परिणाम हमारे लिए बहुत सुविधाजनक नहीं है।

भरण बटन की स्थिति का पता लगाना

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

• विंडो छवि के चार भागों में से एक का चयन करें: खेल के मैदान के बाईं ओर, ऊपर से दाईं ओर और अंत में, नीचे से;
• पैलेट से प्रत्येक रंग के लिए, हम छवि में उसके करीब एक रंग की तलाश करते हैं। खोजने पर, हमें इस बिंदु की स्थिति याद है;
• यदि पैलेट से सभी रंगों के लिए अंक मिलते हैं, तो सब कुछ ठीक है, वे कार्य के साथ मुकाबला करते हैं। अन्यथा, पहले चरण पर जाएं और छवि के अगले भाग का चयन करें;
• यदि छवि के सभी हिस्सों को देखा गया था, लेकिन बटन कभी नहीं मिले थे, तो वे बस नहीं करते हैं! इस मामले में, हम केवल एक और अधिक मानवीय रूप में परिणाम देते हैं।

चित्रा 3. भागों में छवि का टूटना।

कोड में उपरोक्त सभी इस तरह दिखता है:

 public Point[] getButtons(int[] colors) { Point[] out = new Point[colors.length]; //      int size = boardSize * cellSize; //   ,      Rectangle[] partsOfImage = new Rectangle[] { new Rectangle(0, board.y, board.x, size), //    new Rectangle(0, 0, w, board.y), //    new Rectangle(board.x+size, board.y, w-board.x-size, size), //    new Rectangle(0, board.y+size, w, h-board.y-size) //    }; for (int i = 0; i < partsOfImage.length; i++) { Rectangle rect = partsOfImage[i]; BufferedImage part = image.getSubimage(rect.x, rect.y, rect.width, rect.height); //   ,     boolean found = true; for (int j = 0; j < colors.length; j++) { if (colors[i] == -1) continue; Point pt = findButton(part, colors[j]); if (pt != null) { //      pt.translate(rect.x, rect.y); out[j] = pt; } else { found = false; break; } } if (found) return out; } //      return null; } 

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

 private boolean isEquals(int color1, int color2, int tolerance) { if (tolerance < 2) return color1 == color2; int r1 = (color1 >> 16) & 0xff; int g1 = (color1 >> 8) & 0xff; int b1 = color1 & 0xff; int r2 = (color2 >> 16) & 0xff; int g2 = (color2 >> 8) & 0xff; int b2 = color2 & 0xff; return (Math.abs(r1 - r2) <= tolerance) && (Math.abs(g1 - g2) <= tolerance) && (Math.abs(b1 - b2) <= tolerance); } 

खेल स्वचालन

इसलिए, जब सभी बटन मिलते हैं और उनके क्लिक का वांछित क्रम दिया जाता है, तो आप "आटोक्लिक" पर जा सकते हैं। कर्सर को दाईं ओर ले जाने और बाईं माउस बटन को दबाने के लिए कार्यक्रम के लिए, वही वर्ग java.awt.Robot कार्य करता है। फ़ंक्शन इस तरह दिखता है:

 public void clickPoint(Point click) { robot.mouseMove(click.x, click.y); robot.mousePress(InputEvent.BUTTON1_MASK); robot.delay(CLICK_DELAY); robot.mouseRelease(InputEvent.BUTTON1_MASK); } 

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

 public void autoClick(Point[] buttons, byte[] result) { for (int i = 0; i < result.length; i++) { clickPoint(buttons[result[i]]); } } 

वह सब अब स्थिति को संभालने के लिए रहता है जब स्क्रीन पर कोई बटन नहीं होता है। इस स्थिति में, बस एक छवि बनाएं, उस पर सभी रंगों को ड्रा करें (क्रम में रंग, न कि पहचानकर्ता 0, 1, 2 ...) क्रम में।

 public BufferedImage sequenceToImage(byte[] ids, int[] palette) { final int size = 20; //    //    10    final int CELLS_IN_ROW = 10; int width = CELLS_IN_ROW * size; if (width == 0) width = size; int rows = ids.length / CELLS_IN_ROW; BufferedImage out = new BufferedImage(width, (rows*size)+size, BufferedImage.TYPE_INT_RGB); Graphics G = out.getGraphics(); for (int i = 0; i < ids.length; i++) { G.setColor(new Color(palette[ids[i]])); G.fillRect(i % CELLS_IN_ROW * size, i / CELLS_IN_ROW * size, size, size); } G.dispose(); return out; } 

निष्कर्ष

यहाँ वही आंकड़ा 1 के साथ हुआ है:

चित्रा 4. परिणाम।

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