EasyBot External

https://github.com/wojtas99/otibia_bot
Admin
EasyBot External is an open-source, external bot for Tibia Online (and its Open Tibia Servers) that...
Tokens:6,929
Snippets:23
Trust Score:7.1
License:Apache-2.0
Update:1 year ago
Show doc for...
Tokens:
Raw
### Create Executable Bot with PyInstaller

Source: https://github.com/wojtas99/otibia_bot/blob/master/README.md

This command uses PyInstaller to create a standalone executable file for the bot. It bundles all necessary files into a single executable and optionally removes the console window for a cleaner user experience. Ensure you have PyInstaller installed (`pip install pyinstaller`).

```bash
pyinstaller --onefile --noconsole StartBot.py --name="EasyBot" --icon="Images/Icon.jpg"
```

--------------------------------

### Simulate Game Hotkeys (F1-F12)

Source: https://context7.com/wojtas99/otibia_bot/llms.txt

Presses game hotkeys (F1-F12) by sending WM_KEYDOWN and WM_KEYUP messages. This is useful for triggering spells, potions, or other quick actions configured in the game. It includes examples for healing, attacking, and an auto-heal loop.

```python
import Addresses
from Functions.KeyboardFunctions import press_hotkey
from PyQt5.QtCore import QThread
import random

# Press F1 to use healing spell
press_hotkey(1)
QThread.msleep(random.randint(150, 250))

# Press F8 to use attack rune
press_hotkey(8)
QThread.msleep(random.randint(150, 250))

# Press F12 to use buff spell
press_hotkey(12)

# Example: Auto-heal loop
while True:
    current_hp, current_max_hp, _, _ = read_my_stats()
    hp_percentage = (current_hp * 100) / current_max_hp

    if hp_percentage < 70:
        press_hotkey(1)  # Use healing spell on F1
        QThread.msleep(random.randint(1000, 1500))

    QThread.msleep(random.randint(100, 200))
```

--------------------------------

### Get Target Monster Information (Python)

Source: https://context7.com/wojtas99/otibia_bot/llms.txt

Fetches details of the currently targeted monster, including its position (x, y, z), name, and HP percentage. Returns None for each attribute if no target is selected or if the read operation fails.

```python
from Functions.MemoryFunctions import read_target_info, read_targeting_status

# Check if player has a target
target_id = read_targeting_status()
if target_id != 0:
    target_x, target_y, target_z, target_name, target_hp = read_target_info()

    if target_hp > 0 and target_hp <= 100:
        print(f"Target: {target_name}")
        print(f"Position: ({target_x}, {target_y}, {target_z})")
        print(f"HP: {target_hp}%")
    else:
        print("Invalid target HP reading")
else:
    print("No target selected")

# Output: Target: Dragon
#         Position: (1026, 989, 7)
#         HP: 87%
```

--------------------------------

### Get Player Health and Mana Statistics (Python)

Source: https://context7.com/wojtas99/otibia_bot/llms.txt

Retrieves current and maximum health (HP) and mana (MP) values from the game memory. Returns these values as a tuple of four doubles and is crucial for healing and attack modules.

```python
from Functions.MemoryFunctions import read_my_stats

# Get all player stats in one call
current_hp, current_max_hp, current_mp, current_max_mp = read_my_stats()

# Calculate percentages for healing logic
hp_percentage = (current_hp * 100) / current_max_hp
mp_percentage = (current_mp * 100) / current_max_mp

if hp_percentage < 50:
    print(f"Warning: Low HP at {hp_percentage:.1f}%")
if mp_percentage < 20:
    print(f"Warning: Low MP at {mp_percentage:.1f}%")

# Output: Warning: Low HP at 45.2%
```

--------------------------------

### Load and Process Item Images for Recognition (Python)

Source: https://context7.com/wojtas99/otibia_bot/llms.txt

