---

import ctypes
import struct
import psutil
import math
import tkinter as tk
import sys

class Memory:
    def __init__(self):
        self.pid = None
        self.handle = None
        self.base = None
        
        print("[*] Поиск Rust...")
        
        # Ищем Rust (любой процесс с "rust" в названии)
        for proc in psutil.process_iter(['pid', 'name']):
            name = proc.info['name'].lower()
            if 'rust' in name:
                self.pid = proc.info['pid']
                print(f"[+] Найден процесс: {proc.info['name']} (PID: {self.pid})")
                break
        
        # Если не нашли - выводим все процессы для диагностики
        if not self.pid:
            print("[-] Rust не найден! Вот все запущенные процессы:")
            for proc in psutil.process_iter(['pid', 'name']):
                print(f"    {proc.info['name']} (PID: {proc.info['pid']})")
            return
        
        # Открываем процесс
        self.handle = ctypes.windll.kernel32.OpenProcess(0x10 | 0x20, False, self.pid)
        if not self.handle:
            print("[-] Не удалось открыть процесс! Запусти от администратора.")
            return
        
        # Ищем GameAssembly.dll
        try:
            for m in psutil.Process(self.pid).memory_maps():
                if 'gameassembly.dll' in m.path.lower():
                    if hasattr(m, 'addr'):
                        self.base = m.addr
                    elif hasattr(m, 'start'):
                        self.base = m.start
                    print(f"[+] GameAssembly.dll найден! База: {hex(self.base)}")
                    break
        except:
            pass
        
        if not self.base:
            print("[-] GameAssembly.dll не найден!")

    def read(self, addr, size):
        if not self.handle:
            return b'\x00' * size
        buf = ctypes.create_string_buffer(size)
        read = ctypes.c_ulong(0)
        ctypes.windll.kernel32.ReadProcessMemory(self.handle, addr, buf, size, ctypes.byref(read))
        return buf.raw

    def read_int(self, addr):
        return struct.unpack('i', self.read(addr, 4))[0]

    def read_float(self, addr):
        return struct.unpack('f', self.read(addr, 4))[0]

    def read_vec3(self, addr):
        return (self.read_float(addr), self.read_float(addr+4), self.read_float(addr+8))

class ESP:
    def __init__(self):
        self.root = tk.Tk()
        self.root.title("ESP")
        self.root.geometry("500x700")
        self.root.attributes("-topmost", True)
        self.root.configure(bg='black')
        
        self.label = tk.Label(self.root, text="Загрузка...", fg="white", bg="black", font=("Arial", 12))
        self.label.pack(pady=10)
        
        self.listbox = tk.Listbox(self.root, bg="black", fg="#00ff00", font=("Consolas", 10), height=35)
        self.listbox.pack(fill=tk.BOTH, expand=True)
        
        self.mem = Memory()
        if not self.mem.base:
            self.label.config(text="Rust не найден!\nЗапусти от администратора")
            return
        
        self.update()
        self.root.mainloop()
    
    def update(self):
        try:
            local = self.mem.read_int(self.mem.base + 0xDEA964)
            if not local:
                self.root.after(300, self.update)
                return
            
            local_team = self.mem.read_int(local + 0xF4)
            local_pos = self.mem.read_vec3(local + 0x138)
            entities = self.mem.read_int(self.mem.base + 0x4DFFFC4)
            
            if not entities:
                self.root.after(300, self.update)
                return
            
            enemies = []
            for i in range(1, 65):
                entity = self.mem.read_int(entities + i * 0x10)
                if not entity:
                    continue
                health = self.mem.read_int(entity + 0x100)
                if health <= 0 or health > 100:
                    continue
                team = self.mem.read_int(entity + 0xF4)
                if team == local_team or team == 0:
                    continue
                pos = self.mem.read_vec3(entity + 0x138)
                dist = math.sqrt(
                    (pos[0] - local_pos[0])**2 +
                    (pos[1] - local_pos[1])**2 +
                    (pos[2] - local_pos[2])**2
                )
                if dist < 500 and dist > 0:
                    enemies.append(f"• {dist:.0f}м | X:{pos[0]:.1f} Y:{pos[1]:.1f}")
            
            self.listbox.delete(0, tk.END)
            for e in sorted(enemies):
                self.listbox.insert(tk.END, e)
            self.label.config(text=f"Врагов: {len(enemies)}")
            
        except Exception as e:
            self.label.config(text=f"Ошибка: {str(e)[:30]}")
        
        self.root.after(300, self.update)

if __name__ == "__main__":
    app = ESP()
    app.root.mainloop()