Call of Duty: Black Ops 6 Python AFK Bot – Safe Setup & Guide

pip install pytesseract pyautogui pillow pydirectinput pynput

pytesseract.pytesseract.tesseract_cmd = r'C:\Program Files\Tesseract-OCR\tesseract.exe'

# Import required libraries for automation, image processing, threading, and keyboard control
import pytesseract
import pyautogui
from PIL import Image
import time
import random
import pydirectinput
import threading
from pynput.keyboard import Controller, Key, Listener

# Set up configurations for Tesseract and disable fail-safe in pydirectinput
pydirectinput.FAILSAFE = False
pytesseract.pytesseract.tesseract_cmd = r'C:\Program Files\Tesseract-OCR\tesseract.exe'

# Initialize global variables for keyboard control, stopping AFK actions, and script management
keyboard = Controller()
stop_afk = False
afk_threads = []
paused = False
stop_script = False
game_ended_shown = False

# Define keypress handler to toggle pause or stop the script
def on_press(key):
    global paused, stop_script
    try:
        if key == Key.shift_r:  # Right Shift pauses/resumes the script
            paused = not paused
            print("Script paused." if paused else "Script resumed.")
        elif key == Key.end:  # End key stops the script
            stop_script = True
            print("Stopping script.")
            return False
    except AttributeError:
        pass

# Function to halt AFK actions and join all threads
def stop_afk_actions():
    global stop_afk, afk_threads, game_ended_shown
    stop_afk = True
    for thread in afk_threads:  # Wait for each thread to finish
        thread.join()
    afk_threads.clear()  # Clear all AFK action threads
    stop_afk = False
    if not game_ended_shown:
        print("AFK actions stopped.")
        game_ended_shown = True

# Function to initiate AFK actions by starting threads
def start_afk_actions():
    global afk_threads, stop_afk, game_ended_shown
    stop_afk = False
    game_ended_shown = False
    # Define actions to be executed in separate threads
    afk_threads = [
        threading.Thread(target=move_randomly),
        threading.Thread(target=shoot_randomly),
        threading.Thread(target=jump_randomly),
        threading.Thread(target=mouse_movement_randomly),
        # threading.Thread(target=throw_grenade_randomly) # Uncomment if needed
    ]
    for thread in afk_threads:
        thread.start()
    print("AFK actions started.")

# Function to perform random movement, considering recent moves to avoid patterns
def move_randomly():
    directions = [('w',), ('s',), ('a',), ('d',), ('w', 'a'), ('w', 'd'), ('s', 'a'), ('s', 'd')]
    recent_moves = []
    max_recent_moves = 4  # Limit the memory of recent moves to avoid loops
    while not stop_afk and not stop_script:
        if paused:
            time.sleep(1)
            continue
        direction_keys = random.choice([d for d in directions if d not in recent_moves])
        duration = random.uniform(0.5, 1.2)
        for key in direction_keys:
            keyboard.press(key)
        time.sleep(duration)
        for key in direction_keys:
            keyboard.release(key)
        time.sleep(random.uniform(0.1, 0.3))
        recent_moves.append(direction_keys)
        if len(recent_moves) > max_recent_moves:
            recent_moves.pop(0)

# Randomly trigger shooting action with occasional timing intervals
def shoot_randomly():
    while not stop_afk and not stop_script:
        if paused:
            time.sleep(1)
            continue
        if random.random() < 0.01:
            pydirectinput.mouseDown(button='right')
            time.sleep(random.uniform(0.1, 0.2))
            pydirectinput.mouseDown(button='left')
            time.sleep(random.uniform(0.3, 0.6))
            pydirectinput.mouseUp(button='left')
            pydirectinput.mouseUp(button='right')
        time.sleep(random.uniform(0.8, 1.5))

# Randomly jump with varying intervals to simulate real player movement
def jump_randomly():
    while not stop_afk and not stop_script:
        if paused:
            time.sleep(1)
            continue
        if random.random() < 0.2:
            keyboard.press(Key.space)
            time.sleep(random.uniform(0.2, 0.5))
            keyboard.release(Key.space)
        time.sleep(random.uniform(1.0, 2.0))

# Move the mouse cursor to look around, simulating continuous camera movement
def mouse_movement_randomly():
    while not stop_afk and not stop_script:
        max_moves = 20  # Number of iterations to look fully up
        for _ in range(max_moves):
            pydirectinput.moveRel(0, -200)  # Fast upward movement
            time.sleep(0.01)
        print("Looking all the way up - movement stopped.")

# Scan the screen for specific words indicating the game is over or the lobby is open
def scan_for_stop_words():
    stop_words = ["BEST PLAY", "victory", "defeat", "draw", "NOTICE", "returning to lobby"]
    screenshot = preprocess_image(pyautogui.screenshot())
    text = pytesseract.image_to_string(screenshot).lower()

    for word in stop_words:
        if word in text:
            print(f"Stop word detected: '{word}'")
            return True
    return False

# Convert image to binary for better OCR accuracy
def preprocess_image(image):
    image = image.convert('L')  # Convert to grayscale
    image = image.point(lambda x: 0 if x < 128 else 255, '1')  # Binarize image
    return image

# Scan for keywords in the game's screen to initiate actions
def scan_for_keywords():
    keywords = ["loadouts", "autoclass", "custom", "overwatch", "commando"]
    screenshot = preprocess_image(pyautogui.screenshot())
    data = pytesseract.image_to_data(screenshot, output_type=pytesseract.Output.DICT)

    for i, word in enumerate(data['text']):
        if word.lower() in keywords:
            print(f"Keyword '{word}' found - Performing keyboard actions.")
            pydirectinput.press('up')
            time.sleep(0.5)
            pydirectinput.press('down')
            time.sleep(0.5)
            pydirectinput.press('space')
            time.sleep(1)
            pydirectinput.press('space')
            return True
    return False

# Continuously check for stop words to halt AFK actions
def stop_word_scanner():
    global game_ended_shown
    while not stop_script:
        if scan_for_stop_words():
            if not game_ended_shown:
                print("Stop word detected. Stopping AFK actions.")
                game_ended_shown = True
            stop_afk_actions()
            global afk_started
            afk_started = False
        else:
            game_ended_shown = False
        time.sleep(0.3)

# Main function to initiate all functionality, using a listener for keypress events
def start():
    global afk_started
    afk_started = False
    threading.Thread(target=stop_word_scanner, daemon=True).start()

    # Listen for key presses to control pause and stop
    with Listener(on_press=on_press) as listener:
        while not stop_script:
            if paused:
                print("Script is paused.")
                time.sleep(1)
                continue
            try:
                if scan_for_keywords() and not stop_afk and not afk_started:
                    print("Match found - Starting AFK actions.")
                    afk_started = True
                    start_afk_actions()
                elif not afk_started:
                    print("Looking for game")
            except Exception as e:
                print(f"Error in main loop: {e}")
            time.sleep(0.5)
        stop_afk_actions()
        listener.stop()

# Execute the main function to run the script
start()