Loads item images from disk, applies Gaussian blur and grayscale conversion, and stores processed templates in a global dictionary. It requires PyQt5 for UI elements and uses custom functions for image loading. Images are expected in a specific directory structure.

```python
from PyQt5.QtWidgets import QListWidget, QListWidgetItem
from PyQt5.QtCore import Qt
from Functions.GeneralFunctions import load_items_images
import Addresses

# Set client name (determines image folder)
Addresses.client_name = "OTClientV8"

# Create loot list
loot_list = QListWidget()

# Add items (images must exist at Images/OTClientV8/<item_name>.png)
items = ['Gold Coin', 'Dragon Scale', 'Sword', 'Health Potion']
for item_name in items:
    loot_data = {'Loot': 1}
    item = QListWidgetItem(item_name)
    item.setData(Qt.UserRole, loot_data)
    loot_list.addItem(item)

# Load and process all images
load_items_images(loot_list)

# Access processed images
for item_name, data in Addresses.item_list.items():
    processed_image = data[0]  # NumPy array (grayscale, blurred, scaled 3x)
    loot_container = data[1]   # Backpack number
    print(f"{item_name}: shape={processed_image.shape}, container={loot_container}")

# Output: Gold Coin: shape=(66, 96), container=1
#         Dragon Scale: shape=(66, 96), container=1
```

--------------------------------

### Automated Pathfinding and Navigation (Python)

Source: https://context7.com/wojtas99/otibia_bot/llms.txt

Implements an automated pathfinding system using a predefined list of waypoints. It supports various movement actions like walking, using rope, shovel, and ladders, with features for stuck detection and recovery. Requires PyQt5 and custom `WalkerThread` class.

```python
from PyQt5.QtWidgets import QListWidget, QListWidgetItem
from PyQt5.QtCore import Qt
from Walker.WalkerThread import WalkerThread

# Create waypoint list
waypoints = []

# Add normal walking waypoint
waypoints.append({
    'Action': 0,       # 0=walk, 1=rope, 2=shovel, 3=ladder
    'Direction': 0,    # 0=auto, 1=N, 2=S, 3=E, 4=W, 9=center
    'X': 1024,
    'Y': 987,
    'Z': 7
})

# Add waypoint to walk east
waypoints.append({
    'Action': 0,
    'Direction': 3,    # Force east direction
    'X': 1030,
    'Y': 987,
    'Z': 7
})

# Add rope usage waypoint (go up)
waypoints.append({
    'Action': 1,       # Use rope tool
    'Direction': 9,    # Center direction
    'X': 1030,
    'Y': 987,
    'Z': 6
})

# Add shovel waypoint (dig down)
waypoints.append({
    'Action': 2,       # Use shovel tool
    'Direction': 9,
    'X': 1035,
    'Y': 990,
    'Z': 7
})

# Configure tool coordinates
Addresses.coordinates_x[9] = 850  # Shovel X
Addresses.coordinates_y[9] = 250  # Shovel Y
Addresses.coordinates_x[10] = 900  # Rope X
Addresses.coordinates_y[10] = 250  # Rope Y

# Start walker thread
walker = WalkerThread(waypoints)
walker.index_update.connect(lambda option, index: print(f"Waypoint: {index}"))
walker.start()

# Stop when done
# walker.stop()
# walker.wait()
```

--------------------------------

### Custom Hotkey System with SmartHotkeysThread

Source: https://context7.com/wojtas99/otibia_bot/llms.txt

Monitors keyboard input and executes rune clicks with target selection for servers that lack native hotkey support. Supports different targeting options like 'On Target', 'On Yourself', and 'With Crosshair'. Requires PyQt5 and custom threads.

