Creating a bot for Android games: from idea to working solution

Automating game processes on Android using bots is a topic that interests both experienced developers and beginners who want to optimize their routine. Bots can perform repetitive actions in games (farm resources, complete levels, collect rewards), but their creation requires an understanding of both the technical nuances Androidand the mechanics of a particular game. In this article, we will analyze the legal and technical aspects of development, select tools, write a simple bot using Python using ADB, and also discuss how to bypass typical automation protection systems.

It is important to understand: the use of bots in online games often violates service rules (for example, Supercell, MiHoYo or Riot Games actively fight against cheaters). We focus on local games without multiplayer or testing your own projectswhere automation does not affect the interests of other players. If you plan to use a bot in a network game, check the developers' policy to avoid blocking your account.

The article is suitable for those who:

• 🔹 Can work with a team line and has basic knowledge Python or Java/Kotlin.
• 🔹 Wants to automate routine actions in offline games (for example, clickers or simulators).
• 🔹 Interested in reverse engineering of mobile applications (without breaking laws).
• 🔹 Ready to test the bot on an emulator or backup device.

1. Legality and risks: what you need to know before you start

Before starting development, it is worth assessing the legal and technical risks. Most online games (Clash of Clans, Genshin Impact, PUBG Mobile) prohibit the use of bots in their User Agreements. Violation may lead to:

• 🚫 Account ban (temporary or permanent).
• 🚫 Block device by IMEI or Android ID.
• 🚫 A claim for damages (in rare cases, if the bot caused damage to the game economy).

However, there are scenarios where bots are acceptable:

• 🎮 Local games without an online component (for example, Cookie Clicker or Adventure Capitalist).
• 🛠️ Testing your own games (if you are a developer).
• 🤖 Research purposes (training neural networks, analyzing game mechanics).

⚠️ Attention: Even if the game does not detect bots, using automation in multiplayer may be considered cheating. Some studios (for example, Blizzard) sued the creators of cheats.

If you still decide to take a risk, we recommend:

• 🔄 Use secondary account i backup device.
• 🛡️ Disable the bot when updating the game (developers often add new protection systems).
• 📱 Test the code on emulator (BlueStacks, LDPlayer) before running it on a real one smartphone.

2. Selecting tools: what is needed for development

Creating a bot for Androidgames requires a combination of software and hardware tools. Below is the minimum set to get started:

For beginners, the optimal start is Python + ADB. This duo allows you to quickly create bots for clickers and simple simulators. If the game requires working with memory (for example, changing health or mana values), you will need reverse engineering using GameGuardian or Cheat Engine, but this is already an advanced level.

Example of a minimal installation on Windows:

1. Download Platform Tools (includes adb.exe).
2. Install Python from the official website (check the "Add to PATH" box).
3. Connect the phone to the PC and execute in the command line line:

   adb devices

   If the device is displayed, the connection is established.

⚠️ Attention: On some devices (Xiaomi, Huawei), you need to additionally enable USB debugging (factory settings) in the developer menu.

3. Game analysis: determining interaction points

Before writing code, you need to understand how the game reacts to user actions. To do this, we analyze:

• 🎯 Click coordinates (where the buttons are located on the screen).
• 🖼️ Images (which interface elements can be visually recognized).
• 📡 Network requests (if the game communicates with the server).
• 🧠 Game logic (for example, delays between actions).

The simplest way is get a screenshot of the screen and determine the coordinates of the buttons. This can be done by ADB:

adb exec-out screencap -p > screenshot.png

Open the received one screenshot.png in any graphic editor (for example, Paint or GIMP) and write down the coordinates of the necessary elements. For example, the "Attack" button may be located at the point (500, 1200) for permission 1080×2340.

To automate image recognition, use the library OpenCV in Python. Example code for searching for a button by template:

import cv2
import numpy as np

Uploading a screenshot and button template
screenshot = cv2.imread('screenshot.png', cv2.IMREAD_COLOR)
template = cv2.imread('attack_button.png', cv2.IMREAD_COLOR)

Looking for a match
result = cv2.matchTemplate(screenshot, template, cv2.TM_CCOEFF_NORMED)
min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(result)

Coordinates of the center of the button
button_x = max_loc[0] + template.shape[1] // 2
button_y = max_loc[1] + template.shape[0] // 2
print(f"Button found at point: ({button_x}, {button_y})"))

If the game actively uses network interaction (for example, MMORPG), analyze the traffic through Fiddler or Charles Proxy. This will help you understand what data is sent to the server and whether it can be faked. However, this approach requires deep knowledge HTTP/HTTPS and often breaks the rules of the game.

4. We are writing a simple bot in Python + ADB

Consider an example of a bot for a clicker game, where you need to periodically click on the screen at a certain point. We will use:

• 🐍 Python for logic.
• 🔌 ADB to simulate clicks.
• ⏱️ Delays between actions (so that the bot looks “human-like”).

Set the necessary libraries:

pip install opencv-python numpy pyautogui

Example code for a bot that presses a button every 3 seconds:

import subprocess
import time
import random

Button coordinates (replace with your own)
BUTTON_X = 500
BUTTON_Y = 1200

