feelsdaumenman/ai-aimbottensorrt

AI Aimbot - Massive Update

Table of Contents

• AI Aimbot - Massive Update
  • Table of Contents
  • Intro
  • Known games that can identify it as a cheat
  • Configurable Settings
  • Current Stats
  • Different Versions!!!
    • TensorRT Setup help
    • REQUIREMENTS
    • Pre-setup
    • Run
  • Community Based
    • Add your own Model
    • Future Ideas

Intro

AI Aimbot works in any game with humanoid characters and utilizes YOLOv5 (ultralytics/yolov5). Mouse movements don't work in Valorant currently. It is currently 100% undetectable to anti-cheat systems due to it being visual-only in nature. You could be found cheating if you are manually reported by another player and your game is reviewed manually due to the botty looking aimming of an Aimbot.

This is meant for educational purposed and to expose how poorly prepared game developers are with these new waves on AI based cheats. Please share with this with your friendly neighborhood game dev so they can start patching.

Code is all in 1 file for easy of viewing and learning from.

Use at your own risk. If you get banned get rekted idiot

Adhere to our GNU licence, come on we are a nonprofit.

• free to use, sell, profit from, litterally anything you want to do with it
• credit MUST be given to RootKit for the underlying base code

Watch the tutorial video! - https://www.youtube.com/watch?v=TCJHLbbeLhg
Watch the shorts video! - https://youtu.be/EEgspHlU_H0

Watch the live stream explainer - https://www.youtube.com/RootKit
Watch the pre-setup tutorial - Coming soon...
Watch the main setup/run tutorial - Comming soon...
Watch the onnx setup/run tutorial - Comming soon...
Watch the tensorrt setup/run tutorial - Comming soon...

Join teh Discord - discord.gg/rootkitorg

Known games that can identify it as a cheat

