Python Colorbot Hız ve İsabet Nasıl Ayarlanır?

[bloodsea5454]

Merhaba beyler ve bayanlar valorant için bir colorbot yapıyorum ama bazı sorunlarım var ilk önce kodu şöyle gösteriyim -->

import struct
from multiprocessing import shared_memory
import time

def read_shm_and_move_mouse():

    input_width = 99  # Giriş çözünürlüğü genişliği
    input_height = 99  # Giriş çözünürlüğü yüksekliği
    screen_width = 1920  # Gerçek ekran genişliği
    screen_height = 1080  # Gerçek ekran yüksekliği

    REFERENCE_DPI = 1600
    REFERENCE_SENSITIVITY = 4.5
    REFERENCE_CODE_PIXELS = 1000
    REFERENCE_GAME_PIXELS = 446

    # Kullanıcı ayarları
    current_dpi = 1600
    current_sensitivity = 0.4

    game_pixels = REFERENCE_GAME_PIXELS * (current_sensitivity / REFERENCE_SENSITIVITY)
    scale_ratio = REFERENCE_CODE_PIXELS / game_pixels

    center_screen_x = screen_width // 2
    center_screen_y = screen_height // 2

    previous_data = None

    try:
        shm = shared_memory.SharedMemory(name="shm_xywh")
        print("Paylaşımlı bellek bağlandı!")

        while True:
            data = bytes(shm.buf[:16])
            if any(data):
                try:
                    x, y, w, h = struct.unpack("4i", data)

                    if previous_data is None or previous_data == (x, y, w, h):
                        previous_data = (x, y, w, h)
                        continue

                    center_x = round(x + w / 2)
                    center_y = round(y + h / 2 - (h * 0.4))

                    scaled_x = center_x * (screen_width / input_width)
                    scaled_y = center_y * (screen_height / input_height)

                    delta_x = -int((center_screen_x - scaled_x) / scale_ratio)
                    delta_y = -int((center_screen_y - scaled_y) / scale_ratio)

                    delta_x = int(delta_x * 0.9)
                    delta_y = int(delta_y * 0.9)

                    print(f"Delta hesaplandı: delta_x={delta_x}, delta_y={delta_y}")

                    send_mouse_movements(delta_x, delta_y)

                    previous_data = (x, y, w, h)

                except struct.error:
                    print("Veri yapısı hatalı, atlanıyor...")

    except FileNotFoundError:
        print("Paylaşımlı bellek bulunamadı!")
    except Exception as e:
        print(f"Bir hata oluştu: {e}")
    finally:
        shm.close()

def send_mouse_movements(delta_x, delta_y):

    step_size = 127

    while delta_x != 0 or delta_y != 0:
        step_x = max(-step_size, min(step_size, delta_x))
        step_y = max(-step_size, min(step_size, delta_y))

        move_mouse(step_x, step_y)

        delta_x -= step_x
        delta_y -= step_y

def move_mouse(delta_x, delta_y):

    hid_device = "/dev/hidg0"

    try:
        with open(hid_device, 'wb') as device:
            report = struct.pack("bbbb", 0x00, delta_x, delta_y, 0x00)
            device.write(report)
            print(f"Mouse hareket ettirildi: delta_x={delta_x}, delta_y={delta_y}")

            report = struct.pack("bbbb", 0x00, 0x00, 0x00, 0x00)
            device.write(report)

    except Exception as e:
        print(f"HID cihazına veri gönderilemedi: {e}")

if __name__ == "__main__":
    read_shm_and_move_mouse()

kod bu şekilde mantığı basit zaten ama sorun şurda mouseyi hızlandırmak için delta_x ve y deki çarpanı 0.1 ile 0.4 arasında tuttuğumda hedefi tam isabet bulabiliyor ama 0.4 üstüne çıktığımda hedefi 1-2 adım ıskalamaya başlıyor yani nasıl hem çok hızlı olup hem de nasıl çok isabetli olucak şekilde düzenleyebilirim teşekkürler şimdiden yardımcı olucaklar için

 

