Чит для PUBG на основе CV YOLO11. Дело декандентское и порочное.

from ultralytics import YOLO

def main():
    model = YOLO('yolo11s.pt')
    results = model.train(
        data='data4.yaml',
        epochs=50,
        batch=6,
        imgsz=1280,
        freeze=10,
        lr0=0.001,
        device=0,
    )

if __name__ == '__main__':
    main()

from ultralytics import YOLO

def main():
    model = YOLO('best.pt')

    results = model.train(
 
        data='data4.yaml',
        epochs=25,
        batch=4,
        imgsz=1280,
        device=0,
 
        freeze=0,
        lr0=0.0001,                  # скорость вначале
        lrf=0.1,                     # скорость в конце
    )

if __name__ == '__main__':
    main()

# src/wpreal/core/camera.py

import threading
import time
import dxcam
import numpy as np
from typing import Optional

class CameraCapture:
 
    def __init__(self, fps: int = 60):
        self.fps = fps
        self._running = False
        self._latest_frame: Optional[np.ndarray] = None
        self._lock = threading.Lock()
        self._camera = None
        self._capture_count = 0
        self._capture_time = time.time()
        self._capture_fps = 0
 
    def start(self):
        self._running = True
        self._camera = dxcam.create(output_color="BGR")
        threading.Thread(target=self._capture_loop, daemon=True).start()
 
    def stop(self):
        self._running = False
 
    def get_frame(self) -> Optional[np.ndarray]:
        with self._lock:
            return self._latest_frame.copy() if self._latest_frame is not None else None
 
    def get_fps(self) -> int:

        return self._capture_fps
 
    def _capture_loop(self):
        next_frame_time = time.perf_counter()
        frame_interval = 1.0 / self.fps
 
        while self._running:
            current_time = time.perf_counter()
            if current_time < next_frame_time:
                time.sleep(0.001)
                continue
 
            frame = self._camera.grab()
            if frame is not None:
                with self._lock:
                    self._latest_frame = frame
 
            self._capture_count += 1
            now = time.time()
            if now - self._capture_time >= 1.0:
                self._capture_fps = self._capture_count
                self._capture_count = 0
                self._capture_time = now
 
            next_frame_time += frame_interval
            if next_frame_time < time.perf_counter():
                next_frame_time = time.perf_counter() + frame_interval

# src/wpreal/core/detector.py
import time
import numpy as np
from ultralytics import YOLO
from typing import List, Tuple, Optional
from dataclasses import dataclass