```Python
from PyQt5.QtWidgets import QListWidget, QListWidgetItem
from PyQt5.QtCore import Qt
from SmartHotkeys.SmartHotkeysThread import SmartHotkeysThread
import Addresses

# Configure character position
Addresses.coordinates_x[0] = 400
Addresses.coordinates_y[0] = 300
Addresses.square_size = 32  # Pixels per tile

# Create hotkey list
hotkeys_list = QListWidget()

# F1 - Use rune on target
hotkey_data_target = {
    'Hotkey': 'F1',
    'Option': 'On Target',  # Options: 'On Target', 'On Yourself', 'With Crosshair'
    'X': 850,  # Rune position in backpack
    'Y': 200
}
item_target = QListWidgetItem('F1')
item_target.setData(Qt.UserRole, hotkey_data_target)
hotkeys_list.addItem(item_target)

# F2 - Use rune on yourself
hotkey_data_self = {
    'Hotkey': 'F2',
    'Option': 'On Yourself',
    'X': 900,
    'Y': 200
}
item_self = QListWidgetItem('F2')
item_self.setData(Qt.UserRole, hotkey_data_self)
hotkeys_list.addItem(item_self)

# F3 - Use rune with crosshair (follows mouse cursor)
hotkey_data_crosshair = {
    'Hotkey': 'F3',
    'Option': 'With Crosshair',
    'X': 950,
    'Y': 200
}
item_crosshair = QListWidgetItem('F3')
item_crosshair.setData(Qt.UserRole, hotkey_data_crosshair)
hotkeys_list.addItem(item_crosshair)

# Start smart hotkeys thread
smart_hotkeys = SmartHotkeysThread(hotkeys_list)
smart_hotkeys.start()

# Stop when done
# smart_hotkeys.stop()
# smart_hotkeys.wait()
```

--------------------------------

### Save and Load Bot Configurations with manage_profile

Source: https://context7.com/wojtas99/otibia_bot/llms.txt

Saves and loads bot configurations, including targeting, looting, waypoints, healing, and settings, in JSON format. Utilizes the `manage_profile` function from `Functions.GeneralFunctions`.

```Python
from Functions.GeneralFunctions import manage_profile

# Save targeting profile
targeting_config = {
    'targets': [
        {'Name': 'Dragon', 'Dist': 3, 'Stance': 2, 'Skin': True},
        {'Name': 'Demon', 'Dist': 1, 'Stance': 1, 'Skin': True}
    ],
    'attack_key': 'F1',
    'loot_enabled': True
}

success = manage_profile(
    action="save",
    directory="Save/Targeting",
    profile_name="cave_hunt",
    data=targeting_config
)
print(f"Save successful: {success}")

# Load targeting profile
loaded_config = manage_profile(
    action="load",
    directory="Save/Targeting",
    profile_name="cave_hunt"
)

if loaded_config:
    print(f"Loaded {len(loaded_config['targets'])} targets")
    print(f"Attack key: {loaded_config['attack_key']}")
else:
    print("Profile not found")

# Output: Save successful: True
#         Loaded 2 targets
#         Attack key: F1
```

--------------------------------

### Configure Custom Client Addresses in Python

Source: https://context7.com/wojtas99/otibia_bot/llms.txt

Loads client-specific memory addresses for OTibia Bot. This function sets game configuration like tile size and architecture, character position and stats, and target information offsets. It requires `os`, `win32gui`, `win32process`, and `c` modules, and assumes an `Addresses` class and helper functions like `fin_window_name` are defined.

