/**
• =================================================================================
• ScreenTrigger - High-Performance Low-Latency Screen Color Triggerbot
• =================================================================================
• [설명]
• 이 프로그램은 화면 중앙의 설정된 영역(기본 40x40)을 지속적으로 모니터링하여,
• 지정된 4 target 색상 범위 내의 픽셀이 감지되면 자동으로 지정된 키를 입력합니다.
• 강력한 안티 디텍션을 위해 하드웨어 스캔코드를 활용한 SendInput 주입 및
• mt19937 기반의 인간화 딜레이 메커니즘이 포함되어 있습니다.
• [컴파일 방법]
◦ Visual Studio (2019 / 2022 추천)
◦ 프로젝트 속성 -> 일반 -> C++ 언어 표준: ISO C++17 표준 (/std:c++17) 이상 설정
◦ 빌드 구성: Release 모드로 컴파일 (최적화 /O2 자동 적용)
• [파라미터 조정]
◦ 하단의 === CONFIGURATION === 섹션에서 크기, 타겟 색상, 허용 오차, 키 코드,
• 인간화 타이밍(밀리초) 변수들을 직접 변경할 수 있습니다.
*/

#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <iostream>
#include <vector>
#include <random>
#include <thread>
#include <chrono>
#include <cmath>

// 디버그 로그 활성화/비활성화 (주석 해제 시 콘솔 출력 없음, 성능 극대화)
// #define DISABLE_DEBUG_LOG

// 색상 구조체 정의
struct RGB_COLOR {
BYTE r;
BYTE g;
BYTE b;
};

// === CONFIGURATION ===
constexpr int CAPTURE_WIDTH = 40;
constexpr int CAPTURE_HEIGHT = 40;
constexpr int COLOR_TOLERANCE = 10; // 채널별 매칭 허용 오차 (0 ~ 255)
constexpr DWORD TARGET_KEY = VK_SPACE; // 트리거할 가상 키 코드 (예: 스페이스바)

// 모니터링할 타겟 색상 배열
const RGB_COLOR TARGET_COLORS[] = {
{222, 132, 255},
{238, 143, 211},
{253, 118, 255},
{255, 150, 235}
};
constexpr size_t TARGET_COLOR_COUNT = sizeof(TARGET_COLORS) / sizeof(TARGET_COLORS[0]);

// 인간화 타이밍 변수 (밀리초 단위 난수 범위)
constexpr int DELAY_BEFORE_PRESS_MIN = 10; // 입력 전 최소 대기
constexpr int DELAY_BEFORE_PRESS_MAX = 50; // 입력 전 최대 대기
constexpr int HOLD_TIME_MIN = 20; // 키 누름 유지 최소 시간
constexpr int HOLD_TIME_MAX = 80; // 키 누름 유지 최대 시간
constexpr int COOLDOWN_MIN = 500; // 트리거 작동 후 최소 쿨다운
constexpr int COOLDOWN_MAX = 1500; // 트리거 작동 후 최대 쿨다운

constexpr int SCAN_INTERVAL_MS = 1; // 루프당 기본 휴식 시간 (CPU 과열 방지)
// =====================

// 전역 난수 생성기 초기화 (고품질 시드 사용)
std::mt19937& GetRng() {
static std::random_device rd;
static std::mt19937 gen(rd());
return gen;
}

// 범위 내 랜덤 밀리초 반환 함수
int GetRandomRange(int min_val, int max_val) {
if (min_val >= max_val) return min_val;
std::uniform_int_distribution<int> dist(min_val, max_val);
return dist(GetRng());
}

// 하드웨어 레벨을 모방한 SendInput 기반 키 입력 시뮬레이션
void SimulateKeyPress(DWORD vKey, int holdTimeMs) {
INPUT inputs[2] = {};

// 가상 키 코드를 하드웨어 스캔 코드로 변환 (안티치트 우회 핵심)
UINT scanCode = MapVirtualKeyW(vKey, MAPVK_VK_TO_VSC);

// 1. Key Press 설정
inputs[0].type = INPUT_KEYBOARD;
inputs[0].ki.wVk = static_cast<WORD>(vKey);
inputs[0].ki.wScan = static_cast<WORD>(scanCode);
inputs[0].ki.dwFlags = KEYEVENTF_SCANCODE; // 스캔코드 기반 입력 명시

// 2. Key Release 설정
inputs[1].type = INPUT_KEYBOARD;
inputs[1].ki.wVk = static_cast<WORD>(vKey);
inputs[1].ki.wScan = static_cast<WORD>(scanCode);
inputs[1].ki.dwFlags = KEYEVENTF_SCANCODE | KEYEVENTF_KEYUP;

// 키 누르기 수행
SendInput(1, &inputs[0], sizeof(INPUT));

// 인간적인 유지 시간만큼 대기
std::this_thread::sleep_for(std::chrono::milliseconds(holdTimeMs));

// 키 떼기 수행
SendInput(1, &inputs[1], sizeof(INPUT));
}

// 두 색상이 허용 오차 범위 내에 있는지 확인
inline bool MatchColor(BYTE r, BYTE g, BYTE b, const RGB_COLOR& target, int tolerance) {
return (std::abs(static_cast<int>(r) - target.r) <= tolerance) &&
(std::abs(static_cast<int>(g) - target.g) <= tolerance) &&
(std::abs(static_cast<int>(b) - target.b) <= tolerance);
}

