---

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

class Memory:
    def __init__(self):
        self.pid = None
        self.handle = None
        self.base = None
        for p in psutil.process_iter(['pid', 'name']):
            if 'rust' in p.info['name'].lower():
                self.pid = p.info['pid']
                break
        if not self.pid:
            return
        self.handle = ctypes.windll.kernel32.OpenProcess(0x10 | 0x20, False, self.pid)
        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
                break

    def read(self, addr, 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("400x600")
        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=30)
        self.listbox.pack(fill=tk.BOTH, expand=True)
        self.mem = Memory()
        if not self.mem.base:
            self.label.config(text="Rust не запущен!")
            return
        self.update()

    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:
            pass
        self.root.after(300, self.update)

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