blum_script_fast.py

import math
import sys
import os 
import hashlib 
import time
import textwrap
import tkinter as tk
from tkinter import messagebox, simpledialog
from PIL import Image, ImageTk
from threading import Thread
import webbrowser

import cv2
import keyboard
import mss
import numpy as np
import pygetwindow as gw
import win32api
import win32con
from colorama import init, Fore, Style
import pkg_resources
import pkgutil
from io import BytesIO


init(autoreset=True)

class Logger:
    def __init__(self, text_widget):
        self.text_widget = text_widget
        self.text_widget.tag_configure("green", foreground="#33cc33", font=("Helvetica", 10, "bold"))
        self.text_widget.tag_configure("green3", foreground="#33cc33") 
        self.text_widget.tag_configure("green2", foreground="#00FF7F", font=("Helvetica", 10, "bold"))
        self.text_widget.tag_configure("red", foreground="#cc3333", font=("Helvetica", 10, "bold"))
        self.text_widget.tag_configure("red2", foreground="#FF0000", font=("Helvetica", 9, "bold")) 
        self.text_widget.tag_configure("purple", foreground="purple", font=("Helvetica", 10, "bold"))
        self.text_widget.tag_configure("white", foreground="white", font=("Helvetica", 10, "bold"))
        self.text_widget.tag_configure("blue", foreground="blue", font=("Helvetica", 10, "bold"))
        self.text_widget.tag_configure("blue2", foreground="#00BFFF", font=("Helvetica", 10, "bold"))
        self.text_widget.tag_configure("blueV", foreground="#00BFFF", font=("Helvetica", 9, "bold")) 
        self.text_widget.tag_configure("orange", foreground="#ffa500", font=("Helvetica", 10, "bold"))
        self.text_widget.tag_configure("violet", foreground="#8A2BE2", font=("Helvetica", 10, "bold"))
        self.text_widget.tag_configure("violet2", foreground="#9370DB", font=("Helvetica", 10, "bold"))
        self.text_widget.tag_configure("violet3", foreground="#FF00FF", font=("Helvetica", 10, "bold"))
        self.text_widget.tag_configure("violetZ", foreground="#FF00FF", font=("Helvetica", 9, "bold")) 
        self.text_widget.tag_configure("cyan", foreground="#00FFFF", font=("Helvetica", 10, "bold"))
        self.text_widget.tag_configure("snow", foreground="#BC8F8F", font=("Helvetica", 10, "bold"))

    def log(self, data: str, color: str = "white"):
        self.text_widget.configure(state='normal')
        self.text_widget.insert(tk.END, data + "\n", (color,))
        self.text_widget.configure(state='disabled')
        self.text_widget.yview(tk.END)

