🔎 🤳🏿 👨🏼‍💼 मतलूब बॉट, वार्म ट्यूब 🤯 🖕🏾 🤘🏾

मैं नए साल की पूर्व संध्या पर कई अन्य लोगों की तरह, यहां वर्णित वार्म, ट्यूब न्यू ईयर के खेल को वास्तव में पसंद करता हूं।

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

अंत में, मैंने अपने हाथों या खेल में से किसी एक की वक्रता को मापने का फैसला किया।

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

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

विचार इस प्रकार था:
- एक स्क्रीनशॉट लें
- यह साँप के लिए छवि प्रसंस्करण टूलबॉक्स का उपयोग करके पार्स और पुरस्कार
- सही समय पर, बटन पर क्लिक करें

लक्ष्य अंकों की अधिकतम संभव संख्या है, आदर्श रूप से ऐसा कुछ है

केवल अंक की अधिकतम संख्या क्षेत्र की लंबाई (19) के उत्पाद के बराबर होगी और इसकी ऊंचाई (14) शून्य से दो प्रारंभिक वर्ग होगी। यानी 14 * 19 - 2 = 264।

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

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

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

सब कुछ स्पष्ट लगता है और कोशिश न करने का कोई कारण नहीं है।

हर बार (1440 * 900 * 4) = 1.2 एमबी पूरे स्क्रीन को संसाधित नहीं करने के लिए, मैं सॉफ्टवेयर का उपयोग करके वास्तविक गेम फ़ील्ड की तलाश करूंगा। निर्देशांक की तलाश में किसी तरह कोषेर नहीं है।

तो:

%% canvas detction robot = java.awt.Robot; %  scrSize = get(0,'ScreenSize'); %   pause (5); %,         I = getScreenCaptureImageData(scrSize); %  I = medfilt2(I, [5 5]); % ,      ,     I = edge(I,'canny', 0.15, 2); %  I = imfill(I, 'holes'); %  [B,L] = bwboundaries(I); stats = regionprops(L,'BoundingBox', 'Area'); %  ,     [n,m] = size (stats); for i=1:n %  ,  think vectorized     a(i) = stats (i).Area; end [n, m] = max (a); rect = stats(m).BoundingBox; %          I = imcrop(I, rect); %

उसी पद्धति से (थोड़े अंतर के साथ) मैं मैदान के अंदर लाल बटन ढूंढता हूं और इसे शुरू करने के लिए माउस के साथ प्रहार करता हूं।

लाल बटन की तलाश है

 %% button detection and press I = I (:, :, 1); %     ... se = strel('disk',10); I = imopen(I,se); %    .          ,     ... [B,L] = bwboundaries(I); stats = regionprops(L,'Centroid', 'Area'); %        ( ) ... coo = stats(m).Centroid; robot.mouseMove(coo(1),coo(2)); % robot.mousePress (java.awt.event.InputEvent.BUTTON1_MASK); %  robot.mouseRelease(java.awt.event.InputEvent.BUTTON1_MASK);

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

tupim

 %% waiting for begin difference = 0; while difference < 2000 K = I; I = getScreenCaptureImageData(rect); Diff = imabsdiff(I, K); difference = sum (Diff(:))/1000 pause (.2); end

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

ब्रेक को ध्यान में रखते हुए, पहली बार सिर को x, y से (8.5) से (11.5) तक की स्थिति में निर्धारित किया जाता है और फिर मैं इसे चलाता हूं। स्क्रीन की सीमा तक पहुंचने पर, मैं इसे एक नई दिशा में मोड़ देता हूं।

मैं आपको याद दिला दूं, खेल के मैदान का आकार 19 से 14 ब्लॉक है।

ब्रेक के बारे में। मैं खुद एक ब्राउज़र के रूप में मैक एयर 2012 और एफएफ 18 का उपयोग करता हूं। लगभग 25-30% मामलों में, जब आप फिर से खेलते हैं, तो आपको पुरस्कार के बिना शुरू करना होगा, आप जारी नहीं रख सकते। सांप एक ही स्तर पर भी अलग-अलग गति से नेत्रहीन रूप से आगे बढ़ता है और पिछड़ सकता है।
मुझे क्रोम डाउनलोड करना था। यह वहां बेहतर प्रतीत होता है: पुरस्कारों के बिना, खेल 5% मामलों में शुरू होता है, आंदोलन चिकना है और आप कोई समस्या नहीं देख सकते हैं। सीपीयू का उपयोग काफी कम है। मैंने सीखा कि कार्यक्रम में एक ध्वनि है।