```python
import os
import win32gui
import win32process
import c

# Assuming Addresses class and necessary helper functions are defined elsewhere
class Addresses:
    pass

def load_custom_client():
    # Game configuration
    Addresses.square_size = 32              # Tile size in pixels
    Addresses.application_architecture = 64  # 32 or 64 bit
    Addresses.collect_threshold = 0.85      # Image matching sensitivity

    # Character position addresses
    Addresses.my_x_address = 0xCE38F0
    Addresses.my_x_address_offset = []
    Addresses.my_y_address = 0xCE38F4
    Addresses.my_y_address_offset = []
    Addresses.my_z_address = 0xCE38F8
    Addresses.my_z_address_offset = []

    # Character stats
    Addresses.my_stats_address = 0x00CE2870
    Addresses.my_hp_offset = [0x568]
    Addresses.my_hp_max_offset = [0x570]
    Addresses.my_mp_offset = [0x5A0]
    Addresses.my_mp_max_offset = [0x5A8]

    # Target information
    Addresses.attack_address = 0xCE2878
    Addresses.attack_address_offset = []
    Addresses.target_x_offset = 0x38
    Addresses.target_y_offset = 0x3C
    Addresses.target_z_offset = 0x40
    Addresses.target_hp_offset = 0xE8
    Addresses.target_name_offset = 0xA8

    # Client identification
    Addresses.client_name = "CustomOTClient"
    os.makedirs(f"Images/{Addresses.client_name}", exist_ok=True)

    # Find and attach to game process
    Addresses.game_name = Addresses.fin_window_name(Addresses.client_name)
    Addresses.game = win32gui.FindWindow(None, Addresses.game_name)
    Addresses.proc_id = win32process.GetWindowThreadProcessId(Addresses.game)[1]
    Addresses.process_handle = c.windll.kernel32.OpenProcess(0x1F0FFF, False, Addresses.proc_id)
    modules = win32process.EnumProcessModules(Addresses.process_handle)
    Addresses.base_address = modules[0]

# Initialize
load_custom_client()

# Verify connection
# Assuming read_my_wpt() is defined elsewhere and returns (x, y, z) or (None, None, None)
def read_my_wpt():
    # Placeholder for actual memory reading function
    # This would typically read from Addresses.my_x_address, Addresses.my_y_address etc.
    # For demonstration, returning dummy values
    return (100, 200, 50)

x, y, z = read_my_wpt()
if x is not None:
    print(f"Successfully connected to client at position ({x}, {y}, {z})")
else:
    print("Failed to read memory - check addresses")

```

--------------------------------

### Automated Spell Casting with TrainingThread

Source: https://context7.com/wojtas99/otibia_bot/llms.txt

Continuously casts spells when mana threshold is met, useful for training magic level on training dummies. Requires PyQt5 for UI elements and a custom TrainingThread class.

```Python
from PyQt5.QtWidgets import QListWidget, QListWidgetItem
from PyQt5.QtCore import Qt
from Training.TrainingThread import TrainingThread

# Create training list
training_list = QListWidget()

# Add spell F5 (requires 60 MP)
training_data_1 = {'Mana': 60}
item_1 = QListWidgetItem('F5')
item_1.setData(Qt.UserRole, training_data_1)
training_list.addItem(item_1)

# Add spell F6 (requires 100 MP)
traininging_data_2 = {'Mana': 100}
item_2 = QListWidgetItem('F6')
item_2.setData(Qt.UserRole, training_data_2)
training_list.addItem(item_2)

# Start training thread
training = TrainingThread(training_list)
training.start()

# Stop when done
# training.stop()
# training.wait()
```

--------------------------------

### Initialize Tibia Client Memory Addresses

Source: https://context7.com/wojtas99/otibia_bot/llms.txt

Initializes all memory addresses, offsets, and game-specific parameters for a Tibia client. This function must be called before any memory reading operations are performed. It relies on the `Addresses` module.

```Python
import Addresses
```

--------------------------------

### Real-time Waypoint Recording (Python)

Source: https://context7.com/wojtas99/otibia_bot/llms.txt

Enables real-time recording of player waypoints by monitoring movement and automatically generating waypoint entries. It uses a `QComboBox` for direction selection and a custom `RecordThread` class. Updates are emitted via a signal, allowing integration with UI elements.

