Just a heads up to everyone paying this guy for the bot lobby tool, dont.
This is obviously my script tweaked a tiny bit. (Made it ugly, why?)
This tool is FREE and OPEN SOURCE on another popular forum.
As a matter of fact, I'll just post the source here for everyone for free.
Gamepad script:
import vgamepad as vg
import time
import random
import math
import threading
import configparser
import os
class GamepadController:
def __init__(self):
self.gamepad = None
self.running = False
self.movement_enabled = False
self.anti_afk_enabled = False
self.thread = None
self.anti_afk_thread = None
# Load config
self.config = configparser.ConfigParser()
self.config_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "config.ini")
self.load_config()
def load_config(self):
"""Load settings from config file"""
self.config.read(self.config_path)
# Movement settings
self.look_intensity = self.config.getfloat('Movement', 'look_intensity', fallback=1.5) # Increased default
self.move_intensity = self.config.getfloat('Movement', 'move_intensity', fallback=0.3)
self.forward_intensity = self.config.getfloat('Movement', 'forward_intensity', fallback=1.0)
self.ads_chance = self.config.getfloat('Movement', 'ads_chance', fallback=0.1)
self.jump_chance = self.config.getfloat('Movement', 'jump_chance', fallback=0.15)
self.jump_interval = self.config.getfloat('Movement', 'jump_interval', fallback=3.0)
self.weapon_switch_chance = self.config.getfloat('Movement', 'weapon_switch_chance', fallback=0.1)
self.weapon_switch_interval = self.config.getfloat('Movement', 'weapon_switch_interval', fallback=5.0)
self.strafe_chance = self.config.getfloat('Movement', 'strafe_chance', fallback=0.2)
self.forward_bias = self.config.getfloat('Movement', 'forward_bias', fallback=0.7)
self.shoot_chance = self.config.getfloat('Movement', 'shoot_chance', fallback=0.3)
self.shoot_duration = self.config.getfloat('Movement', 'shoot_duration', fallback=0.2)
self.crouch_chance = self.config.getfloat('Movement', 'crouch_chance', fallback=0.3)
self.x_button_chance = self.config.getfloat('Movement', 'x_button_chance', fallback=0.3)
self.x_button_interval = self.config.getfloat('Movement', 'x_button_interval', fallback=5.0)
self.min_movement_duration = self.config.getfloat('Movement', 'min_movement_duration', fallback=2.0)
self.max_movement_duration = self.config.getfloat('Movement', 'max_movement_duration', fallback=8.0)
self.min_break_duration = self.config.getfloat('Movement', 'min_break_duration', fallback=3.0)
self.max_break_duration = self.config.getfloat('Movement', 'max_break_duration', fallback=12.0)
# Anti-AFK settings
self.anti_afk_interval = self.config.getfloat('AntiAFK', 'interval', fallback=60)
self.right_bumper_duration = self.config.getfloat('AntiAFK', 'right_bumper_duration', fallback=0.1)
self.left_bumper_duration = self.config.getfloat('AntiAFK', 'left_bumper_duration', fallback=0.1)
self.delay_between_buttons = self.config.getfloat('AntiAFK', 'delay_between_buttons', fallback=0.5)
def save_config(self):
"""Save current settings to config file"""
# Movement settings
self.config['Movement'] = {
'look_intensity': str(self.look_intensity),
'move_intensity': str(self.move_intensity),
'forward_intensity': str(self.forward_intensity),
'ads_chance': str(self.ads_chance),
'jump_chance': str(self.jump_chance),
'jump_interval': str(self.jump_interval),
'weapon_switch_chance': str(self.weapon_switch_chance),
'weapon_switch_interval': str(self.weapon_switch_interval),
'strafe_chance': str(self.strafe_chance),
'forward_bias': str(self.forward_bias),
'shoot_chance': str(self.shoot_chance),
'shoot_duration': str(self.shoot_duration),
'crouch_chance': str(self.crouch_chance),
'x_button_chance': str(self.x_button_chance),
'x_button_interval': str(self.x_button_interval),
'min_movement_duration': str(self.min_movement_duration),
'max_movement_duration': str(self.max_movement_duration),
'min_break_duration': str(self.min_break_duration),
'max_break_duration': str(self.max_break_duration)
}
# Anti-AFK settings
self.config['AntiAFK'] = {
'interval': str(self.anti_afk_interval),
'right_bumper_duration': str(self.right_bumper_duration),
'left_bumper_duration': str(self.left_bumper_duration),
'delay_between_buttons': str(self.delay_between_buttons)
}
with open(self.config_path, 'w') as configfile:
self.config.write(configfile)
def update_config(self, section, key, value):
"""Update a specific config value"""
if section == 'Movement':
if key == 'look_intensity': self.look_intensity = float(value)
elif key == 'move_intensity': self.move_intensity = float(value)
elif key == 'forward_intensity': self.forward_intensity = float(value)
elif key == 'ads_chance': self.ads_chance = float(value)
elif key == 'jump_chance': self.jump_chance = float(value)
elif key == 'jump_interval': self.jump_interval = float(value)
elif key == 'weapon_switch_chance': self.weapon_switch_chance = float(value)
elif key == 'weapon_switch_interval': self.weapon_switch_interval = float(value)
elif key == 'strafe_chance': self.strafe_chance = float(value)
elif key == 'forward_bias': self.forward_bias = float(value)
elif key == 'shoot_chance': self.shoot_chance = float(value)
elif key == 'shoot_duration': self.shoot_duration = float(value)
elif key == 'crouch_chance': self.crouch_chance = float(value)
elif key == 'x_button_chance': self.x_button_chance = float(value)
elif key == 'x_button_interval': self.x_button_interval = float(value)
elif key == 'min_movement_duration': self.min_movement_duration = float(value)
elif key == 'max_movement_duration': self.max_movement_duration = float(value)
elif key == 'min_break_duration': self.min_break_duration = float(value)
elif key == 'max_break_duration': self.max_break_duration = float(value)
elif section == 'AntiAFK':
if key == 'interval': self.anti_afk_interval = float(value)
elif key == 'right_bumper_duration': self.right_bumper_duration = float(value)
elif key == 'left_bumper_duration': self.left_bumper_duration = float(value)
elif key == 'delay_between_buttons': self.delay_between_buttons = float(value)
def connect(self):
"""Connect the virtual gamepad"""
if self.gamepad is None:
self.gamepad = vg.VX360Gamepad()
time.sleep(1) # Wait for gamepad to initialize
return True
return False
def disconnect(self):
"""Disconnect the virtual gamepad"""
self.stop()
if self.gamepad:
self.gamepad = None
def _smooth_value(self, current, target, smooth_factor=0.1):
"""Smoothly interpolate between current and target value"""
return current + (target - current) * smooth_factor
def _generate_smooth_random(self, intensity):
"""Generate a smooth random value between -intensity and +intensity"""
return (random.random() * 2 - 1) * intensity
def _anti_afk_loop(self):
"""Anti-AFK loop that periodically presses buttons"""
print("Anti-AFK loop started")
while self.running and self.gamepad:
try:
if not self.anti_afk_enabled:
time.sleep(0.1)
continue
print("Anti-AFK: Pressing right bumper")
self.gamepad.press_button(button=vg.XUSB_BUTTON.XUSB_GAMEPAD_RIGHT_SHOULDER)
self.gamepad.update()
time.sleep(self.right_bumper_duration)
self.gamepad.release_button(button=vg.XUSB_BUTTON.XUSB_GAMEPAD_RIGHT_SHOULDER)
self.gamepad.update()
time.sleep(self.delay_between_buttons)
print("Anti-AFK: Pressing left bumper")
self.gamepad.press_button(button=vg.XUSB_BUTTON.XUSB_GAMEPAD_LEFT_SHOULDER)
self.gamepad.update()
time.sleep(self.left_bumper_duration)
self.gamepad.release_button(button=vg.XUSB_BUTTON.XUSB_GAMEPAD_LEFT_SHOULDER)
self.gamepad.update()
print(f"Anti-AFK: Waiting {self.anti_afk_interval} seconds")
time.sleep(self.anti_afk_interval)
except Exception as e:
print(f"Error in anti-AFK loop: {e}")
time.sleep(1)
print("Anti-AFK loop ended")
def start(self):
"""Start the controller"""
if not self.running and self.gamepad:
print("Starting controller...")
self.running = True
self.movement_enabled = False # Start with movement disabled
# Start movement thread
self.thread = threading.Thread(target=self._movement_loop)
self.thread.daemon = True
self.thread.start()
print("Controller started")
def stop(self):
"""Stop the controller"""
self.running = False
self.movement_enabled = False
self.anti_afk_enabled = False
if self.thread:
self.thread.join(timeout=1)
self.thread = None
if self.anti_afk_thread:
self.anti_afk_thread.join(timeout=1)
self.anti_afk_thread = None
print("Controller stopped")
def toggle_movement(self):
"""Toggle movement bot"""
print(f"Toggling movement from {self.movement_enabled} to {not self.movement_enabled}")
self.movement_enabled = not self.movement_enabled
return self.movement_enabled
def toggle_anti_afk(self):
"""Toggle anti-AFK"""
print(f"Toggling anti-AFK from {self.anti_afk_enabled} to {not self.anti_afk_enabled}")
if not self.anti_afk_enabled:
self.anti_afk_enabled = True
self.anti_afk_thread = threading.Thread(target=self._anti_afk_loop)
self.anti_afk_thread.daemon = True
self.anti_afk_thread.start()
else:
self.anti_afk_enabled = False
if self.anti_afk_thread:
self.anti_afk_thread.join(timeout=1)
self.anti_afk_thread = None
return self.anti_afk_enabled
def select_class(self):
"""Select a class by pressing A button 5 times"""
if not self.gamepad:
print("Gamepad not connected")
return False
print("Selecting class...")
time.sleep(2) # Initial wait
for i in range(5):
print(f"Class selection press {i+1}/5")
self.gamepad.press_button(button=vg.XUSB_BUTTON.XUSB_GAMEPAD_A)
self.gamepad.update()
time.sleep(0.1) # Short press duration
self.gamepad.release_button(button=vg.XUSB_BUTTON.XUSB_GAMEPAD_A)
self.gamepad.update()
time.sleep(0.9) # Wait remaining time to make it 1 second total
print("Class selection complete")
return True
def _movement_loop(self):
"""Movement loop that simulates random controller inputs with breaks"""
print("Movement loop started")
last_x_press = 0 # Track last X button press time
last_movement_was_forward = False # Track last movement direction
current_move_x = 0 # Track current movement values for smooth transitions
current_move_y = 0
current_look_x = 0
current_look_y = 0
last_jump_time = 0 # Track last jump time
last_weapon_switch_time = 0 # Track last weapon switch time
while self.running and self.gamepad:
try:
if not self.movement_enabled:
# Reset controller state when movement is disabled
self.gamepad.left_joystick_float(x_value_float=0, y_value_float=0)
self.gamepad.right_joystick_float(x_value_float=0, y_value_float=0)
self.gamepad.left_trigger_float(value_float=0)
self.gamepad.right_trigger_float(value_float=0)
self.gamepad.update()
time.sleep(0.1)
continue
# Automatically disable Anti-AFK when movement starts
if self.anti_afk_enabled:
print("Automatically disabling Anti-AFK")
self.toggle_anti_afk()
# Randomize movement duration for this cycle
current_movement_duration = random.uniform(self.min_movement_duration, self.max_movement_duration)
current_break_duration = random.uniform(self.min_break_duration, self.max_break_duration)
# Movement phase
print(f"Starting movement phase for {current_movement_duration:.1f} seconds")
movement_start_time = time.time()
# Choose movement type based on previous movement
if last_movement_was_forward:
movement_type = 'backward'
else:
movement_type = 'forward'
last_movement_was_forward = (movement_type == 'forward')
print(f"Movement type: {movement_type}")
# Continue movement until duration is reached or movement is disabled
while self.running and self.movement_enabled and (time.time() - movement_start_time) < current_movement_duration:
current_time = time.time()
# X button press check
if current_time - last_x_press >= self.x_button_interval and random.random() < self.x_button_chance:
print("X button pressed")
self.gamepad.press_button(button=vg.XUSB_BUTTON.XUSB_GAMEPAD_X)
self.gamepad.update()
time.sleep(0.1)
self.gamepad.release_button(button=vg.XUSB_BUTTON.XUSB_GAMEPAD_X)
self.gamepad.update()
last_x_press = current_time
# Jump check
if current_time - last_jump_time >= self.jump_interval and random.random() < self.jump_chance:
print("Jumping")
self.gamepad.press_button(button=vg.XUSB_BUTTON.XUSB_GAMEPAD_A)
self.gamepad.update()
time.sleep(0.1)
self.gamepad.release_button(button=vg.XUSB_BUTTON.XUSB_GAMEPAD_A)
self.gamepad.update()
last_jump_time = current_time
# Weapon switch check
if current_time - last_weapon_switch_time >= self.weapon_switch_interval and random.random() < self.weapon_switch_chance:
print("Switching weapon")
self.gamepad.press_button(button=vg.XUSB_BUTTON.XUSB_GAMEPAD_Y)
self.gamepad.update()
time.sleep(0.1)
self.gamepad.release_button(button=vg.XUSB_BUTTON.XUSB_GAMEPAD_Y)
self.gamepad.update()
last_weapon_switch_time = current_time
# Generate target look values
target_look_x = random.uniform(-1, 1) * self.look_intensity * 1.5 # Increased look intensity
target_look_y = random.uniform(-1, 1) * self.look_intensity * 1.5 # Increased look intensity
# Smoothly interpolate look values
current_look_x = self._smooth_value(current_look_x, target_look_x, 0.1)
current_look_y = self._smooth_value(current_look_y, target_look_y, 0.1)
# Set movement based on type with smooth transitions
target_move_x = random.uniform(-0.3, 0.3) * self.move_intensity # Small side-to-side movement
if movement_type == 'forward':
target_move_y = random.uniform(0.7, 1.0) * self.forward_intensity
else: # backward
target_move_y = random.uniform(-0.7, -1.0) * self.forward_intensity
# Smoothly interpolate movement values
current_move_x = self._smooth_value(current_move_x, target_move_x, 0.15)
current_move_y = self._smooth_value(current_move_y, target_move_y, 0.15)
# Apply movements with clamping
current_look_x = max(min(current_look_x, 1), -1)
current_look_y = max(min(current_look_y, 1), -1)
current_move_x = max(min(current_move_x, 1), -1)
current_move_y = max(min(current_move_y, 1), -1)
print(f"Movement: type={movement_type}, pos=({current_move_x:.2f}, {current_move_y:.2f})")
self.gamepad.right_joystick_float(x_value_float=current_look_x, y_value_float=current_look_y)
self.gamepad.left_joystick_float(x_value_float=current_move_x, y_value_float=current_move_y)
# Random actions with configured chances
if random.random() < self.ads_chance:
print("ADS triggered")
self.gamepad.left_trigger_float(value_float=1.0)
time.sleep(0.1)
else:
self.gamepad.left_trigger_float(value_float=0.0)
if random.random() < self.shoot_chance:
print("Shooting")
self.gamepad.right_trigger_float(value_float=1.0)
self.gamepad.update()
time.sleep(self.shoot_duration)
self.gamepad.right_trigger_float(value_float=0.0)
self.gamepad.update()
self.gamepad.update()
time.sleep(0.01) # Small sleep to prevent excessive CPU usage
# Break phase - only if movement is still enabled
if self.running and self.movement_enabled:
print(f"Starting break phase for {current_break_duration:.1f} seconds")
# Reset controller state during break
self.gamepad.left_joystick_float(x_value_float=0, y_value_float=0)
self.gamepad.right_joystick_float(x_value_float=0, y_value_float=0)
self.gamepad.left_trigger_float(value_float=0)
self.gamepad.right_trigger_float(value_float=0)
self.gamepad.update()
break_start = time.time()
while self.running and self.movement_enabled and (time.time() - break_start) < current_break_duration:
time.sleep(0.1) # Check movement state every 100ms
print("Break phase complete")
except Exception as e:
print(f"Error in movement loop: {e}")
time.sleep(1)
print("Movement loop ended")
if __name__ == "__main__":
# Example usage
controller = GamepadController()
try:
print("Connecting gamepad...")
if controller.connect():
print("Gamepad connected.")
else:
print("Failed to connect gamepad.")
exit(1)
print("Starting controller automation...")
controller.start()
# Keep running until Ctrl+C
while True:
time.sleep(1)
except KeyboardInterrupt:
print("\nStopping automation...")
controller.stop()
controller.disconnect()
GUI script:
import customtkinter as ctk
from gamepad_control import GamepadController
import webbrowser
import os
import subprocess
import time
import configparser
class AutomatorGUI:
def __init__(self):
self.controller = None
self.chrome_path = 'C:/Program Files/Google/Chrome/Application/chrome.exe'
self.num_accounts = 20
self.shortcuts_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "Shortcuts")
self.bo6_url = "https://www.xbox.com/en-US/play/launch/call-of-duty-black-ops-6---cross-gen-bundle/9PF528M6CRHQ"
# Load config
self.config = configparser.ConfigParser()
self.config_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "config.ini")
self.config.read(self.config_path)
# Setup the main window
self.window = ctk.CTk()
self.window.title("Bot Ops Lobby Tool")
self.window.geometry("900x900")
ctk.set_appearance_mode("dark")
# Create tabview
self.tabview = ctk.CTkTabview(self.window)
self.tabview.pack(fill="both", expand=True, padx=10, pady=10)
# Create tabs
self.main_tab = self.tabview.add("Main")
self.settings_tab = self.tabview.add("Settings")
# Setup main tab
self.setup_main_tab()
# Setup settings tab
self.setup_settings_tab()
# Set default tab
self.tabview.set("Main")
# Initial log message
self.log("Ready to start. Select number of accounts and click 'Open Xbox Sessions'")
# Initialize state
self.is_running = False
# Scan for available profiles
self.available_profiles = self.scan_profiles()
self.profile_label.configure(text=f"Available Profiles: {len(self.available_profiles)}/20")
# Update dropdown values based on available profiles
if self.available_profiles:
values = [str(i+1) for i in range(len(self.available_profiles))]
self.account_counter.configure(values=values)
self.account_counter.set("1") # Set default value
def setup_main_tab(self):
"""Setup the main tab with existing controls"""
# Profile frame
self.profile_frame = ctk.CTkFrame(self.main_tab)
self.profile_frame.pack(fill="x", padx=10, pady=5)
# Title and description
title = ctk.CTkLabel(
self.profile_frame,
text="Bot Ops Lobby Tool - (BETA)",
font=("Arial", 20, "bold")
)
title.pack(pady=(0, 10))
description = ctk.CTkLabel(
self.profile_frame,
text="Let's get that schmoney\n",
font=("Arial", 12),
justify="center"
)
description.pack(pady=(0, 20))
# Profile status
profile_frame = ctk.CTkFrame(self.main_tab)
profile_frame.pack(padx=10, pady=10, fill="x")
self.profile_label = ctk.CTkLabel(
profile_frame,
text=f"Available Profiles: 0/20",
font=("Arial", 12, "bold")
)
self.profile_label.pack(pady=5)
# Account counter dropdown
counter_frame = ctk.CTkFrame(self.main_tab)
counter_frame.pack(padx=10, pady=10, fill="x")
ctk.CTkLabel(counter_frame, text="Number of Accounts:", font=("Arial", 12)).pack(side="left", padx=5)
self.account_counter = ctk.CTkComboBox(
counter_frame,
width=70,
values=["1"], # Will be updated after profile scan
state="readonly"
)
self.account_counter.pack(side="left", padx=5)
# Status display
self.status_label = ctk.CTkLabel(
self.main_tab,
text="Status: Ready",
font=("Arial", 12, "bold"),
fg_color=("gray85", "gray25"),
corner_radius=6
)
self.status_label.pack(padx=10, pady=20, fill="x")
# Control buttons
button_frame = ctk.CTkFrame(self.main_tab)
button_frame.pack(padx=10, pady=10, fill="x")
# Open Browser Button
self.browser_button = ctk.CTkButton(
button_frame,
text="Open Xbox Sessions",
command=self.open_browser_windows,
font=("Arial", 14, "bold"),
height=40
)
self.browser_button.pack(padx=5, pady=5, fill="x")
# Gamepad Controls Frame
gamepad_frame = ctk.CTkFrame(self.main_tab)
gamepad_frame.pack(padx=10, pady=10, fill="x")
# Connect Controller Button
self.connect_button = ctk.CTkButton(
gamepad_frame,
text="Connect Controller",
command=self.toggle_controller_connection,
font=("Arial", 14, "bold"),
height=40
)
self.connect_button.pack(padx=5, pady=5, fill="x")
# Movement Bot Button
self.movement_button = ctk.CTkButton(
gamepad_frame,
text="Enable Movement Bot",
command=self.toggle_movement,
font=("Arial", 14, "bold"),
height=40,
state="disabled"
)
self.movement_button.pack(padx=5, pady=5, fill="x")
# Select Class Button
self.select_class_button = ctk.CTkButton(
gamepad_frame,
text="Select Class",
command=self.select_class,
font=("Arial", 14, "bold"),
height=40,
state="disabled"
)
self.select_class_button.pack(padx=5, pady=5, fill="x")
# Anti-AFK Button
self.anti_afk_button = ctk.CTkButton(
gamepad_frame,
text="Enable Anti-AFK",
command=self.toggle_anti_afk,
font=("Arial", 14, "bold"),
height=40,
state="disabled"
)
self.anti_afk_button.pack(padx=5, pady=5, fill="x")
# Log display
log_frame = ctk.CTkFrame(self.main_tab)
log_frame.pack(padx=10, pady=10, fill="both", expand=True)
ctk.CTkLabel(log_frame, text="Activity Log:", font=("Arial", 12, "bold")).pack(padx=5, pady=5, anchor="w")
self.log_text = ctk.CTkTextbox(log_frame, height=150)
self.log_text.pack(padx=5, pady=5, fill="both", expand=True)
def create_labeled_slider(self, parent, row, label_text, from_, to_, section, key, fallback):
"""Helper function to create a labeled slider with value display"""
# Label
label = ctk.CTkLabel(parent, text=label_text)
label.grid(row=row, column=0, padx=10, pady=(5,0))
# Value label
value_label = ctk.CTkLabel(parent, text="0.00", width=50)
value_label.grid(row=row, column=1, padx=5, pady=(5,0))
# Slider
slider = ctk.CTkSlider(parent, from_=from_, to=to_)
slider.grid(row=row+1, column=0, columnspan=2, padx=10, pady=(0,5), sticky="ew")
# Set initial value
initial_value = self.config.getfloat(section, key, fallback=fallback)
slider.set(initial_value)
value_label.configure(text=f"{initial_value:.2f}")
# Update function
def on_slider_change(value):
value_label.configure(text=f"{value:.2f}")
self.update_setting(section, key, value)
slider.configure(command=on_slider_change)
return slider
def setup_settings_tab(self):
"""Setup the settings tab with config controls"""
# Movement Settings Frame
self.movement_settings_frame = ctk.CTkFrame(self.settings_tab)
self.movement_settings_frame.grid(row=0, column=0, padx=10, pady=10, sticky="nsew")
# Movement Settings Label
self.movement_settings_label = ctk.CTkLabel(self.movement_settings_frame, text="Movement Settings", font=("Arial", 16, "bold"))
self.movement_settings_label.grid(row=0, column=0, columnspan=2, padx=10, pady=5)
# Configure columns for value labels
self.movement_settings_frame.grid_columnconfigure(0, weight=3)
self.movement_settings_frame.grid_columnconfigure(1, weight=1)
current_row = 1
# Create all movement sliders
self.look_intensity_slider = self.create_labeled_slider(
self.movement_settings_frame, current_row, "Look Intensity", 0, 3, 'Movement', 'look_intensity', 1.5)
current_row += 2
self.move_intensity_slider = self.create_labeled_slider(
self.movement_settings_frame, current_row, "Move Intensity", 0, 2, 'Movement', 'move_intensity', 0.3)
current_row += 2
self.forward_intensity_slider = self.create_labeled_slider(
self.movement_settings_frame, current_row, "Forward Intensity", 0, 2, 'Movement', 'forward_intensity', 1.0)
current_row += 2
# Add jump settings
self.jump_chance_slider = self.create_labeled_slider(
self.movement_settings_frame, current_row, "Jump Chance", 0, 1, 'Movement', 'jump_chance', 0.15)
current_row += 2
self.jump_interval_slider = self.create_labeled_slider(
self.movement_settings_frame, current_row, "Jump Interval (s)", 1, 10, 'Movement', 'jump_interval', 3.0)
current_row += 2
# Add weapon switch settings
self.weapon_switch_chance_slider = self.create_labeled_slider(
self.movement_settings_frame, current_row, "Weapon Switch Chance", 0, 1, 'Movement', 'weapon_switch_chance', 0.1)
current_row += 2
self.weapon_switch_interval_slider = self.create_labeled_slider(
self.movement_settings_frame, current_row, "Weapon Switch Interval (s)", 1, 15, 'Movement', 'weapon_switch_interval', 5.0)
current_row += 2
self.min_movement_duration_slider = self.create_labeled_slider(
self.movement_settings_frame, current_row, "Min Movement Duration (s)", 1, 10, 'Movement', 'min_movement_duration', 2.0)
current_row += 2
self.max_movement_duration_slider = self.create_labeled_slider(
self.movement_settings_frame, current_row, "Max Movement Duration (s)", 2, 15, 'Movement', 'max_movement_duration', 8.0)
current_row += 2
self.min_break_duration_slider = self.create_labeled_slider(
self.movement_settings_frame, current_row, "Min Break Duration (s)", 1, 10, 'Movement', 'min_break_duration', 3.0)
current_row += 2
self.max_break_duration_slider = self.create_labeled_slider(
self.movement_settings_frame, current_row, "Max Break Duration (s)", 2, 20, 'Movement', 'max_break_duration', 12.0)
current_row += 2
# Anti-AFK Settings Frame
self.afk_frame = ctk.CTkFrame(self.settings_tab)
self.afk_frame.grid(row=0, column=1, padx=10, pady=10, sticky="nsew")
# Configure columns for value labels
self.afk_frame.grid_columnconfigure(0, weight=3)
self.afk_frame.grid_columnconfigure(1, weight=1)
# Anti-AFK Label
self.afk_label = ctk.CTkLabel(self.afk_frame, text="Anti-AFK Settings", font=("Arial", 16, "bold"))
self.afk_label.grid(row=0, column=0, columnspan=2, padx=10, pady=5)
current_row = 1
# Create all Anti-AFK sliders
self.interval_slider = self.create_labeled_slider(
self.afk_frame, current_row, "Interval (seconds)", 10, 120, 'AntiAFK', 'interval', 60.0)
current_row += 2
self.right_bumper_slider = self.create_labeled_slider(
self.afk_frame, current_row, "Right Bumper Duration", 0.1, 1, 'AntiAFK', 'right_bumper_duration', 0.1)
current_row += 2
self.left_bumper_slider = self.create_labeled_slider(
self.afk_frame, current_row, "Left Bumper Duration", 0.1, 1, 'AntiAFK', 'left_bumper_duration', 0.2)
current_row += 2
self.delay_slider = self.create_labeled_slider(
self.afk_frame, current_row, "Delay Between Buttons", 0.1, 2, 'AntiAFK', 'delay_between_buttons', 1.0)
current_row += 2
# Configure grid weights for both frames
self.settings_tab.grid_columnconfigure(0, weight=1)
self.settings_tab.grid_columnconfigure(1, weight=1)
# Save Button
self.save_button = ctk.CTkButton(self.settings_tab, text="Save Settings", command=self.save_settings)
self.save_button.grid(row=1, column=0, columnspan=2, pady=10)
def update_setting(self, section, key, value):
"""Update a setting in the controller"""
if self.controller:
self.controller.update_config(section, key, value)
def save_settings(self):
"""Save all settings to config file"""
if self.controller:
self.controller.save_config()
self.log("Settings saved to config.ini")
else:
with open(self.config_path, 'w') as configfile:
self.config.write(configfile)
self.log("Settings saved to config.ini")
def scan_profiles(self):
"""Scan for available Chrome profiles in shortcuts directory"""
profiles = []
if os.path.exists(self.shortcuts_path):
for i in range(1, 21): # b1 through b20
profile_name = f"b{i}"
if os.path.exists(os.path.join(self.shortcuts_path, f"{profile_name}.lnk")):
profiles.append(profile_name)
self.log(f"Found {len(profiles)} profiles in Shortcuts folder")
return profiles
def open_browser_windows(self):
"""Open multiple Chrome windows using profile shortcuts"""
try:
num_accounts = min(int(self.account_counter.get()), len(self.available_profiles))
if num_accounts < 1:
self.log("Please enter a valid number of accounts")
return
if not self.available_profiles:
self.log("No profiles found in shortcuts directory")
return
self.log(f"Opening {num_accounts} Xbox Cloud Gaming sessions...")
for i in range(num_accounts):
# Open Chrome using shortcut
profile = self.available_profiles[i]
# Use start command to open the shortcut
cmd = [
'start',
'', # Title parameter (empty)
'/d', self.shortcuts_path, # Set working directory
f"{profile}.lnk",
'https://xbox.com/play',
]
subprocess.run(cmd, shell=True)
self.log(f"Opened session {i+1}/{num_accounts} with profile {profile}")
# Change button to launch Black Ops 6
self.browser_button.configure(
text="Launch Black Ops 6",
command=self.launch_black_ops,
fg_color="orange"
)
self.log("All sessions opened successfully")
except ValueError:
self.log("Please enter a valid number")
except Exception as e:
self.log(f"Error opening browser windows: {str(e)}")
def launch_black_ops(self):
"""Launch Black Ops 6 in all open sessions"""
try:
num_accounts = min(int(self.account_counter.get()), len(self.available_profiles))
for i in range(num_accounts):
profile = self.available_profiles[i]
cmd = [
'start',
'', # Title parameter (empty)
'/d', self.shortcuts_path, # Set working directory
f"{profile}.lnk",
self.bo6_url,
]
subprocess.run(cmd, shell=True)
self.log(f"Launching Black Ops 6 for profile {profile}")
self.log("Black Ops 6 launched in all sessions")
except Exception as e:
self.log(f"Error launching Black Ops 6: {str(e)}")
def toggle_controller_connection(self):
"""Connect or disconnect the controller"""
if not self.controller:
self.controller = GamepadController()
if self.controller.gamepad is None:
if self.controller.connect():
self.controller.start()
self.connect_button.configure(text="Disconnect Controller", fg_color="red")
self.movement_button.configure(state="normal")
self.anti_afk_button.configure(state="normal")
self.select_class_button.configure(state="normal")
self.log("Controller connected and started")
else:
self.log("Failed to connect controller")
else:
self.controller.disconnect()
self.connect_button.configure(text="Connect Controller", fg_color=["#3B8ED0", "#1F6AA5"])
self.movement_button.configure(state="disabled")
self.anti_afk_button.configure(state="disabled")
self.select_class_button.configure(state="disabled")
self.movement_button.configure(text="Enable Movement Bot", fg_color=["#3B8ED0", "#1F6AA5"])
self.anti_afk_button.configure(text="Enable Anti-AFK", fg_color=["#3B8ED0", "#1F6AA5"])
self.log("Controller disconnected")
def toggle_movement(self):
"""Toggle movement bot"""
if not self.controller:
self.log("Controller not connected")
return
is_enabled = self.controller.toggle_movement()
if is_enabled:
self.movement_button.configure(text="Stop Movement", fg_color="red")
self.log("Movement bot started")
else:
self.movement_button.configure(text="Start Movement", fg_color="green")
self.log("Movement bot stopped")
def toggle_anti_afk(self):
"""Toggle anti-AFK"""
if not self.controller:
self.log("Controller not connected")
return
is_enabled = self.controller.toggle_anti_afk()
if is_enabled:
self.anti_afk_button.configure(text="Stop Anti-AFK", fg_color="red")
self.log("Anti-AFK started")
else:
self.anti_afk_button.configure(text="Start Anti-AFK", fg_color="green")
self.log("Anti-AFK stopped")
def select_class(self):
"""Handle class selection button press"""
if not self.controller:
self.log("Controller not connected")
return
self.log("Starting class selection...")
if self.controller.select_class():
self.log("Class selection complete")
else:
self.log("Class selection failed")
def log(self, message):
"""Add message to log display"""
self.log_text.insert("end", f"{message}\n")
self.log_text.see("end")
def cleanup(self):
"""Clean up resources"""
if self.controller:
self.controller.stop()
def run(self):
"""Start the GUI"""
try:
self.window.mainloop()
finally:
self.cleanup()
if __name__ == "__main__":
gui = AutomatorGUI()
gui.run()
Example config:
[Movement]
look_intensity = 3.0
move_intensity = 2.0
forward_intensity = 0.9900497512437811
ads_chance = 0.040000000000000036
jump_chance = 0.04999999999999993
jump_interval = 3.0
weapon_switch_chance = 0.1
weapon_switch_interval = 5.0
strafe_chance = 0.25
forward_bias = 0.4
shoot_chance = 0.09999999999999998
shoot_duration = 0.29799999999999993
crouch_chance = 0.3
x_button_chance = 0.3
x_button_interval = 5.0
min_movement_duration = 4.0
max_movement_duration = 6.04228855721393
min_break_duration = 3.1044776119402986
max_break_duration = 7.014925373134329
[AntiAFK]
interval = 60.599999999999994
right_bumper_duration = 0.1359999999999999
left_bumper_duration = 0.1417857142857143
delay_between_buttons = 1.012
|