ADB command for tapping on the screen
def tap_screen(x, y):
subprocess.run(f"adb shell input tap {x} {y}", shell=True)

Main loop
while True:
tap_screen(BUTTON_X, BUTTON_Y)
# Random delay from 2.5 to 3.5 seconds
delay = 2.5 + random.random()
time.sleep(delay)

To start the bot:

1. Connect the device to the PC.
2. Start the game and go to the desired screen.
3. Run the script: python bot.py.

To complicate the logic, you can add:

• 🔍 Image recognition (if the button changes position).
• 📊 Pixel color analysis (for example, checking whether an enemy has appeared on the screen).
• 🔄 Error handling (if the game crashes or advertising appears).

⚠️ Attention: Some games (for example, Genshin Impact) block ADB-commands during gameplay. In this case, you will need to use emulator with root access or alternative input methods (for example, OctoWiFi for wireless control).

5. Bypassing protection: how to make a bot less noticeable

Modern games use various methods of Detection of bots. Here are the most common and ways to bypass them:

For advanced bots you can use: Imitation of human behavior (use with variable parameters). data-i="242">Encrypt command lines

• 🎭 Imitation of human behavior:
  • Random pauses between actions (for example, from 0.5 to 2 seconds).
  • Inaccurate clicks (coordinate deviation by ±5–15 pixels).
  • Swipe at different speeds (use adb shell input swipe with variable parameters).
• 🔍 Code obfuscation:
  • Compile Python-script in .exe by using PyInstaller.
  • Encrypt command strings ADB.
• 🛡️ Change device signature:
  • Change Android ID, IMEI (requires root).
  • Use VPN to change IP (but this may cause suspicions).

An example of a “humanoid” click with errors:

import random

def human_like_tap(x, y):
# Adding a random deviation
offset_x = random.randint(-10, 10)
offset_y = random.randint(-10, 10)
real_x = x + offset_x
real_y = y + offset_y
subprocess.run(f"adb shell input tap {real_x} {real_y}", shell=True)

Use
human_like_tap(500, 1200)

For games with server verification (for example, MMORPG) can required Packet interception and modification. This is a complex task that requires knowledge TCP/IP and often breaks the rules. We do not recommend this approach for beginners.

6. Testing and debugging: how to avoid errors

Even the simplest bot can be unstable due to:

• 🔄 Changes in the game interface (buttons have moved after the update).
• 📱 Differences in screen resolution (coordinates do not match on another device).
• 🚫 Command blocking (the game ignores ADB-input).
• 🔋 Battery drain (some devices turn off ADB in power saving mode).

To minimize problems:

1. Test on an emulator with a fixed resolution (for example, 720×1280).
2. Add logging:

   with open("bot_log.txt", "a") as f:
   f.write(f"{time.strftime('%H:%M:%S')} - Click on ({x}, {y})\n")

3. Handle exceptions:

   try:
   tap_screen(BUTTON_X, BUTTON_Y)
   except subprocess.CalledProcessError:
   print("ADB error! Check your connection.")

4. Use relative coordinates:

   # Example: button in the center of the screen
   screen_width = 1080
   screen_height = 2340
   center_x = screen_width // 2
   center_y = screen_height // 2

If the bot stopped working after updating the game:

1. Take a new screenshot and update the coordinates.
2. Check if the interface has changed (for example, new animation has been added).
3. Update ADB and device drivers.

⚠️ Attention: On devices Samsung with One UI you may need to disable the function Optimize battery usage for ADBotherwise the connection will be lost.

7. Advanced techniques: neural networks and machine learning

For complex games (for example, MOBA or RTS) ordinary scripts are not suitable - required computer vision and machine learning. Let's consider the basic approaches:

1. Object recognition using OpenCV and Template Matching

import cv2

Loading the "Attack" button template
template = cv2.imread('attack_button.png', 0)
screenshot = cv2.imread('screen.png', 0)

Looking for a match
result = cv2.matchTemplate(screenshot, template, cv2.TM_CCOEFF_NORMED)
threshold = 0.8 # Similarity threshold
loc = np.where(result >= threshold)

If a match is found
if len(loc[0]) > 0:
x, y = loc[1][0], loc[0][0]
tap_screen(x + 10, y + 10) # Click in the center of the button

import pytesseract
from PIL import Image

Crop the area with text
image = Image.open('health_bar.png').crop((100, 50, 200, 70))
text = pytesseract.image_to_string(image)
print(f"Health: {text}")

-- Autoclicker for a button with coordinates (300, 500)
while true do
touchDown(0, 300, 500)
touchUp(0, 300, 500)
sleep(1000) -- Pause 1 second
end

<service
android:name=".MyAccessibilityService"
android:permission="android.permission.BIND_ACCESSIBILITY_SERVICE">
<intent-filter>
<action android:name="android.accessibilityservice.AccessibilityService" />
</intent-filter>
<meta-data
android:name="android.accessibilityservice"
android:resource="@xml/accessibility_service_config" />
</service>

adb shell uiautomator dump /sdcard/window.xml
adb pull /sdcard/window.xml