---

import pymem
import pymem.process
import ctypes
import time
import math

# Windows API
user32 = ctypes.windll.user32
gdi32 = ctypes.windll.gdi32
kernel32 = ctypes.windll.kernel32

# === ВАШИ ОФФСЕТЫ ===
OFFSET_VIEW_MATRIX = 0x12EAF0      # Client + 0x12EAF0
OFFSET_ENTITY_LIST = 0x12043C8     # Engine + 0x12043C8
OFFSET_HEALTH = 0xF8
OFFSET_TEAM = 0xF0
OFFSET_ORIGIN = 0x130

ESP_ENABLED = True
BOX_SIZE = 20

# Глобальные переменные
overlay_hwnd = None
overlay_dc = None
game_hwnd = None

def world_to_screen(x, y, z, view_matrix, sw, sh):
    w = view_matrix[12]*x + view_matrix[13]*y + view_matrix[14]*z + view_matrix[15]
    if w < 0.01:
        return None
    sx = view_matrix[0]*x + view_matrix[1]*y + view_matrix[2]*z + view_matrix[3]
    sy = view_matrix[4]*x + view_matrix[5]*y + view_matrix[6]*z + view_matrix[7]
    sx = (sw / 2) * (1 + sx / w)
    sy = (sh / 2) * (1 - sy / w)
    return (sx, sy)

def draw_rect(x, y, w, h, color):
    global overlay_dc
    brush = gdi32.CreateSolidBrush(color)
    gdi32.SelectObject(overlay_dc, brush)
    gdi32.Rectangle(overlay_dc, int(x - w/2), int(y - h/2), int(x + w/2), int(y + h/2))
    gdi32.DeleteObject(brush)

def create_overlay():
    global overlay_hwnd, overlay_dc, game_hwnd
    
    game_hwnd = user32.FindWindowW(None, "Counter-Strike")
    if not game_hwnd:
        return False
    
    # Получаем размеры окна игры
    rect = ctypes.wintypes.RECT()
    user32.GetWindowRect(game_hwnd, ctypes.byref(rect))
    width = rect.right - rect.left
    height = rect.bottom - rect.top
    
    # Создаём прозрачное окно поверх игры
    wc = ctypes.WNDCLASSEXW()
    wc.cbSize = ctypes.sizeof(wc)
    wc.lpfnWndProc = ctypes.WNDPROC(user32.DefWindowProcW)
    wc.hInstance = kernel32.GetModuleHandleW(None)
    wc.lpszClassName = "ESP_Overlay"
    
    user32.RegisterClassExW(ctypes.byref(wc))
    
    overlay_hwnd = user32.CreateWindowExW(
        0x8000008,  # WS_EX_TOPMOST | WS_EX_TRANSPARENT | WS_EX_LAYERED
        "ESP_Overlay",
        "ESP",
        0x80000000,  # WS_POPUP
        rect.left, rect.top, width, height,
        None, None, wc.hInstance, None
    )
    
    # Делаем окно прозрачным
    user32.SetLayeredWindowAttributes(overlay_hwnd, 0, 0, 0x00000001)  # LWA_COLORKEY
    user32.SetLayeredWindowAttributes(overlay_hwnd, 0, 255, 0x00000002) # LWA_ALPHA
    
    user32.ShowWindow(overlay_hwnd, 5)  # SW_SHOW
    overlay_dc = user32.GetDC(overlay_hwnd)
    
    return True

def destroy_overlay():
    global overlay_dc, overlay_hwnd
    if overlay_dc:
        user32.ReleaseDC(overlay_hwnd, overlay_dc)
    if overlay_hwnd:
        user32.DestroyWindow(overlay_hwnd)

def main():
    global ESP_ENABLED, overlay_dc
    
    print("=== CS 1.6 ESP (прозрачный оверлей) ===")
    print("Rutube: https://rutube.ru/channel/43805541")
    print("Telegram: hackeriks")
    print()
    
    # Создаём оверлей
    if not create_overlay():
        print("[-] CS 1.6 не запущена или окно не найдено")
        return
    
    print("[+] Прозрачное окно создано")
    
    try:
        pm = pymem.Pymem("hl.exe")
        print("[+] hl.exe найден")
    except:
        print("[-] CS 1.6 не запущена")
        destroy_overlay()
        return
    
    # Получаем базы модулей
    engine = pymem.process.module_from_name(pm.process_handle, "hw.dll")
    client = pymem.process.module_from_name(pm.process_handle, "client.dll")
    
    engine_base = engine.lpBaseOfDll
    client_base = client.lpBaseOfDll
    
    view_matrix_addr = client_base + OFFSET_VIEW_MATRIX
    entity_list_addr = engine_base + OFFSET_ENTITY_LIST
    
    print("[*] ESP активен. F1 - вкл/выкл, F2 - выход")
    
    running = True
    while running:
        # Управление
        if user32.GetAsyncKeyState(0x70) & 1:  # F1
            ESP_ENABLED = not ESP_ENABLED
            print(f"ESP: {'ON' if ESP_ENABLED else 'OFF'}")
            time.sleep(0.2)
        if user32.GetAsyncKeyState(0x71) & 1:  # F2
            running = False
            break
        
        if not ESP_ENABLED:
            time.sleep(0.05)
            continue
        
        # Очищаем оверлей (делаем прозрачным)
        user32.InvalidateRect(overlay_hwnd, None, True)
        
        try:
            # Читаем матрицу вида
            view_matrix = [pm.read_float(view_matrix_addr + i*4) for i in range(16)]
            
            # Читаем EntityList
            entity_list = pm.read_int(entity_list_addr)
            if not entity_list:
                continue
            
            # Получаем размеры окна
            rect = ctypes.wintypes.RECT()
            user32.GetClientRect(overlay_hwnd, ctypes.byref(rect))
            sw = rect.right - rect.left
            sh = rect.bottom - rect.top
            
            # Перебираем игроков
            for i in range(1, 33):
                entity = pm.read_int(entity_list + i * 4)
                if not entity:
                    continue
                
                health = pm.read_int(entity + OFFSET_HEALTH)
                if health <= 0:
                    continue
                
                x = pm.read_float(entity + OFFSET_ORIGIN)
                y = pm.read_float(entity + OFFSET_ORIGIN + 4)
                z = pm.read_float(entity + OFFSET_ORIGIN + 8)
                
                screen = world_to_screen(x, y, z + 60, view_matrix, sw, sh)
                if screen:
                    draw_rect(screen[0], screen[1], BOX_SIZE, BOX_SIZE, 0x0000FF)
                    
        except Exception as e:
            pass
        
        time.sleep(0.03)
    
    destroy_overlay()
    print("ESP остановлен.")

if __name__ == "__main__":
    main()