[Zestial]

Hedef kaçırıldığında, kaymanın ortalama büyüklüğünü kaydedip ve düzeltici kod dizini ekleyebilirsin.

Örn kod:

if abs(delta_x) < threshold and abs(delta_y) < threshold:
    send_mouse_movements(delta_x, delta_y)

 

[bloodsea5454]

Hedef kaçırıldığında, kaymanın ortalama büyüklüğünü kaydedip ve düzeltici kod dizini ekleyebilirsin.

Örn kod:

if abs(delta_x) < threshold and abs(delta_y) < threshold:
    send_mouse_movements(delta_x, delta_y)

evet aklıma geldi ama işte zaten hedef kaçtıktan sonra 2. adımda ve en kötü 3. adımda hedefi buluyor ama işte ortalama alma gibi bir kod eklediğim zaman bu sefer düşman hareketlendiğinde düşmana yetişemiyor ve ilk adımda düşmanı bulmamız gerekiyor yani diğer hilelere baktığımda bunun gibi sorunlar yaşamıyorlar o yüzden çözümü olduğunu biliyorum ama işte önemli olan o çözümü bulmak

 

[Zestial]

evet aklıma geldi ama işte zaten hedef kaçtıktan sonra 2. adımda ve en kötü 3. adımda hedefi buluyor ama işte ortalama alma gibi bir kod eklediğim zaman bu sefer düşman hareketlendiğinde düşmana yetişemiyor ve ilk adımda düşmanı bulmamız gerekiyor yani diğer hilelere baktığımda bunun gibi sorunlar yaşamıyorlar o yüzden çözümü olduğunu biliyorum ama işte önemli olan o çözümü bulmak

Lineer predict modeli yerine daha geniş kapsamlı bayes filter tarzı bir model deneyebilirsin. Tabii yazılım daha karmaşık bir hal aldıkça Python yavaş kalabilir.

 

