---

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

# Смещения для версии 1.1.2.7
dwLocalPlayer = 0x1A29B8
dwEntityList = 0x1A2A78
m_iHealth = 0xF8
m_iTeamNum = 0xF0
m_vecOrigin = 0x130
m_vecViewOffset = 0x104
m_angRotation = 0x110
dwForceAttack = 0x1B8A0C

# Настройки Aimbot
FOV = 30          # угол обзора (градусы)
SMOOTH = 5.0      # плавность (1 = мгновенно, больше = плавнее)
AIM_KEY = 0x04    # средняя кнопка мыши (0x02 = правая, 0x04 = средняя)
AIM_HEAD = True   # True = в голову, False = в тело

def get_angle(source, destination):
    """Вычисляет углы для наведения из source в destination"""
    delta_x = source[0] - destination[0]
    delta_y = source[1] - destination[1]
    delta_z = source[2] - destination[2]
    
    hyp = math.sqrt(delta_x * delta_x + delta_y * delta_y)
    angle_x = math.atan(delta_z / hyp) * (180.0 / math.pi)
    angle_y = math.atan(delta_y / delta_x) * (180.0 / math.pi)
    
    if delta_x >= 0.0:
        angle_y += 180.0
    
    return [angle_x, angle_y]

def normalize_angles(angles):
    """Нормализует углы"""
    if angles[0] > 89.0:
        angles[0] = 89.0
    if angles[0] < -89.0:
        angles[0] = -89.0
    while angles[1] > 180.0:
        angles[1] -= 360.0
    while angles[1] < -180.0:
        angles[1] += 360.0
    return angles

def smooth_angles(current, target, smooth_value):
    """Плавное наведение"""
    delta_x = target[0] - current[0]
    delta_y = target[1] - current[1]
    
    if smooth_value > 0:
        return [current[0] + delta_x / smooth_value, current[1] + delta_y / smooth_value]
    return target

def get_key_state(key_code):
    """Проверка нажатия клавиши"""
    return ctypes.windll.user32.GetAsyncKeyState(key_code) & 0x8000

def main():
    try:
        pm = pymem.Pymem("hl.exe")
    except:
        print("CS 1.6 не запущен!")
        return
    
    client = pymem.process.module_from_name(pm.process_handle, "hw.dll")
    client_base = client.lpBaseOfDll
    
    print(f"[+] Aimbot запущен. Client base: {hex(client_base)}")
    print("[+] Зажмите среднюю кнопку мыши для наведения на врага")
    
    while True:
        try:
            # Проверка нажатия клавиши аима
            if not get_key_state(AIM_KEY):
                time.sleep(0.01)
                continue
            
            # Получаем локального игрока
            local_player = pm.read_int(client_base + dwLocalPlayer)
            if local_player == 0:
                time.sleep(0.01)
                continue
            
            local_team = pm.read_int(local_player + m_iTeamNum)
            
            # Координаты локального игрока (глаза)
            origin = [
                pm.read_float(local_player + m_vecOrigin),
                pm.read_float(local_player + m_vecOrigin + 4),
                pm.read_float(local_player + m_vecOrigin + 8)
            ]
            view_offset = [
                pm.read_float(local_player + m_vecViewOffset),
                pm.read_float(local_player + m_vecViewOffset + 4),
                pm.read_float(local_player + m_vecViewOffset + 8)
            ]
            local_eye = [origin[0] + view_offset[0], origin[1] + view_offset[1], origin[2] + view_offset[2]]
            
            # Текущие углы
            current_angles = [
                pm.read_float(local_player + m_angRotation),
                pm.read_float(local_player + m_angRotation + 4)
            ]
            
            best_target = None
            best_fov = FOV
            
            # Поиск ближайшего врага в поле зрения
            for i in range(1, 33):
                entity = pm.read_int(client_base + dwEntityList + i * 4)
                if entity == 0:
                    continue
                
                entity_team = pm.read_int(entity + m_iTeamNum)
                if entity_team == local_team:
                    continue
                
                health = pm.read_int(entity + m_iHealth)
                if health <= 0:
                    continue
                
                # Координаты цели (голова или тело)
                target_pos = [
                    pm.read_float(entity + m_vecOrigin),
                    pm.read_float(entity + m_vecOrigin + 4),
                    pm.read_float(entity + m_vecOrigin + 8)
                ]
                if AIM_HEAD:
                    target_pos[2] += 60.0  # примерная высота головы
                else:
                    target_pos[2] += 30.0  # центр тела
                
                # Вычисляем углы до цели
                angles = get_angle(local_eye, target_pos)
                angles = normalize_angles(angles)
                
                # Вычисляем разницу углов
                delta_angle_x = abs(angles[0] - current_angles[0])
                delta_angle_y = abs(angles[1] - current_angles[1])
                
                fov = math.sqrt(delta_angle_x**2 + delta_angle_y**2)
                
                if fov < best_fov:
                    best_fov = fov
                    best_target = angles
            
            # Наводим на цель
            if best_target:
                smoothed = smooth_angles(current_angles, best_target, SMOOTH)
                smoothed = normalize_angles(smoothed)
                
                # Записываем углы в память
                pm.write_float(local_player + m_angRotation, smoothed[0])
                pm.write_float(local_player + m_angRotation + 4, smoothed[1])
                
                # Опционально: автоматический выстрел
                # force_attack = client_base + dwForceAttack
                # pm.write_int(force_attack, 5)
                # time.sleep(0.01)
                # pm.write_int(force_attack, 4)
            
            time.sleep(0.01)
            
        except Exception as e:
            pass

if __name__ == "__main__":
    main()