version 0.6.4

Author: SunOner

README.md

@@ -46,7 +46,7 @@ Before you get started, make sure you have the following prerequisites installed
   <thead><tr><th>Python:</th><td>3.11.6</td></tr></thead>
   <thead><tr><th>CUDA:</th><td>12.4</td></tr></thead>
   <thead><tr><th>TensorRT:</th><td>10.0.1</td></tr></thead>
-  <thead><tr><th>Ultralytics:</th><td>8.2.42</td></tr></thead>
+  <thead><tr><th>Ultralytics:</th><td>8.2.48</td></tr></thead>
   <thead><tr><th>GitHub AI Model:</th><td>0.4.1 (YOLOv8)</td></tr></thead>
   <thead><tr><th>Boosty AI Model:</th><td>0.5.7 (YOLOv10)</td></tr></thead>
 </table>
@@ -74,6 +74,7 @@ The behavior of the aimbot can be configured via the [`config.ini`](https://gith
 - hideout_targets `bool`: Allows shooting at targets on the range (for example in warface on the polygon or in aimlabs).
 - disable_headshot `bool`: Disable head targerting.
 - disable_prediction `bool`: Disable target position prediction.
+- third_person `bool`: Turn on the third-person game mode. (sunxds_0.5.7+)
 
 ### Hot keys:
 - The names of all the keys are [here](https://github.com/SunOner/sunone_aimbot/blob/main/logic/buttons.py). Type `None` is empty button.

config.ini

@@ -16,6 +16,7 @@ body_y_offset = 0.35
 hideout_targets = False
 disable_headshot = False
 disable_prediction = False
+third_person = False
 
 [Hotkeys]
 hotkey_targeting = RightMouseButton

helper.py

@@ -1,5 +1,6 @@
 import os
 import subprocess
+import tempfile
 import time
 import re
 import sys
@@ -32,7 +33,7 @@
 
 def install_cuda():
         st.write("Cuda 12.4 is being downloaded, and installation will begin after downloading.")
-        download_file("https://developer.download.nvidia.com/compute/cuda/12.4.0/local_installers/cuda_12.4.0_551.61_windows.exe', './cuda_12.4.0_551.61_windows.exe")
+        download_file("https://developer.download.nvidia.com/compute/cuda/12.4.0/local_installers/cuda_12.4.0_551.61_windows.exe", "./cuda_12.4.0_551.61_windows.exe")
         subprocess.call(f'{os.path.join(os.path.dirname(os.path.abspath(__file__)), "cuda_12.4.0_551.61_windows.exe")}')
 
 def delete_files_in_folder(folder):
@@ -128,7 +129,7 @@ def upgrade_ultralytics():
 if 'python_version' not in st.session_state:
     st.session_state.python_version = sys.version_info
 
-HELPER, EXPORT, CONFIG = st.tabs(["HELPER", "EXPORT", "CONFIG"])
+HELPER, EXPORT, CONFIG, TRAIN = st.tabs(["HELPER", "EXPORT", "CONFIG", "TRAIN"])
 
 with HELPER:
     st.title("Helper")
@@ -574,4 +575,103 @@ def save_config(config):
         config.set('Debug window', 'show_window', "False")
 
     if st.button('Save Config'):
-        save_config(config)
+        save_config(config)
+
+with TRAIN:
+    st.title("Train model")
+    resume = False
+    
+    # model selection
+    pretrained_models = ["yolov8n.pt", "yolov8s.pt", "yolov8m.pt", "yolov10n.pt", "yolov10s.pt", "yolov10m.pt"]
+    
+    user_trained_models = st.toggle(label="Use user pretrained models", value=False)
+    if user_trained_models:
+        last_pt_files = []
+        root_folder = r'runs\detect'
+
+        for root, dirs, files in os.walk(root_folder):
+            for file in files:
+                if file == 'last.pt':
+                    last_pt_files.append(os.path.join(root, file))
+                    
+        selected_model_path = st.selectbox(label="Select model", options=last_pt_files)
+        resume = st.toggle(label="Resume training", value=False)
+    else:
+        selected_model_path = st.selectbox(label="Select model", options=pretrained_models)
+    
+    if resume == False:
+        
+        # data yaml
+        data_yaml = st.text_input(label="Path to the dataset configuration file", value="logic/game.yaml")
+        
+        # epochs
+        epochs = st.number_input(label="Epochs", value=80, format="%u", min_value=10, step=10)
+        
+        # image size
+        img_size = st.number_input(label="Image size", value=640, format="%u", min_value=120, max_value=1280, step=10)
+
+        # device
+        input_devices = ["cpu", "0", "1", "2", "3", "4", "5"]
+        train_device = st.selectbox(label="Specifies the computational device for training",
+                                    options=input_devices,
+                                    index=1,
+                                    help="cpu - Train on processor, 0-5 GPU ID for training.")
+        if train_device != "cpu":
+            train_device = int(train_device)
+        
+        # cache
+        use_cache = st.toggle(label="Enables caching of dataset images in memory",
+                            value=False)
+        
+        # batch size
+        batch_size_options = ["auto", "4", "8", "16", "32", "64", "128", "256"]
+        batch_size = st.selectbox(label="Batch size",
+                                options=batch_size_options,
+                                index=0)
+        if batch_size == "auto":
+            batch_size = "-1"
+        batch_size = int(batch_size)
+        
+        augment = st.toggle(label="Use augmentation", value=True)
+        
+        if augment: #TODO Add more settings
+            augment_degrees = st.number_input(label="Degrees", format="%u", value=5, min_value=-180, max_value=180, step=5)
+            augment_flipud = st.number_input(label="Flipud", format="%f", value=0.2, min_value=0.0, max_value=1.0, step=0.1)
+    
+    # WANDB
+    wandb = st.toggle(label="Force disable WANDB logger", value=True)
+    if wandb:
+        os.environ['WANDB_DISABLED'] = 'true'
+    else:
+        os.environ['WANDB_DISABLED'] = 'false'
+    
+    # START TRAIN
+    if st.button(label="Start"):
+        with st.spinner("Train in process, check terminal window."):
+            with tempfile.NamedTemporaryFile(delete=False, suffix=".py") as temp_script:
+                # for multiprocessing "if __name__ == '__main__':" required
+                temp_script.write(f"""
+if __name__ == '__main__':
+    from ultralytics import YOLO
+    yolo_model = YOLO('{selected_model_path}')
+    yolo_model.train(
+        data='{data_yaml}',
+        epochs={epochs},
+        imgsz={img_size},
+        device={train_device},
+        cache={use_cache},
+        batch={batch_size},
+        augment={augment},
+        degrees={augment_degrees},
+        flipud={augment_flipud},
+        resume={resume}
+    )
+                """.encode('utf-8'))
+                temp_script_path = temp_script.name
+            
+            if os.name == 'nt':
+                os.system(f'start cmd /k python {temp_script_path}')
+            else:
+                os.system(f'xterm -e python {temp_script_path}')
+
+            st.success("Training started in a new terminal window.")

logic/capture.py

@@ -1,10 +1,18 @@
 import cv2
 import bettercam
 from screeninfo import get_monitors
+import threading
+import queue
+import time
+
 from logic.config_watcher import cfg
 
-class Capture():
+class Capture(threading.Thread):
     def __init__(self):
+        super().__init__()
+        self.daemon = True
+        self.name = "Capture"
+        
         self.Warnings()
         self.print_startup_messages()
 
@@ -19,43 +27,66 @@ def __init__(self):
         self.prev_detection_window_height = cfg.detection_window_height
         self.prev_bettercam_capture_fps = cfg.bettercam_capture_fps
 
-        if cfg.Bettercam_capture:
-            self.bc = bettercam.create(device_idx=cfg.bettercam_monitor_id, output_idx=cfg.bettercam_gpu_id, output_color="BGR", max_buffer_len=64, region=self.Calculate_screen_offset())
-            if self.bc.is_capturing == False:
-                self.bc.start(region=self.Calculate_screen_offset(custom_region=[] if len(self._custom_region) <=0 else self._custom_region, x_offset=None if self._offset_x == None else self._offset_x, y_offset = None if self._offset_y == None else self._offset_y), target_fps=cfg.bettercam_capture_fps)
+        self.frame_queue = queue.Queue(maxsize=5)
+        self.running = True
 
-        if cfg.Obs_capture:
-            if cfg.Obs_camera_id == 'auto':
-                camera_id = self.find_obs_virtual_camera()
-                if camera_id == -1:
-                    print('OBS Virtual Camera not found')
-                    exit(0)
-            elif cfg.Obs_camera_id.isdigit:
-                camera_id = int(cfg.Obs_camera_id)
-            self.obs_camera = cv2.VideoCapture(camera_id)
-            self.obs_camera.set(cv2.CAP_PROP_FRAME_WIDTH, cfg.detection_window_width)
-            self.obs_camera.set(cv2.CAP_PROP_FRAME_HEIGHT, cfg.detection_window_height)
-            self.obs_camera.set(cv2.CAP_PROP_FPS, cfg.Obs_capture_fps)
+        if cfg.Bettercam_capture:
+            self.setup_bettercam()
+        elif cfg.Obs_capture:
+            self.setup_obs()
+            
+    def setup_bettercam(self):
+        self.bc = bettercam.create(device_idx=cfg.bettercam_monitor_id, output_idx=cfg.bettercam_gpu_id, output_color="BGR", max_buffer_len=64, region=self.Calculate_screen_offset())
+        if not self.bc.is_capturing:
+            self.bc.start(region=self.Calculate_screen_offset(custom_region=[] if len(self._custom_region) <=0 else self._custom_region, x_offset=None if self._offset_x == None else self._offset_x, y_offset = None if self._offset_y == None else self._offset_y), target_fps=cfg.bettercam_capture_fps)
+
+    def setup_obs(self):
+        if cfg.Obs_camera_id == 'auto':
+            camera_id = self.find_obs_virtual_camera()
+            if camera_id == -1:
+                print('OBS Virtual Camera not found')
+                exit(0)
+        elif cfg.Obs_camera_id.isdigit:
+            camera_id = int(cfg.Obs_camera_id)
+        self.obs_camera = cv2.VideoCapture(camera_id)
+        self.obs_camera.set(cv2.CAP_PROP_FRAME_WIDTH, cfg.detection_window_width)
+        self.obs_camera.set(cv2.CAP_PROP_FRAME_HEIGHT, cfg.detection_window_height)
+        self.obs_camera.set(cv2.CAP_PROP_FPS, cfg.Obs_capture_fps)
 
-    def get_new_frame(self):
+    def run(self):
+        while self.running:
+            frame = self.capture_frame()
+            if frame is not None:
+                if self.frame_queue.full():
+                    self.frame_queue.get()
+                self.frame_queue.put(frame)
+            time.sleep(1 / cfg.bettercam_capture_fps)
+            
+    def capture_frame(self):
         if cfg.Bettercam_capture:
             return self.bc.get_latest_frame()
-        
-        if cfg.Obs_capture:
+        elif cfg.Obs_capture:
             ret_val, img = self.obs_camera.read()
             if ret_val:
                 return img
             else:
-                print('OBS Virtual Camera not found')
-                exit(0)
+                print('Failed to capture frame from OBS Virtual Camera')
+                return None
+            
+    def get_new_frame(self):
+        try:
+            return self.frame_queue.get(timeout=1)
+        except queue.Empty:
+            print("No frame available")
+            return None
 
     def restart(self):
-        if cfg.Bettercam_capture and self.prev_detection_window_height != cfg.detection_window_height or cfg.Bettercam_capture and self.prev_detection_window_width != cfg.detection_window_width or cfg.Bettercam_capture and self.prev_bettercam_capture_fps != cfg.bettercam_capture_fps:
+        if cfg.Bettercam_capture and (self.prev_detection_window_height != cfg.detection_window_height or 
+                                      self.prev_detection_window_width != cfg.detection_window_width or 
+                                      self.prev_bettercam_capture_fps != cfg.bettercam_capture_fps):
             self.bc.stop()
             del self.bc
-            
-            self.bc = bettercam.create(device_idx=cfg.bettercam_monitor_id, output_idx=cfg.bettercam_gpu_id, output_color="BGR", max_buffer_len=64)
-            self.bc.start(self.Calculate_screen_offset(), target_fps=cfg.bettercam_capture_fps)
+            self.setup_bettercam()
 
             self.screen_x_center = cfg.detection_window_width / 2
             self.screen_y_center = cfg.detection_window_height / 2
@@ -152,7 +183,12 @@ def Warnings(self):
             print('WARNING: A small value of `AI_conf ` can lead to a large number of false positives.')
 
     def Quit(self):
+        self.running = False
         if cfg.Bettercam_capture and self.bc.is_capturing:
             self.bc.stop()
+        if cfg.Obs_capture:
+            self.obs_camera.release()
+        self.join()
 
-capture = Capture()
+capture = Capture()
+capture.start()

logic/config_watcher.py

@@ -30,6 +30,7 @@ def Read(self, verbose=False, ):
         self.hideout_targets = self.config_Aim.getboolean('hideout_targets')
         self.disable_headshot = self.config_Aim.getboolean('disable_headshot')
         self.disable_prediction = self.config_Aim.getboolean('disable_prediction')
+        self.third_person = self.config_Aim.getboolean('third_person')
         # Hotkeys
         self.config_Hotkeys_settings = self.config['Hotkeys']
         self.hotkey_targeting = str(self.config_Hotkeys_settings['hotkey_targeting'])

logic/frame_parser.py

@@ -5,6 +5,7 @@
 from logic.capture import capture
 from logic.visual import visuals
 from logic.mouse import mouse
+from logic.shooting import shooting
 
 class Target():
     def __init__(self, x, y, w, h, cls):
@@ -40,8 +41,7 @@ def parse(self, result):
                         visuals.draw_predicted_position(target.x, target.y)
             else:
                 if cfg.auto_shoot or cfg.triggerbot:
-                    mouse.shoot(False) # release shooting buttons
-                pass
+                    shooting.shoot(False, False) # release shooting buttons
 
             if cfg.show_window and cfg.show_detection_speed == True:
                 visuals.draw_speed(frame.speed['preprocess'], frame.speed['inference'], frame.speed['postprocess'])

logic/ghub.py

@@ -0,0 +1,75 @@
+from ctypes import *
+from os import path
+
+class GhubMouse:
+    def __init__(self):
+        self.basedir = path.dirname(path.abspath(__file__))
+        self.dlldir = path.join(self.basedir, 'ghub_mouse.dll')
+        self.gm = CDLL(self.dlldir)
+        self.gmok = self.gm.mouse_open()
+
+    @staticmethod
+    def _ghub_SendInput(*inputs):
+        nInputs = len(inputs)
+        LPINPUT = INPUT * nInputs
+        pInputs = LPINPUT(*inputs)
+        cbSize = c_int(sizeof(INPUT))
+        return windll.user32.SendInput(nInputs, pInputs, cbSize)
+
+    @staticmethod
+    def _ghub_Input(structure):
+        return INPUT(0, _INPUTunion(mi=structure))
+
+    @staticmethod
+    def _ghub_MouseInput(flags, x, y, data):
+        return MOUSEINPUT(x, y, data, flags, 0, None)
+
+    @staticmethod
+    def _ghub_Mouse(flags, x=0, y=0, data=0):
+        return GhubMouse._ghub_Input(GhubMouse._ghub_MouseInput(flags, x, y, data))
+
+    def mouse_xy(self, x, y):
+        if self.gmok:
+            return self.gm.moveR(x, y)
+        return self._ghub_SendInput(self._ghub_Mouse(0x0001, x, y))
+
+    def mouse_down(self, key=1):
+        if self.gmok:
+            return self.gm.press(key)
+        if key == 1:
+            return self._ghub_SendInput(self._ghub_Mouse(0x0002))
+        elif key == 2:
+            return self._ghub_SendInput(self._ghub_Mouse(0x0008))
+
+    def mouse_up(self, key=1):
+        if self.gmok:
+            return self.gm.release()
+        if key == 1:
+            return self._ghub_SendInput(self._ghub_Mouse(0x0004))
+        elif key == 2:
+            return self._ghub_SendInput(self._ghub_Mouse(0x0010))
+
+    def mouse_close(self):
+        if self.gmok:
+            return self.gm.mouse_close()
+
+LONG = c_long
+DWORD = c_ulong
+ULONG_PTR = POINTER(DWORD)
+            
+class MOUSEINPUT(Structure):
+    _fields_ = (('dx', LONG),
+                ('dy', LONG),
+                ('mouseData', DWORD),
+                ('dwFlags', DWORD),
+                ('time', DWORD),
+                ('dwExtraInfo', ULONG_PTR))
+
+class _INPUTunion(Union):
+    _fields_ = (('mi', MOUSEINPUT),)
+
+class INPUT(Structure):
+    _fields_ = (('type', DWORD),
+                ('union', _INPUTunion))
+    
+gHub = GhubMouse()