@dataclass
class Detection:
    x1: int
    y1: int
    x2: int
    y2: int
    confidence: float
    class_id: int
    
    @property
    def center(self) -> Tuple[int, int]:
        """Центр бокса"""
        return ((self.x1 + self.x2) // 2, (self.y1 + self.y2) // 2)
    
    @property
    def width(self) -> int:
        return self.x2 - self.x1
    
    @property
    def height(self) -> int:
        return self.y2 - self.y1
    
    def to_tuple(self) -> Tuple[int, int, int, int]:
        return (self.x1, self.y1, self.x2, self.y2)

class YOLODetector:

    def __init__(self, model_path: str, confidence: float = 0.5, image_size: int = 640):
        self.model = YOLO(model_path)
        self.model.model.half()  # FP16
        self.confidence = confidence
        self.image_size = image_size
        self._yolo_count = 0
        self._yolo_time = time.time()
        self._yolo_fps = 0
    
    def detect(self, frame: np.ndarray) -> List[Detection]:

        if frame is None:
            return []
        
        results = self.model(
            frame,
            conf=self.confidence,
            imgsz=self.image_size,
            verbose=False,
            half=True
        )
        
        detections = []
        if results[0].boxes is not None:
            for box in results[0].boxes:
                x1, y1, x2, y2 = map(int, box.xyxy[0].tolist())
                detections.append(Detection(
                    x1=x1, y1=y1, x2=x2, y2=y2,
                    confidence=float(box.conf[0]),
                    class_id=int(box.cls[0])
                ))
        
        # Подсчет FPS
        self._yolo_count += 1
        now = time.time()
        if now - self._yolo_time >= 1.0:
            self._yolo_fps = self._yolo_count
            self._yolo_count = 0
            self._yolo_time = now
        
        return detections
    
    def get_fps(self) -> int:
        return self._yolo_fps
    
    def filter_by_class(self, detections: List[Detection], class_ids: List[int]) -> List[Detection]:
        return [d for d in detections if d.class_id in class_ids]

# src/wpreal/gui/overlay.py
import time
import tkinter as tk
from typing import List
from ..core.detector import Detection
from ..config import LABEL_TEXT, LABEL_FONT, BOX_OUTLINE, BOX_WIDTH

class GUIOverlay:

    def __init__(self, screen_width: int, screen_height: int):
        self.screen_width = screen_width
        self.screen_height = screen_height
        self.root = None
        self.canvas = None
        self.running = True
        self._gui_count = 0
        self._gui_time = time.time()
        self._gui_fps = 0
 
        self._init_gui()
 
    def _init_gui(self):

        self.root = tk.Tk()
        self.root.title("PUBG Overlay")
 
        self.root.attributes('-topmost', True)
        self.root.attributes('-fullscreen', True)
        self.root.attributes('-transparentcolor', 'black')
        self.root.configure(bg='black')
        self.root.overrideredirect(True)
 
        self.canvas = tk.Canvas(
            self.root,
            width=self.screen_width,
            height=self.screen_height,
            bg='black',
            highlightthickness=0
        )
        self.canvas.pack()
 
    def update(self, detections: List[Detection]):

        if not self.running:
            return
 
        self._gui_count += 1
        now = time.time()
        if now - self._gui_time >= 1.0:
            self._gui_fps = self._gui_count
            self._gui_count = 0
            self._gui_time = now
 
        self.canvas.delete("all")
 
        for det in detections:
            self.canvas.create_rectangle(
                det.x1, det.y1, det.x2, det.y2,
                outline=BOX_OUTLINE,
                width=BOX_WIDTH
            )
            self.canvas.create_text(
                det.x1, det.y1 - 10,
                text=LABEL_TEXT,
                fill=BOX_OUTLINE,
                anchor='sw',
                font=LABEL_FONT
            )
 
        self.root.update()
 
    def get_fps(self) -> int:
        return self._gui_fps
 
    def start(self):

        self.root.mainloop()
 
    def stop(self):

        self.running = False
        if self.root:
            self.root.quit()
            self.root.destroy()

# src/wpreal/aimbot/trajectory.py

import numpy as np
import onnxruntime as ort
from typing import List, Tuple, Optional

class TrajectoryGenerator:

    def __init__(self, model_path: Optional[str] = None, screen_width: int = 1920, screen_height: int = 1080):
        self.session = None
        self.screen_width = screen_width
        self.screen_height = screen_height
 
        if model_path:
            try:
                self.session = ort.InferenceSession(model_path)
                print(" Модель траекторий загружена")
            except Exception as e:
                print(f" Ошибка загрузки модели траекторий: {e}")
                print("Будет использовано линейное наведение")
 
    def generate(self, start: Tuple[int, int], end: Tuple[int, int]) -> List[Tuple[int, int]]:

        if self.session is None:
            return [start, end]
 
        # Нормализация
        norm_start = self._normalize(start)
        norm_end = self._normalize(end)
 
        input_data = np.array([norm_start, norm_end], dtype=np.float32)
        input_tensor = input_data.reshape(1, 2, 2)
        outputs = self.session.run(None, {"lstm_input": input_tensor})
        raw_trajectory = outputs[0][0]
 
        # Денормализация
        trajectory = [
            self._denormalize(p)
            for p in raw_trajectory
        ]
 
        if len(trajectory) > 0 and trajectory[-1] != end:
            trajectory.append(end)
 
        return trajectory
 
    def _normalize(self, point: Tuple[int, int]) -> List[float]:
        return [
            (point[0] / (self.screen_width / 2)) - 1,
            (point[1] / (self.screen_height / 2)) - 1
        ]
 
    def _denormalize(self, point: List[float]) -> Tuple[int, int]:

        x = int(((point[0] + 1) / 2) * self.screen_width)
        y = int(((point[1] + 1) / 2) * self.screen_height)
        return (x, y)

# src/wpreal/arduino_initialization.py
import serial
import serial.tools.list_ports
import time

def find_arduino_port():

    ports = serial.tools.list_ports.comports()
    for port in ports:
        if "Arduino" in port.description or "Arduino" in port.manufacturer:
            return port.device
        # if port.vid == 0x2341 and port.pid == 0x8037:  # Pro Micro
        #     return port.device
 
    print(" Не удалось найти Arduino.")
    return None

def connect_to_arduino(baud_rate=115200):

    arduino_port = find_arduino_port()
    if not arduino_port:
        return None
 
    try:
        ser = serial.Serial(arduino_port, baud_rate, timeout=1, write_timeout=5)
        time.sleep(2)
        print(f" Подключено к {arduino_port} со скоростью {baud_rate}")
        return ser
    except serial.SerialException as e:
        print(f" Не удалось открыть порт {arduino_port}: {e}")
        return None

# src/wpreal/aimbot/aimbot.py

import math
import time
from typing import List, Tuple, Optional
from ..core.detector import Detection
from ..core.mouse import MouseController
from .trajectory import TrajectoryGenerator

class Aimbot:

    def __init__(self, mouse: MouseController, trajectory: TrajectoryGenerator,
                 screen_width: int, screen_height: int, fov_radius: int = 300):
        self.mouse = mouse
        self.trajectory = trajectory
        self.screen_width = screen_width
        self.screen_height = screen_height
 
        self.enabled = True
        self.fov_radius = fov_radius
        self.smoothness = 0.3
        self.active = False
 
        # Screen center
        self.screen_center = (screen_width // 2, screen_height // 2)
 
    def activate(self):
        self.active = True
        print("Aimbot активирован!")
 
    def deactivate(self):
        self.active = False
 
    def find_best_target(self, detections: List[Detection]) -> Optional[Detection]:

        if not detections:
            return None
 
        best = None
        best_dist = float('inf')
 
        for det in detections:
            center = det.center
            dist = math.sqrt(
                (center[0] - self.screen_center[0]) ** 2 +
                (center[1] - self.screen_center[1]) ** 2
            )
 
            if dist <= self.fov_radius and dist < best_dist:
                best_dist = dist
                best = det
 
        return best
 
    def aim_at(self, target: Detection) -> bool:

        if not self.enabled or not self.active:
            return False
 
        target_center = target.center
 
        trajectory = self.trajectory.generate(self.screen_center, target_center)
 
        print(f"Траектория: {len(trajectory)} точек")
        print(f"Цель: {target_center}")
 
        for i in range(1, len(trajectory)):
            prev = trajectory[i-1]
            curr = trajectory[i]
 
            dx = curr[0] - prev[0]
            dy = curr[1] - prev[1]
 
            self.mouse.move(dx, dy)
            time.sleep(0.001)
 
        self.active = False
        print(f"Наведение завершено!")
        return True

# src/wpreal/core/mouse.py

from abc import ABC, abstractmethod
import serial
import ctypes
import time
from typing import Optional

class MouseController(ABC):
 
    @abstractmethod
    def move(self, dx: int, dy: int):

        pass
 
    @abstractmethod
    def click(self, button: str = "left"):
        pass

class ArduinoMouse(MouseController):
 
    def __init__(self, ser: serial.Serial = None):
        self.ser = ser
        if self.ser:
            print(f" Arduino готов к работе!")
 
    def move(self, dx: int, dy: int):
        if self.ser is None:
            return
 
        dx = max(-127, min(127, dx))
        dy = max(-127, min(127, dy))
 
        try:
            self.ser.write(f"{dx},{dy}\n".encode())
        except Exception as e:
            print(f"Ошибка отправки: {e}")
 
    def click(self, button: str = "left"):
        if self.ser is None:
            return
        try:
            self.ser.write(b"CLICK\n")
        except Exception:
            pass

#include <Mouse.h>

String inputString = "";

void setup() {
  Serial.begin(115200);
  Mouse.begin();
}

void loop() {
  while (Serial.available()) {
    char c = Serial.read();

    if (c == '\n') {
      int comma = inputString.indexOf(',');

      if (comma != -1) {
        int dx = inputString.substring(0, comma).toInt();
        int dy = inputString.substring(comma + 1).toInt();
        Mouse.move(dx, dy);
      }

      inputString = "";
    } else {
      inputString += c;
    }
  }