Features:
- Automatically open 10 instances of xbox.com/play
- Automatically navigate to BO6
- Anti-AFK: Automatically press left bumper/right bumper every 60 seconds to prevent AFK disconnect from game cloud
- Fully configurable movement settings
- No physical controller required, we are emulating the gamepad. (no need for a cronus, just your PC and this application.)
Minimum requirements:
MINIMUM SPECS (10 Streams)
CPU: Intel i5-10400 or Ryzen 5 3600 (6 cores/12 threads)
RAM: 16GB DDR4
Storage: 256GB SSD
Internet: 50Mbps Download/10Mbps Upload
GPU: Any modern integrated graphics (Intel UHD 630+)
OS: Windows 10 64-bit
Note: May experience occasional stuttering or need to reduce stream quality
Important Notes:
- Wired internet connection strongly recommended
- Chrome hardware acceleration should be enabled
- Multiple monitors recommended but not required
- Close unnecessary background applications
- Running fewer streams will improve performance
Instructions:
Download Python 3.13 and Visual Studio Code
after you have downloaded those open CMD as admin and
copy and paste
pip install customtkinter vgamepad
In visual studio create a file named gui.py, and copy the gui script below into this file.
After you have created the gui.py, create another file named gamepad_control.py and copy the gamepad script below into that.
Once you've got both files setup, you'll need to either generate a new config via the gui (automatic at launch) or use the one I've provided below.
Now, in order for the script to work, you need to create 10 profiles in chrome. Label them as follows: b1, b2, b3, b4, b5, b6, b7, b8, b9, b10
Now, create a shortcut for each of these chrome profiles and label them the same way you named the profiles. b1, b2, b3, etc. And in the folder where you have the gui/gamepad scripts, create a new folder named "Shortcuts" and drop them in there. This is CASE SENSITIVE
Once that's done, you're pretty much ready to go. You'll just need to log in to all 10 of your xbox accounts in the 10 profiles, and the bot will handle the rest.
CODE:
gui.py
import customtkinter as ctk
from gamepad_control import GamepadController
import webbrowser
import os
import subprocess
import time
import configparser
# 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")
# 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
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
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()
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
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
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
# 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
# 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)
Amazing work ! disgusting people try and take open source projects and charge ridiculous amounts of money for it hopefully people that purchased can get there money back or do charge backs
Motto: BO6 / WZ4 Services available. Join the Discord: https://discord.gg/bo6camos
Motto: BO6 / WZ4 Services available. Join the Discord: https://discord.gg/bo6camos
Status: Online
Joined: Jun 22, 20159Year Member
Posts: 8,311
Reputation Power: 10899
Motto: BO6 / WZ4 Services available. Join the Discord: https://discord.gg/bo6camos
More surprised it took this long for someone to post it on here. Before anyone comes at XeMike for sharing it on here. The bot lobby market is already beyond pucked.
