Temat: [BOT] Tibia 7.4

import pyautogui
import time
import random
from PIL import ImageGrab, ImageChops
from pynput import keyboard
import threading
import traceback


running = True
paused = False
mouse_lock = threading.Lock()
pause_lock = threading.Lock()
blank_rune_color = None


def log_error(e):
    with open("bot_errors.log", "a") as f:
        f.write(traceback.format_exc() + "\n")


def on_press(key):
    global paused
    if key == keyboard.Key.f8:
        with pause_lock:
            paused = not paused
        print("▶️ Bot wznowiony." if not paused else "⏸️ Bot zapauzowany.")


keyboard.Listener(on_press=on_press).start()


def get_position(name):
    input(f"🖱️ Ustaw myszkę na {name} i naciśnij ENTER...")
    pos = pyautogui.position()
    print(f"{name} pozycja: {pos}")
    return pos


def is_similar_color(rgb1, rgb2, tolerance=35):
    return all(abs(a - b) <= tolerance for a, b in zip(rgb1, rgb2))


def is_water_color(rgb):
    ref = (30, 80, 200)
    return is_similar_color(rgb, ref, tolerance=30)


def find_water_tiles(area_top_left, area_bottom_right):
    print("🔍 Szukam kratek z wodą...")
    screenshot = ImageGrab.grab(bbox=(area_top_left[0], area_top_left[1], area_bottom_right[0], area_bottom_right[1]))
    width, height = screenshot.size
    tile_size = 32
    water_tiles = []


    for y in range(0, height - tile_size, tile_size):
        for x in range(0, width - tile_size, tile_size):
            try:
                pixel_color = screenshot.getpixel((x + tile_size // 2, y + tile_size // 2))
                if is_water_color(pixel_color):
                    screen_x = area_top_left[0] + x + tile_size // 2
                    screen_y = area_top_left[1] + y + tile_size // 2
                    water_tiles.append((screen_x, screen_y))
            except:
                continue


    print(f"💧 Znaleziono {len(water_tiles)} kratek z wodą.")
    return water_tiles


def wait_if_paused():
    while True:
        with pause_lock:
            if not paused:
                break
        time.sleep(0.5)


def fish(fishing_rod_pos, water_tiles):
    global running
    print("🎣 Rozpoczynam łowienie...")


    while running:
        duration = random.uniform(60, 120)
        print(f"🕒 Nowa runda łowienia: {int(duration)} sekund.")
        start_time = time.time()


        while time.time() - start_time < duration:
            wait_if_paused()
            try:
                with mouse_lock:
                    pyautogui.moveTo(fishing_rod_pos)
                    pyautogui.rightClick()
                    time.sleep(random.uniform(0.2, 0.4))


                    tile = random.choice(water_tiles)
                    pyautogui.moveTo(tile)
                    pyautogui.leftClick()


                time.sleep(random.uniform(0.4, 0.8))
            except Exception as e:
                log_error(e)
                time.sleep(1)


        print("⏱️ Koniec rundy łowienia.")
        break_time = random.uniform(300, 780)
        print(f"⏸️ Przerwa przed kolejnym cyklem łowienia: {int(break_time // 60)} minut.")
        time.sleep(break_time)


def eat_fish(fish_pos):
    global running
    print("🍽️ Rozpoczynam jedzenie ryb...")


    while running:
        wait_if_paused()
        time_until_eat = random.uniform(420, 780)
        time.sleep(time_until_eat)


        click_count = random.randint(5, 9)
        print(f"🍴 Jedzenie ryby ({click_count} razy)")


        try:
            with mouse_lock:
                pyautogui.moveTo(fish_pos)
                for _ in range(click_count):
                    wait_if_paused()
                    pyautogui.rightClick()
                    time.sleep(random.uniform(0.3, 0.7))
        except Exception as e:
            log_error(e)


def monitorowanie(monitor_top_left, monitor_bottom_right, check_interval=1.0):
    global running, paused
    print("🖥️ Monitorowanie obszaru pod kątem zmian uruchomione...")


    prev_screenshot = ImageGrab.grab(bbox=(monitor_top_left[0], monitor_top_left[1], monitor_bottom_right[0], monitor_bottom_right[1]))
    last_trigger_time = 0
    cooldown = 5


    while running:
        wait_if_paused()


        current_screenshot = ImageGrab.grab(bbox=(monitor_top_left[0], monitor_top_left[1], monitor_bottom_right[0], monitor_bottom_right[1]))
        diff = ImageChops.difference(prev_screenshot, current_screenshot)
        bbox = diff.getbbox()


        if bbox and (time.time() - last_trigger_time) > cooldown:
            print("⚠️ Zmiana wykryta! Wysyłam Ctrl + L i wstrzymuję bota.")
            with mouse_lock:
                pyautogui.keyDown('ctrl')
                pyautogui.press('l')
                pyautogui.keyUp('ctrl')


            with pause_lock:
                paused = True
            last_trigger_time = time.time()
            prev_screenshot = current_screenshot


        time.sleep(check_interval)


def robienie_run(blank_rune_positions):
    global running, blank_rune_color
    print("🏃‍♂️ Uruchomiono funkcję robienia run.")


    while running:
        wait_if_paused()
        time.sleep(random.uniform(300, 480))  # ⏱️ Zmieniony interwał: 5–8 minut


        try:
            wait_if_paused()
            print("🔍 Sprawdzam pozycje Blank Rune...")
            current_color = ImageGrab.grab().getpixel(blank_rune_positions[0])


            if is_similar_color(current_color, blank_rune_color, tolerance=35):
                print("✅ Blank Rune znaleziona. Używam F1.")
                with mouse_lock:
                    pyautogui.press('f1')


                time.sleep(random.uniform(0.5, 1.5))  # ⏱️ Czekaj aż F1 zadziała


                new_color = ImageGrab.grab().getpixel(blank_rune_positions[0])
                if is_similar_color(new_color, blank_rune_color, tolerance=35):
                    print("🛑 Blank Rune nadal aktualna – nie przenoszę nowej.")
                    continue
                else:
                    print("⚠️ Blank Rune zużyta – przenoszę nową.")
            else:
                print("❌ Blank Rune nie została znaleziona w pierwszej pozycji. Przenoszę nową.")


            for pos in blank_rune_positions[1:]:
                wait_if_paused()
                current_color = ImageGrab.grab().getpixel(pos)
                if is_similar_color(current_color, blank_rune_color, tolerance=35):
                    print(f"🔄 Przenoszę Blank Rune z pozycji {pos} na pierwszą.")
                    with mouse_lock:
                        pyautogui.moveTo(pos)
                        pyautogui.mouseDown()
                        time.sleep(0.2)
                        pyautogui.moveTo(blank_rune_positions[0])
                        pyautogui.mouseUp()
                    break
        except Exception as e:
            log_error(e)


def main():
    global running, blank_rune_color


    try:
        fishing_rod_pos = get_position("WĘDKĘ (fishing rod)")
        area_top_left = get_position("GÓRNY LEWY róg obszaru wody")
        area_bottom_right = get_position("DOLNY PRAWY róg obszaru wody")
        fish_pos = get_position("Pozycja ryb")
        monitor_top_left = get_position("GÓRNY LEWY róg OBSZARU MONITOROWANEGO")
        monitor_bottom_right = get_position("DOLNY PRAWY róg OBSZARU MONITOROWANEGO")


        blank_rune_positions = [
            get_position("POZYCJA 1 Blank Rune (główna)"),
            get_position("POZYCJA 2 Blank Rune"),
            get_position("POZYCJA 3 Blank Rune"),
            get_position("POZYCJA 4 Blank Rune")
        ]


        blank_rune_color = ImageGrab.grab().getpixel(blank_rune_positions[0])
        print(f"🎨 Zapisany kolor Blank Rune: {blank_rune_color}")


        water_tiles = find_water_tiles(area_top_left, area_bottom_right)


        if not water_tiles:
            print("❌ Nie znaleziono kratek z wodą.")
        else:
            threading.Thread(target=fish, args=(fishing_rod_pos, water_tiles), daemon=True).start()
            threading.Thread(target=eat_fish, args=(fish_pos,), daemon=True).start()
            threading.Thread(target=monitorowanie, args=(monitor_top_left, monitor_bottom_right), daemon=True).start()
            threading.Thread(target=robienie_run, args=(blank_rune_positions,), daemon=True).start()


            while running:
                time.sleep(1)


    except KeyboardInterrupt:
        running = False
        print("⛔ Bot zatrzymany przez użytkownika.")
    except Exception as e:
        log_error(e)


if __name__ == "__main__":
    main()