[#Adc Main]

import struct
import time
import random
import sys

def read_shm_and_move_mouse():
    input_width = 99
    input_height = 99
    screen_width = 1920
    screen_height = 1080

    REFERENCE_DPI = 1600
    REFERENCE_SENSITIVITY = 4.5
    REFERENCE_CODE_PIXELS = 1000
    REFERENCE_GAME_PIXELS = 446

   
    current_dpi = 1600
    current_sensitivity = 0.4

    game_pixels = REFERENCE_GAME_PIXELS * (current_sensitivity / REFERENCE_SENSITIVITY)
    scale_ratio = REFERENCE_CODE_PIXELS / game_pixels

    center_screen_x = screen_width // 2
    center_screen_y = screen_height // 2

    previous_data = None

    try:
        shm = open_shared_memory("shm_xywh")
        print("Paylaşımlı bellek bağlandı!")

        while True:
            data = read_shared_data(shm)
            if data:
                try:
                    x, y, w, h = struct.unpack("4i", data)

                    if previous_data is None or previous_data == (x, y, w, h):
                        previous_data = (x, y, w, h)
                        continue

                    center_x = round(x + w / 2)
                    center_y = round(y + h / 2 - (h * 0.4))

                    scaled_x = center_x * (screen_width / input_width)
                    scaled_y = center_y * (screen_height / input_height)

                    delta_x = -int((center_screen_x - scaled_x) / scale_ratio)
                    delta_y = -int((center_screen_y - scaled_y) / scale_ratio)

                 
                    delta_x, delta_y = adjust_speed(delta_x, delta_y)

                    send_mouse_movements(delta_x, delta_y)

                    previous_data = (x, y, w, h)

                except struct.error:
                    print("Veri yapısı hatalı, atlanıyor...")

    except Exception as e:
        print(f"Bir hata oluştu: {e}")
    finally:
        close_shared_memory(shm)

def adjust_speed(delta_x, delta_y, max_speed=0.4):
    step_size = 127

   
    speed_factor = max(0.1, min(max_speed, 1.0))
    delta_x = int(delta_x * speed_factor)
    delta_y = int(delta_y * speed_factor)

 
    if abs(delta_x) < step_size and abs(delta_y) < step_size:
        speed_factor = 0.2

    delta_x = int(delta_x * speed_factor)
    delta_y = int(delta_y * speed_factor)

    return delta_x, delta_y

def send_mouse_movements(delta_x, delta_y):
    step_size = 127

    while delta_x != 0 or delta_y != 0:
        step_x = max(-step_size, min(step_size, delta_x))
        step_y = max(-step_size, min(step_size, delta_y))

        move_mouse(step_x, step_y)

        delta_x -= step_x
        delta_y -= step_y

def move_mouse(delta_x, delta_y):
   
    hid_device = "/dev/hidg0"

    try:
        with open(hid_device, 'wb') as device:
            report = struct.pack("bbbb", 0x00, delta_x, delta_y, 0x00)
            device.write(report)

           
            report = struct.pack("bbbb", 0x00, 0x00, 0x00, 0x00)
            device.write(report)

    except Exception as e:
        print(f"HID cihazına veri gönderilemedi: {e}")

def open_shared_memory(name):
   
    try:
        shm = open(name, "rb")
        return shm
    except Exception as e:
        print(f"Paylaşımlı bellek açılamadı: {e}")
        sys.exit(1)

def read_shared_data(shm):
   
    try:
        data = shm.read(16)
        return data
    except Exception as e:
        print(f"Veri okunamadı: {e}")
        return None

def close_shared_memory(shm):
   
    try:
        shm.close()
    except Exception as e:
        print(f"Paylaşımlı bellek kapatılamadı: {e}")

if __name__ == "__main__":
    read_shm_and_move_mouse()

 

[MAJORR]

PID kontrolcüsü gibi bir algoritma kullanabilirsiniz. Bu algoritma hedef nokta ile fare pozisyonu arasındaki farkı dengeleyerek hareketi optimize eder

python :

def pid_control(error, prev_error, integral, kp=0.6, ki=0.3, kd=0.1):
proportional = kp * error
integral += ki * error
derivative = kd * (error - prev_error)
return proportional + integral + derivative, integral

Fare hareketini şu şekilde güncelleyebilirsiniz:

python :

error_x = center_screen_x - scaled_x
error_y = center_screen_y - scaled_y
delta_x, integral_x = pid_control(error_x, prev_error_x, integral_x)
delta_y, integral_y = pid_control(error_y, prev_error_y, integral_y)

 

[cocukadam64]

knka özelden birşey yazdım bakabilir misin sana zahmet

 

[bloodsea5454]

Lineer predict modeli yerine daha geniş kapsamlı bayes filter tarzı bir model deneyebilirsin. Tabii yazılım daha karmaşık bir hal aldıkça Python yavaş kalabilir.

import struct
from multiprocessing import shared_memory
import numpy as np
from filterpy.kalman import KalmanFilter
import time

def read_shm_and_move_mouse():
    input_width = 99  # Giriş çözünürlüğü genişliği
    input_height = 99  # Giriş çözünürlüğü yüksekliği
    screen_width = 1920  # Gerçek ekran genişliği
    screen_height = 1080  # Gerçek ekran yüksekliği

    REFERENCE_DPI = 1600
    REFERENCE_SENSITIVITY = 4.5
    REFERENCE_CODE_PIXELS = 1000
    REFERENCE_GAME_PIXELS = 446

    # Kullanıcı ayarları
    current_dpi = 1600
    current_sensitivity = 0.4

    game_pixels = REFERENCE_GAME_PIXELS * (current_sensitivity / REFERENCE_SENSITIVITY)
    scale_ratio = REFERENCE_CODE_PIXELS / game_pixels

    center_screen_x = screen_width // 2
    center_screen_y = screen_height // 2

    previous_data = None

    # Kalman filtresi
    kf = KalmanFilter(dim_x=4, dim_z=2)
    kf.x = np.array([0., 0., 0., 0.])
    speed_factor = 2.9 # Hız Ayarlama
    dt = 1.0 / 60.0
    kf.F = np.array([[1, 0, dt,  0],
                     [0, 1,  0, dt],
                     [0, 0,  1,  0],
                     [0, 0,  0,  1]])
    kf.H = np.array([[1, 0, 0, 0],
                     [0, 1, 0, 0]])
    kf.R = np.eye(2) * (5 * speed_factor)  # Ölçüm gürültüsü
    kf.Q = np.eye(4) * (0.1 * speed_factor)  # Hareket gürültüsü
    kf.P = np.eye(4) * 100

    try:
        shm = shared_memory.SharedMemory(name="shm_xywh")
        print("Paylaşımlı bellek bağlandı!")

        while True:
            data = bytes(shm.buf[:16])
            if any(data):
                try:
                    x, y, w, h = struct.unpack("4i", data)

                    if previous_data is None or previous_data == (x, y, w, h):
                        previous_data = (x, y, w, h)
                        continue

                    center_x = round(x + w / 2)
                    center_y = round(y + h / 2 - (h * 0.4))

                    kf.predict()
                    kf.update([center_x, center_y])

                    filtered_x, filtered_y = kf.x[:2]

                    scaled_x = filtered_x * (screen_width / input_width)
                    scaled_y = filtered_y * (screen_height / input_height)

                    delta_x = -int((center_screen_x - scaled_x) / scale_ratio)
                    delta_y = -int((center_screen_y - scaled_y) / scale_ratio)

                    delta_x = int(delta_x * min(1.0, speed_factor / 2))
                    delta_y = int(delta_y * min(1.0, speed_factor / 2))

                    print(f"Delta hesaplandı: delta_x={delta_x}, delta_y={delta_y}")

                    send_mouse_movements(delta_x, delta_y)

                    previous_data = (x, y, w, h)

                except struct.error:
                    print("Veri yapısı hatalı, atlanıyor...")

    except FileNotFoundError:
        print("Paylaşımlı bellek bulunamadı!")
    except Exception as e:
        print(f"Bir hata oluştu: {e}")
    finally:
        shm.close()

def send_mouse_movements(delta_x, delta_y):
    step_size = 127

    while delta_x != 0 or delta_y != 0:
        step_x = max(-step_size, min(step_size, delta_x))
        step_y = max(-step_size, min(step_size, delta_y))

        move_mouse(step_x, step_y)

        delta_x -= step_x
        delta_y -= step_y

def move_mouse(delta_x, delta_y):
    hid_device = "/dev/hidg0"

    try:
        with open(hid_device, 'wb') as device:
            report = struct.pack("bbbb", 0x00, delta_x, delta_y, 0x00)
            device.write(report)
            print(f"Mouse hareket ettirildi: delta_x={delta_x}, delta_y={delta_y}")

            report = struct.pack("bbbb", 0x00, 0x00, 0x00, 0x00)
            device.write(report)

    except Exception as e:
        print(f"HID cihazına veri gönderilemedi: {e}")

if __name__ == "__main__":
    read_shm_and_move_mouse()

hocam dediğiniz tarza olan en iyi olucağını düşündüğüm kalman filteri denedim ama yine hedefi geçiyor aşağıda linki paylaşıyorum (videodaki kodlar burdaki kodlar değiller ona aldanma lütfen -->

 

[bloodsea5454]

import struct
import time
import random
import sys

def read_shm_and_move_mouse():
    input_width = 99
    input_height = 99
    screen_width = 1920
    screen_height = 1080

    REFERENCE_DPI = 1600
    REFERENCE_SENSITIVITY = 4.5
    REFERENCE_CODE_PIXELS = 1000
    REFERENCE_GAME_PIXELS = 446

  
    current_dpi = 1600
    current_sensitivity = 0.4

    game_pixels = REFERENCE_GAME_PIXELS * (current_sensitivity / REFERENCE_SENSITIVITY)
    scale_ratio = REFERENCE_CODE_PIXELS / game_pixels

    center_screen_x = screen_width // 2
    center_screen_y = screen_height // 2

    previous_data = None

    try:
        shm = open_shared_memory("shm_xywh")
        print("Paylaşımlı bellek bağlandı!")

        while True:
            data = read_shared_data(shm)
            if data:
                try:
                    x, y, w, h = struct.unpack("4i", data)

                    if previous_data is None or previous_data == (x, y, w, h):
                        previous_data = (x, y, w, h)
                        continue

                    center_x = round(x + w / 2)
                    center_y = round(y + h / 2 - (h * 0.4))

                    scaled_x = center_x * (screen_width / input_width)
                    scaled_y = center_y * (screen_height / input_height)

                    delta_x = -int((center_screen_x - scaled_x) / scale_ratio)
                    delta_y = -int((center_screen_y - scaled_y) / scale_ratio)

                
                    delta_x, delta_y = adjust_speed(delta_x, delta_y)

                    send_mouse_movements(delta_x, delta_y)

                    previous_data = (x, y, w, h)

                except struct.error:
                    print("Veri yapısı hatalı, atlanıyor...")

    except Exception as e:
        print(f"Bir hata oluştu: {e}")
    finally:
        close_shared_memory(shm)

def adjust_speed(delta_x, delta_y, max_speed=0.4):
    step_size = 127

  
    speed_factor = max(0.1, min(max_speed, 1.0))
    delta_x = int(delta_x * speed_factor)
    delta_y = int(delta_y * speed_factor)

 
    if abs(delta_x) < step_size and abs(delta_y) < step_size:
        speed_factor = 0.2

    delta_x = int(delta_x * speed_factor)
    delta_y = int(delta_y * speed_factor)

    return delta_x, delta_y

def send_mouse_movements(delta_x, delta_y):
    step_size = 127

    while delta_x != 0 or delta_y != 0:
        step_x = max(-step_size, min(step_size, delta_x))
        step_y = max(-step_size, min(step_size, delta_y))

        move_mouse(step_x, step_y)

        delta_x -= step_x
        delta_y -= step_y

def move_mouse(delta_x, delta_y):
  
    hid_device = "/dev/hidg0"

    try:
        with open(hid_device, 'wb') as device:
            report = struct.pack("bbbb", 0x00, delta_x, delta_y, 0x00)
            device.write(report)

          
            report = struct.pack("bbbb", 0x00, 0x00, 0x00, 0x00)
            device.write(report)

    except Exception as e:
        print(f"HID cihazına veri gönderilemedi: {e}")

def open_shared_memory(name):
  
    try:
        shm = open(name, "rb")
        return shm
    except Exception as e:
        print(f"Paylaşımlı bellek açılamadı: {e}")
        sys.exit(1)

def read_shared_data(shm):
  
    try:
        data = shm.read(16)
        return data
    except Exception as e:
        print(f"Veri okunamadı: {e}")
        return None

def close_shared_memory(shm):
  
    try:
        shm.close()
    except Exception as e:
        print(f"Paylaşımlı bellek kapatılamadı: {e}")

if __name__ == "__main__":
    read_shm_and_move_mouse()

hocam attığınız kodu denedim ama yine aynı şekilde hedef etrafında ya yuvarlak çiziyor ya da es geçiyor video aşağıda -->

PID kontrolcüsü gibi bir algoritma kullanabilirsiniz. Bu algoritma hedef nokta ile fare pozisyonu arasındaki farkı dengeleyerek hareketi optimize eder

python :

def pid_control(error, prev_error, integral, kp=0.6, ki=0.3, kd=0.1):
proportional = kp * error
integral += ki * error
derivative = kd * (error - prev_error)
return proportional + integral + derivative, integral

Fare hareketini şu şekilde güncelleyebilirsiniz:

python :

error_x = center_screen_x - scaled_x
error_y = center_screen_y - scaled_y
delta_x, integral_x = pid_control(error_x, prev_error_x, integral_x)
delta_y, integral_y = pid_control(error_y, prev_error_y, integral_y)

import struct
from multiprocessing import shared_memory
import time

integral_x, integral_y = 0, 0
previous_error_x, previous_error_y = 0, 0

def calculate_pid(delta_x, delta_y, kp=1.5, ki=0.1, kd=0.05, integral_limit=50):
    global integral_x, integral_y, previous_error_x, previous_error_y

    error_x = delta_x
    error_y = delta_y

    integral_x += error_x
    integral_y += error_y

    integral_x = max(-integral_limit, min(integral_x, integral_limit))
    integral_y = max(-integral_limit, min(integral_y, integral_limit))

    derivative_x = error_x - previous_error_x
    derivative_y = error_y - previous_error_y

    output_x = (kp * error_x) + (ki * integral_x) + (kd * derivative_x)
    output_y = (kp * error_y) + (ki * integral_y) + (kd * derivative_y)

    previous_error_x = error_x
    previous_error_y = error_y

    print(f"[PID DEBUG] Input: delta_x={delta_x}, delta_y={delta_y} | Output: output_x={output_x}, output_y={output_y}")

    return output_x, output_y

def read_shm_and_move_mouse():
    input_width = 99  # Giriş çözünürlüğü genişliği
    input_height = 99  # Giriş çözünürlüğü yüksekliği
    screen_width = 1920  # Gerçek ekran genişliği
    screen_height = 1080  # Gerçek ekran yüksekliği

    REFERENCE_DPI = 1600
    REFERENCE_SENSITIVITY = 4.5
    REFERENCE_CODE_PIXELS = 1000
    REFERENCE_GAME_PIXELS = 446

    current_dpi = 1600
    current_sensitivity = 0.4

    game_pixels = REFERENCE_GAME_PIXELS * (current_sensitivity / REFERENCE_SENSITIVITY)
    scale_ratio = REFERENCE_CODE_PIXELS / game_pixels

    center_screen_x = screen_width // 2
    center_screen_y = screen_height // 2

    previous_data = None

    try:
        shm = shared_memory.SharedMemory(name="shm_xywh")
        print("Paylaşımlı bellek bağlandı!")

        while True:
            data = bytes(shm.buf[:16])
            if any(data):
                try:
                    x, y, w, h = struct.unpack("4i", data)

                    if previous_data is None or previous_data == (x, y, w, h):
                        previous_data = (x, y, w, h)
                        continue

                    center_x = round(x + w / 2)
                    center_y = round(y + h / 2 - (h * 0.4))

                    scaled_x = center_x * (screen_width / input_width)
                    scaled_y = center_y * (screen_height / input_height)

                    delta_x = int((scaled_x - center_screen_x) / scale_ratio)
                    delta_y = int((scaled_y - center_screen_y) / scale_ratio)

                    print(f"Delta hesaplandı: delta_x={delta_x}, delta_y={delta_y}")

                    send_mouse_movements(delta_x, delta_y)

                    previous_data = (x, y, w, h)

                except struct.error:
                    print("Veri yapısı hatalı, atlanıyor...")

    except FileNotFoundError:
        print("Paylaşımlı bellek bulunamadı!")
    except Exception as e:
        print(f"Bir hata oluştu: {e}")
    finally:
        shm.close()

def send_mouse_movements(delta_x, delta_y):

    step_size = 127
    movement_threshold = 1

    while abs(delta_x) > 0 or abs(delta_y) > 0:
        pid_delta_x, pid_delta_y = calculate_pid(delta_x, delta_y)

        step_x = max(-step_size, min(step_size, int(pid_delta_x)))
        step_y = max(-step_size, min(step_size, int(pid_delta_y)))

        if abs(step_x) < movement_threshold and abs(step_y) < movement_threshold:
            break

        step_x = step_x if delta_x >= 0 else -abs(step_x)
        step_y = step_y if delta_y >= 0 else -abs(step_y)

        move_mouse(step_x, step_y)

        delta_x -= step_x
        delta_y -= step_y

        if abs(delta_x) < 1 and abs(delta_y) < 1:
            delta_x = 0
            delta_y = 0

def move_mouse(delta_x, delta_y):

    hid_device = "/dev/hidg0"

    try:
        with open(hid_device, 'wb') as device:
            report = struct.pack("bbbb", 0x00, delta_x, delta_y, 0x00)
            device.write(report)
            print(f"Mouse hareket ettirildi: delta_x={delta_x}, delta_y={delta_y}")

            report = struct.pack("bbbb", 0x00, 0x00, 0x00, 0x00)
            device.write(report)

    except Exception as e:
        print(f"HID cihazına veri gönderilemedi: {e}")

if __name__ == "__main__":
    read_shm_and_move_mouse()

hocam sizin de dediğiniz şekilde pid kontrolcüsü ekledim ama yani hızlandımak için kp sayısını arttırdığım zaman 2 ve üzerinde ilki çok hızlı flickliyor onu görebiliyorum ama ekran full titreme yapıyor zaten ilkinden sonra bir daha sistem de çalışamıyor loopa giriyor kp,ki,kd arasında da bir orantı bulmaya çalıştım ama bulamadım video aşağıdadır --->

 

[MAJORR]

hocam attığınız kodu denedim ama yine aynı şekilde hedef etrafında ya yuvarlak çiziyor ya da es geçiyor video aşağıda -->

import struct
from multiprocessing import shared_memory
import time

integral_x, integral_y = 0, 0
previous_error_x, previous_error_y = 0, 0

def calculate_pid(delta_x, delta_y, kp=1.5, ki=0.1, kd=0.05, integral_limit=50):
    global integral_x, integral_y, previous_error_x, previous_error_y

    error_x = delta_x
    error_y = delta_y

    integral_x += error_x
    integral_y += error_y

    integral_x = max(-integral_limit, min(integral_x, integral_limit))
    integral_y = max(-integral_limit, min(integral_y, integral_limit))

    derivative_x = error_x - previous_error_x
    derivative_y = error_y - previous_error_y

    output_x = (kp * error_x) + (ki * integral_x) + (kd * derivative_x)
    output_y = (kp * error_y) + (ki * integral_y) + (kd * derivative_y)

    previous_error_x = error_x
    previous_error_y = error_y

    print(f"[PID DEBUG] Input: delta_x={delta_x}, delta_y={delta_y} | Output: output_x={output_x}, output_y={output_y}")

    return output_x, output_y

def read_shm_and_move_mouse():
    input_width = 99  # Giriş çözünürlüğü genişliği
    input_height = 99  # Giriş çözünürlüğü yüksekliği
    screen_width = 1920  # Gerçek ekran genişliği
    screen_height = 1080  # Gerçek ekran yüksekliği

    REFERENCE_DPI = 1600
    REFERENCE_SENSITIVITY = 4.5
    REFERENCE_CODE_PIXELS = 1000
    REFERENCE_GAME_PIXELS = 446

    current_dpi = 1600
    current_sensitivity = 0.4

    game_pixels = REFERENCE_GAME_PIXELS * (current_sensitivity / REFERENCE_SENSITIVITY)
    scale_ratio = REFERENCE_CODE_PIXELS / game_pixels

    center_screen_x = screen_width // 2
    center_screen_y = screen_height // 2

    previous_data = None

    try:
        shm = shared_memory.SharedMemory(name="shm_xywh")
        print("Paylaşımlı bellek bağlandı!")

        while True:
            data = bytes(shm.buf[:16])
            if any(data):
                try:
                    x, y, w, h = struct.unpack("4i", data)

                    if previous_data is None or previous_data == (x, y, w, h):
                        previous_data = (x, y, w, h)
                        continue

                    center_x = round(x + w / 2)
                    center_y = round(y + h / 2 - (h * 0.4))

                    scaled_x = center_x * (screen_width / input_width)
                    scaled_y = center_y * (screen_height / input_height)

                    delta_x = int((scaled_x - center_screen_x) / scale_ratio)
                    delta_y = int((scaled_y - center_screen_y) / scale_ratio)

                    print(f"Delta hesaplandı: delta_x={delta_x}, delta_y={delta_y}")

                    send_mouse_movements(delta_x, delta_y)

                    previous_data = (x, y, w, h)

                except struct.error:
                    print("Veri yapısı hatalı, atlanıyor...")

    except FileNotFoundError:
        print("Paylaşımlı bellek bulunamadı!")
    except Exception as e:
        print(f"Bir hata oluştu: {e}")
    finally:
        shm.close()

def send_mouse_movements(delta_x, delta_y):

    step_size = 127
    movement_threshold = 1

    while abs(delta_x) > 0 or abs(delta_y) > 0:
        pid_delta_x, pid_delta_y = calculate_pid(delta_x, delta_y)

        step_x = max(-step_size, min(step_size, int(pid_delta_x)))
        step_y = max(-step_size, min(step_size, int(pid_delta_y)))

        if abs(step_x) < movement_threshold and abs(step_y) < movement_threshold:
            break

        step_x = step_x if delta_x >= 0 else -abs(step_x)
        step_y = step_y if delta_y >= 0 else -abs(step_y)

        move_mouse(step_x, step_y)

        delta_x -= step_x
        delta_y -= step_y

        if abs(delta_x) < 1 and abs(delta_y) < 1:
            delta_x = 0
            delta_y = 0

def move_mouse(delta_x, delta_y):

    hid_device = "/dev/hidg0"

    try:
        with open(hid_device, 'wb') as device:
            report = struct.pack("bbbb", 0x00, delta_x, delta_y, 0x00)
            device.write(report)
            print(f"Mouse hareket ettirildi: delta_x={delta_x}, delta_y={delta_y}")

            report = struct.pack("bbbb", 0x00, 0x00, 0x00, 0x00)
            device.write(report)

    except Exception as e:
        print(f"HID cihazına veri gönderilemedi: {e}")

if __name__ == "__main__":
    read_shm_and_move_mouse()

hocam sizin de dediğiniz şekilde pid kontrolcüsü ekledim ama yani hızlandımak için kp sayısını arttırdığım zaman 2 ve üzerinde ilki çok hızlı flickliyor onu görebiliyorum ama ekran full titreme yapıyor zaten ilkinden sonra bir daha sistem de çalışamıyor loopa giriyor kp,ki,kd arasında da bir orantı bulmaya çalıştım ama bulamadım video aşağıdadır --->

​

dene bakalım bunu bir de ekleyip hedefe yaklaştıkça delta değerlerini daha küçük adımlarla güncellemek aşmayı önlüyor

proximity_threshold = 10 # Piksel cinsinden yakınlık eşiği
if abs(delta_x) < proximity_threshold and abs(delta_y) < proximity_threshold:
delta_x = int(delta_x * 0.5)
delta_y = int(delta_y * 0.5)

 

[bloodsea5454]

​

dene bakalım bunu bir de ekleyip hedefe yaklaştıkça delta değerlerini daha küçük adımlarla güncellemek aşmayı önlüyor

proximity_threshold = 10 # Piksel cinsinden yakınlık eşiği
if abs(delta_x) < proximity_threshold and abs(delta_y) < proximity_threshold:
delta_x = int(delta_x * 0.5)
delta_y = int(delta_y * 0.5)

hocam o dediğinizi de denedim kp 2 iken thresholdu 30 ayarladığımda titreme kesiliyor ama şöyle bir şey var yani kp 2 threshold 30 daki hız = kp 1.5 threshold 0 ile aynı hıza denk geliyor yani hız artışı yaşayamıyorum yine threshold 30 da iken kp 3 yaptığımda yine titremeye başlıyor orantılı arttırsam da yine hız her zaman kp 1.5 threshold 0 halideki hızına eşit geliyor algılamada bir sorun mu var diye baktım ama onda da hiçbir sorun yok fps de gayet yeterli düzeyde (90-110) ne yapabiliriz sizce? rahat bu sorun için 3-4 haftadır uğraşıyorum ama hala bir çözüm bulamadım