C++与Selenium IDE自动化灯泡游戏效率不足，求得分优化方案

Hey there! Let’s figure out how to get your bulb game automation up to that 150+ score target—you’re already hitting 90 manually, so we just need to crush the speed bottlenecks holding back your C++ code and ditch the slow Selenium IDE approach.

First, let’s break down the core problem #

The game’s rules (60-second timer, 5-second penalty for misses) mean every millisecond counts. Your manual score proves your logic is solid—automation is failing because the tools you’re using add too much lag between detecting a lit bulb and clicking it.

Here’s how to optimize your C++ code for maximum speed #

1. Supercharge screen capture & bulb detection #

Stop using generic, slow screen capture methods. Switch to Windows-native APIs for lightning-fast frame grabs and targeted scanning:

• Capture only the game’s bulb area, not the entire screen. Use GetWindowRect to lock onto the game window, then BitBlt to copy just that region to a memory DC instead of scanning every pixel on your monitor.
• Use color thresholding instead of complex image matching. Lit bulbs have a distinct color—skip fancy algorithms and just scan for pixels that match that color range. Example code snippet:

#include <windows.h>

// Predefine your game's bulb area once at startup
RECT gameBulbArea;

POINT findLitBulb(HDC hdc) {
    for (int y = gameBulbArea.top; y < gameBulbArea.bottom; y++) {
        for (int x = gameBulbArea.left; x < gameBulbArea.right; x++) {
            COLORREF pixel = GetPixel(hdc, x, y);
            // Adjust these values to match your lit bulb's color (e.g., bright white)
            if (GetRValue(pixel) > 245 && GetGValue(pixel) > 245 && GetBValue(pixel) > 245) {
                return {x, y};
            }
        }
    }
    return {-1, -1};
}

• Avoid redundant scans: Only check for a new lit bulb after you’ve clicked the previous one—no need to poll continuously when you’re waiting for the game to switch.

2. Cut click delay to near-zero #

Ditch any high-level click APIs and use Windows’ direct input methods:

• Use SendInput (or the older but faster mouse_event) to simulate clicks directly, instead of relying on browser or UI frameworks. Example:

void clickAt(POINT pos) {
    SetCursorPos(pos.x, pos.y);
    // Simulate left click down/up
    mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0);
    mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
}

• Replace Sleep() calls with active polling: As soon as you detect a new lit bulb, click it immediately—don’t wait a fixed amount of time that wastes precious seconds.

3. Strip out all unnecessary overhead #

• Compile your code in Release mode with optimization level set to O2 or O3—this removes debug checks and speeds up execution drastically.
• Skip any logging or console output during runtime—even cout calls can add unexpected lag.
• If this is a web-based game, skip Selenium entirely. Use Windows APIs to control the browser window directly, or switch to a lighter headless browser tool (but C++ native methods will still be faster).

4. Avoid penalties like the plague #

• Pre-map all bulb positions at startup: Instead of scanning the entire area every time, only check the exact coordinates where bulbs can appear—this eliminates false positives that trigger 5-second penalties.
• Add a quick error check: After clicking, scan for a penalty indicator (like a red warning text) and if you see it, immediately reset your scan to avoid wasting more time on a bad click.

Final thought #

Your manual score shows you know the game’s rhythm—automation just needs to replicate that rhythm without the lag of human reaction time or slow tools. By using native Windows APIs for capture and clicks, and cutting out all unnecessary steps, you’ll get your per-click time down to a few milliseconds. That’ll let you squeeze way more correct clicks into the 60-second window, easily hitting (or surpassing) that 150+ target.

内容的提问来源于stack exchange，提问作者Andrei Mihailescu