```python
from PyQt5.QtWidgets import QComboBox
from Walker.WalkerThread import RecordThread

# Create direction selector
direction_combo = QComboBox()
direction_combo.addItems(['Auto', 'North', 'South', 'East', 'West', 'Center'])
direction_combo.setCurrentIndex(0)  # Set to 'Auto'

# Start recording
record_thread = RecordThread(direction_combo)

# Handle waypoint updates
def on_waypoint_added(option, waypoint_item):
    waypoint_data = waypoint_item.data(Qt.UserRole)
    print(f"Recorded: {waypoint_item.text()}")
    print(f"  Position: ({waypoint_data['X']}, {waypoint_data['Y']}, {waypoint_data['Z']})")
    print(f"  Direction: {waypoint_data['Direction']}")
    # Add to waypoint list in your UI

record_thread.wpt_update.connect(on_waypoint_added)
record_thread.start()

# Stop recording
# record_thread.stop()
# record_thread.wait()

# Output: Recorded: Stand: 1024 987 7 Auto
```

--------------------------------

### Capture Game Window Screenshots (Python)

Source: https://context7.com/wojtas99/otibia_bot/llms.txt

Captures screenshots of a specified game window region without requiring the window to be in focus. It uses a custom `WindowCapture` class and libraries like OpenCV (cv2) and NumPy for image processing and template matching. The output is a BGR NumPy array.

```python
from Functions.GeneralFunctions import WindowCapture
import Addresses
import cv2 as cv
import numpy as np

# Initialize game
Addresses.game_name = "Tibia - Character Name"

# Define capture region (relative to window)
x_offset = 100    # Start X in window
y_offset = 150    # Start Y in window
width = 400       # Capture width
height = 300      # Capture height

# Create capture object
capture = WindowCapture(width, height, x_offset, y_offset)

# Capture screenshot
screenshot = capture.get_screenshot()  # Returns numpy array (H, W, 3) BGR

# Process screenshot
gray = cv.cvtColor(screenshot, cv.COLOR_BGR2GRAY)
blurred = cv.GaussianBlur(gray, (7, 7), 0)

# Find items using template matching
template = cv.imread('Images/OTClientV8/Gold Coin.png', cv.IMREAD_GRAYSCALE)
result = cv.matchTemplate(blurred, template, cv.TM_CCOEFF_NORMED)
locations = np.where(result >= 0.8)

print(f"Found {len(locations[0])} matches")
# Output: Found 3 matches
```

--------------------------------

### Move Character Toward Target (Python)

Source: https://context7.com/wojtas99/otibia_bot/llms.txt

Calculates the optimal direction to reach a target and sends the corresponding arrow key press. Includes randomization for diagonal choices when multiple paths are valid. Reads character and target information from memory.

```python
from Functions.KeyboardFunctions import chase_monster
from Functions.MemoryFunctions import read_my_wpt, read_target_info
import random
from PyQt5.QtCore import QThread

# Get positions
my_x, my_y, my_z = read_my_wpt()
target_x, target_y, target_z, target_name, target_hp = read_target_info()

# Chase until adjacent (within 1 tile diagonally)
while abs(my_x - target_x) > 1 or abs(my_y - target_y) > 1:
    chase_monster(my_x, my_y, target_x, target_y)
    QThread.msleep(random.randint(90, 150))
    my_x, my_y, my_z = read_my_wpt()

print("Reached target!")
```

--------------------------------

### Manage Monster Targeting and Combat Stance

Source: https://context7.com/wojtas99/otibia_bot/llms.txt

Manages target selection, combat positioning (chase, stay diagonal, chase diagonal), and triggers looting after kills. Integrates with walker system to control movement during combat. Configures attack keys and loot states.

