Source APB Reloaded — C++ Colorbot with Exclusion Areas

[byte_corvus]

Anyone still grinding the streets of San Paro might find this useful. This is a raw C++ base for a color-based aim assist, specifically targeting the APB Reloaded environment. The original dev moved on, but the logic for the exclusion zones is worth a look if you're building your own external tool.

Technical Overview
This isn't your standard pixel-search script. It utilizes the Windows GDI for screen capture and implements a specific exclusion mask to prevent the aimbot from snapping to your own crosshair or static UI elements.

Core Components:

1. Capture Engine: Uses BitBlt and GetDIBits to pull raw pixel data into an RGBQUAD array.
2. Targeting Logic: Scans for a specific Red-dominant range (R: 210-255, G/B: 0-100), typically used for player outlines or markers.
3. Exclusion Zones: A hardcoded coordinate check within the FOV loop to ignore the center of the screen.
4. Resolution Scaling: A separate thread tracks the "APB RELOADED" window size and adjusts the aim center dynamically.

The Source Snippet

#include "Windows.h"
#include "vector"
 
using namespace std;
 
HWND hwnd = 0;
 
POINT a, b; // top left and bottom right corners
int screenWidth; // width
int screenHeight; // height
const int width = 400; // aimfov width
const int height = 320; // aimfov height
 
RGBQUAD* capture(POINT a, POINT b) {
    // copy screen to bitmap
    HDC hScreen = GetDC(hwnd);
    HDC hDC = CreateCompatibleDC(hScreen);
    HBITMAP hBitmap = CreateCompatibleBitmap(hScreen, abs(b.x - a.x), abs(b.y - a.y));
    HGDIOBJ old_obj = SelectObject(hDC, hBitmap);
    BOOL bRet = BitBlt(hDC, 0, 0, abs(b.x - a.x), abs(b.y - a.y), hScreen, a.x, a.y, SRCCOPY);
 
    // Array conversion:
    RGBQUAD* pixels = new RGBQUAD[width * height];
 
    BITMAPINFOHEADER bmi = { 0 };
    bmi.biSize = sizeof(BITMAPINFOHEADER);
    bmi.biPlanes = 1;
    bmi.biBitCount = 32;
    bmi.biWidth = width;
    bmi.biHeight = -height;
    bmi.biCompression = BI_RGB;
    bmi.biSizeImage = 0;
 
    GetDIBits(hDC, hBitmap, 0, height, pixels, (BITMAPINFO*)&bmi, DIB_RGB_COLORS);
 
    // clean up
    SelectObject(hDC, old_obj);
    DeleteDC(hDC);
    ReleaseDC(hwnd, hScreen);
    DeleteObject(hBitmap);
    return pixels;
}
 
bool checkColourInRange(RGBQUAD sample, byte minRed, byte maxRed, byte minGreen, byte maxGreen, byte minBlue, byte maxBlue) {
    int sampleRed = static_cast<int>(sample.rgbRed);
    int sampleGreen = static_cast<int>(sample.rgbGreen);
    int sampleBlue = static_cast<int>(sample.rgbBlue);
 
    return (sampleRed >= minRed && sampleRed <= maxRed &&
        sampleGreen >= minGreen && sampleGreen <= maxGreen &&
        sampleBlue >= minBlue && sampleBlue <= maxBlue);
}
 
byte RminValue = 210;
byte RmaxValue = 255;
byte GminValue = 0;
byte GmaxValue = 100;
byte BminValue = 0;
byte BmaxValue = 100;
 
 
 
void Aim() {
    RGBQUAD* pixels;
 
    while (true) {
        if (GetKeyState(VK_SHIFT) & 0x8000) {
            pixels = capture(a, b);
 
            int startX = -1;
            int endX = -1;
 
            // Find the first and last pixels in the specified color range
            for (int x = 0; x < width; x++) {
                for (int y = 0; y < height; y++) {
                    int index = y * width + x;
 
                    // Check if the current pixel is within the exception areas
                    int center_x = width / 2;
                    int center_y = height / 2;
                    if (
                        (x >= center_x && x < center_x + 126 && y >= center_y - 6 && y < center_y + 6) ||
                        (x >= center_x - 18 && x < center_x + 18 && y >= center_y - 18 && y < center_y + 18) ||
                        (x >= center_x - 126 && x < center_x && y >= center_y - 6 && y < center_y + 6) ||
                        (x >= center_x - 6 && x < center_x + 6 && y >= center_y && y < center_y + 126) ||
                        (x >= center_x - 6 && x < center_x + 6 && y >= center_y - 40 && y < center_y)
                        ) {
                        continue;  // Skip aiming if the pixel is in an exception area
                    }
 
                    if (checkColourInRange(pixels[index], RminValue, RmaxValue, GminValue, GmaxValue, BminValue, BmaxValue)) {
                        if (startX == -1) {
                            startX = x;
                        }
                        endX = x;
                    }
                }
            }
 
               // Calculate the middle of the range
                int middleX = (startX + endX) / 2;
                int middleY = height / 2;
 
                int xAdjust = middleX - width / 2;
                int yAdjust = middleY - height / 2;
 
                // Introduce a slight delay before making the adjustment
                Sleep(5);
 
                mouse_event(MOUSEEVENTF_MOVE, xAdjust, yAdjust, 0, 0);
            }
 
            delete[] pixels;
        }
        Sleep(1);
    }
 
 
void updateResolution() {
    while (1) {
        Sleep(4000);
        hwnd = GetForegroundWindow(); // get handle of currently active window
        hwnd = FindWindowA(0, "APB RELOADED");
 
        RECT windowsize;
        GetClientRect(hwnd, &windowsize);
        HDC monitor = GetDC(hwnd);
        int current = GetDeviceCaps(monitor, VERTRES);
        int total = GetDeviceCaps(monitor, DESKTOPVERTRES);
 
        screenWidth = (windowsize.right - windowsize.left) * total / current;
        screenHeight = (windowsize.bottom - windowsize.top) * total / current;
 
        a.x = screenWidth / 2 - width / 2;
        a.y = screenHeight / 2 - height / 2;
        b.x = screenWidth / 2 + width / 2;
        b.y = screenHeight / 2 + height / 2;
        Sleep(6000);
    }
}
 
int main() {
    printf("Ready");
    CreateThread(0, 0, (LPTHREAD_START_ROUTINE)updateResolution, 0, 0, 0);
    Aim();
    return 0;
}

Spoiler: Exclusion Area Explained

The exclusion logic prevents the bot from getting confused by your own reticle. It checks if the current pixel x, y falls within specific offsets from the center (horizontal and vertical crosshair lines) before deciding to lock on. This is crucial for avoiding jitter when the target is behind your UI.

Operational Risks
Using mouse_event and GDI is basic and easily flagged by more aggressive anti-cheats if they monitor for synthetic input or screenshot hooks. If you're serious about staying undetected (UD), you should look into moving the movement logic to a kernel-mode driver or at least a KMBox/DMA setup to bypass standard input detection.

Drop a comment if you manage to optimize the scan speed—BitBlt is okay, but there are definitely faster ways to handle the buffer.

Anyone tested this on the latest patch yet?