==============================================================
 Pine: Neural-Network Aimbot (v2.0 by Wendel for Apex Legends)
==============================================================

[INFO] press '0' to quit or ctrl+C in console...
[INFO] loading neural-network from disk…
[INFO] loading screencapture device…
[OKAY] Aimbot enabled!
[OKAY] OpenCL is working!
[WARNING] CUDA acceleration is disabled!

Exception in thread Thread-1 (capture_screen):
Traceback (most recent call last):
  File "C:\Users\Wendel\AppData\Local\Programs\Python\Python312\Lib\threading.py", line 1073, in _bootstrap_inner
    self.run()
  File "C:\Users\Wendel\AppData\Local\Programs\Python\Python312\Lib\threading.py", line 1010, in run
    self._target(*self._args, **self._kwargs)
  File "C:\Users\Wendel\Desktop\Apex_Aimbot_PY\teste\lib\pine.py", line 71, in capture_screen
    frame = np.array(sct.grab(region))
                     ^^^^^^^^^^^^^^^^
  File "C:\Users\Wendel\AppData\Local\Programs\Python\Python312\Lib\site-packages\mss\windows.py", line 136, in grab
    bmi.bmiHeader.biWidth = monitor['width']
                            ~~~~~~~^^^^^^^^^
TypeError: tuple indices must be integers or slices, not str
Traceback (most recent call last):
  File "C:\Users\Wendel\Desktop\Apex_Aimbot_PY\teste\pine.py", line 14, in <module>
    pine.start(ENABLE_AIMBOT=True)
  File "C:\Users\Wendel\Desktop\Apex_Aimbot_PY\teste\lib\pine.py", line 149, in start
    frame = capture_screen(origbox) # Substituir esta linha pelo retorno da thread no vindo da captura de tela
            ^^^^^^^^^^^^^^^^^^^^^^^
  File "C:\Users\Wendel\Desktop\Apex_Aimbot_PY\teste\lib\pine.py", line 71, in capture_screen
    frame = np.array(sct.grab(region))
                     ^^^^^^^^^^^^^^^^
  File "C:\Users\Wendel\AppData\Local\Programs\Python\Python312\Lib\site-packages\mss\windows.py", line 136, in grab
    bmi.bmiHeader.biWidth = monitor['width']
                            ~~~~~~~^^^^^^^^^
TypeError: tuple indices must be integers or slices, not str



meu codigo abaixo:

import numpy as np
from termcolor import colored
import timeit
import thread
import imutils
import time
import mss
import cv2
import os
import signal
import sys
import pynput
import ctypes
import pyautogui
from lib.grab import grab_screen
import matplotlib.pyplot as plt

import win32gui
import win32api
import win32con
import mouse
import keyboard
import threading

sct = mss.mss()
Wd, Hd = sct.monitors[1]["width"], sct.monitors[1]["height"]
SendInput = ctypes.windll.user32.SendInput
PUL = ctypes.POINTER(ctypes.c_ulong)

class KeyBdInput(ctypes.Structure):
    fields = [("wVk", ctypes.c_ushort),
                ("wScan", ctypes.c_ushort),
                ("dwFlags", ctypes.c_ulong),
                ("time", ctypes.c_ulong),
                ("dwExtraInfo", PUL)]
class HardwareInput(ctypes.Structure):
    fields = [("uMsg", ctypes.c_ulong),
                ("wParamL", ctypes.c_short),
                ("wParamH", ctypes.c_ushort)]
class MouseInput(ctypes.Structure):
    fields = [("dx", ctypes.c_long),
                ("dy", ctypes.c_long),
                ("mouseData", ctypes.c_ulong),
                ("dwFlags", ctypes.c_ulong),
                ("time", ctypes.c_ulong),
                ("dwExtraInfo", PUL)]
class Input_I(ctypes.Union):
    fields = [("ki", KeyBdInput),
                ("mi", MouseInput),
                ("hi", HardwareInput)]
class Input(ctypes.Structure):
    fields = [("type", ctypes.c_ulong),
                ("ii", Input_I)]

def set_pos(x, y):
   if mouse.is_pressed(button='left') or keyboard.is_pressed('alt'):
        x = int(x - (Wd / 2))
        y = int(y - (Hd / 2))

        extra = ctypes.c_ulong(0)
        ii = pynput.util.win32.INPUT_union()
        ii.mi = pynput._util.win32.MOUSEINPUT(x, y, 0, (0x0001 | 0x8000), 0, ctypes.cast(ctypes.pointer(extra), ctypes.c_void_p))
        command = pynput.util.win32.INPUT(ctypes.c_ulong(0), ii)
        SendInput(1, ctypes.pointer(command), ctypes.sizeof(command))

if __name__ == "__main__":
    print("Do not run this file directly.")

def capture_screen(region):
    with mss.mss() as sct:
        frame = np.array(sct.grab(region))
        return cv2.cvtColor(frame, cv2.COLOR_BGRA2BGR)