```python
from PyQt5.QtWidgets import QListWidget
from Target.TargetLootThread import TargetThread

# Define targets with combat parameters
targets = [
    {
        'Name': 'Dragon',
        'Dist': 3,       # Attack from 3+ tiles away
        'Stance': 2,     # 0=stand, 1=chase, 2=diagonal, 3=chase diagonal
        'Skin': True     # Open corpse after kill
    },
    {
        'Name': 'Demon',
        'Dist': 1,       # Melee range
        'Stance': 1,     # Chase target
        'Skin': True
    },
    {
        'Name': '*',     # Any other monster
        'Dist': 0,       # Any distance
        'Stance': 0,     # Stand still
        'Skin': False    # Don't loot
    }
]

# Start targeting thread
attack_key = 0  # F1 key (0-indexed, so F1 = 0, F2 = 1, etc.)
loot_enabled = True
target_thread = TargetThread(targets, loot_enabled, attack_key)
target_thread.start()

# Update loot state dynamically
target_thread.update_states(option=0, state=False)  # Disable looting

# Stop when done
# target_thread.stop()
# target_thread.wait()
```

--------------------------------

### Automated Item Collection with Image Recognition (Python)

Source: https://context7.com/wojtas99/otibia_bot/llms.txt

Captures the game screen, uses OpenCV template matching to identify items, and automatically collects them to configured backpack slots. Supports priority-based collection order and defines screen capture and backpack coordinates.

```python
from PyQt5.QtWidgets import QListWidget, QListWidgetItem
from PyQt5.QtCore import Qt
from Target.TargetLootThread import LootThread
import Addresses

# Configure screen capture area
Addresses.screen_x[0] = 100  # Loot area X
Addresses.screen_y[0] = 150  # Loot area Y
Addresses.screen_width[0] = 400
Addresses.screen_height[0] = 300

# Configure backpack slots
Addresses.coordinates_x[1] = 800  # First backpack X
Addresses.coordinates_y[1] = 200  # First backpack Y
Addresses.coordinates_x[2] = 850  # Second backpack X
Addresses.coordinates_y[2] = 200

# Create loot list (priority order: top = collected first)
loot_list = QListWidget()

# Add gold coins to first backpack (loot container 1)
loot_data_gold = {'Loot': 1}
item_gold = QListWidgetItem('Gold Coin')  # Must match Images/ClientName/Gold Coin.png
item_gold.setData(Qt.UserRole, loot_data_gold)
loot_list.addItem(item_gold)

# Add dragon scale to second backpack (loot container 2)
loot_data_scale = {'Loot': 2}
item_scale = QListWidgetItem('Dragon Scale')
item_scale.setData(Qt.UserRole, loot_data_scale)
loot_list.addItem(item_scale)

# Add item to drop on ground (loot container 0)
loot_data_trash = {'Loot': 0}
item_trash = QListWidgetItem('Meat')
item_trash.setData(Qt.UserRole, loot_data_trash)
loot_list.addItem(item_trash)

# Add item to right-click (loot container -1)
loot_data_click = {'Loot': -1}
item_click = QListWidgetItem('Flask')
item_click.setData(Qt.UserRole, loot_data_click)
loot_list.addItem(item_click)

# Start looting thread
target_active = True  # Link with targeting state
loot_thread = LootThread(loot_list, target_active)
loot_thread.start()

# Update targeting state
loot_thread.update_states(state=False)

# Stop when done
# loot_thread.stop()
# loot_thread.wait()
```

--------------------------------

### Navigate Character to Target Coordinates

Source: https://context7.com/wojtas99/otibia_bot/llms.txt

Moves the character to specified target coordinates using directional key presses or map clicks. It handles pathfinding for adjacent tiles with arrow keys and distant locations with mouse clicks on the map.

```python
from Functions.KeyboardFunctions import walk
from Functions.MemoryFunctions import read_my_wpt

# Get current position
my_x, my_y, my_z = read_my_wpt()

# Navigate to waypoint
target_x = 1030
target_y = 990
target_z = 7
direction = 0  # 0=auto, 1=north, 2=south, 3=east, 4=west, 9=center

# Auto-walk to target (uses arrow keys for adjacent, clicks for distant)
walk(direction, my_x, my_y, my_z, target_x, target_y, target_z)

# Force walk north if target is within 3 tiles north
walk(1, my_x, my_y, my_z, target_x, target_y, target_z)

# Walk using map click if destination is far
walk(9, my_x, my_y, my_z, target_x + 10, target_y + 8, target_z)
```