class AutoClicker:
    def __init__(self, window_title, target_colors_hex, nearby_colors_hex, logger, click_interval, freeze_colors_hex, collect_freeze):
        self.window_title = window_title
        self.target_colors_hex = target_colors_hex
        self.freeze_colors_hex = freeze_colors_hex
        self.nearby_colors_hex = nearby_colors_hex
        self.collect_freeze = collect_freeze
        self.logger = logger
        self.running = False
        self.clicked_points = []
        self.iteration_count = 0
        self.click_interval = click_interval
        self.last_freeze_check_time = 0
        self.freeze_cooldown_time = 0

    def getchecksum():
        md5_hash = hashlib.md5()
        file = open(''.join(sys.argv), "rb")
        md5_hash.update(file.read())
        digest = md5_hash.hexdigest()
        return digest


    def check_and_click_freeze_button(self, sct, monitor):
        freeze_hsvs = [self.hex_to_hsv(color) for color in self.freeze_colors_hex]
        current_time = time.time()
        if current_time - self.last_freeze_check_time >= 1 and current_time >= self.freeze_cooldown_time:
            self.last_freeze_check_time = current_time
            img = np.array(sct.grab(monitor))
            img_bgr = cv2.cvtColor(img, cv2.COLOR_BGRA2BGR)
            hsv = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2HSV)
            for freeze_hsv in freeze_hsvs:
                lower_bound = np.array([max(0, freeze_hsv[0] - 1), 30, 30])
                upper_bound = np.array([min(179, freeze_hsv[0] + 1), 255, 255])
                mask = cv2.inRange(hsv, lower_bound, upper_bound)
                contours, _ = cv2.findContours(mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)

                for contour in contours:
                    if cv2.contourArea(contour) < 3:
                        continue

                    M = cv2.moments(contour)
                    if M["m00"] == 0:
                        continue
                    cX = int(M["m10"] / M["m00"]) + monitor["left"]
                    cY = int(M["m01"] / M["m00"]) + monitor["top"]

                    self.click_at(cX, cY)
                    self.logger.log(f'Нажал на заморозку...',"cyan")
                    self.freeze_cooldown_time = time.time() + 6  
                    return  

    @staticmethod
    def hex_to_hsv(hex_color):
        hex_color = hex_color.lstrip('#')
        h_len = len(hex_color)
        rgb = tuple(int(hex_color[i:i + h_len // 3], 16) for i in range(0, h_len, h_len // 3))
        rgb_normalized = np.array([[rgb]], dtype=np.uint8)
        hsv = cv2.cvtColor(rgb_normalized, cv2.COLOR_RGB2HSV)
        return hsv[0][0]

    @staticmethod
    def click_at(x, y):
        win32api.SetCursorPos((x, y))
        win32api.mouse_event(win32con.MOUSEEVENTF_LEFTDOWN, x, y, 0, 0)
        win32api.mouse_event(win32con.MOUSEEVENTF_LEFTUP, x, y, 0, 0)

    def toggle_script(self):
        self.running = not self.running
        r_text = "Скрипт включен" if self.running else "Скрипт поставлен на паузу"
        color = "green2" if self.running else "orange"
        self.logger.log(f'Статус изменен: {r_text}', color)
        if self.running:
            if autofarm_status.get():
                auto_farm_thread = Thread(target=self.auto_farm)
                auto_farm_thread.daemon = True
                auto_farm_thread.start()

    def is_near_color(self, hsv_img, center, target_hsvs, radius=8):
        x, y = center
        height, width = hsv_img.shape[:2]
        for i in range(max(0, x - radius), min(width, x + radius + 1)):
            for j in range(max(0, y - radius), min(height, y + radius + 1)):
                distance = math.sqrt((x - i) ** 2 + (y - j) ** 2)
                if distance <= radius:
                    pixel_hsv = hsv_img[j, i]
                    for target_hsv in target_hsvs:
                        if np.allclose(pixel_hsv, target_hsv, atol=[1, 50, 50]):
                            return True
        return False

    def click_color_areas(self):
        while True:
            try:
                windows = gw.getWindowsWithTitle(self.window_title)
                if not windows:
                    self.logger.log(f"Я ПОТЕРЯЛ {self.window_title}, пожалуйста нажми снова кнопку: inject", "red")
                    inject_btn.config(state=tk.NORMAL)
                    time.sleep(10)
                    continue

                self.logger.log(f'Успешный Inject на {self.window_title}', "green")

                window = windows[0]
                window.activate()
                target_hsvs = [self.hex_to_hsv(color) for color in self.target_colors_hex]
                nearby_hsvs = [self.hex_to_hsv(color) for color in self.nearby_colors_hex]

                with mss.mss() as sct:
                    keyboard.add_hotkey('q', self.toggle_script)

                    while True:
                        if self.running:
                            monitor = {
                                "top": window.top,
                                "left": window.left,
                                "width": window.width,
                                "height": window.height
                            }
                            img = np.array(sct.grab(monitor))
                            img_bgr = cv2.cvtColor(img, cv2.COLOR_BGRA2BGR)
                            hsv = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2HSV)

                            for target_hsv in target_hsvs:
                                lower_bound = np.array([max(0, target_hsv[0] - 1), 30, 30])
                                upper_bound = np.array([min(179, target_hsv[0] + 1), 255, 255])
                                mask = cv2.inRange(hsv, lower_bound, upper_bound)
                                contours, _ = cv2.findContours(mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)

                                for contour in reversed(contours):
                                    if cv2.contourArea(contour) < 1:
                                        continue

                                    M = cv2.moments(contour)
                                    if M["m00"] == 0:
                                        continue
                                    cX = int(M["m10"] / M["m00"]) + monitor["left"]
                                    cY = int(M["m01"] / M["m00"]) + monitor["top"]

                                    if not self.is_near_color(hsv, (cX - monitor["left"], cY - monitor["top"]), nearby_hsvs):
                                        continue

                                    if any(math.sqrt((cX - px) ** 2 + (cY - py) ** 2) < 35 for px, py in self.clicked_points):
                                        continue
                                    cY += 5
                                    self.click_at(cX, cY)
                                    self.clicked_points.append((cX, cY))

                            if self.collect_freeze and freeze_status.get():
                                self.check_and_click_freeze_button(sct, monitor)

                            time.sleep(self.click_interval)
                            self.iteration_count += 1
                            if self.iteration_count >= 5:
                                self.clicked_points.clear()
                                self.iteration_count = 0
            except Exception as e:
                self.logger.log(f"Произошла ошибка: {e}", "red")
                time.sleep(10)

    def auto_farm(self):
        while self.running:
            self.click_play_button()  
            time.sleep(1)

    def click_play_button(self):
        
        button_data_autofarm = pkg_resources.resource_string(__name__, 'image/autofarm.png')
        button_img_autofarm = Image.open(BytesIO(button_data_autofarm))
        button_img_autofarm = cv2.cvtColor(np.array(button_img_autofarm), cv2.COLOR_RGB2BGR)
        button_img_autofarm_gray = cv2.cvtColor(button_img_autofarm, cv2.COLOR_BGR2GRAY)
        w_autofarm, h_autofarm = button_img_autofarm_gray.shape[::-1]

        button_data_lobby = pkg_resources.resource_string(__name__, 'image/lobby-play.png')
        button_img_lobby = Image.open(BytesIO(button_data_lobby))
        button_img_lobby = cv2.cvtColor(np.array(button_img_lobby), cv2.COLOR_RGB2BGR)
        button_img_lobby_gray = cv2.cvtColor(button_img_lobby, cv2.COLOR_BGR2GRAY)
        w_lobby, h_lobby = button_img_lobby_gray.shape[::-1]

        button_data_restart = pkg_resources.resource_string(__name__, 'image/restart.png')
        button_img_restart = Image.open(BytesIO(button_data_restart))
        button_img_restart = cv2.cvtColor(np.array(button_img_restart), cv2.COLOR_RGB2BGR)
        button_img_restart_gray = cv2.cvtColor(button_img_restart, cv2.COLOR_BGR2GRAY)
        w_restart, h_restart = button_img_restart_gray.shape[::-1]

        
        windows = gw.getWindowsWithTitle(self.window_title)
        if windows:
            window = windows[0]
            monitor = {
                "top": window.top,
                "left": window.left,
                "width": window.width,
                "height": window.height
            }

           
            with mss.mss() as sct:
                img = np.array(sct.grab(monitor))
                img_bgr = cv2.cvtColor(img, cv2.COLOR_BGRA2BGR)
                img_gray = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2GRAY)

               
                res_autofarm = cv2.matchTemplate(img_gray, button_img_autofarm_gray, cv2.TM_CCOEFF_NORMED)
                res_lobby = cv2.matchTemplate(img_gray, button_img_lobby_gray, cv2.TM_CCOEFF_NORMED)
                res_restart = cv2.matchTemplate(img_gray, button_img_restart_gray, cv2.TM_CCOEFF_NORMED)  
                threshold = 0.8
                loc_autofarm = np.where(res_autofarm >= threshold)
                loc_lobby = np.where(res_lobby >= threshold)
                loc_restart = np.where(res_restart >= threshold)  

                if len(loc_autofarm[0]) > 0:
                    
                    pt = (loc_autofarm[1][0] + w_autofarm // 2, loc_autofarm[0][0] + h_autofarm // 2)
                    self.click_at(pt[0] + monitor["left"], pt[1] + monitor["top"])
                    self.logger.log("Нажатие play...", "violet2")
                elif len(loc_lobby[0]) > 0:
                    
                    pt = (loc_lobby[1][0] + w_lobby // 2, loc_lobby[0][0] + h_lobby // 2)
                    self.click_at(pt[0] + monitor["left"], pt[1] + monitor["top"])
                    self.logger.log("Нажатие play в лобби...", "violet2")
                elif len(loc_restart[0]) > 0:  
                    
                    pt = (loc_restart[1][0] + w_restart // 2, loc_restart[0][0] + h_restart // 2)
                    self.click_at(pt[0] + monitor["left"], pt[1] + monitor["top"])
                    self.logger.log("Нажатие restart...", "violet2")    
                else:
                    
                    for _ in range(5):  
                        for _ in range(12):  
                            self.scroll_down_in_telegram(window)
                        img = np.array(sct.grab(monitor))
                        img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
                        res_lobby = cv2.matchTemplate(img_gray, button_img_lobby_gray, cv2.TM_CCOEFF_NORMED)
                        loc_lobby = np.where(res_lobby >= threshold)
                        if len(loc_lobby[0]) > 0:
                            pt = (loc_lobby[1][0] + w_lobby // 2, loc_lobby[0][0] + h_lobby // 2)
                            self.click_at(pt[0] + monitor["left"], pt[1] + monitor["top"])
                            break

    def scroll_down_in_telegram(self, window):
        """Скроллим вниз по центру окна Telegram"""
        x_center = window.left + window.width // 2
        y_center = window.top + window.height // 2
        
        win32api.SetCursorPos((x_center, y_center))
        win32api.mouse_event(win32con.MOUSEEVENTF_WHEEL, x_center, y_center, -1, 0)  

def inject():
    global auto_clicker
    inject_btn.config(state=tk.DISABLED)

 
    windows = gw.getAllTitles()
    windows = [win for win in windows if win]  

    
    select_window = tk.Toplevel(root)
    select_window.title("Выберите приложение")
    select_window.geometry("500x500")

    
    for i, win in enumerate(windows):
        label = tk.Label(select_window, text=f"{i+1}. {win}")
        label.pack()

   
    entry = tk.Entry(select_window)
    entry.pack()

    def on_ok():
        try:
            selected_index = int(entry.get()) - 1
            if 0 <= selected_index < len(windows):
                selected_window = windows[selected_index]
                auto_clicker.window_title = selected_window
                select_window.destroy()
                auto_clicker_thread = Thread(target=auto_clicker.click_color_areas)
                auto_clicker_thread.daemon = True
                auto_clicker_thread.start()
            else:
                messagebox.showerror("Ошибка", "Неверный номер приложения")
        except ValueError:
            messagebox.showerror("Ошибка", "Введите корректный номер")

    
    ok_btn = tk.Button(select_window, text="OK", command=on_ok)
    ok_btn.pack()

def set_click_interval():
    global click_interval
    try:
        click_interval = float(click_entry.get())
        auto_clicker.click_interval = click_interval
        logger.log("Заданная скорость клика: " + str(click_interval), "purple")
    except ValueError:
        messagebox.showerror("Ошибка", "Пожалуйста, введите корректное число.")

def toggle_autofarm():
    if inject_btn['state'] == tk.DISABLED:
        autofarm_status.set(not autofarm_status.get())
        color = "green" if autofarm_status.get() else "red"
        text = "ON" if autofarm_status.get() else "OFF"
        autofarm_btn.configure(bg=color, text=text)
        status_text = "режим autofarm включен" if autofarm_status.get() else "режим autofarm выключен"
        logger.log(status_text, color)

def toggle_freeze():
    freeze_status.set(not freeze_status.get())
    color = "cyan" if freeze_status.get() else "snow"
    text = "L" if freeze_status.get() else "L"
    freeze_btn.configure(bg=color, text=text)
    status_text = "Legit mod включен" if freeze_status.get() else "Legit mod выключен"
    logger.log(status_text, color)

def open_perk_ai_link():
    link = "https://t.me/qq_guyses"
    webbrowser.open(link)


root = tk.Tk()
root.title("qq | blum clicker")
root.geometry("610x400")  
root.configure(bg='black')


ascii_art = """                             
          _                   _
        /\ \                /\ \     
       /  \ \              /  \ \    
      / /\ \ \            / /\ \ \   
     / / /\ \ \          / / /\ \ \  
    / / /  \ \_\        / / /  \ \_\ 
   / / / _ / / /       / / / _ / / / 
  / / / /\ \/ /       / / / /\ \/ /  
 / / /__\ \ \/       / / /__\ \ \/   
/ / /____\ \ \      / / /____\ \ \   
\/________\_\/     \/ ________\_\/                                                                           
"""


text_widget = tk.Text(root, height=15, state='disabled', bg='black', fg='white', insertbackground='white')
text_widget.pack(pady=10, padx=10, fill='both', expand=True)


logger = Logger(text_widget)
logger.log(ascii_art, "green3")


try:
    icon_data = pkg_resources.resource_string(__name__, 'image/blum1.png')
    icon_image = Image.open(BytesIO(icon_data))
    icon_photo = ImageTk.PhotoImage(icon_image)
    root.iconphoto(False, icon_photo)
except FileNotFoundError:
    messagebox.showerror("Ошибка", "Не удалось найти файл 'blum1.png'. Убедитесь, что он находится в правильном каталоге.")


button_frame = tk.Frame(root, bg='black')
button_frame.pack(pady=5, padx=10, fill='x')

inject_btn = tk.Button(button_frame, text="Inject", command=inject, bg='white', fg='black', height=2, width=10)
inject_btn.pack(side='left', padx=5, pady=5)

perk_ai_btn = tk.Button(button_frame, text="qq | тгк", command=open_perk_ai_link, bg='white', fg='black', height=2, width=10)
perk_ai_btn.pack(side='left', padx=5, pady=5)

autofarm_status = tk.BooleanVar(root, False)
autofarm_btn = tk.Button(button_frame, text="OFF", bg='red', fg='black', command=toggle_autofarm, height=2, width=10)
autofarm_btn.pack(side='left', padx=5, pady=5)

click_entry = tk.Entry(button_frame, bg='black', fg='white', insertbackground='white', width=10)
click_entry.pack(side='left', padx=5, pady=5)
click_btn = tk.Button(button_frame, text="Set Click Interval", command=set_click_interval, bg='black', fg='white', height=2, width=15)
click_btn.pack(side='left', padx=5, pady=5)

freeze_btn = tk.Button(button_frame, text="L", bg='white', fg='black', command=toggle_freeze, height=2, width=5)
freeze_btn.pack(side='left', padx=5, pady=5)

logger.log("VERSION 2.0", "blueV")
logger.log("Если вы не понимаете как работает скрипт или в чем то не разобрались читайте гайд внимательно.", "violetZ")
logger.log("ВСЕ ОБНОВЛ И РЕЛИЗ БУДУТ ОПОВЕЩАТЬСЯ В ТГК - КНОПКА: qq | ткг ", "red2")

def background_task():
    while True:
        time.sleep(10)
        if not auto_clicker.running:
            windows = gw.getWindowsWithTitle("TelegramDesktop")
            if not windows:
                logger.log("Я ПОТЕРЯЛ ОКНО, пожалуйста нажми снова кнопку: inject", "red")
                inject_btn.config(state=tk.NORMAL)


bg_thread = Thread(target=background_task)
bg_thread.daemon = True
bg_thread.start()
freeze_status = tk.BooleanVar(root, False)
collect_freeze = True  

freeze_colors_hex = ["#81dff1", "#96eafc"]
target_colors_hex = ["#e6f975", "#f100dc"]
nearby_colors_hex = ["#e6f471", "#ec00dc" ]
click_interval = 0.001
auto_clicker = AutoClicker("TelegramDesktop", target_colors_hex, nearby_colors_hex, logger, click_interval, freeze_colors_hex, collect_freeze)



CORRECT_KEY = "LVQM-000NDKVD-WW1"  


def check_key(key):
    try:
        
        if key == CORRECT_KEY:
            return True
        else:
            return False
    except Exception as e:
        messagebox.showerror("Ошибка", f"Ошибка при проверке ключа: {e}")
        return False


def show_key_input():
    key_window = tk.Toplevel(root)
    key_window.title("Введите ключ")
    key_window.geometry("300x150")
    key_window.configure(bg='black')  
    key_window.protocol("WM_DELETE_WINDOW", lambda: sys.exit())  


    key_window.grab_set()  
    key_window.focus_set()  

    try:
        icon_data = pkg_resources.resource_string(__name__, 'image/blum1.png')
        icon_image = Image.open(BytesIO(icon_data))
        icon_photo = ImageTk.PhotoImage(icon_image)
        key_window.iconphoto(False, icon_photo)
    except FileNotFoundError:
        messagebox.showerror("Ошибка", "Не удалось найти файл 'blum1.png'. Убедитесь, что он находится в правильном каталоге.")

    
    key_label = tk.Label(key_window, text="Введите ключ доступа:", bg='black', fg='white', font=("Helvetica", 10, "bold"))
    key_label.pack(pady=10)

    key_entry = tk.Entry(key_window, bg='black', fg='white', insertbackground='white', font=("Helvetica", 10))
    key_entry.pack(pady=5)

    def on_submit():
        key = key_entry.get()
        if key:
            if check_key(key):
                messagebox.showinfo("Успех", "Ключ принят! Доступ разрешен.")
                key_window.grab_release()  
                key_window.destroy()  
            else:
                messagebox.showerror("Ошибка", "Неверный ключ доступа!")
        else:
            messagebox.showerror("Ошибка", "Пожалуйста, введите ключ!")

    submit_btn = tk.Button(key_window, text="OK", command=on_submit, bg='white', fg='black', font=("Helvetica", 10, "bold"))
    submit_btn.pack(pady=5)

    def get_key():
        webbrowser.open("https://t.me/qqkey_bot?start=_tgr_Qs0uxDdmZTFi")  

    get_key_btn = tk.Button(key_window, text="Получить ключ", command=get_key, bg='white', fg='black', font=("Helvetica", 10, "bold"))
    get_key_btn.pack(pady=5)


show_key_input()



root.mainloop()