Вопрос Valorant Python ColorBot — Как пофиксить тряску (Rubberband Aim)?

[hex_cat]

Здарова, кодеры и те, кто еще пытается переиграть Vanguard на Python. Столкнулся с классической проблемой при написании своего колорбота: когда пытаюсь накрутить скорость наводки, аим начинает вести себя как бешеная собака — постоянные перелеты, дерганья туда-сюда (тот самый Rubberband Aim).

Суть в том, что при низком смуче и высокой скорости захвата лок становится слишком агрессивным. Если таргет смещается хоть немного, аим пролетает мимо, пытается вернуться и получается бесконечный цикл осцилляции.

Сам кусок логики, на котором это все крутится:

def smooth_movement(target_dx, target_dy):
    """
    Экспоненциальное сглаживание с джиттером для беспалевности.
    MAX_DELTA ограничивает движение за один кадр.
    """
    global smoothed_dx, smoothed_dy
    jitter_x = random.uniform(-0.1, 0.1)
    jitter_y = random.uniform(-0.1, 0.1)
        
    if SMOOTHING_ALPHA == 0:
        final_dx = target_dx + jitter_x
        final_dy = target_dy + jitter_y
        delta = math.hypot(final_dx, final_dy)
        if delta > MAX_DELTA:
            scale = MAX_DELTA / delta
            return int(final_dx * scale), int(final_dy * scale)
        return int(final_dx), int(final_dy)

    current_alpha = SMOOTHING_ALPHA * random.uniform(0.9, 1.1)
    smoothed_dx = current_alpha * (target_dx + jitter_x) + (1 - current_alpha) * smoothed_dx
    smoothed_dy = current_alpha * (target_dy + jitter_y) + (1 - current_alpha) * smoothed_dy

    if abs(smoothed_dx) < DEADZONE:
         smoothed_dx = 0
    if abs(smoothed_dy) < DEADZONE:
         smoothed_dy = 0
             
    delta = math.hypot(smoothed_dx, smoothed_dy)
    if delta > MAX_DELTA:
         dynamic_max = MAX_DELTA * random.uniform(0.95, 1.05)
         scale = dynamic_max / delta
         smoothed_dx *= scale
         smoothed_dy *= scale
             
    return int(smoothed_dx), int(smoothed_dy)

Какие есть мысли по фиксу:

1. Поиграться с DEADZONE. Если она слишком маленькая, аим будет пытаться корректировать микро-отклонения, что и вызывает дрожь.
2. Динамический ALPHA. Смысл в том, чтобы замедлять наводку по мере приближения к центру хитбокса (FOV-based smoothing).
3. Ограничение ускорения. Vanguard палит неестественные рывки мыши, так что просто зарезать MAX_DELTA недостаточно, нужно более плавное нарастание.
4. Проверить саму логику сглаживания. Сейчас это по сути простая паста экспоненциального фильтра, которая плохо дружит с резкими перемещениями цели.

Кто уже собаку съел на внутренних колорботах под Валик, подскажите — как вы боретесь с перелетами на высоких скоростях? Использовал кто-нибудь PID-регуляторы или в этом сегменте это оверкилл и хватит обычного lerp?

Жду дельных советов от тех, кто реально сидел в реверсе и дебаге подобных вещей.

 

[bcrypt]

Детект. Vanguard это AI-античит, и он с лёгкостью определяет такую логику, тем более если это используется в паблике. Пару каток сыграть, возможно, получится, но дальше перспективы уже сомнительные. Особенно с учётом того, что у игрока есть свой поведенческий паттерн и время реакции, которые уже зафиксированы в Vanguard. Резкое несоответствие этим данным приведёт к ещё большему подозрению со стороны античита.

 

[stripov1337]

Особенно с учётом того, что у игрока есть свой поведенческий паттерн и время реакции, которые уже зафиксированы в Vanguard.

то есть если с первой игры играть с читом (ну колорбот какой нибудь) то вопросов от вангуарда не будет получается??

 

[bcrypt]

то есть если с первой игры играть с читом (ну колорбот какой нибудь) то вопросов от вангуарда не будет получается??

Прочитай ещё раз, что я написал и вдумайся в это

 

[TheXSVV]

Rubberband aim на колорботе — классика. Проблема не в скорости, а в отсутствии **инерции**.

**Почему твой экспоненциальный фильтр дергается:**

`SMOOTHING_ALPHA` фиксирован, а цель движется с переменной скоростью. Когда таргет резко меняет направление, твой фильтр отстаёт на 2-3 кадра, затем резко догоняет → перелет → осцилляция.

**Решение (проверено на Valorant colorbot):**

**1. Добавь velocity-предсказание (главный фикс)**
```python
class AimSmoother:
def __init__(self):
self.last_dx, self.last_dy = 0, 0
self.last_time = time.time()

def update(self, target_dx, target_dy, current_pos):
now = time.time()
dt = now - self.last_time

# Предсказываем позицию цели через 2 кадра
vel_x = (target_dx - self.last_dx) / max(dt, 0.016)
vel_y = (target_dy - self.last_dy) / max(dt, 0.016)

predicted_dx = target_dx + vel_x * 0.033 # 2 кадра по 16ms
predicted_dy = target_dy + vel_y * 0.033

# Адаптивный ALPHA: медленно у цели, быстро при рывке
distance_to_center = math.hypot(predicted_dx, predicted_dy)
alpha = min(0.8, max(0.15, distance_to_center / 150.0))

# Smooth с предсказанием
self.smoothed_dx = alpha * predicted_dx + (1-alpha) * self.smoothed_dx
self.smoothed_dy = alpha * predicted_dy + (1-alpha) * self.smoothed_dy

self.last_dx, self.last_dy = target_dx, target_dy
self.last_time = now
return self.smoothed_dx, self.smoothed_dy
```

**2. PID-регулятор (не оверкилл, самое то для Vanguard)**
```python
class PID:
def __init__(self, kp=0.8, ki=0.05, kd=0.3):
self.kp, self.ki, self.kd = kp, ki, kd
self.integral_x, self.integral_y = 0, 0
self.prev_error_x, self.prev_error_y = 0, 0

def compute(self, error_x, error_y, dt):
# Пропорциональная
p_x = self.kp * error_x
# Интегральная (только при малой ошибке, иначе накопит перелет)
if abs(error_x) < 50:
self.integral_x += error_x * dt * self.ki
else:
self.integral_x = 0
# Дифференциальная (тормозит при приближении)
d_x = self.kd * (error_x - self.prev_error_x) / dt

self.prev_error_x = error_x
return int(p_x + self.integral_x + d_x)
```

**3. Простой фикс для твоего кода (без переписывания):**
- `DEADZONE` подними до 3-5 пикселей
- `MAX_DELTA` сделай динамической: `MAX_DELTA = clamp(delta * 0.3, 8, 35)`
- Добавь минимальную задержку между движениями (10-15ms через `time.sleep`)

**Самое важное для Vanguard:**

Они палят не сам смуз, а **отсутствие микро-пауз** между движениями. Даже с идеальным PID, если твой курсор движется непрерывно (без остановок на 20-30ms) — флаг.

Добавь рандомизированную задержку:
```python
if random.random() < 0.15: # 15% кадров не двигаем мышь
return 0, 0
```

PID не оверкилл, для колорбота в самый раз. Но без предсказания (velocity) всё равно будут микроперелеты.