Splitgate (discovered by ˞˞˞˞˞˞˞˞˞˞˞˞˞˞˞˞˞˞#2373 on discord 06/20/22) EQU8 Detects win32 library for mouse movement

Configurable Settings

*Default settings are good for most use cases. Read comments in code for more details.
CAPS_LOCK is the default for toggling on and off the autoaim functionality

videoGameWindowTitle - (Legacy) Window title of the game you want to play. Does not need to be the complete window title.

aaRightShift - May need to be changed in 3rd person games like Fortnite and New World. Typically 100 or 150 will be sufficient.

aaQuitKey - Default is q, this may need to be changed to another key depending on the game.

headshot_mode - Make False if you want to aim more toward center mass.

cpsDisplay - Make False if you don't want the CPS to be displayed in the terminal.

visuals - Make True if you want to see what the AI sees. Can help with debugging issues.

aaMovementAmp - Default should be fine for 99% of use cases. Lower the value, the more smooth the autoaim will be. Recommended range is 0.5 - 2.

confidence - Default should be kept unless you know what you are doing.

screenShotHeight - Default should be kept unless you know what you are doing.

screenShotWidth - Default should be kept unless you know what you are doing.

aaDetectionBox - Default should be kept unless you know what you are doing.

Current Stats

This bot's speed is VERY dependent on your hardware. We will update the model it uses for detection later with a faster one. Bot was tested on a:

- AMD Ryzen 7 2700
- 64 GB DDR4
- Nvidia RTX 2080

We got anywhere from 15-60 corrections per second depending on the version used. All games were ran at 1920x1080 or close to it when testing.

ANYTHING dealing with Machine Learning can be funky with your computer. So if you keep getting CUDA errors, you may want to restart your PC in order to make sure everything resets properly.

Different Versions!!!

The guide below starting with Pre-Setup* will get the main.py version running, BUT the main.py IS THE SLOWEST!!!

Also there is a custom folder with user submitted models you can try out. Go explore them and see what you think. Make sure you shout out the dev if you like what they have done!

If you are comfortable with your skills, you can run the other 4 versions. You can also get AMD GPUs running the bot using the onnx version. This is advance stuff. If you are not advance, skip to pre-setup below. Python 3.9 is recommened if you are going to continue due to packages compatibility issues.

EXPECT LITTLE TO NO HELP FROM STAFF IN REGARDS TO ANY OF THE ADVANCE SET UP UNLESS YOU ARE A PATREON MEMBER. This includes openning issues. If you are opening an issue, give full content including but not limited to OS, GPU, RAM, Toolkit version, cuDNN version, tensorRT version, etc.

main_torch_gpu.py will be the easiest to get running. You just need to install pip install cupy based on your CUDA Toolkti version. This can give up to a 10% performance boost.

main_onnx_cpu.py is for those of you who don't have a nvidia CPU. It will be optimized for CPU based compute. You need to pip install onnxruntime.

main_onnx_nvidia.py will give you up to a 100% performance boost. You will need to pip install pip install onnxruntime-gpu.

main_onnx_amd.py will give you up to a 100% performance boost. You will need to run pip install -r requirements_onnx_amd.txt.

main_tensorrt_gpu.py is the BEST. It gives over a 200% performance boost.

TensorRT Setup help

In our testing, the screenshot engine was the bottleneck. Tensorrt is only available via download from NVIDIA's site.

You will need to make an account. Just go to this link and get TensorRT 8.5 GA Update 2. https://developer.nvidia.com/tensorrt You will need to install it via the .whl file they give you. You may also need https://developer.nvidia.com/cudnn.

Sometimes you will need to remake the .engine model. To do this you need to visit the YoloV5's Github repo and download it. Then execute the export.py script in the repo with the command below. This can take up to 20 minutes and have no visual feedback. It's not frozen, just looks like it.

NOTE, you will need to use the provided or download a new version of the yolov5 weights (aka the .pt file). We use the small model, but with tensorrt, you should be able to use a larger model.

python .\export.py --weights ./yolov5s.pt --include engine --half --imgsz 320 320 --device 0

REQUIREMENTS

• Nvidia RTX 2050 or higher
• One of the following
  • Nvidia CUDA Toolkit 11.6 (Most compatibility) (https://developer.nvidia.com/cuda-11-6-0-download-archive)
  • Nvidia CUDA Toolkit 11.7 (No onnx support currently, faster) (https://developer.nvidia.com/cuda-11-7-0-download-archive)

Pre-setup

1. Unzip the file and place the folder somewhere easy to access

2. Make sure you have a pet Python (aka install python, use 3.10) - https://www.python.org/

IF YOU GET THE FOLLOWING ERROR python is not recognized as an internal or external command, operable program, or batch file Watch This: https://youtu.be/E2HvWhhAW0g

IF YOU GET THE FOLLOWING ERROR pip is not recognized as an internal or external command, operable program, or batch file Watch This: https://youtu.be/zWYvRS7DtOg

3. (Windows Users) Open up either PowerShell or Command Prompt. This can be done by pressing the Windows Key and searching for one of those applications.

4. To install PyTorch go to this website, https://pytorch.org/get-started/locally/, and Select the stable build, your OS, Pip, Python and CUDA version you installed. Then select the text that is generated and run that command.

5. Copy and paste the commands below into your terminal. This will install the Open Source packages needed to run the program. You will need to cd into the downloaded directory first. Follow step 2 in the Run section below if you need help.

pip install -r requirements.txt

pip install --index-url https://test.pypi.org/simple/ --extra-index-url https://pypi.org/simple dxcam

Run

If you have python and the packages you are good to go. Load up any game on your MAIN monitor and load into a game.

1. (Windows Users) Open up either PowerShell or Command Prompt. This can be done by pressing the Windows Key and searching for one of those applications.

2. Type cd (make sure you add the space after the cd or else I will call you a monkey)

3. Drag and drop the folder that has the bot code onto the terminal

4. Press the enter key

5. Type python main.py, press enter.

6. Use CAPS_LOCK to toggle on and off the autoaim functionality. It is off by default

7. Pressing q at anytime will completely quit the program

Community Based

We are a community based nonprofit. We are always open to pull requests on any of our repos. You will always be given credit for all of you work. Depending on what you contribute, we will give you any revenue earned on your contributions 💰💰💰!

We are always looking for new Volunteers to join our Champions! If you have any ideas for videos or programs, let us know!

Custom Aimbots

If you have some new functionality you have added to the bot you would like to show off and have people learn from, put it in here and send a Pull Request!

Just add a folder to the customScripts folder with your github name and inside put your all your code and a readme.md explaining what they are and what they do.

For an example, look at the example-user folder in customScripts.

Custom Models

If you trained your own model, then submit a PR with it!

Just add a folder to the customModels folder with your github name and inside put your model(s) and a readme.md explaining what they are and how you made them.

For an example, look at the example-user folder in customModels.

Another view of the layout -

/custom/
  exampleUsername/
    model_general.pt
    readme.md

Future Ideas

• Config File Instead of hardcoded values

ai-aimbottensorrt's Issues

message 5.txt Bug Report

Here are some potential issues found in the code:

1. The line targets['priority'] = targets['width'] * targets['height'] * targets['confidence'] may cause an error if the DataFrame targets does not have the columns 'width', 'height', and 'confidence'. It is better to check if these columns exist before performing this operation.

2. In the function adjust_prediction_horizon(target, prediction_horizon), the returned value is assigned to the global variable prediction_horizon. However, this global variable is not used in the main loop. It might be a mistake, and the local variable prediction_horizon should be used instead.

3. The functions prioritize_targets(targets) and adjust_prediction_horizon(target, prediction_horizon) are placeholders and do not have any real implementation. They should be updated with the desired functionality.

4. The variables recoil_amount_x and recoil_amount_y are placeholders and are never updated with actual recoil compensation amounts. This may cause the function compensate_recoil(mouseMove, recoil_amount_x, recoil_amount_y) to not work as expected.

5. The code uses the aaQuitKey variable for quitting the program, but it is not clear if this variable is ever set to the desired key. It might be better to use a more standard way of quitting the application, like using a specific key combination (e.g., Ctrl+C).

6. The code uses the dxcam library, which is not a standard Python library. Make sure that this library is properly installed and working as expected.

7. The code uses the win32api, win32gui, and win32con libraries, which are specific to the Windows operating system. If the code is intended to run on other platforms, these libraries should be replaced with cross-platform alternatives.

8. The code uses the cv2 library for image processing and display. Make sure that this library is properly installed and working as expected.

9. The code uses the torch library for deep learning. Make sure that this library is properly installed and working as expected, and that the correct version of CUDA is installed if using a GPU.

10. The code uses the seaborn library for visualization, but it is not clear if this library is used anywhere in the code. If not, it can be removed to reduce unnecessary dependencies.

11. The code uses the numpy library, but it is imported twice with different aliases (np and n). It is better to use a single import statement to avoid confusion.

12. The code uses the pandas library, but it is imported with a custom alias (pd). Make sure that this alias is used consistently throughout the code.

13. The code uses the torch.hub library to load a pre-trained YOLOv5 model. Make sure that the correct model is loaded and that the input image is preprocessed correctly before passing it to the model.

14. The code uses the non_max_suppression function from the utils.general module. Make sure that this module is properly imported and that the function is available.

15. The code uses the xyxy2xywh function from the utils.general module. Make sure that this module is properly imported and that the function is available.

16. The code uses the ord function from the operator module to convert a single-character string to its ASCII code. Make sure that this function is used correctly and that the input string contains only a single character.

17. The code uses the time library for measuring elapsed time. Make sure that this library is used consistently and that the time measurements are accurate.

18. The code uses the torch.no_grad() context manager to disable gradient computation during inference. Make sure that this context manager is used correctly and that gradient computation is disabled only when necessary.

19. The code uses the torch.from_numpy function to convert a NumPy array to a PyTorch tensor. Make sure that this function is used correctly and that the input array is in the correct format.

20. The code uses the torch.tensor function to create a new PyTorch tensor. Make sure that this function is used correctly and that the input data is in the correct format.

21. The code uses the iloc attribute to index DataFrame rows by integer position. Make sure that this attribute is used correctly and that the input indices are in the correct format.

22. The code uses the view method to reshape PyTorch tensors. Make sure that this method is used correctly and that the input dimensions are in the correct format.

23. The code uses the tolist method to convert PyTorch tensors to Python lists. Make sure that this method is used correctly and that the input tensors are in the correct format.

24. The code uses the sort_values method to sort a DataFrame by one or more columns. Make sure that this method is used correctly and that the input columns are in the correct format.

25. The code uses the np.linalg.norm function to calculate the Euclidean distance between two points. Make sure that this function is used correctly and that the input arrays are in the correct format.

26. The code uses the torch.unsqueeze function to add an extra dimension to a PyTorch tensor. Make sure that this function is used correctly and that the input tensor is in the correct format.

27. The code uses the / operator to perform element-wise division between PyTorch tensors. Make sure that this operator is used correctly and that the input tensors are in the correct format.

28. The code uses the * operator to perform element-wise multiplication between PyTorch tensors. Make sure that this operator is used correctly and that the input tensors are in the correct format.

29. The code uses the - operator to perform element-wise subtraction between PyTorch tensors. Make sure that this operator is used correctly and that the input tensors are in the correct format.

30. The code uses the + operator to perform element-wise addition between PyTorch tensors. Make sure that this operator is used correctly and that the input tensors are in the correct format.

31. The code uses the round function

.gitignore Bug Report

The given text is a list of file patterns for a .gitignore file, used to exclude certain files and directories from version control in Git. There are no bugs or issues in the list itself, but here are some notes to consider:

1. The list is well-organized and includes common file patterns that are often excluded from version control, such as byte-compiled files, C extensions, distribution/packaging files, and build artifacts.
2. The list is quite extensive and covers many use cases. However, depending on the specific project or development environment, some additional patterns might be necessary or desirable.
3. Some of the patterns might be overly broad, such as *.pyc and *.pyo. While it's generally a good idea to exclude compiled Python files, there might be cases where it's useful to include them (e.g., when working with a shared library).
4. Similarly, the pattern *.so might be too broad for some projects, as it excludes all shared object files, not just those related to Python.
5. The pattern .Python might be unnecessary, as it's an unusual name for a directory or file, and is unlikely to be created by accident.
6. The pattern share/python-wheels/ might be specific to certain Linux distributions or package managers, and might not be relevant for all projects.
7. The pattern *.egg-info/ should probably be *.egg-info (without the trailing slash) to match the behavior of other patterns in the list.
8. The comment # PyInstaller is misleading, as the following patterns (*.manifest and *.spec) are not specific to PyInstaller and might be used by other tools as well.

Overall, the list is a good starting point for excluding unnecessary files and directories from version control, but it should be tailored to the specific needs of the project and development environment.

LICENSE Bug Report

The provided code is the Apache License Version 2.0 and it is not a programming code with bugs. It is a legal document that outlines the terms and conditions for using, reproducing, and distributing software or other works released under this license. There are no bugs in this license as it is not a program or code that can have functional or syntax errors.

main_tensorrt_gpu_chat_gpt 3.py Bug Report

Here are some potential issues or bugs in the code:

1. The function load_model() is defined but not called anywhere in the code.
2. The function plot_boxes() is defined but not called anywhere in the code.
3. The variable some_threshold is defined but not used anywhere in the code.
4. The variable aaRightShift is not initialized before being used in the calculation of sctArea.
5. The variable sctArea is defined but not used anywhere in the code.
6. The variable sTime is defined but not initialized before being used in the calculation of elapsed_time.
7. The function normalize_angle() is defined but not used anywhere in the code.
8. The function smooth_angle() is defined but not used anywhere in the code.
9. The function cv2.imshow() is called but there is no corresponding cv2.waitKey() call, which may cause the program to crash.
10. The function cv2.imshow() is called with the window name "Live Feed", but there is no corresponding cv2.destroyAllWindows() call, which may cause the program to leave orphaned windows.
11. The code uses the cp (Cupy) library for GPU acceleration, but it is not clear if the required Cupy CUDA backend is installed and configured correctly.
12. The code uses the dxcam library for screen capturing, but it is not clear if the library is installed and working correctly.
13. The code uses the pygetwindow library for window management, but it is not clear if the library is installed and working correctly.
14. The code uses the pyautogui library for mouse control, but it is not clear if the library is installed and working correctly.
15. The code uses the torch library for deep learning, but it is not clear if the library is installed and working correctly.
16. The code uses the numpy library for numerical operations, but it is not clear if the library is installed and working correctly.
17. The code uses the pandas library for data manipulation, but it is not clear if the library is installed and working correctly.
18. The code uses the math library for mathematical operations, but it is not clear if the library is imported correctly.
19. The code uses the time library for timing operations, but it is not clear if the library is imported correctly.
20. The code uses the win32api and win32con libraries for window and mouse control, but it is not clear if the libraries are installed and working correctly.
21. The code uses the unittest library for testing, but the result variable is not used anywhere in the code.
22. The code has several unused imports, such as random, sys, result, and gc.
23. The code has several hard-coded values, such as the screen shot size, the aim smoothing factor, the confidence threshold, and the aim time, which may not be optimal for all use cases.
24. The code has several magic numbers, such as the aspect ratio and area thresholds, which may not be self-explanatory.
25. The code has several comments in non-English language, which may not be understandable to all readers.
26. The code has several long lines, which may be hard to read and maintain.
27. The code has several inconsistent indentations, which may cause syntax errors.
28. The code has several potential security issues, such as the lack of error handling and the use of global variables, which may make the code vulnerable to attacks or bugs.
29. The code has several potential performance issues, such as the lack of memoization and caching, which may slow down the code or consume unnecessary resources.
30. The code has several potential usability issues, such as the lack of documentation and user feedback, which may make the code hard to use or understand.