int main() {
#ifndef DISABLE_DEBUG_LOG
std::cout << "[ScreenTrigger] 프로그램이 시작되었습니다." << std::endl;
    std::cout <<"nia oma " << std ::endl;
std::cout << "[정보] 감지 키: " << TARGET_KEY << " | 해상도: " << CAPTURE_WIDTH << "x" << CAPTURE_HEIGHT << std::endl;
#endif

// 화면 해상도 획득 및 중앙 타겟 영역 좌표 계산
int screenWidth = GetSystemMetrics(SM_CXSCREEN);
int screenHeight = GetSystemMetrics(SM_CYSCREEN);
int captureX = (screenWidth - CAPTURE_WIDTH) / 2;
int captureY = (screenHeight - CAPTURE_HEIGHT) / 2;

// GDI 컨텍스트 및 재사용 가능한 DIB 비트맵 세팅 (메모리 릭 및 할당 지연 방지)
HDC hScreenDC = GetDC(NULL);
HDC hMemoryDC = CreateCompatibleDC(hScreenDC);

BITMAPINFO bmi = {};
bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
bmi.bmiHeader.biWidth = CAPTURE_WIDTH;
bmi.bmiHeader.biHeight = -CAPTURE_HEIGHT; // 상하 뒤집힘 방지 (Top-Down DIB)
bmi.bmiHeader.biPlanes = 1;
bmi.bmiHeader.biBitCount = 32; // RGBA 8888 포맷
bmi.bmiHeader.biCompression = BI_RGB;

void* pPixels = nullptr;
HBITMAP hBitmap = CreateDIBSection(hMemoryDC, &bmi, DIB_RGB_COLORS, &pPixels, NULL, 0);
HGDIOBJ hOldBitmap = SelectObject(hMemoryDC, hBitmap);

// 고성능 루프 플래그 및 타이밍 변수
bool running = true;

while (running) {
// 단일 키 종료 메커니즘 (END 키 누르면 안전하게 종료)
if (GetAsyncKeyState(VK_END) & 0x8000) {
break;
}

// 1. 고성능 화면 캡처 실행 (BitBlt 사용)
if (!BitBlt(hMemoryDC, 0, 0, CAPTURE_WIDTH, CAPTURE_HEIGHT, hScreenDC, captureX, captureY, SRCCOPY)) {
continue;
}

bool matchFound = false;
const DWORD* pixels = static_cast<const DWORD*>(pPixels);
int totalPixels = CAPTURE_WIDTH * CAPTURE_HEIGHT;

// 2. 픽셀 스캔 고속 파이프라인
for (int i = 0; i < totalPixels; ++i) {
// 32비트 BGRA 포맷 데이터 추출
DWORD pixel = pixels[i];
BYTE b = static_cast<BYTE>(pixel & 0xFF);
BYTE g = static_cast<BYTE>((pixel >> 8) & 0xFF);
BYTE r = static_cast<BYTE>((pixel >> 16) & 0xFF);

// 정의된 모든 타겟 색상과 대조
for (size_t c = 0; c < TARGET_COLOR_COUNT; ++c) {
if (MatchColor(r, g, b, TARGET_COLORS[c], COLOR_TOLERANCE)) {
matchFound = true;
break; // 타겟 컬러 매칭 시 내부 루프 탈출
}
}
if (matchFound) break; // 조기 종료(Early Exit)로 연산 속도 극대화
}

// 3. 인간화 액션 핸들러
if (matchFound) {
// A. 입력 전 랜덤 지연 (반응 속도 인간화)
int delayBefore = GetRandomRange(DELAY_BEFORE_PRESS_MIN, DELAY_BEFORE_PRESS_MAX);
std::this_thread::sleep_for(std::chrono::milliseconds(delayBefore));

// B. 랜덤 키 유지 시간을 조합한 입력 실행
int holdTime = GetRandomRange(HOLD_TIME_MIN, HOLD_TIME_MAX);
SimulateKeyPress(TARGET_KEY, holdTime);

#ifndef DISABLE_DEBUG_LOG
std::cout << "[Triggered] 색상 감지 완료! (지연: " << delayBefore << "ms, 유지: " << holdTime << "ms)" << std::endl;
std::cout << "nia om a"<<std::endl;
std:: cout << "niomen a"  << std ::endl; 
#endif

// C. 입력 후 랜덤 쿨다운 적용 (연속 매치로 인한 정지 및 밴 위험 방지)
int cooldown = GetRandomRange(COOLDOWN_MIN, COOLDOWN_MAX);
std::this_thread::sleep_for(std::chrono::milliseconds(cooldown));
}

// 비정상적인 CPU 점유율 상승을 막기 위한 마이크로 슬립
std::this_thread::sleep_for(std::chrono::milliseconds(SCAN_INTERVAL_MS));
}

// GDI 자원 해제 (메모리 누수 완전 차단)
SelectObject(hMemoryDC, hOldBitmap);
DeleteObject(hBitmap);
DeleteDC(hMemoryDC);
ReleaseDC(NULL, hScreenDC);

#ifndef DISABLE_DEBUG_LOG
std::cout << "[ScreenTrigger] 자원을 해제하고 안전하게 종료되었습니다." << std::endl;
#endif
return 0;
}