main

#include "ScanContents.h"

bool TakeScreenshot(std::string WindowToFind, BITMAP &bm, HBITMAP &hbmap, BITMAPINFO &bmi, HDC &hdcShot, HBITMAP &hbitmapOld, HWND &hwnd);

void SetupBitmapInfo(BITMAPINFO &bmi, int bWitdth, int bHeight, int bitsPerPixel);
bool CompareColour(RGBQUAD * pPixels, int height, int width, int x, int y);
void ScanBMP(ScanContents * scan);
bool Aim_Bot(HWND appWnd, std::string GameWindow);
MouseCoord CurrentMouseXY(0, 0);

int main()
{
    std::string GameWindow = "Hero OnLine";
    HWND appWnd = FindWindow(0, GameWindow.c_str());

    while(!appWnd)
    {
    std::cout << "Unable to find" << GameWindow.c_str() << std::endl;
    Sleep(500);
    }

    POINT currentPos;
    GetCursorPos(& currentPos);
    CurrentMouseXY.X = currentPos.x;
    CurrentMouseXY.Y = currentPos.y;

    Aim_Bot(appWnd, GameWindow);
    system("PAUSE");
    return 0;
}

bool TakeScreenshot(std::string WindowToFind, BITMAP &bm, HBITMAP &hbmap, BITMAPINFO &bmi, HDC &hdcShot, HBITMAP &hbitmapOld, HWND &hwnd)
{
    RECT rc;
    GetWindowRect(hwnd, &rc);

    hdcShot = CreateCompatibleDC(0);
    hbmap = CreateCompatibleBitmap(GetDC(0), rc.right - rc.left, rc.bottom - rc.top);
    SelectObject(hdcShot, hbmap);

    BitBlt(hdcShot, 0, 0, rc.right - rc.left,  rc.bottom - rc.top, hdcShot, rc.left, rc.top, SRCCOPY);

    if(!GetObject(hbmap, sizeof(BITMAP), (LPSTR)&bm))
        return false;

    int bitsPerPixel = bm.bmBitsPixel;

    if(bitsPerPixel != 32 ||  bm.bmPlanes != 1)
        return false;

    SetupBitmapInfo(bmi, bm.bmWidth, bm.bmHeight, bitsPerPixel);
    return true;

}

