🤸🏽 👨‍👦‍👦 🔊 प्रोग्रामर मतभेदों को कैसे देखते हैं 🚮 ⚓️ 🤬

अक्सर मैं खुद के बाद देखता हूं कि जब मैं एक कार्यक्रम, खेल या वेबसाइट देखता हूं, तो मेरे पास अजीब विचार होते हैं। और ये विचार मुझे डराते हैं। और हर बार मैं सोचता हूं कि इस कार्यक्रम / साइट / गेम को कैसे हैक किया जा सकता है, हैक किया जा सकता है, संरक्षित सुरक्षा, स्वचालित, विस्तारित कार्यक्षमता। शायद, पेशेवर विकृति खुद को महसूस करती है। या यह संचित ज्ञान का उपयोग करने के लिए एक अवचेतन इच्छा है जो काम पर उपयोग नहीं किया जाता है। एक नियम के रूप में, ये इच्छाएं विचारों के स्तर पर रहती हैं, लेकिन अपवाद हैं। मैं आपको आज ऐसे ही एक मामले के बारे में बताता हूँ ...

बहुत समय पहले की बात है। वर्ष, विज्ञापनों में, 2008 में। यह एक साधारण सर्दियों का दिन था। कुछ भी नहीं एक रातों की नींद हराम कर दिया। लेकिन फिर मैंने देखा कि कैसे भविष्य की पत्नी एक गेम में कंप्यूटर पर खेलती है ...

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

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

1. उपयोगकर्ता ने मदद कार्यक्रम (पीपी) लॉन्च किया

2. लक्ष्य खेल का शुभारंभ किया

3. एक जादू कुंजी संयोजन दबाता है

4. चित्र के सही स्थानों में PP अंतर को उजागर करता है

मुझे यह पसंद है जब प्रोग्राम मुझसे बात करते हैं: वे लॉग लिखते हैं, अपने कार्यों पर रिपोर्ट करते हैं, और त्रुटियों की रिपोर्ट करते हैं। तब ऐसा लगता है कि यह कार्यक्रम एक स्मृतिहीन एल्गोरिथ्म नहीं है जो सिर्फ अपना काम करता है, बल्कि एक जीवित जीव है। वह चुप हो सकता है, कभी-कभी संदेश प्रदर्शित कर सकता है, या बातूनी, सक्रिय रूप से सांत्वना के लिए लगा सकता है ...

सामान्य तौर पर, मैंने कंसोल एप्लिकेशन को पीपी के लिए आधार के रूप में चुना। मैंने एक हॉटकी संयोजन Ctrl + F1 (प्रकार, "सहायता") पंजीकृत किया, एक हैंडलर को लटका दिया। लेकिन खेल से 2 चित्रों में अंतर कैसे ढूंढें? शुरुआत के लिए, चित्रों को प्रोग्रामेटिक रूप से "देखा" जाना था। यहां भी, सब कुछ सरल है - हम गर्म कुंजियों को दबाकर स्मृति में फ़ोकस करने में खिड़की को "फोटोग्राफ" करते हैं:

स्क्रीन शॉट