--------------------------------

### Automated Spell Casting and Rune Usage

Source: https://context7.com/wojtas99/otibia_bot/llms.txt

A thread that monitors the current target and automatically casts attack spells or uses runes based on target HP, monster name, and player conditions. It supports hotkey spells and rune clicking.

```python
from PyQt5.QtWidgets import QListWidget, QListWidgetItem
from PyQt5.QtCore import Qt
from HealAttack.HealingAttackThread import AttackThread

# Create attack list
attack_list = QListWidget()

# Add attack spell for Dragons when target HP 100-50%
attack_data_spell = {
    'Name': 'Dragon',
    'Key': 'F3',
    'HpFrom': 100,   # Target HP upper limit
    'HpTo': 50,      # Target HP lower limit
    'MinMp': 80,     # Player MP requirement
    'MinHp': 30      # Player HP requirement (percentage)
}
item_spell = QListWidgetItem()
item_spell.setData(Qt.UserRole, attack_data_spell)
attack_list.addItem(item_spell)

# Add rune attack for any target when HP 50-0%
attack_data_rune = {
    'Name': '*',           # Wildcard for any monster
    'Key': 'First Rune',   # Use first rune slot
    'HpFrom': 50,
    'HpTo': 0,
    'MinMp': 20,
    'MinHp': 40
}
item_rune = QListWidgetItem()
item_rune.setData(Qt.UserRole, attack_data_rune)
attack_list.addItem(item_rune)

# Start attack thread
attack_thread = AttackThread(attack_list)
attack_thread.start()

# Stop when done
# attack_thread.stop()
# attack_thread.wait()
```

--------------------------------

### Execute Mouse Actions in Game Window (Python)

Source: https://context7.com/wojtas99/otibia_bot/llms.txt

Simulates mouse actions such as clicks and drag-and-drop operations within the game window by sending window messages. Includes optional randomization for coordinates to mimic human behavior. Supports various click types and item collection.

```python
import Addresses
from Functions.MouseFunctions import mouse_function

# Left click at character position (option 2)
char_x = Addresses.coordinates_x[0]  # Character center X
char_y = Addresses.coordinates_y[0]  # Character center Y
mouse_function(char_x, char_y, option=2)

# Right click on rune to open context menu (option 1)
rune_x = Addresses.coordinates_x[6]  # First rune slot
rune_y = Addresses.coordinates_y[6]
mouse_function(rune_x, rune_y, option=1)

# Collect item from ground to backpack (option 3)
item_x = 450  # Item screen coordinates
item_y = 320
backpack_x = Addresses.coordinates_x[1]  # First backpack slot
backpack_y = Addresses.coordinates_y[1]
mouse_function(item_x, item_y, backpack_x, backpack_y, option=3)

# Drag item from one slot to another (option 4)
mouse_function(backpack_x, backpack_y, char_x, char_y, option=4)
```

--------------------------------

### Use Potion with Mouse Click

Source: https://context7.com/wojtas99/otibia_bot/llms.txt

Simulates using a potion by performing a right-click followed by a left-click on the character's coordinates. This action is triggered using a specific mouse function with predefined coordinates and an option code.

```python
potion_x = Addresses.coordinates_x[5]
potion_y = Addresses.coordinates_y[5]
mouse_function(potion_x, potion_y, char_x, char_y, option=5)
```

--------------------------------

### Automated Healing and Mana Management

Source: https://context7.com/wojtas99/otibia_bot/llms.txt

A background thread that monitors HP/MP percentages and automatically uses potions or spells based on configurable conditions. It supports health potions, mana potions, and hotkey-based healing spells.