def process_frame(frame, net, ln):
    frame = imutils.resize(frame, width=400)
    
    blob = cv2.dnn.blobFromImage(frame, 1/255.0, (416, 416), swapRB=True, crop=False)
    net.setInput(blob)
    return net.forward(ln)

def start(ENABLE_AIMBOT):
    YOLO_DIRECTORY = "models"
    CONFIDENCE = 0.20
    THRESHOLD = 0.01
    ACTIVATION_RANGE = 200

    labelsPath = os.path.sep.join([YOLO_DIRECTORY, "obj.names"])
    LABELS = open(labelsPath).read().strip().split("\n")

    np.random.seed(42)
    COLORS = np.random.randint(0, 255, size=(len(LABELS), 3), dtype="uint8")

    weightsPath = os.path.sep.join([YOLO_DIRECTORY, "PESOCNN/yolov4-tiny-obj_final.weights"])
    configPath = os.path.sep.join([YOLO_DIRECTORY, "PESOCNN/yolov4-tiny-obj.cfg"])

    time.sleep(0.4)

    print("[INFO] loading neural-network from disk…")
    net = cv2.dnn.readNetFromDarknet(configPath, weightsPath)
    net.setPreferableBackend(cv2.dnn.DNN_BACKEND_CUDA)
    net.setPreferableTarget(cv2.dnn.DNN_TARGET_CUDA)

    ln = net.getLayerNames()
    ln = [ln[i - 1] for i in net.getUnconnectedOutLayers()]

    print("[INFO] loading screencapture device…")

    W, H = None, None
    origbox = (
        int(Wd/2 - ACTIVATION_RANGE/2),
        int(Hd/2 - ACTIVATION_RANGE/2),
        int(Wd/2 + ACTIVATION_RANGE/2),
        int(Hd/2 + ACTIVATION_RANGE/2)
    )

    if not ENABLE_AIMBOT:
        print("[INFO] aimbot disabled, using visualizer only…")
    else:
        print(colored("[OKAY] Aimbot enabled!", "green"))

    def signal_handler(sig, frame):
        print("\n[INFO] cleaning up…")
        sct.close()
        cv2.destroyAllWindows()
        sys.exit(0)
    signal.signal(signal.SIGINT, signal_handler)

    build_info = str("".join(cv2.getBuildInformation().split()))
    if cv2.ocl.haveOpenCL():
        cv2.ocl.setUseOpenCL(True)
        cv2.ocl.useOpenCL()
        print(colored("[OKAY] OpenCL is working!", "green"))
    else:
        print(colored("[WARNING] OpenCL acceleration is disabled!", "yellow"))
    if "CUDA:YES" in build_info:
        print(colored("[OKAY] CUDA is working!", "green"))
    else:
        print(colored("[WARNING] CUDA acceleration is disabled!", "yellow"))

    print()

    while True:
        start_time = timeit.default_timer()

        capture_thread = threading.Thread(target=capture_screen, args=(origbox,))
        capture_thread.start()
        capture_thread.join()

        frame = capture_screen(origbox) # Substituir esta linha pelo retorno da thread no vindo da captura de tela

        layerOutputs = process_frame(frame, net, ln)

        boxes = []
        confidences = []
        classIDs = []

        for output in layerOutputs:
            for detection in output:
                scores = detection[5:] 
                classID = 0  
                confidence = scores[classID]

                if confidence > CONFIDENCE:
                    box = detection[0: 4] * np.array([W, H, W, H])
                    (centerX, centerY, width, height) = box.astype("int")

                    x = int(centerX - (width / 2))
                    y = int(centerY - (height / 2))

                    boxes.append([x, y, int(width), int(height)])
                    confidences.append(float(confidence))
                    classIDs.append(classID)

        idxs = cv2.dnn.NMSBoxes(boxes, confidences, CONFIDENCE, THRESHOLD)

        if len(idxs) > 0:
            bestMatch = confidences[np.argmax(confidences)]

            for i in idxs.flatten():
                (x, y) = (boxes[i][0], boxes[i][1])
                (w, h) = (boxes[i][2], boxes[i][3])

                cv2.circle(frame, (int(x + w / 2), int(y + h / 3)), 2, (0, 0, 255), -1)

                cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 1)

                text = "enemy {}%".format(int(confidences[i] * 100))
                cv2.putText(frame, text, (x, y - 5), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)

                if ENABLE_AIMBOT and bestMatch == confidences[i]:
                    mouseX = origbox[0] + (x + w/1.55)
                    mouseY = origbox[1] + (y + h/2.50)
                    set_pos(mouseX, mouseY)

        cv2.imshow("Neural Net Vision (Pine)", frame)
        elapsed = timeit.default_timer() - start_time
        sys.stdout.write(
            "\r{1} FPS with {0} MS interpolation delay \t".format(int(elapsed*1000), int(1/elapsed)))
        sys.stdout.flush()
        if cv2.waitKey(1) & 0xFF == ord('0'):
            break

    signal_handler(0, 0)