HWND targetWindow = ::GetForegroundWindow(); HDC targetWindowDC = ::GetWindowDC(targetWindow); if (targetWindowDC != NULL) { HDC memoryDC = ::CreateCompatibleDC(targetWindowDC); if (memoryDC != NULL) { CRect targetWindowRectangle; ::GetWindowRect(targetWindow, &targetWindowRectangle); HBITMAP memoryBitmap = ::CreateCompatibleBitmap(targetWindowDC, targetWindowRectangle.Width(), targetWindowRectangle.Height()); if (memoryBitmap != NULL) { ::SelectObject(memoryDC, memoryBitmap); ::BitBlt(memoryDC, 0, 0, targetWindowRectangle.Width(), targetWindowRectangle.Height(), targetWindowDC, 0, 0, SRCCOPY);

गेम में अंतर वाले चित्रों की स्थिति स्थिर है, गेम विंडो का आकार भी है - इसलिए, यह ऑफ़सेट्स और आकारों के हार्डकोड को हल करता है (आखिरकार, हमारा सॉफ़्टवेयर केवल इस गेम के साथ काम करता है)। स्मृति में हम 2 चित्र लेते हैं और "ज़ोरिम" उन्हें एक के ऊपर एक रखते हैं:

XOR दो हिस्सों

  #define BITMAP_WIDTH 375 #define BITMAP_HEIGHT 292 #define COORD_X_LEFT_IMAGE_UPPER_LEFT 19 #define COORD_Y_LEFT_IMAGE_UPPER_LEFT 152 #define COORD_X_RIGHT_IMAGE_UPPER_LEFT 405 #define COORD_Y_RIGHT_IMAGE_UPPER_LEFT COORD_Y_LEFT_IMAGE_UPPER_LEFT ::BitBlt( memoryDC, COORD_X_LEFT_IMAGE_UPPER_LEFT, COORD_Y_LEFT_IMAGE_UPPER_LEFT, BITMAP_WIDTH, BITMAP_HEIGHT, memoryDC, COORD_X_RIGHT_IMAGE_UPPER_LEFT, COORD_Y_RIGHT_IMAGE_UPPER_LEFT, SRCINVERT );

निम्न चित्र दिखाई देता है:

और फिर मतभेदों की खोज शुरू होती है।

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

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

1. चित्र के माध्यम से जाना

2. एक गैर-काला पिक्सेल ढूंढें

3. इसके आसपास के क्षेत्र में देखें और इसके गैर-काले पड़ोसियों के लिए देखें - हमने यह सब पाया क्षेत्र में डाल दिया है (यदि प्रश्न में पिक्सेल पहले संसाधित नहीं हुए थे)

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

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

मतभेदों की खोज का स्रोत (कोड पुराना है, मैं बदलाव के बिना प्रकाशित करता हूं):

मतभेद खोजें

 #include "StdAfx.h" #include ".\bitmapinfo.h" #include <stack> const CPixel CBitmapInfo::m_defaultPixel; CBitmapInfo::CBitmapInfo(void) { m_uWidth = 0; m_uHeight = 0; } CBitmapInfo::~CBitmapInfo(void) { Clear(); } HRESULT CBitmapInfo::Clear() { m_uWidth = 0; m_uHeight = 0; // Pixel clearing for (CPixelAreaIterator pixelAreaIterator = m_arPixels.begin(); pixelAreaIterator != m_arPixels.end(); ++pixelAreaIterator) { delete (*pixelAreaIterator); } m_arPixels.clear(); return S_OK; } HRESULT CBitmapInfo::LoadBitmap(HDC hDC, const CRect &bitmapRect) { Clear(); m_uWidth = bitmapRect.Width(); m_uHeight = bitmapRect.Height(); m_arPixels.assign(m_uHeight * m_uWidth, NULL); for (INT nPixelY = 0; nPixelY < m_uHeight; ++nPixelY) { for (INT nPixelX = 0; nPixelX < m_uWidth; ++nPixelX) { CPixel *pPixel = new CPixel(nPixelX, nPixelY, ::GetPixel(hDC, nPixelX + bitmapRect.left, nPixelY + bitmapRect.top)); SetPixel(nPixelX, nPixelY, pPixel); } } return S_OK; } HRESULT CBitmapInfo::GetPixelAreas(INT nPixelVicinityWidth, CPixelAreaList &arPixelAreaList) { arPixelAreaList.clear(); if (m_uHeight > 0) { // Reinitialize all pixel reserved values (if needed) const CPixel *pFirstPixel = GetPixel(0, 0); if (pFirstPixel->IsValid() != FALSE && pFirstPixel->GetReserved() != CBitmapInfo::m_defaultPixel.GetReserved()) { for (INT nPixelY = 0; nPixelY < m_uHeight; ++nPixelY) { for (INT nPixelX = 0; nPixelX < m_uWidth; ++nPixelX) { CPixel *pPixel = GetPixel(nPixelX, nPixelY); pPixel->SetReserved(-1); } } } // Process pixels typedef stack<CPixel*> CPixelStack; // Look through all bitmap pixels const UINT uPixelCount = m_uWidth * m_uHeight; UINT uPixelAreaIndex = 0; for (INT nPixelY = 0; nPixelY < (INT)m_uHeight; ++nPixelY) { for (INT nPixelX = 0; nPixelX < (INT)m_uWidth; ++nPixelX) { CPixel *pPixel = GetPixel(nPixelX, nPixelY); // If this pixel is valid (belongs to bitmap) if (pPixel->IsValid() != FALSE) { // If this current pixel is not already processed if (pPixel->GetReserved() == CBitmapInfo::m_defaultPixel.GetReserved()) { // Set this pixel as processed pPixel->SetReserved(uPixelAreaIndex); // If this pixel matches localization criteria if (pPixel->GetColor() != COLOR_BITMAP_BACKGROUND) { // Add pixel to its area CPixelArea *pPixelArea = new CPixelArea(); pPixelArea->push_back(pPixel); // Push pixel to its stack CPixelStack pixelStack; pixelStack.push(pPixel); do { CPixel *pVicinityPixel = pixelStack.top(); pixelStack.pop(); INT nStartingX = pVicinityPixel->GetX(); INT nStartingY = pVicinityPixel->GetY(); for (INT nVicinityY = nStartingY - nPixelVicinityWidth; nVicinityY <= nStartingY + nPixelVicinityWidth; ++nVicinityY) { for (INT nVicinityX = nStartingX - nPixelVicinityWidth; nVicinityX <= nStartingX + nPixelVicinityWidth; ++nVicinityX) { pVicinityPixel = GetPixel(nVicinityX, nVicinityY); // If this pixel is valid (belongs to bitmap) if (pVicinityPixel->IsValid() != FALSE) { // If this current pixel is not already processed if (pVicinityPixel->GetReserved() == CBitmapInfo::m_defaultPixel.GetReserved()) { // Set this pixel as processed pVicinityPixel->SetReserved(uPixelAreaIndex); // If this pixel matches localization criteria if (pVicinityPixel->GetColor() != COLOR_BITMAP_BACKGROUND) { pPixelArea->push_back(pVicinityPixel); pixelStack.push(pVicinityPixel); } } } } } } while (pixelStack.size() > 0); arPixelAreaList.push_back(pPixelArea); ++uPixelAreaIndex; } } } } } } return S_OK; }

इसके अलावा और भी सरल स्क्रीन पर पाए गए क्षेत्रों को उजागर करना है। चूंकि गेम प्रोग्राम किसी भी DirectX'ov (जहां तक मैं बता सकता हूं) का उपयोग नहीं करता है, तो गेम विंडो पर ग्राफिक्स का एक सरल प्रदर्शन मदद करता है। सामान्य तौर पर, अगर DirectX होता, तो स्क्रीन के "चित्र लेना" इतना आसान नहीं होता, न कि खेल के शीर्ष पर अंतर को उजागर करने का उल्लेख करना। लेकिन यहां WinAPI नियम (फ़ंक्शन :: आयत) ()। बैकलाइट परिणाम:

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

यह सब संभव है, लेकिन, जाहिरा तौर पर, तब मेरे पास केवल एक रात की नींद थी।

प्रोग्रामर मतभेदों को कैसे देखते हैं

More articles: