Hello everyone! Just yesterday, they posted another color aimbot for Valorant, but this source is interesting because it comes with a spoofer and bypass. As the author said, it only works with Razer mice and Synapse 3. But that's not so important; the main thing is the functionality, which can be adjusted for your own mouse. Author: Mafia4321x.
Why do you need a spoofer (bypass) in Valorant?
If you've already been banned by HWID, then that's exactly what it's for. Because if you just log in from the same computer again into the game with a new account, you'll get an automatic ban. Without spoofing your PC, you won't be able to play Valorant. Also, spoofers are used to test cheats. To avoid banning your own HWID, you can use a temporary one, test it, and turn it off.
The bypass helps to avoid detection by Vanguard. It masks the code and changes identifiers so it's harder to detect.
What’s in the hack?
- Selection of radius (FOV). You can choose the size of the aiming distance.
- Keybinds. You can assign keys for functions.
- Color selection for aiming: optimized for specific game conditions.
- Works with popular mice, and if needed, it can be adapted to your own.
- Includes a spoofer and bypass, which help bypass bans and anti-cheat.
- Open-source code, so you can modify it for yourself.
Source code:
Python:
import uuid
import json
import random
import os
import time
import re
UUID_PATTERN = r'UUID = "([a-f0-9]{32})"'
NUMBER_PATTERN = r'#[0-9]+'
# Function to generate random number strings
def random_number_string(match=None):
return f"#{random.randint(1000000000000000000000, 9999999999999999999999)}"
# Function to generate multiple random number strings
def random_number_lines(num_lines=5):
return "\n".join(random_number_string() for _ in range(num_lines))
def ensure_uuid_and_numbers_in_file(filename, num_lines=5):
try:
with open(filename, "r") as f:
content = f.read()
new_uuid = uuid.uuid4().hex
number_lines = random_number_lines(num_lines)
# Ensure UUIDs are at the beginning and end of the file
if not re.search(UUID_PATTERN, content):
new_content = f'{number_lines}\nUUID = "{new_uuid}"\n{content}\nUUID = "{new_uuid}"\n{number_lines}'
with open(filename, "w") as f:
f.write(new_content)
print(f"Added new UUID and numbers to {filename}: {new_uuid}")
else:
content_lines = content.split('\n')
updated_content = []
# Ensure random numbers at the beginning
if not all(re.search(NUMBER_PATTERN, line) for line in content_lines[:num_lines]):
updated_content.append(number_lines)
updated_content.extend(content_lines)
# Ensure random numbers at the end
if not all(re.search(NUMBER_PATTERN, line) for line in content_lines[-num_lines:]):
updated_content.append(number_lines)
# Replace UUID in the file content
new_uuid_str = f'UUID = "{new_uuid}"'
content_new = re.sub(UUID_PATTERN, new_uuid_str, "\n".join(updated_content))
with open(filename, "w") as f:
f.write(content_new)
print(f"Ensured UUID and numbers in {filename}")
except Exception as e:
print(f"Error ensuring UUID and numbers in {filename}: {e}")
def updateUUID_and_numbers_in_file(filename, new_uuid, num_lines=5):
try:
with open(filename, "r") as f:
content = f.read()
new_uuid_str = f'UUID = "{new_uuid}"'
number_lines = random_number_lines(num_lines)
content_new = re.sub(UUID_PATTERN, new_uuid_str, content)
lines = content_new.split('\n')
updated_content = []
# Ensure random numbers at the beginning
if not all(re.search(NUMBER_PATTERN, line) for line in lines[:num_lines]):
updated_content.append(number_lines)
updated_content.extend(lines)
# Ensure random numbers at the end
if not all(re.search(NUMBER_PATTERN, line) for line in lines[-num_lines:]):
updated_content.append(number_lines)
content_new = "\n".join(updated_content)
with open(filename, "w") as f:
f.write(content_new)
print(f"Done! New UUID and numbers for {filename}: {new_uuid}")
except Exception as e:
print(f"Error updating UUID and numbers in {filename}: {e}")
# Function to replace any number starting with '#' with random 20-digit number
def replace_numbers_in_file(filename):
try:
with open(filename, "r") as f:
content = f.read()
# Replace any line starting with '#' followed by numbers with a random 20-digit number
content_new = re.sub(r'#[0-9]+', random_number_string, content)
with open(filename, "w") as f:
f.write(content_new)
print(f"Replaced all numbers starting with '#' in {filename}")
except Exception as e:
print(f"Error replacing numbers in {filename}: {e}")
# Main function to manage the spoofing and config updates
def main():
operagx_file = 'Spotify.py'
ensure_uuid_and_numbers_in_file(operagx_file) # Ensure UUID is in the file
new_uuid = uuid.uuid4().hex
updateUUID_and_numbers_in_file(operagx_file, new_uuid) # Update UUID in the file
replace_numbers_in_file(operagx_file) # Replace any numbers starting with '#' with random 20-digit numbers
print("Spoof complete! Spotify.py has been updated.")
if __name__ == '__main__':
main()
Code:
#6060446306475060790527
#3652125955555606423444
#2864442694739693692342
#7769238765567088509175
#8942491578092886761309
#3463658841134657527181
#4872772300869031882271
#3048826134673662942072
#9405846093016526358272
import cv2 as c2
import time as t
import numpy as np
import ctypes as c
import win32api as wapi
import threading as th
import bettercam as bcam
from multiprocessing import Pipe as p, Process as proc
from ctypes import windll as wdl
import os
import json as js
import socket
import pyautogui
# UUID = "d2448d19159e44d7a799992f4b500544"
#1895179017871820750457
#3687788831828447497317
#9261248987611532719907
#3466989354063471134044
# UUID = "d2448d19159e44d7a799992f4b500544"
# Utility to clear the terminal
def cl():
os.system('cls' if os.name == 'nt' else 'clear')
# Function to simulate keyboard events
def kbd_evt(pipe):
keybd_event = wdl.user32.keybd_event
while True:
try:
key = pipe.recv()
if key == b'\x01':
keybd_event(0x4F, 0, 0, 0) # O key press
keybd_event(0x4F, 0, 2, 0) # O key release
except EOFError:
break
# Helper function to send key press
def snd_key_evt(pipe):
pipe.send(b'\x01')
# Function to send coordinates to server
def send_coordinates_to_server(x, y):
try:
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as client_socket:
client_socket.connect(('127.0.0.1', 9999))
coords = {'x': int(x), 'y': int(y)} # Ensure the coordinates are integers
client_socket.sendall(js.dumps(coords).encode('utf-8'))
print(f"Sending coordinates to server: x={x}, y={y}")
except Exception as e:
print(f"Error sending coordinates to server: {e}")
# Triggerbot class
class Trgbt:
def __init__(self, pipe, keybind, fov, hsv_range, shooting_rate, fps, mouse_movement_enabled, color_tolerance):
user32 = wdl.user32
self.WIDTH, self.HEIGHT = user32.GetSystemMetrics(0), user32.GetSystemMetrics(1)
self.size = fov
self.Fov = (
int(self.WIDTH / 2 - self.size),
int(self.HEIGHT / 2 - self.size),
int(self.WIDTH / 2 + self.size),
int(self.HEIGHT / 2 + self.size),
)
self.camera = bcam.create(output_idx=0, region=self.Fov)
self.frame = None
self.keybind = keybind
self.pipe = pipe
self.cmin, self.cmax = hsv_range
self.shooting_rate = shooting_rate
self.frame_duration = 1 / fps # FPS to frame duration in seconds
self.mouse_movement_enabled = mouse_movement_enabled
self.color_tolerance = color_tolerance
self.color_positions = []
self.keybind_pressed = False
def capture_frame(self):
while True:
self.frame = self.camera.grab()
t.sleep(self.frame_duration)
def detect_color(self):
if self.frame is not None:
hsv = c2.cvtColor(self.frame, c2.COLOR_RGB2HSV)
min_hue = max(0, self.cmin[0] - self.color_tolerance)
min_saturation = max(0, self.cmin[1] - self.color_tolerance)
min_value = max(0, self.cmin[2] - self.color_tolerance)
max_hue = min(255, self.cmax[0] + self.color_tolerance)
max_saturation = min(255, self.cmax[1] + self.color_tolerance)
max_value = min(255, self.cmax[2] + self.color_tolerance)
cmin_adjusted = np.array([min_hue, min_saturation, min_value], dtype=np.uint8)
cmax_adjusted = np.array([max_hue, max_saturation, max_value], dtype=np.uint8)
mask = c2.inRange(hsv, cmin_adjusted, cmax_adjusted)
contours, _ = c2.findContours(mask, c2.RETR_EXTERNAL, c2.CHAIN_APPROX_SIMPLE)
detected_positions = []
for contour in contours:
if len(contour) > 0:
x, y, w, h = c2.boundingRect(contour)
detected_positions.append((x + w // 2, y + h // 2))
return detected_positions
return []
def shooting_logic(self):
while True:
if wapi.GetAsyncKeyState(self.keybind) < 0:
self.keybind_pressed = True
self.color_positions = self.detect_color()
if self.color_positions:
snd_key_evt(self.pipe)
t.sleep(self.shooting_rate / 1000) # Shooting rate in seconds
else:
self.keybind_pressed = False
t.sleep(0.001)
def mouse_movement_logic(self):
while True:
if self.mouse_movement_enabled and self.keybind_pressed and self.color_positions:
start_x, start_y = pyautogui.position()
closest_position = None
min_distance = float('inf')
for target_x, target_y in self.color_positions:
distance = abs(target_x - start_x) + abs(target_y - start_y)
if distance < min_distance:
min_distance = distance
closest_position = (target_x, target_y)
if closest_position:
target_x, target_y = closest_position
new_x = target_x
new_y = target_y
num_steps = 20
for i in range(1, num_steps + 1):
if not self.keybind_pressed:
break
interpolated_x = start_x + (new_x - start_x) * i / num_steps
interpolated_y = start_y + (new_y - start_y) * i / num_steps
c.windll.user32.SetCursorPos(int(interpolated_x), int(interpolated_y))
t.sleep(self.frame_duration / 2)
if self.keybind_pressed:
send_coordinates_to_server(new_x, new_y)
t.sleep(0.001)
#8991806895508426439874
#7374961568565652387389
#5802269634033866582833
#8245862776418077575610
# Config saving and loading
def save_cfg(cfg):
with open('config.json', 'w') as cfg_file:
js.dump(cfg, cfg_file, indent=4)
def load_cfg():
with open('config.json', 'r') as cfg_file:
return js.load(cfg_file)
if __name__ == "__main__":
cl()
parent_conn, child_conn = p()
p_proc = proc(target=kbd_evt, args=(child_conn,))
p_proc.start()
cfg = {}
if os.path.exists('config.json'):
cl()
print("Config file found. Load (1) or update (2)?")
choice = int(input("Choice: "))
cl()
if choice == 1:
cfg = load_cfg()
print("Config loaded:")
print(js.dumps(cfg, indent=4))
else:
cfg['fov'] = float(input("Enter FOV size: "))
cfg['keybind'] = int(input("Enter keybind (hex): "), 16)
cfg['shooting_rate'] = float(input("Enter shooting rate (ms): "))
cfg['fps'] = float(input("Enter FPS: "))
cfg['hsv_range'] = [(30, 125, 150), (30, 255, 255)]
cfg['mouse_movement_enabled'] = bool(int(input("Enable mouse movement? (1 for Yes, 0 for No): ")))
cfg['color_tolerance'] = int(input("Enter color tolerance (0-255): "))
save_cfg(cfg)
else:
cfg['fov'] = float(input("Enter FOV size: "))
cfg['keybind'] = int(input("Enter keybind (hex): "), 16)
cfg['shooting_rate'] = float(input("Enter shooting rate (ms): "))
cfg['fps'] = float(input("Enter FPS: "))
cfg['hsv_range'] = [(30, 125, 150), (30, 255, 255)]
cfg['mouse_movement_enabled'] = bool(int(input("Enable mouse movement? (1 for Yes, 0 for No): ")))
cfg['color_tolerance'] = int(input("Enter color tolerance (0-255): "))
save_cfg(cfg)
trgbt = Trgbt(parent_conn, cfg['keybind'], cfg['fov'], cfg['hsv_range'], cfg['shooting_rate'], cfg['fps'], cfg['mouse_movement_enabled'], cfg['color_tolerance'])
th.Thread(target=trgbt.capture_frame).start()
th.Thread(target=trgbt.shooting_logic).start()
th.Thread(target=trgbt.mouse_movement_logic).start()
p_proc.join()
#7779811781420453597126
#7492953213110487345525
#5117311757457087884366
#3580563267057968884169
#6657854344619658296611
#6767936448451732590464
#7117373651480308206107
#5500722120766290420197
#4468968808985565672001