bool Aim_Bot(HWND appWnd, std::string GameWindow)
{
    RECT rcWindow;
    GetWindowRect(appWnd, &rcWindow);

    BITMAP bm;
    HBITMAP hbmap;
    HBITMAP hBitmapOld;
    BITMAPINFO bmi;
    HDC hdcShot;
    HDC hdcScreen;

    RGBQUAD *pPixels;
    //Do things with bits here
    int TimeTakenScreenAndScan;

    while(true)
    {
        //only allow pressing with a x ms difference
        if(!GetAsyncKeyState('X')) //VK_RBUTTON
        {
        TimeTakenScreenAndScan = clock();
            //get all contents of our screen and store them in bm
            if(!TakeScreenshot(GameWindow, bm, hbmap, bmi, hdcShot, hBitmapOld, appWnd))
                break;

            ////NEED TO CALL THESE AGAIN FOR THE SCREENSHOT TO WORK PROPERLY, screenshotception
            HBITMAP hbmapNew = CreateCompatibleBitmap(hdcShot, rcWindow.right - rcWindow.left, rcWindow.bottom - rcWindow.top);

            HDC hdcShotNew = CreateCompatibleDC(hdcShot);

            HBITMAP OldBmp  = (HBITMAP) SelectObject(hdcShotNew, hbmapNew);

            //store our screenshot FROM TO, storing just the size of the window Keeping resource allocation down by a couple of 100,000 pixels
            BitBlt(hdcShotNew, 0, 0, rcWindow.right - rcWindow.left/*Window WIDTH*/, rcWindow.bottom - rcWindow.top/*Window HEIGHT*/
                , hdcShot, 0, 0, SRCCOPY);

            //--TOOK ABOUT 50 milliSECONDS TO TAKE SCREENSHOT AND GET HERE--, with improvements approximately 40 ms
            //std::cout << "Took screenshot in " << clock() - TimeTakenScreenAndScan << " milliseconds" << std::endl;
            pPixels = new RGBQUAD[bm.bmWidth * bm.bmHeight];
            if (!pPixels) return false;

            SelectObject(hdcShotNew, OldBmp);

            //HDC hdc = GetDC(HWND_DESKTOP);
            if (!GetDIBits(hdcShotNew, hbmapNew, 0, bm.bmHeight, pPixels, &bmi, DIB_RGB_COLORS))
            {
                ReleaseDC(appWnd, hdcShot);
                delete [] pPixels;
                return false;
            }
            ReleaseDC(appWnd, hdcShot);

            ScanContents scanContentsMain(bm, rcWindow, pPixels);


            //system("pause");

        //CURRENTLY AT 66 MILLISECONDS PER SCAN(A PROBLEM)
        //IMPROVED TO BETWEEN 40-50 MS WITH FOCUSED SCREENSHOTS, E.G. storing the games screen only instead of the whole desktop


        //CHECK IF OUR THREADS are still running and i+f NOT then we allow player to scan aimbot again

        //system("pause");
        //if we ended our scan we free up the memory for our next screenshot

            //free our memory again or head on to crash town
            if(pPixels)free(pPixels);
            SelectObject(hdcShot, hBitmapOld);
            DeleteObject(hbmap);
            DeleteDC(hdcShot);
            DeleteObject(hbmapNew);
            DeleteObject(OldBmp);
            DeleteDC(hdcShotNew);
            //  std::cout << "out of scan, took " << clock() - TimeTakenScreenAndScan << " milliseconds" << std::endl;
        }
        //std::cout << "NORMAL Scan " << " took " << clock() - TimeTakenScreenAndScan << " ms to complete" << std::endl;
    }
}

void SetupBitmapInfo(BITMAPINFO &bmi, int bWidth, int bHeight, int bitsPerPixel)
{
    bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    bmi.bmiHeader.biWidth = bWidth;
    bmi.bmiHeader.biHeight = bHeight;
    bmi.bmiHeader.biPlanes = 1;
    bmi.bmiHeader.biBitCount = bitsPerPixel;
    bmi.bmiHeader.biCompression = BI_RGB;
    bmi.bmiHeader.biSizeImage = 0;

}

void ShootBot(int x, int y)
{
    mouse_event(MOUSEEVENTF_LEFTDOWN, x, y, 0, 0);
    mouse_event(MOUSEEVENTF_LEFTUP, x, y, 0, 0);
}

void ScanBMP(ScanContents * scan)
{
    for(int y = (scan->RcWindow.bottom - scan->RcWindow.top)/4;
        y < ((scan->RcWindow.bottom - scan->RcWindow.top) - (scan->RcWindow.bottom - scan->RcWindow.top)/3.5);
        y++)
    {
            for(int x = (scan->RcWindow.right - scan->RcWindow.left)/4;
        x < ((scan->RcWindow.right - scan->RcWindow.left) - (scan->RcWindow.right - scan->RcWindow.left)/4);
        x++)
            {
                if(CompareColour(scan->PPixels, scan->Bm.bmHeight, scan->Bm.bmWidth, x, y))
                {
                    SetCursorPos(x+scan->RcWindow.left, (y+4)+scan->RcWindow.top);

                    POINT currentPos;
                    GetCursorPos(&currentPos);

                    //ShootBot(x+scan->RcWindow.left, y+scan->RcWindow.top);

                    CurrentMouseXY.X = currentPos.x;
                    CurrentMouseXY.Y = currentPos.y;
                    return;
                }
            }
    }
}
bool CompareColour(RGBQUAD * pPixels, int height, int width, int x, int y)
{
    int p = (height-y-1)*width+x;

    if((int)pPixels[p].rgbRed > 215 && (int)pPixels[p].rgbGreen < 30 && (int)pPixels[p].rgbBlue < 30)
    {
        return true;
    }

    if(GetAsyncKeyState(VK_DELETE))
    {
        exit(0);
    }
    return false;
}