```python
from PyQt5.QtWidgets import QListWidget, QListWidgetItem
from PyQt5.QtCore import Qt
from HealAttack.HealingAttackThread import HealThread

# Create healing list with configurations
healing_list = QListWidget()

# Add HP healing spell (use F1 when HP 50-70%, requires 50+ MP)
heal_data_hp = {
    'Type': 'HP',
    'Key': 'F1',
    'Below': 70,    # Trigger when HP below 70%
    'Above': 50,    # Stop when HP above 50%
    'MinMp': 50     # Minimum MP required
}
item_hp = QListWidgetItem()
item_hp.setData(Qt.UserRole, heal_data_hp)
healing_list.addItem(item_hp)

# Add health potion (use when HP 40-60%, no MP requirement)
heal_data_pot = {
    'Type': 'HP',
    'Key': 'Health',  # Special key for health potion
    'Below': 60,
    'Above': 40,
    'MinMp': 0
}
item_pot = QListWidgetItem()
item_pot.setData(Qt.UserRole, heal_data_pot)
healing_list.addItem(item_pot)

# Add MP recovery spell (use F2 when MP below 30%)
heal_data_mp = {
    'Type': 'MP',
    'Key': 'F2',
    'Below': 30,
    'Above': 0,
    'MinMp': 0
}
item_mp = QListWidgetItem()
item_mp.setData(Qt.UserRole, heal_data_mp)
healing_list.addItem(item_mp)

# Start healing thread
heal_thread = HealThread(healing_list)
heal_thread.start()

# Stop when done
# heal_thread.stop()
# heal_thread.wait()
```

--------------------------------

### Read Pointer Address from Game Memory (Python)

Source: https://context7.com/wojtas99/otibia_bot/llms.txt

Reads multi-level pointer values from game memory using a base address and a chain of offsets. Supports various data types including byte, short, int, ulonglong, double, and UTF-8 strings. Returns None on read failure.

```python
import Addresses
from Functions.MemoryFunctions import read_pointer_address

# Initialize game process and load addresses
Addresses.load_tibia()

# Read player HP (following pointer chain from my_stats_address + offsets)
current_hp = read_pointer_address(
    Addresses.my_stats_address,     # Base address: 0x00CE2870
    Addresses.my_hp_offset,          # Offset chain: [0x568]
    Addresses.my_hp_type             # Data type: 5 (double)
)

# Read player position
x = read_pointer_address(Addresses.my_x_address, Addresses.my_x_address_offset, Addresses.my_x_type)
y = read_pointer_address(Addresses.my_y_address, Addresses.my_y_address_offset, Addresses.my_y_type)
z = read_pointer_address(Addresses.my_z_address, Addresses.my_z_address_offset, Addresses.my_z_type)

print(f"HP: {current_hp}, Position: ({x}, {y}, {z})")
# Output: HP: 785.0, Position: (1024, 987, 7)
```

--------------------------------

### Maintain Diagonal Positioning from Target (Python)

Source: https://context7.com/wojtas99/otibia_bot/llms.txt

Keeps the character exactly one tile diagonally from the target, moving randomly when aligned horizontally or vertically. This is used for ranged combat while avoiding melee damage. Reads character and target information from memory.

```python
from Functions.KeyboardFunctions import stay_diagonal
from Functions.MemoryFunctions import read_my_wpt, read_target_info
from PyQt5.QtCore import QThread
import random

my_x, my_y, my_z = read_my_wpt()
target_x, target_y, target_z, target_name, target_hp = read_target_info()

# Maintain diagonal position during combat
while target_hp > 0:
    stay_diagonal(my_x, my_y, target_x, target_y)
    QThread.msleep(random.randint(90, 150))

    my_x, my_y, my_z = read_my_wpt()
    target_x, target_y, target_z, target_name, target_hp = read_target_info()
```
Tokens:
Raw