यहाँ मेरा मुख्य लूप है:

 %  t = timer('StartDelay', 0.1, 'Period', X, 'TasksToExecute', k,'ExecutionMode', 'fixedRate'); t.TimerFcn = { @timer_callback}; start(t); ... %   nested ,                  function timer_callback (obj, event) %      1914,   0  1.   -  . head (x,y) -   ... %% head detection, P is already detected switch direction case right if P ( head (1,2), head (1,1)+1) head (1,1) = head (1,1) + 1; end case left if P (head (1,2), head (1,1)-1) head (1,1) = head (1,1) - 1; end case up if P (head (1,2)-1, head (1,1)) head (1,2) = head (1,2) - 1; end case down if P (head (1,2)+1, head (1,1)) head (1,2) = head (1,2) + 1; end end %% new direction switch direction case right if head (1,1) == 19; direction = down; robot.keyPress (direction); robot.keyRelease (direction); end case left if (head (1,1) == 1) && (head (1,2)==14) direction = up; robot.keyPress (direction); robot.keyRelease (direction); elseif (head (1,1) == 2) && (head (1,2) < 14) direction = down; robot.keyPress (direction); robot.keyRelease (direction); end case up if (head (1,1) == 1) && (head(1,2) == 1) direction = right; robot.keyPress (direction); robot.keyRelease (direction); end case down if (rem(head (1,2), 2) == 0) && (head (1,1) == 19) direction = left; robot.keyPress (direction); robot.keyRelease (direction); end if (rem(head (1,2), 2) == 1) && (head (1,1) == 2) direction = right; robot.keyPress (direction); robot.keyRelease (direction); end end end

एक छवि मान्यता पद्धति लागू करना जो स्टैटिक्स में ठीक काम करता है, मुझे एक काम करने वाली स्क्रिप्ट नहीं मिली - मेरे कंप्यूटर पर पूरे चक्र में लगभग 0.8 सेकंड (800 एमएस) लगे, जबकि शुरुआती स्तर पर भी सांप हर 0.2 सेकंड (200) में चलता है एमएस)। साँप दीवारों से नियमित रूप से मिलते थे।

फ़िल्टर गुणांक और इनपुट मापदंडों के साथ थोड़ा सा खेलने के बाद, मैंने 350ms का परिणाम हासिल किया।
फिल्टर के लिए केवल एक चैनल छोड़ दिया, 190 एमएस, बंद। अधिकतम परिणाम 11 अंक है। "तेज, सांप .." - सोचा, मैंने जारी रखा।

फिर से लिखा, सभी चक्रों को हटा दिया। फिर मैंने फिल्टर को पूरी तरह से हटा दिया, परिणामस्वरूप छवि को 19x14 ब्लॉकों (42x42 पिक्सल) में विभाजित किया और प्रत्येक ब्लॉक के पिक्सल की राशि की गणना करना शुरू किया - 100ms, अधिकतम परिणाम 35 अंक है।

शायद ऑपरेटिंग सिस्टम में मामला, सब के बाद realtime नहीं। यद्यपि वास्तविक समय निष्पादन (टिक और टो कमांड, साथ ही प्रोफाइलर कमांड) का मापन गणना वाले से बहुत अलग नहीं है। आगे बढ़ो।

प्रत्येक ब्लॉक में सभी 42x42 पिक्सल के योग पर विचार क्यों करें? यह 20x20 लेने के लिए पर्याप्त है, काले को सफेद से अलग करें और इसे पुरस्कार के साथ भ्रमित न करें। 70 एमएस, 52 अंक।

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

स्क्रीनशॉट कार्य पहले और बाद में

 %before function imgData = getScreenCaptureImageData(positionRect) if isempty(positionRect) | all(positionRect==0) | positionRect(3)<=0 | positionRect(4)<=0 %#ok ML6 imgData = []; else rect = java.awt.Rectangle(positionRect(1), positionRect(2), positionRect(3), positionRect(4)); robot = java.awt.Robot; jImage = robot.createScreenCapture(rect); h = jImage.getHeight; w = jImage.getWidth; pixelsData = reshape(typecast(jImage.getData.getDataStorage, 'uint8'), 4, w, h); imgData = cat(3, ... transpose(reshape(pixelsData(3, :, :), w, h)), ... transpose(reshape(pixelsData(2, :, :), w, h)), ... transpose(reshape(pixelsData(1, :, :), w, h))); end %----------------------------------- %after function imgData = getScreenCaptureImageData(positionRect) if isempty(positionRect) | all(positionRect==0) | positionRect(3)<=0 | positionRect(4)<=0 %#ok ML6 imgData = []; else rect = java.awt.Rectangle(positionRect(1), positionRect(2), positionRect(3), positionRect(4)); robot = java.awt.Robot; jImage = robot.createScreenCapture(rect); h = jImage.getHeight; w = jImage.getWidth; imgData = typecast(jImage.getData.getDataStorage, 'uint8'); imgData = reshape (imgData(3:4:4*w*h), w, h)'; end

25ms के औसत और अधिकतम 75 अंक के साथ 30ms की गारंटी (चरम पर)। आम तौर पर, काम की शुरुआत के समय यह मेरा लक्ष्य था, लेकिन इस समय तक सबसे अधिक लगातार (अब मुझे संदेह है कि ये भी बॉट हैं) ने बार को 116 अंक तक बढ़ा दिया। तो चलिए आगे बढ़ते हैं।

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

इससे गंदी चाल चली गई। मैं संक्षेप में सामान्य रूप से फेंक देता हूं और केवल 42 वें पिक्सेल पर लंबवत और क्षैतिज रूप से देखता हूं। यदि एक निश्चित सीमा से अधिक है, तो मुझे लगता है कि सांप यहां है। मैं ऐसी सीमा मूल्य का चयन करता हूं ताकि सांप को पुरस्कारों के साथ भ्रमित न करें। 25ms की गारंटी और 87 अंक। बस तीस में हो रही है।

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

जहां दो, चार हैं। मैं चार चतुर्भुज ए, बी, सी, डी। 17 एमएस लेता हूं और औसतन 11।

 if (head (1,1) <=10) && (head(1,2) <=7) I (1:9*42, 1:11*42) = getScreenCaptureImageData(rectgA); elseif (head (1,1) >= 11) && (head(1,2) <=7) I (1:9*42, 8*42+1:end) = getScreenCaptureImageData(rectgB); elseif (head (1,1) <= 10) && (head(1,2) >=8) I (5*42+1:end, 1:11*42) = getScreenCaptureImageData(rectgC); elseif (head (1,1) >= 11) && (head(1,2) >=8) I (5*42+1:end, 8*42+1:end) = getScreenCaptureImageData(rectgD); end P = I (i,j) > 150; %i = 3:42:42*14; j = 1:42:42*19; 150 -

बिंगो! 131 अंक।

यह पहले से ही स्क्रीन के केवल किनारों को स्कैन करने और एक साँप की उपस्थिति का निर्धारण करने के लिए सोचा गया था ताकि एक और मिलीसेकंड या दो जीतने के लिए, लेकिन यह सब अब के लिए है।
सबसे पहले, मैं पहले से ही पहले से ही हूं।
दूसरे, यह स्पष्ट है कि कार्यक्रम की प्रकृति के कारण अधिकतम 262 अंक प्राप्त करना असंभव है।
तीसरा, ऑपरेटिंग सिस्टम से देरी पहले से ही एल्गोरिथ्म के चलने के समय के साथ तुलनीय है (औसतन 11 सेमी, चोटियों में 17)। यानी OS 6ms की त्रुटि देता है।
चौथा, मैंने अपना मुख्य लक्ष्य हासिल नहीं किया - छवियों (अच्छी तरह से) के साथ काम करने का तरीका जानने के लिए।
पांचवें, अस्थायी परिणाम बहुत हार्डवेयर पर निर्भर है, और प्लस या माइनस के साथ मेरे घर के कंप्यूटर पर औसतन दो बार धीमी गति से काम करता है (Win7x64)। शायद अगर मैं अपनी स्क्रिप्ट किसी प्रोडक्शन सर्वर पर चलाऊं, तो यह और तेज हो जाएगा।

मैंने नैतिक और नैतिक कारणों से सर्वर को मेरे नाम के साथ परिणाम नहीं भेजे।

त्याग

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

क्यों?

लगभग उसी समय, लोग पानी से डामर पर चित्रलिपि क्यों लिखते हैं, जो एक मिनट में वाष्पित हो जाती है।

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

आप सभी का धन्यवाद, यह अच्छा था। मुझे कोड की गुणवत्ता में सुधार पर किसी भी टिप्पणी और सिफारिशों को स्वीकार करने में खुशी होगी।

मतलूब बॉट, वार्म ट्यूब

More articles: