BO6Bot Ops BO6 Bot Lobby tool FREE! Credit DarkFerret
Posted:

BO6Bot Ops BO6 Bot Lobby tool FREE! Credit DarkFerretPosted:

XeMike
  • Summer 2019
Status: Offline
Joined: May 25, 20159Year Member
Posts: 582
Reputation Power: 587
Motto: Don't give a p*** about nothing but the tide!
Motto: Don't give a p*** about nothing but the tide!
Status: Offline
Joined: May 25, 20159Year Member
Posts: 582
Reputation Power: 587
Motto: Don't give a p*** about nothing but the tide!
Hello Everyone! Thx to DarkFerret over at UC we have a awesome Bot lobby tool FREE





Screenshots:



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

RECOMMENDED SPECS (10+ Streams)
CPU: Intel i7-12700 or Ryzen 7 5800X (8+ cores)
RAM: 32GB DDR4
Storage: 500GB SSD
Internet: 100Mbps Download/20Mbps Upload
GPU: GTX 1650 or better (for hardware acceleration)
OS: Windows 10/11 64-bit

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
 
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()


gamepad_control.py
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()



config.ini
[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





CREDIT

DarkFerret
itswillyferret




Need Help with Set up ?
DM Me can help set up in under 30 mins for a small fee

The following 8 users thanked XeMike for this useful post:

saudhq (12-23-2024), Reversing (12-18-2024), BIoom (12-18-2024), Robert188575 (12-16-2024), Certz (12-16-2024), ThickMeister (12-16-2024), Psychonautic (12-16-2024), Carcer (12-16-2024)
#2. Posted:
LIL_PAPA_S_42
  • New Member
Status: Offline
Joined: Nov 04, 201410Year Member
Posts: 26
Reputation Power: 1
Status: Offline
Joined: Nov 04, 201410Year Member
Posts: 26
Reputation Power: 1
i sent you msg on discord bro need this
#3. Posted:
Status: Offline
Joined: May 24, 201113Year Member
Posts: 979
Reputation Power: 45
Status: Offline
Joined: May 24, 201113Year Member
Posts: 979
Reputation Power: 45
having an issue setting it up on my side, cool to pm ya?


Last edited by Carcer ; edited 1 time in total
#4. Posted:
ThickMeister
  • Junior Member
Status: Offline
Joined: Apr 04, 201113Year Member
Posts: 64
Reputation Power: 8
Status: Offline
Joined: Apr 04, 201113Year Member
Posts: 64
Reputation Power: 8
having an issue setting it up on my side, call to pm ya?
#5. Posted:
Psychonautic
  • Blind Luck
Status: Offline
Joined: Dec 08, 201311Year Member
Posts: 1,038
Reputation Power: 8755
Motto: Once poor always poor
Motto: Once poor always poor
Status: Offline
Joined: Dec 08, 201311Year Member
Posts: 1,038
Reputation Power: 8755
Motto: Once poor always poor
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
#6. Posted:
itswillyferret
  • New Member
Status: Offline
Joined: Dec 15, 2024
Posts: 4
Reputation Power: 1
Status: Offline
Joined: Dec 15, 2024
Posts: 4
Reputation Power: 1
Thank you for posting

@CodPlug you gonna give me a kick back for stealing open source code?
#7. Posted:
XeCookie
  • Trusted Seller
Status: Online
Joined: Jun 22, 20159Year Member
Posts: 8,338
Reputation Power: 10900
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,338
Reputation Power: 10900
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.
#8. Posted:
Robert188575
  • New Member
Status: Offline
Joined: Dec 16, 2024
Posts: 1
Reputation Power: 0
Status: Offline
Joined: Dec 16, 2024
Posts: 1
Reputation Power: 0
Ive been trying to set this up for days and still nothing, Mind helping me out???? can you dm me?
#9. Posted:
Certz
  • Wise One
Status: Offline
Joined: Aug 29, 20186Year Member
Posts: 531
Reputation Power: 1881
Status: Offline
Joined: Aug 29, 20186Year Member
Posts: 531
Reputation Power: 1881
How to get ultimate cheap for the bot accounts?


Last edited by Certz ; edited 2 times in total
#10. Posted:
LIL_PAPA_S_42
  • New Member
Status: Offline
Joined: Nov 04, 201410Year Member
Posts: 26
Reputation Power: 1
Status: Offline
Joined: Nov 04, 201410Year Member
Posts: 26
Reputation Power: 1
100% legit! repeat customer!! would recommend, fast wait times and great pricing!
Users browsing this topic: None
Jump to:


RECENT POSTS

HOT TOPICS