From f09c758e7acd5e31935d4e1a40b83e6fa8a4988d Mon Sep 17 00:00:00 2001 From: zhougf Date: Sun, 10 May 2026 19:54:15 +0800 Subject: [PATCH] =?UTF-8?q?feat:=20=E6=B7=BB=E5=8A=A0=E5=AE=9E=E6=97=B6?= =?UTF-8?q?=E7=9B=91=E6=8E=A7=E7=82=B9=E5=87=BB=E4=BB=BB=E5=8A=A1=E5=8A=9F?= =?UTF-8?q?=E8=83=BD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- integrated_task_tool.py | 1683 +++++++++++++++++++++++++++++++++++++++ task_config.json | 69 ++ 2 files changed, 1752 insertions(+) create mode 100644 integrated_task_tool.py create mode 100644 task_config.json diff --git a/integrated_task_tool.py b/integrated_task_tool.py new file mode 100644 index 0000000..4b811fc --- /dev/null +++ b/integrated_task_tool.py @@ -0,0 +1,1683 @@ +import cv2 +import numpy as np +import pyautogui +import time +import mss +import mss.tools +import os +import sys +import json +import logging +import random +from datetime import datetime +from PyQt5.QtWidgets import ( + QApplication, QMainWindow, QWidget, QLabel, QLineEdit, + QPushButton, QVBoxLayout, QHBoxLayout, QTextEdit, + QFileDialog, QDoubleSpinBox, QMessageBox, QSpinBox, QCheckBox, + QGroupBox, QProgressBar, QComboBox, QTabWidget, QInputDialog, + QScrollArea +) +from PyQt5.QtCore import ( + Qt, QThread, pyqtSignal, QTimer, QMutex, QMutexLocker, + QCoreApplication +) +from PyQt5.QtGui import QColor, QFont, QPainter, QPixmap + +os.environ["QT_MAC_WANTS_LAYER"] = "1" +os.environ["QT_IM_MODULE"] = "" + +CONFIG_FILE = "task_config.json" +LOG_FILE = "task_execution.log" + +class QTextEditLogger(logging.Handler): + def __init__(self, text_edit): + super().__init__() + self.text_edit = text_edit + self.text_edit.setReadOnly(True) + + def emit(self, record): + msg = self.format(record) + timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S") + log_msg = f"[{timestamp}] [{record.levelname}] {msg}\n" + + QCoreApplication.processEvents() + if record.levelno == logging.ERROR: + self.text_edit.setTextColor(QColor(255, 0, 0)) + elif record.levelno == logging.WARNING: + self.text_edit.setTextColor(QColor(255, 165, 0)) + elif record.levelno == logging.SUCCESS: + self.text_edit.setTextColor(QColor(0, 128, 0)) + else: + self.text_edit.setTextColor(QColor(0, 0, 0)) + + self.text_edit.insertPlainText(log_msg) + self.text_edit.moveCursor(self.text_edit.textCursor().End) + +logging.SUCCESS = 25 +logging.addLevelName(logging.SUCCESS, 'SUCCESS') + +def get_random_offset(pos, max_offset=15): + x, y = pos + x_offset = random.randint(-max_offset, max_offset) + y_offset = random.randint(-max_offset, max_offset) + x_new = max(0, x + x_offset) + y_new = max(0, y + y_offset) + return (x_new, y_new), (x_offset, y_offset) + +def get_random_wait(base_time, variance=0.3): + offset = base_time * variance + return base_time + random.uniform(-offset, offset) + +class ScreenCapture: + def __init__(self, monitor_config=None): + self.sct = mss.MSS() + if monitor_config: + self.monitor = monitor_config + else: + self.monitor = { + "top": 240, + "left": 450, + "width": 1490, + "height": 1000 + } + + def capture(self): + screenshot = self.sct.grab(self.monitor) + img = np.array(screenshot) + img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) + return img + + def capture_as_bgr(self): + screenshot = self.sct.grab(self.monitor) + img = np.array(screenshot) + img = cv2.cvtColor(img, cv2.COLOR_BGRA2BGR) + return img + + def get_monitor(self): + return self.monitor + + def get_full_monitor(self): + return { + "left": self.monitor['left'], + "top": self.monitor['top'], + "width": self.monitor['width'], + "height": self.monitor['height'] + } + +class TaskStatistics: + def __init__(self): + self.reset() + + def reset(self): + self.start_time = None + self.end_time = None + self.total_cycles = 0 + self.successful_cycles = 0 + self.failed_cycles = 0 + self.images_found = 0 + self.images_not_found = 0 + self.total_clicks = 0 + + def start(self): + self.start_time = datetime.now() + + def end(self): + self.end_time = datetime.now() + + def get_duration(self): + if self.start_time and self.end_time: + return (self.end_time - self.start_time).total_seconds() + return 0 + + def to_dict(self): + return { + "start_time": self.start_time.strftime("%Y-%m-%d %H:%M:%S") if self.start_time else None, + "end_time": self.end_time.strftime("%Y-%m-%d %H:%M:%S") if self.end_time else None, + "duration_seconds": self.get_duration(), + "total_cycles": self.total_cycles, + "successful_cycles": self.successful_cycles, + "failed_cycles": self.failed_cycles, + "images_found": self.images_found, + "images_not_found": self.images_not_found, + "total_clicks": self.total_clicks + } + +class SafeTaskThread(QThread): + log_signal = pyqtSignal(str, int) + progress_signal = pyqtSignal(int) + finish_signal = pyqtSignal() + stats_signal = pyqtSignal(dict) + + def __init__(self, task_type, screenshot_path, target_path, target_path2, threshold, + is_cycle, cycle_times, wait_time, max_offset=15, screen_capture=None, + jg_wait_time=15, task_images=None, interval=2, max_fail=0): + super().__init__() + self.mutex = QMutex() + self.is_running = True + self.is_paused = False + + self.task_type = task_type + self.screenshot_path = screenshot_path + self.target_path = target_path + self.target_path2 = target_path2 + self.threshold = threshold + self.is_cycle = is_cycle + self.cycle_times = cycle_times + self.wait_time = wait_time + self.max_offset = max_offset + self.screen_capture = screen_capture + self.jg_wait_time = jg_wait_time + self.task_images = task_images or [] + self.interval = interval + self.max_fail = max_fail + + self.stats = TaskStatistics() + + def stop(self): + locker = QMutexLocker(self.mutex) + self.is_running = False + locker.unlock() + self.log_signal.emit("正在停止任务,请等待...", logging.WARNING) + self.wait(5000) + + def pause(self): + locker = QMutexLocker(self.mutex) + self.is_paused = True + locker.unlock() + self.log_signal.emit("任务已暂停", logging.INFO) + + def resume(self): + locker = QMutexLocker(self.mutex) + self.is_paused = False + locker.unlock() + self.log_signal.emit("任务已恢复", logging.INFO) + + def is_thread_running(self): + locker = QMutexLocker(self.mutex) + return self.is_running + + def run(self): + self.stats.start() + try: + if self.task_type == "cycle_click": + self.log_signal.emit("开始执行循环点击任务(带随机偏移)", logging.INFO) + self._run_cycle_task() + elif self.task_type == "screenshot": + self.log_signal.emit("开始执行:仅截图", logging.INFO) + self._run_screenshot_task() + elif self.task_type == "find": + self.log_signal.emit("开始执行:仅找图", logging.INFO) + self._run_find_task() + elif self.task_type == "sequence": + self.log_signal.emit("开始执行序列任务", logging.INFO) + self._run_sequence_task() + elif self.task_type == "kun28": + self.log_signal.emit("开始执行困28任务", logging.INFO) + self._run_kun28_task() + elif self.task_type == "monitor_click": + self.log_signal.emit("开始执行实时监控点击任务", logging.INFO) + self._run_monitor_click_task() + except Exception as e: + self.log_signal.emit(f"任务异常:{str(e)}", logging.ERROR) + finally: + self.stats.end() + locker = QMutexLocker(self.mutex) + self.is_running = False + self.is_paused = False + locker.unlock() + self.log_signal.emit("任务线程已安全退出", logging.INFO) + self.stats_signal.emit(self.stats.to_dict()) + self.finish_signal.emit() + + def _check_stop(self): + locker = QMutexLocker(self.mutex) + should_stop = not self.is_running + locker.unlock() + return should_stop + + def _check_pause(self): + while True: + locker = QMutexLocker(self.mutex) + is_paused = self.is_paused + locker.unlock() + if not is_paused: + break + time.sleep(0.1) + + def _capture_screen(self): + if self.screen_capture: + return self.screen_capture.capture_as_bgr() + else: + with mss.MSS() as sct: + monitor = sct.monitors[0] + screenshot = sct.grab(monitor) + img = np.array(screenshot) + return cv2.cvtColor(img, cv2.COLOR_BGRA2BGR) + + def _find_image_in_screenshot(self, image_path, screenshot): + try: + if not os.path.exists(image_path): + self.log_signal.emit(f"目标图文件不存在:{image_path}", logging.ERROR) + return None + + target = cv2.imread(image_path) + if target is None: + self.log_signal.emit(f"目标图读取失败:{image_path}", logging.ERROR) + return None + + result = cv2.matchTemplate(screenshot, target, cv2.TM_CCOEFF_NORMED) + min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(result) + self.log_signal.emit(f"匹配度:{max_val:.4f}(阈值:{self.threshold})", logging.INFO) + + if max_val >= self.threshold: + target_h, target_w = target.shape[:2] + center_x = max_loc[0] + target_w // 2 + center_y = max_loc[1] + target_h // 2 + target_pos = (int(center_x), int(center_y)) + self.log_signal.emit(f"找到目标!坐标:{target_pos},匹配度:{max_val:.4f}", logging.SUCCESS) + self.stats.images_found += 1 + return target_pos + else: + self.log_signal.emit(f"未找到目标:匹配度({max_val:.4f}) < 阈值({self.threshold})", logging.WARNING) + self.stats.images_not_found += 1 + return None + except Exception as e: + self.log_signal.emit(f"找图异常:{str(e)}", logging.ERROR) + return None + + def _wait_for_image(self, image_path, timeout=10, click_offset=None): + found = False + found_pos = None + start_time = time.time() + + while time.time() - start_time < timeout and self.is_running and not found: + self._check_pause() + if self._check_stop(): + break + screenshot = self._capture_screen() + if screenshot is not None: + pos = self._find_image_in_screenshot(image_path, screenshot) + if pos: + if click_offset: + screen_x = pos[0] + self.screen_capture.get_monitor()['left'] + click_offset[0] + screen_y = pos[1] + self.screen_capture.get_monitor()['top'] + click_offset[1] + else: + screen_x = pos[0] + self.screen_capture.get_monitor()['left'] + screen_y = pos[1] + self.screen_capture.get_monitor()['top'] + self._click_position(screen_x, screen_y) + found_pos = (screen_x, screen_y) + found = True + time.sleep(0.5) + + return found, found_pos + + def _click_position(self, x, y): + if self._check_stop(): + return + try: + click_pos, offset = get_random_offset((x, y), self.max_offset) + self.log_signal.emit(f"点击坐标:原始={x,y},偏移={offset},最终={click_pos}", logging.INFO) + pyautogui.moveTo(click_pos[0], click_pos[1], duration=random.uniform(0.1, 0.3)) + pyautogui.click(click_pos[0], click_pos[1]) + self.log_signal.emit(f"点击完成:{click_pos}", logging.SUCCESS) + self.stats.total_clicks += 1 + except Exception as e: + self.log_signal.emit(f"点击失败:{str(e)}", logging.ERROR) + + def _run_full_task(self): + if self._check_stop(): + return + screenshot = self._capture_screen() + if screenshot is None or self._check_stop(): + return + target_pos = self._find_image_in_screenshot(self.target_path, screenshot) + if target_pos and not self._check_stop(): + monitor = self.screen_capture.get_monitor() + self._click_position(target_pos[0] + monitor['left'], target_pos[1] + monitor['top']) + self.stats.successful_cycles += 1 + self.log_signal.emit("一键任务执行完毕", logging.SUCCESS) + + def _run_cycle_task(self): + screenshot = self._capture_screen() + if screenshot is None or self._check_stop(): + return + target_pos = self._find_image_in_screenshot(self.target_path, screenshot) + if not target_pos or self._check_stop(): + self.log_signal.emit("循环任务终止:未找到目标坐标或任务已停止", logging.ERROR) + self.stats.failed_cycles += 1 + return + + monitor = self.screen_capture.get_monitor() + click_x = target_pos[0] + monitor['left'] + click_y = target_pos[1] + monitor['top'] + + self.log_signal.emit(f"开始循环点击:坐标={target_pos},最大随机偏移={self.max_offset}像素", logging.INFO) + self.log_signal.emit(f"循环配置:次数={self.cycle_times}(0=无限),间隔={self.wait_time}秒", logging.INFO) + + cycle_count = 0 + while True: + if self._check_stop(): + self.log_signal.emit(f"循环任务已停止,共执行{cycle_count}次", logging.WARNING) + break + self._check_pause() + if self.cycle_times > 0 and cycle_count >= self.cycle_times: + self.log_signal.emit(f"循环完成:共执行{cycle_count}次", logging.SUCCESS) + break + + cycle_count += 1 + self.stats.total_cycles += 1 + self.log_signal.emit(f"===== 循环第{cycle_count}次 =====", logging.INFO) + + self._click_position(click_x, click_y) + actual_wait = get_random_wait(self.wait_time) + self.log_signal.emit(f"等待{actual_wait:.1f}秒(基础{self.wait_time}秒)", logging.INFO) + for i in range(int(actual_wait)): + if self._check_stop(): + break + self._check_pause() + time.sleep(1) + + if self._check_stop(): + break + self.stats.successful_cycles += 1 + if self.cycle_times == 0 and not self._check_stop(): + self.log_signal.emit(f"无限循环中(第{cycle_count}次)", logging.INFO) + + def _run_tp_js_cycle_task(self): + screenshot = self._capture_screen() + if screenshot is None or self._check_stop(): + return + tp_pos = self._find_image_in_screenshot(self.target_path, screenshot) + if not tp_pos or self._check_stop(): + self.log_signal.emit("tp+js循环任务终止:未找到tp目标坐标", logging.ERROR) + return + + if not os.path.exists(self.target_path2): + self.log_signal.emit(f"js目标图文件不存在:{self.target_path2}", logging.ERROR) + return + + monitor = self.screen_capture.get_monitor() + click_x = tp_pos[0] + monitor['left'] + click_y = tp_pos[1] + monitor['top'] + + self.log_signal.emit(f"开始tp+js循环:tp坐标={tp_pos},最大随机偏移={self.max_offset}像素", logging.INFO) + + cycle_count = 0 + while True: + if self._check_stop(): + self.log_signal.emit(f"tp+js循环任务已停止,共执行{cycle_count}次", logging.WARNING) + break + self._check_pause() + if self.cycle_times > 0 and cycle_count >= self.cycle_times: + self.log_signal.emit(f"tp+js循环完成:共执行{cycle_count}次", logging.SUCCESS) + break + + cycle_count += 1 + self.stats.total_cycles += 1 + self.log_signal.emit(f"===== tp+js循环第{cycle_count}次 =====", logging.INFO) + + self._click_position(click_x, click_y) + time.sleep(3) + + tp_y_plus_150 = (click_x, click_y + 150) + self.log_signal.emit(f"y轴+150后点击,新坐标={tp_y_plus_150}", logging.INFO) + self._click_position(tp_y_plus_150[0], tp_y_plus_150[1]) + time.sleep(2) + + screenshot = self._capture_screen() + if not screenshot or self._check_stop(): + return + + self.log_signal.emit("查找js图标", logging.INFO) + js_pos = self._find_image_in_screenshot(self.target_path2, screenshot) + + if not js_pos: + self.log_signal.emit("未找到js图标,跳过本次循环", logging.WARNING) + else: + self.log_signal.emit(f"点击js图标,坐标={js_pos}", logging.INFO) + js_click_x = js_pos[0] + monitor['left'] + js_click_y = js_pos[1] + monitor['top'] + self._click_position(js_click_x, js_click_y) + + time.sleep(20) + if self._check_stop(): + break + self.stats.successful_cycles += 1 + if self.cycle_times == 0 and not self._check_stop(): + self.log_signal.emit(f"无限循环中(第{cycle_count}次)", logging.INFO) + + def _run_screenshot_task(self): + if not self._check_stop(): + screenshot = self._capture_screen() + if screenshot is not None: + cv2.imwrite(self.screenshot_path, screenshot) + self.log_signal.emit(f"截图已保存:{self.screenshot_path}", logging.SUCCESS) + self.stats.successful_cycles += 1 + self.log_signal.emit("截图任务执行完毕", logging.INFO) + + def _run_find_task(self): + if not self._check_stop(): + screenshot = self._capture_screen() + if screenshot is not None and not self._check_stop(): + pos = self._find_image_in_screenshot(self.target_path, screenshot) + if pos: + monitor = self.screen_capture.get_monitor() + screen_x = pos[0] + monitor['left'] + screen_y = pos[1] + monitor['top'] + self.log_signal.emit(f"找到目标,屏幕坐标:({screen_x}, {screen_y}),移动鼠标...", logging.SUCCESS) + pyautogui.moveTo(screen_x, screen_y, duration=random.uniform(0.2, 0.5)) + self.log_signal.emit(f"鼠标已移动到目标位置", logging.SUCCESS) + else: + self.log_signal.emit("未找到目标", logging.WARNING) + self.stats.successful_cycles += 1 + self.log_signal.emit("找图任务执行完毕", logging.INFO) + + def _run_sequence_task(self): + if not self.task_images or len(self.task_images) == 0: + self.log_signal.emit("序列任务错误:未配置任何图片", logging.ERROR) + return + + self.log_signal.emit(f"开始序列任务,共{len(self.task_images)}张图片", logging.INFO) + self.log_signal.emit(f"查找失败上限:{self.max_fail}次(0=不限制)", logging.INFO) + self.log_signal.emit("=" * 50, logging.INFO) + + monitor = self.screen_capture.get_monitor() + + cycle_count = 0 + total_fail_count = 0 + while self.is_running: + cycle_count += 1 + self.stats.total_cycles += 1 + if self.cycle_times > 0 and cycle_count > self.cycle_times: + self.log_signal.emit(f"已达到循环次数限制({self.cycle_times}次),任务结束", logging.SUCCESS) + break + + self.log_signal.emit(f"===== 第{cycle_count}轮序列 =====", logging.INFO) + + for i, image_path in enumerate(self.task_images): + self._check_pause() + if self._check_stop(): + break + + self.log_signal.emit(f"[步骤{i+1}/{len(self.task_images)}] 查找 {os.path.basename(image_path)}", logging.INFO) + + found = False + start_time = time.time() + + while not found and self.is_running: + self._check_pause() + if self._check_stop(): + break + + screenshot = self._capture_screen() + if screenshot is not None: + pos = self._find_image_in_screenshot(image_path, screenshot) + if pos: + screen_x = pos[0] + monitor['left'] + screen_y = pos[1] + monitor['top'] + self._click_position(screen_x, screen_y) + self.log_signal.emit(f"找到 {os.path.basename(image_path)} 并点击", logging.SUCCESS) + found = True + total_fail_count = 0 + time.sleep(self.interval) + + if not found: + total_fail_count += 1 + self.stats.failed_cycles += 1 + self.log_signal.emit(f"未找到 {os.path.basename(image_path)},累计失败{total_fail_count}次", logging.WARNING) + if self.max_fail > 0 and total_fail_count >= self.max_fail: + self.log_signal.emit(f"已达到查找失败上限({self.max_fail}次),任务结束", logging.ERROR) + return + + if found and self.is_running: + self._check_pause() + if self._check_stop(): + break + actual_wait = get_random_wait(self.wait_time) + self.log_signal.emit(f"等待{actual_wait:.1f}秒(基础{self.wait_time}秒)...", logging.INFO) + for _ in range(int(actual_wait)): + if self._check_stop(): + break + self._check_pause() + time.sleep(1) + + if self._check_stop(): + break + self.stats.successful_cycles += 1 + self.log_signal.emit("===== 一轮序列完成 =====", logging.INFO) + self.log_signal.emit("=" * 50, logging.INFO) + time.sleep(1) + + def _run_kun28_task(self): + self.log_signal.emit("开始困28任务流程", logging.INFO) + self.log_signal.emit("=" * 50, logging.INFO) + + monitor = self.screen_capture.get_monitor() + center_x = monitor['width'] // 2 + monitor['left'] + center_y = monitor['height'] // 2 + monitor['top'] + + self.log_signal.emit("[初始化] 点击屏幕中间", logging.INFO) + self._click_position(center_x, center_y) + time.sleep(3) + + self.log_signal.emit("[步骤2] 识别281.png", logging.INFO) + img_281_path = self.task_images.get('281', '281.png') + found_281, pos = self._wait_for_image(img_281_path, timeout=10) + if found_281: + self.log_signal.emit("找到281.png并点击", logging.SUCCESS) + time.sleep(3) + else: + self.log_signal.emit("未找到281.png,任务可能无法正常执行", logging.WARNING) + + self.log_signal.emit("[步骤3] 识别ts.png", logging.INFO) + ts_path = self.task_images.get('ts', 'ts.png') + found_ts, pos = self._wait_for_image(ts_path, timeout=10) + if found_ts: + self.log_signal.emit("找到ts.png并点击", logging.SUCCESS) + time.sleep(3) + else: + self.log_signal.emit("未找到ts.png,任务可能无法正常执行", logging.WARNING) + + cycle_count = 0 + while self.is_running: + cycle_count += 1 + self.stats.total_cycles += 1 + if self.cycle_times > 0 and cycle_count > self.cycle_times: + self.log_signal.emit(f"已达到循环次数限制({self.cycle_times}次),任务结束", logging.SUCCESS) + break + + self.log_signal.emit(f"循环第{cycle_count}轮" + (f" (共{self.cycle_times}轮)" if self.cycle_times > 0 else " (无限循环)"), logging.INFO) + self.log_signal.emit("-" * 30, logging.INFO) + + self._check_pause() + if self._check_stop(): + break + + self.log_signal.emit("[步骤1] 点击屏幕中间", logging.INFO) + self._click_position(center_x, center_y) + time.sleep(3) + + self._check_pause() + if self._check_stop(): + break + + self.log_signal.emit("[步骤4] 识别ss.png", logging.INFO) + ss_path = self.task_images.get('ss', 'ss.png') + + found_ss = False + exception_count = 0 + max_exceptions = 2 + + while not found_ss and exception_count < max_exceptions and self.is_running: + found, pos = self._wait_for_image(ss_path, timeout=10) + if found: + self.log_signal.emit("找到ss.png并点击", logging.SUCCESS) + found_ss = True + else: + exception_count += 1 + if exception_count < max_exceptions: + self.log_signal.emit(f"未找到ss.png,执行异常步骤({exception_count}/{max_exceptions})", logging.WARNING) + yd_path = self.task_images.get('yd', 'yd.png') + yd_found, yd_pos = self._wait_for_image(yd_path, timeout=10, click_offset=(0, -150)) + if yd_found: + self.log_signal.emit("找到yd.png并点击(y轴-150)", logging.SUCCESS) + time.sleep(3) + else: + self.log_signal.emit("未找到yd.png", logging.WARNING) + else: + self.log_signal.emit(f"步骤4未找到ss.png,已达到异常处理上限({max_exceptions}次),任务结束", logging.ERROR) + self.stats.failed_cycles += 1 + self.is_running = False + break + + if found_ss and self.is_running: + actual_wait = get_random_wait(self.jg_wait_time) + self.log_signal.emit(f"等待{actual_wait:.1f}秒(基础{self.jg_wait_time}秒)...", logging.INFO) + for i in range(int(actual_wait)): + if self._check_stop(): + break + self._check_pause() + time.sleep(1) + + if not self.is_running: + break + self.stats.successful_cycles += 1 + self.log_signal.emit("任务流程循环", logging.INFO) + self.log_signal.emit("=" * 50, logging.INFO) + time.sleep(1) + + def _run_monitor_click_task(self): + self.log_signal.emit("开始实时监控点击任务", logging.INFO) + self.log_signal.emit(f"监控间隔:{self.interval}秒", logging.INFO) + self.log_signal.emit(f"点击后等待:{self.jg_wait_time}秒", logging.INFO) + self.log_signal.emit(f"目标图片数量:{len(self.task_images)}", logging.INFO) + max_offset = self.max_offset + + while self.is_running: + self._check_pause() + if self._check_stop(): + break + + screenshot = self._capture_screen() + if screenshot is None: + time.sleep(self.interval) + continue + + found_pos = None + for img_path in self.task_images: + if self._check_stop(): + break + pos = self._find_image_in_screenshot(img_path, screenshot) + if pos: + found_pos = pos + break + + if found_pos: + monitor = self.screen_capture.get_monitor() + click_x = found_pos[0] + monitor['left'] + click_y = found_pos[1] + monitor['top'] + click_pos, offset = get_random_offset((click_x, click_y), max_offset) + self.log_signal.emit(f"点击坐标:原始={click_x,click_y},偏移={offset},最终={click_pos}", logging.INFO) + self._click_position(click_pos[0], click_pos[1]) + + actual_wait = get_random_wait(self.jg_wait_time) + self.log_signal.emit(f"找到目标并点击,等待{actual_wait:.1f}秒", logging.INFO) + for i in range(int(actual_wait)): + if self._check_stop(): + break + self._check_pause() + time.sleep(1) + + time.sleep(self.interval) + +class MainWindow(QMainWindow): + def __init__(self): + super().__init__() + random.seed(time.time()) + self.current_dir = os.path.dirname(os.path.abspath(__file__)) or os.getcwd() + self.task_thread = None + self.screen_capture = ScreenCapture() + self.config = self.load_config() + + self.initUI() + self.initLogging() + self.load_settings() + self.load_sequence_presets() + + def load_config(self): + try: + if os.path.exists(CONFIG_FILE): + with open(CONFIG_FILE, 'r', encoding='utf-8') as f: + return json.load(f) + except Exception as e: + print(f"加载配置文件失败: {e}") + return {} + + def save_config(self): + try: + with open(CONFIG_FILE, 'w', encoding='utf-8') as f: + json.dump(self.config, f, ensure_ascii=False, indent=4) + except Exception as e: + print(f"保存配置文件失败: {e}") + + def initUI(self): + self.setWindowTitle("任务自动化工具 V6.0 (优化版)") + self.setGeometry(100, 100, 1000, 850) + self.setMinimumSize(900, 800) + + central_widget = QWidget() + self.setCentralWidget(central_widget) + main_layout = QVBoxLayout(central_widget) + + self.tabs = QTabWidget() + + self.tab_basic = QWidget() + self.tab_monitor = QWidget() + self.tab_kun28 = QWidget() + self.tab_sequence = QWidget() + self.tab_config = QWidget() + + self.tabs.addTab(self.tab_basic, "基础任务") + self.tabs.addTab(self.tab_monitor, "实时监控") + self.tabs.addTab(self.tab_kun28, "困28任务") + self.tabs.addTab(self.tab_sequence, "序列任务") + self.tabs.addTab(self.tab_config, "配置管理") + + self.setup_basic_tab() + self.setup_monitor_tab() + self.setup_kun28_tab() + self.setup_sequence_tab() + self.setup_config_tab() + + main_layout.addWidget(self.tabs) + + control_group = QGroupBox("任务控制") + control_layout = QHBoxLayout(control_group) + + self.start_btn = QPushButton("开始任务") + self.start_btn.clicked.connect(self.start_task) + self.pause_btn = QPushButton("暂停") + self.pause_btn.clicked.connect(self.pause_task) + self.pause_btn.setEnabled(False) + self.stop_btn = QPushButton("停止") + self.stop_btn.clicked.connect(self.stop_task) + self.stop_btn.setEnabled(False) + + control_layout.addWidget(self.start_btn) + control_layout.addWidget(self.pause_btn) + control_layout.addWidget(self.stop_btn) + + self.status_label = QLabel("就绪") + control_layout.addWidget(self.status_label) + control_layout.addStretch() + + main_layout.addWidget(control_group) + + log_group = QGroupBox("日志输出") + log_layout = QVBoxLayout(log_group) + + self.log_text = QTextEdit() + self.log_text.setReadOnly(True) + log_layout.addWidget(self.log_text) + + main_layout.addWidget(log_group) + + stats_group = QGroupBox("执行统计") + stats_layout = QHBoxLayout(stats_group) + + self.stats_label = QLabel("运行时长: 0s | 循环: 0 | 成功: 0 | 失败: 0 | 点击: 0") + stats_layout.addWidget(self.stats_label) + self.save_log_btn = QPushButton("保存日志") + self.save_log_btn.clicked.connect(self.save_log_to_file) + stats_layout.addWidget(self.save_log_btn) + + main_layout.addWidget(stats_group) + + def setup_basic_tab(self): + layout = QVBoxLayout(self.tab_basic) + + task_group = QGroupBox("任务配置") + task_layout = QVBoxLayout(task_group) + + task_type_layout = QHBoxLayout() + task_type_label = QLabel("任务类型:") + self.task_type_combo = QComboBox() + self.task_type_combo.addItem("仅截图(screenshot)", "screenshot") + self.task_type_combo.addItem("仅找图(find)", "find") + self.task_type_combo.addItem("循环点击(cycle)", "cycle_click") + self.task_type_combo.addItem("实时监控点击(monitor_click)", "monitor_click") + self.task_type_combo.currentIndexChanged.connect(self.on_task_type_changed) + task_type_layout.addWidget(task_type_label) + task_type_layout.addWidget(self.task_type_combo) + task_layout.addLayout(task_type_layout) + + target_layout = QHBoxLayout() + target_label = QLabel("目标图片路径:") + self.target_edit = QLineEdit() + target_browse_btn = QPushButton("浏览") + target_browse_btn.clicked.connect(self.browse_target_path) + target_layout.addWidget(target_label) + target_layout.addWidget(self.target_edit, 1) + target_layout.addWidget(target_browse_btn) + task_layout.addLayout(target_layout) + + threshold_layout = QHBoxLayout() + threshold_label = QLabel("匹配阈值:") + self.threshold_spin = QDoubleSpinBox() + self.threshold_spin.setRange(0.5, 1.0) + self.threshold_spin.setSingleStep(0.01) + self.threshold_spin.setValue(0.8) + threshold_layout.addWidget(threshold_label) + threshold_layout.addWidget(self.threshold_spin) + threshold_layout.addStretch() + task_layout.addLayout(threshold_layout) + + cycle_layout = QHBoxLayout() + cycle_label = QLabel("循环次数(0=无限):") + self.cycle_spin = QSpinBox() + self.cycle_spin.setRange(0, 9999) + self.cycle_spin.setValue(0) + cycle_layout.addWidget(cycle_label) + cycle_layout.addWidget(self.cycle_spin) + cycle_layout.addWidget(QLabel("等待时间(秒):")) + self.wait_time_spin = QSpinBox() + self.wait_time_spin.setRange(1, 999) + self.wait_time_spin.setValue(15) + cycle_layout.addWidget(self.wait_time_spin) + task_layout.addLayout(cycle_layout) + + offset_layout = QHBoxLayout() + offset_label = QLabel("最大随机偏移:") + self.offset_spin = QSpinBox() + self.offset_spin.setRange(0, 50) + self.offset_spin.setValue(15) + offset_layout.addWidget(offset_label) + offset_layout.addWidget(self.offset_spin) + offset_layout.addStretch() + task_layout.addLayout(offset_layout) + + self.multi_image_group = QGroupBox("多目标图片配置(实时监控点击)") + multi_image_layout = QVBoxLayout(self.multi_image_group) + + preset_layout = QHBoxLayout() + preset_layout.addWidget(QLabel("配置预设:")) + self.monitor_preset_combo = QComboBox() + self.monitor_preset_combo.addItem("选择预设...", "") + self.monitor_preset_combo.currentIndexChanged.connect(self.on_monitor_preset_changed) + preset_layout.addWidget(self.monitor_preset_combo) + + save_preset_btn = QPushButton("保存预设") + save_preset_btn.clicked.connect(self.save_monitor_preset) + preset_layout.addWidget(save_preset_btn) + + delete_preset_btn = QPushButton("删除预设") + delete_preset_btn.clicked.connect(self.delete_monitor_preset) + preset_layout.addWidget(delete_preset_btn) + preset_layout.addStretch() + multi_image_layout.addLayout(preset_layout) + + scroll_area = QScrollArea() + scroll_area.setWidgetResizable(True) + scroll_area.setMinimumHeight(150) + scroll_content = QWidget() + self.multi_image_layout = QVBoxLayout(scroll_content) + scroll_area.setWidget(scroll_content) + multi_image_layout.addWidget(scroll_area) + + add_remove_layout = QHBoxLayout() + add_img_btn = QPushButton("+ 添加图片") + add_img_btn.clicked.connect(self.add_monitor_target) + remove_img_btn = QPushButton("- 移除最后一个") + remove_img_btn.clicked.connect(self.remove_monitor_target) + add_remove_layout.addWidget(add_img_btn) + add_remove_layout.addWidget(remove_img_btn) + multi_image_layout.addLayout(add_remove_layout) + self.multi_image_targets = [] + task_layout.addWidget(self.multi_image_group) + self.multi_image_group.hide() + + self.monitor_interval_widget = QWidget() + self.monitor_interval_layout = QHBoxLayout(self.monitor_interval_widget) + self.monitor_interval_layout.addWidget(QLabel("监控间隔(秒):")) + self.monitor_interval_spin = QSpinBox() + self.monitor_interval_spin.setRange(1, 60) + self.monitor_interval_spin.setValue(2) + self.monitor_interval_layout.addWidget(self.monitor_interval_spin) + self.monitor_interval_layout.addWidget(QLabel("点击后等待(秒):")) + self.monitor_click_wait_spin = QSpinBox() + self.monitor_click_wait_spin.setRange(1, 999) + self.monitor_click_wait_spin.setValue(3) + self.monitor_interval_layout.addWidget(self.monitor_click_wait_spin) + self.monitor_interval_layout.addWidget(QLabel("随机偏移:")) + self.monitor_offset_spin = QSpinBox() + self.monitor_offset_spin.setRange(0, 50) + self.monitor_offset_spin.setValue(15) + self.monitor_interval_layout.addWidget(self.monitor_offset_spin) + self.monitor_interval_layout.addStretch() + task_layout.addWidget(self.monitor_interval_widget) + self.monitor_interval_widget.hide() + + self.load_monitor_click_config() + + layout.addWidget(task_group) + layout.addStretch() + + def setup_monitor_tab(self): + layout = QVBoxLayout(self.tab_monitor) + + monitor_group = QGroupBox("截图区域实时预览") + monitor_layout = QVBoxLayout(monitor_group) + + monitor_values_layout = QHBoxLayout() + monitor_values_layout.addWidget(QLabel("left:")) + self.monitor_left = QSpinBox() + self.monitor_left.setRange(0, 9999) + self.monitor_left.setValue(450) + monitor_values_layout.addWidget(self.monitor_left) + monitor_values_layout.addWidget(QLabel("top:")) + self.monitor_top = QSpinBox() + self.monitor_top.setRange(0, 9999) + self.monitor_top.setValue(240) + monitor_values_layout.addWidget(self.monitor_top) + monitor_values_layout.addWidget(QLabel("width:")) + self.monitor_width = QSpinBox() + self.monitor_width.setRange(100, 9999) + self.monitor_width.setValue(1490) + monitor_values_layout.addWidget(self.monitor_width) + monitor_values_layout.addWidget(QLabel("height:")) + self.monitor_height = QSpinBox() + self.monitor_height.setRange(100, 9999) + self.monitor_height.setValue(1000) + monitor_values_layout.addWidget(self.monitor_height) + monitor_layout.addLayout(monitor_values_layout) + + preview_btn_layout = QHBoxLayout() + self.preview_toggle_btn = QPushButton("开始实时预览") + self.preview_toggle_btn.clicked.connect(self.toggle_live_preview) + preview_btn_layout.addWidget(self.preview_toggle_btn) + monitor_layout.addLayout(preview_btn_layout) + + self.preview_label = QLabel('点击"开始实时预览"显示实时画面') + self.preview_label.setAlignment(Qt.AlignCenter) + self.preview_label.setStyleSheet("border: 1px solid gray; background: #2b2b2b; color: white;") + self.preview_label.setMinimumHeight(300) + monitor_layout.addWidget(self.preview_label) + + self.preview_timer = None + self.is_preview_running = False + + layout.addWidget(monitor_group) + layout.addStretch() + + def toggle_live_preview(self): + if self.is_preview_running: + self.is_preview_running = False + if self.preview_timer: + self.preview_timer.stop() + self.preview_timer = None + self.preview_toggle_btn.setText("开始实时预览") + self.preview_label.setText('点击"开始实时预览"显示实时画面') + self.preview_label.clear() + else: + self.is_preview_running = True + self.preview_toggle_btn.setText("停止实时预览") + self.preview_timer = QTimer(self) + self.preview_timer.timeout.connect(self.update_live_preview) + self.preview_timer.start(100) + + def update_live_preview(self): + try: + left = self.monitor_left.value() + top = self.monitor_top.value() + width = self.monitor_width.value() + height = self.monitor_height.value() + + monitor_config = { + "left": left, + "top": top, + "width": width, + "height": height + } + sct = mss.MSS() + screenshot = sct.grab(monitor_config) + img = np.array(screenshot) + img = cv2.cvtColor(img, cv2.COLOR_BGRA2BGR) + + target_path = self.target_edit.text().strip() + if target_path and os.path.exists(target_path): + try: + target = cv2.imread(target_path) + if target is not None: + result = cv2.matchTemplate(img, target, cv2.TM_CCOEFF_NORMED) + min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(result) + threshold = self.threshold_spin.value() + if max_val >= threshold: + target_h, target_w = target.shape[:2] + top_left = max_loc + bottom_right = (top_left[0] + target_w, top_left[1] + target_h) + cv2.rectangle(img, top_left, bottom_right, (0, 255, 255), 2) + center_x = top_left[0] + target_w // 2 + center_y = top_left[1] + target_h // 2 + cv2.putText(img, f"{max_val:.2f}", (top_left[0], top_left[1] - 5), + cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 255), 1) + except Exception: + pass + + preview_path = os.path.join(self.current_dir, "preview_region.png") + cv2.imwrite(preview_path, img) + + pixmap = QPixmap(preview_path) + scaled_pixmap = pixmap.scaled(400, 300, Qt.KeepAspectRatio, Qt.SmoothTransformation) + self.preview_label.setPixmap(scaled_pixmap) + except Exception: + pass + + def setup_kun28_tab(self): + layout = QVBoxLayout(self.tab_kun28) + + info_label = QLabel("困28任务流程:点击中心 → 281.png → ts.png → 循环(点击中心 → ss.png[异常yd.png] → 等待)") + info_label.setStyleSheet("color: blue; font-weight: bold;") + info_label.setWordWrap(True) + layout.addWidget(info_label) + + config_group = QGroupBox("困28任务图片配置") + config_layout = QVBoxLayout(config_group) + + img281_layout = QHBoxLayout() + img281_layout.addWidget(QLabel("281.png 路径:")) + self.kun28_281_edit = QLineEdit() + self.kun28_281_edit.setPlaceholderText("默认为当前目录的281.png") + img281_browse_btn = QPushButton("浏览") + img281_browse_btn.clicked.connect(lambda: self.browse_image_file(self.kun28_281_edit)) + img281_layout.addWidget(self.kun28_281_edit) + img281_layout.addWidget(img281_browse_btn) + config_layout.addLayout(img281_layout) + + ts_layout = QHBoxLayout() + ts_layout.addWidget(QLabel("ts.png 路径:")) + self.kun28_ts_edit = QLineEdit() + self.kun28_ts_edit.setPlaceholderText("默认为当前目录的ts.png") + ts_browse_btn = QPushButton("浏览") + ts_browse_btn.clicked.connect(lambda: self.browse_image_file(self.kun28_ts_edit)) + ts_layout.addWidget(self.kun28_ts_edit) + ts_layout.addWidget(ts_browse_btn) + config_layout.addLayout(ts_layout) + + ss_layout = QHBoxLayout() + ss_layout.addWidget(QLabel("ss.png 路径:")) + self.kun28_ss_edit = QLineEdit() + self.kun28_ss_edit.setPlaceholderText("默认为当前目录的ss.png") + ss_browse_btn = QPushButton("浏览") + ss_browse_btn.clicked.connect(lambda: self.browse_image_file(self.kun28_ss_edit)) + ss_layout.addWidget(self.kun28_ss_edit) + ss_layout.addWidget(ss_browse_btn) + config_layout.addLayout(ss_layout) + + yd_layout = QHBoxLayout() + yd_layout.addWidget(QLabel("yd.png 路径:")) + self.kun28_yd_edit = QLineEdit() + self.kun28_yd_edit.setPlaceholderText("默认为当前目录的yd.png") + yd_browse_btn = QPushButton("浏览") + yd_browse_btn.clicked.connect(lambda: self.browse_image_file(self.kun28_yd_edit)) + yd_layout.addWidget(self.kun28_yd_edit) + yd_layout.addWidget(yd_browse_btn) + config_layout.addLayout(yd_layout) + + layout.addWidget(config_group) + + task_group = QGroupBox("困28任务参数") + task_layout = QVBoxLayout(task_group) + + cycle_layout = QHBoxLayout() + cycle_layout.addWidget(QLabel("循环次数(0=无限):")) + self.kun28_cycle_spin = QSpinBox() + self.kun28_cycle_spin.setRange(0, 9999) + self.kun28_cycle_spin.setValue(0) + cycle_layout.addWidget(self.kun28_cycle_spin) + cycle_layout.addWidget(QLabel("ss等待时间(秒):")) + self.kun28_wait_spin = QSpinBox() + self.kun28_wait_spin.setRange(1, 999) + self.kun28_wait_spin.setValue(15) + cycle_layout.addWidget(self.kun28_wait_spin) + cycle_layout.addStretch() + task_layout.addLayout(cycle_layout) + + threshold_layout = QHBoxLayout() + threshold_layout.addWidget(QLabel("匹配阈值:")) + self.kun28_threshold_spin = QDoubleSpinBox() + self.kun28_threshold_spin.setRange(0.5, 1.0) + self.kun28_threshold_spin.setSingleStep(0.01) + self.kun28_threshold_spin.setValue(0.8) + threshold_layout.addWidget(self.kun28_threshold_spin) + threshold_layout.addWidget(QLabel("最大随机偏移:")) + self.kun28_offset_spin = QSpinBox() + self.kun28_offset_spin.setRange(0, 50) + self.kun28_offset_spin.setValue(15) + threshold_layout.addWidget(self.kun28_offset_spin) + threshold_layout.addStretch() + task_layout.addLayout(threshold_layout) + + layout.addWidget(task_group) + layout.addStretch() + + def setup_sequence_tab(self): + layout = QVBoxLayout(self.tab_sequence) + + info_label = QLabel("序列任务:按顺序查找多张图片,找到后点击,然后继续下一张,完成后循环") + info_label.setStyleSheet("color: blue; font-weight: bold;") + info_label.setWordWrap(True) + layout.addWidget(info_label) + + preset_group = QGroupBox("预设配置") + preset_layout = QHBoxLayout(preset_group) + + preset_layout.addWidget(QLabel("选择配置:")) + self.seq_preset_combo = QComboBox() + self.seq_preset_combo.currentIndexChanged.connect(self.on_seq_preset_changed) + preset_layout.addWidget(self.seq_preset_combo, 1) + + save_preset_btn = QPushButton("保存当前") + save_preset_btn.clicked.connect(self.save_sequence_preset) + preset_layout.addWidget(save_preset_btn) + + delete_preset_btn = QPushButton("删除") + delete_preset_btn.clicked.connect(self.delete_sequence_preset) + preset_layout.addWidget(delete_preset_btn) + + layout.addWidget(preset_group) + + config_group = QGroupBox("序列任务图片配置") + config_layout = QVBoxLayout(config_group) + + self.sequence_images = [] + self.sequence_container = QWidget() + self.sequence_layout = QVBoxLayout(self.sequence_container) + config_layout.addWidget(self.sequence_container) + + add_btn_layout = QHBoxLayout() + add_image_btn = QPushButton("+ 添加图片") + add_image_btn.clicked.connect(lambda: self.add_sequence_image()) + remove_image_btn = QPushButton("- 移除最后一个") + remove_image_btn.clicked.connect(lambda: self.remove_sequence_image()) + add_btn_layout.addWidget(add_image_btn) + add_btn_layout.addWidget(remove_image_btn) + add_btn_layout.addStretch() + config_layout.addLayout(add_btn_layout) + + layout.addWidget(config_group) + + task_group = QGroupBox("序列任务参数") + task_layout = QVBoxLayout(task_group) + + cycle_layout = QHBoxLayout() + cycle_layout.addWidget(QLabel("循环次数(0=无限):")) + self.seq_cycle_spin = QSpinBox() + self.seq_cycle_spin.setRange(0, 9999) + self.seq_cycle_spin.setValue(0) + cycle_layout.addWidget(self.seq_cycle_spin) + cycle_layout.addWidget(QLabel("找到后等待(秒):")) + self.seq_wait_spin = QSpinBox() + self.seq_wait_spin.setRange(1, 999) + self.seq_wait_spin.setValue(3) + cycle_layout.addWidget(self.seq_wait_spin) + cycle_layout.addWidget(QLabel("搜索间隔(秒):")) + self.seq_interval_spin = QSpinBox() + self.seq_interval_spin.setRange(1, 60) + self.seq_interval_spin.setValue(2) + cycle_layout.addWidget(self.seq_interval_spin) + cycle_layout.addWidget(QLabel("查找失败上限:")) + self.seq_max_fail_spin = QSpinBox() + self.seq_max_fail_spin.setRange(0, 999) + self.seq_max_fail_spin.setValue(0) + cycle_layout.addWidget(self.seq_max_fail_spin) + cycle_layout.addStretch() + task_layout.addLayout(cycle_layout) + + threshold_layout = QHBoxLayout() + threshold_layout.addWidget(QLabel("匹配阈值:")) + self.seq_threshold_spin = QDoubleSpinBox() + self.seq_threshold_spin.setRange(0.5, 1.0) + self.seq_threshold_spin.setSingleStep(0.01) + self.seq_threshold_spin.setValue(0.8) + threshold_layout.addWidget(self.seq_threshold_spin) + threshold_layout.addWidget(QLabel("最大随机偏移:")) + self.seq_offset_spin = QSpinBox() + self.seq_offset_spin.setRange(0, 50) + self.seq_offset_spin.setValue(15) + threshold_layout.addWidget(self.seq_offset_spin) + threshold_layout.addStretch() + task_layout.addLayout(threshold_layout) + + layout.addWidget(task_group) + layout.addStretch() + + def add_sequence_image(self): + index = len(self.sequence_images) + 1 + row_layout = QHBoxLayout() + label = QLabel(f"图片{index}:") + line_edit = QLineEdit() + line_edit.setPlaceholderText(f"选择第{index}张图片路径") + browse_btn = QPushButton("浏览") + browse_btn.clicked.connect(lambda: self.browse_image_file(line_edit)) + row_layout.addWidget(label) + row_layout.addWidget(line_edit, 1) + row_layout.addWidget(browse_btn) + self.sequence_layout.addLayout(row_layout) + self.sequence_images.append(line_edit) + + def setup_config_tab(self): + layout = QVBoxLayout(self.tab_config) + + info_label = QLabel("配置管理:编辑 task_config.json 文件内容") + info_label.setStyleSheet("color: blue; font-weight: bold;") + layout.addWidget(info_label) + + json_group = QGroupBox("JSON 配置内容") + json_layout = QVBoxLayout(json_group) + + self.json_text = QTextEdit() + self.json_text.setFont(QFont("Courier New", 9)) + self.json_text.setPlaceholderText("JSON 配置内容...") + json_layout.addWidget(self.json_text) + + btn_layout = QHBoxLayout() + refresh_btn = QPushButton("刷新") + refresh_btn.clicked.connect(self.refresh_json_config) + save_json_btn = QPushButton("保存JSON") + save_json_btn.clicked.connect(self.save_json_config) + btn_layout.addWidget(refresh_btn) + btn_layout.addWidget(save_json_btn) + btn_layout.addStretch() + json_layout.addLayout(btn_layout) + + layout.addWidget(json_group) + layout.addStretch() + + self.refresh_json_config() + + def refresh_json_config(self): + try: + with open(CONFIG_FILE, 'r', encoding='utf-8') as f: + content = f.read() + self.json_text.setPlainText(content) + except Exception as e: + self.logger.error(f"刷新配置失败:{str(e)}") + + def save_json_config(self): + try: + content = self.json_text.toPlainText() + json.loads(content) + with open(CONFIG_FILE, 'w', encoding='utf-8') as f: + f.write(content) + self.config = json.loads(content) + self.logger.info("JSON 配置已保存并重新加载") + except json.JSONDecodeError as e: + self.logger.error(f"JSON 格式错误:{str(e)}") + except Exception as e: + self.logger.error(f"保存配置失败:{str(e)}") + + def remove_sequence_image(self): + if self.sequence_images: + last_layout = self.sequence_layout.itemAt(self.sequence_layout.count() - 1) + if last_layout: + while last_layout.count(): + item = last_layout.takeAt(0) + if item.widget(): + item.widget().deleteLater() + elif item.layout(): + item.layout().deleteLater() + self.sequence_layout.removeItem(last_layout) + self.sequence_images.pop() + + def get_sequence_current_config(self): + images = [edit.text() for edit in self.sequence_images if edit.text()] + return { + 'images': images, + 'cycle_times': self.seq_cycle_spin.value(), + 'wait_time': self.seq_wait_spin.value(), + 'interval': self.seq_interval_spin.value(), + 'max_fail': self.seq_max_fail_spin.value(), + 'threshold': self.seq_threshold_spin.value(), + 'max_offset': self.seq_offset_spin.value() + } + + def load_sequence_config(self, config): + while self.sequence_images: + self.remove_sequence_image() + + for img_path in config.get('images', []): + self.add_sequence_image() + self.sequence_images[-1].setText(img_path) + + self.seq_cycle_spin.setValue(config.get('cycle_times', 0)) + self.seq_wait_spin.setValue(config.get('wait_time', 3)) + self.seq_interval_spin.setValue(config.get('interval', 2)) + self.seq_max_fail_spin.setValue(config.get('max_fail', 0)) + self.seq_threshold_spin.setValue(config.get('threshold', 0.8)) + self.seq_offset_spin.setValue(config.get('max_offset', 15)) + + def save_sequence_preset(self): + name, ok = QInputDialog.getText(self, "保存配置", "请输入配置名称:") + if not ok or not name: + return + + name = name.strip() + if not name: + self.logger.warning("配置名称不能为空") + return + + if 'sequence_presets' not in self.config: + self.config['sequence_presets'] = {} + + self.config['sequence_presets'][name] = self.get_sequence_current_config() + self.save_config() + self.load_sequence_presets() + self.seq_preset_combo.setCurrentText(name) + self.logger.info(f"配置 '{name}' 已保存") + + def delete_sequence_preset(self): + current = self.seq_preset_combo.currentText() + if not current: + self.logger.warning("请先选择一个配置") + return + + reply = QMessageBox.question(self, "确认删除", f"确定删除配置 '{current}' 吗?", + QMessageBox.Yes | QMessageBox.No) + if reply != QMessageBox.Yes: + return + + if 'sequence_presets' in self.config and current in self.config['sequence_presets']: + del self.config['sequence_presets'][current] + self.save_config() + self.load_sequence_presets() + self.logger.info(f"配置 '{current}' 已删除") + + def on_seq_preset_changed(self, index): + if index < 0: + return + name = self.seq_preset_combo.currentText() + if not name: + return + if 'sequence_presets' in self.config and name in self.config['sequence_presets']: + self.load_sequence_config(self.config['sequence_presets'][name]) + + def load_sequence_presets(self): + self.seq_preset_combo.blockSignals(True) + self.seq_preset_combo.clear() + self.seq_preset_combo.addItem("") + if 'sequence_presets' in self.config: + for name in self.config['sequence_presets']: + self.seq_preset_combo.addItem(name) + self.seq_preset_combo.blockSignals(False) + + def initLogging(self): + self.logger = logging.getLogger("TaskLogger") + self.logger.setLevel(logging.INFO) + handler = QTextEditLogger(self.log_text) + handler.setFormatter(logging.Formatter('%(message)s')) + self.logger.addHandler(handler) + + file_handler = logging.FileHandler(LOG_FILE, encoding='utf-8') + file_handler.setFormatter(logging.Formatter('[%(asctime)s] [%(levelname)s] %(message)s', datefmt='%Y-%m-%d %H:%M:%S')) + self.logger.addHandler(file_handler) + + def load_settings(self): + if 'target_path' in self.config: + self.target_edit.setText(self.config['target_path']) + if 'threshold' in self.config: + self.threshold_spin.setValue(self.config['threshold']) + + self.kun28_281_edit.setText(self.config.get('kun28_281', '')) + self.kun28_ts_edit.setText(self.config.get('kun28_ts', '')) + self.kun28_ss_edit.setText(self.config.get('kun28_ss', '')) + self.kun28_yd_edit.setText(self.config.get('kun28_yd', '')) + + def save_settings(self): + self.config['target_path'] = self.target_edit.text() + self.config['threshold'] = self.threshold_spin.value() + self.config['kun28_281'] = self.kun28_281_edit.text() + self.config['kun28_ts'] = self.kun28_ts_edit.text() + self.config['kun28_ss'] = self.kun28_ss_edit.text() + self.config['kun28_yd'] = self.kun28_yd_edit.text() + self.config['monitor_click_images'] = [edit.text() for edit in self.multi_image_targets if edit.text()] + self.config['monitor_interval'] = self.monitor_interval_spin.value() + self.config['monitor_click_wait'] = self.monitor_click_wait_spin.value() + self.config['monitor_offset'] = self.monitor_offset_spin.value() + self.save_config() + + def browse_target_path(self): + path, _ = QFileDialog.getOpenFileName(self, "选择目标图片", self.current_dir, "Image Files (*.png *.jpg)") + if path: + self.target_edit.setText(path) + + def browse_image_file(self, line_edit): + path, _ = QFileDialog.getOpenFileName(self, "选择图片", self.current_dir, "Image Files (*.png *.jpg)") + if path: + line_edit.setText(path) + + def add_monitor_target(self): + row_layout = QHBoxLayout() + edit = QLineEdit() + edit.setPlaceholderText("选择目标图片路径...") + browse_btn = QPushButton("浏览") + browse_btn.clicked.connect(lambda: self.browse_image_file(edit)) + row_layout.addWidget(edit, 1) + row_layout.addWidget(browse_btn) + self.multi_image_layout.addLayout(row_layout) + self.multi_image_targets.append(edit) + + def remove_monitor_target(self): + if self.multi_image_targets: + last = self.multi_image_targets.pop() + self.multi_image_layout.removeWidget(last) + last.deleteLater() + + def load_monitor_click_config(self): + images = self.config.get('monitor_click_images', []) + for img_path in images: + row_layout = QHBoxLayout() + edit = QLineEdit() + edit.setText(img_path) + browse_btn = QPushButton("浏览") + browse_btn.clicked.connect(lambda _, e=edit: self.browse_image_file(e)) + row_layout.addWidget(edit, 1) + row_layout.addWidget(browse_btn) + self.multi_image_layout.addLayout(row_layout) + self.multi_image_targets.append(edit) + + self.monitor_interval_spin.setValue(self.config.get('monitor_interval', 2)) + self.monitor_click_wait_spin.setValue(self.config.get('monitor_click_wait', 3)) + self.monitor_offset_spin.setValue(self.config.get('monitor_offset', 15)) + + def on_task_type_changed(self): + task_type = self.task_type_combo.currentData() + if task_type == "monitor_click": + self.multi_image_group.show() + self.monitor_interval_widget.show() + self.load_monitor_presets() + else: + self.multi_image_group.hide() + self.monitor_interval_widget.hide() + + def load_monitor_presets(self): + self.monitor_preset_combo.clear() + self.monitor_preset_combo.addItem("选择预设...", "") + presets = self.config.get('monitor_presets', {}) + for name in presets.keys(): + self.monitor_preset_combo.addItem(name, name) + + def on_monitor_preset_changed(self): + preset_name = self.monitor_preset_combo.currentData() + if preset_name: + presets = self.config.get('monitor_presets', {}) + if preset_name in presets: + preset = presets[preset_name] + self.clear_monitor_targets() + for img_path in preset.get('images', []): + row_layout = QHBoxLayout() + edit = QLineEdit() + edit.setText(img_path) + browse_btn = QPushButton("浏览") + browse_btn.clicked.connect(lambda _, e=edit: self.browse_image_file(e)) + row_layout.addWidget(edit, 1) + row_layout.addWidget(browse_btn) + self.multi_image_layout.addLayout(row_layout) + self.multi_image_targets.append(edit) + self.monitor_interval_spin.setValue(preset.get('interval', 2)) + self.monitor_click_wait_spin.setValue(preset.get('click_wait', 3)) + self.monitor_offset_spin.setValue(preset.get('offset', 15)) + + def clear_monitor_targets(self): + for edit in self.multi_image_targets: + self.multi_image_layout.removeWidget(edit) + edit.deleteLater() + self.multi_image_targets.clear() + + def save_monitor_preset(self): + name, ok = QInputDialog.getText(self, "保存预设", "请输入预设名称:") + if ok and name.strip(): + preset = { + 'images': [edit.text() for edit in self.multi_image_targets if edit.text()], + 'interval': self.monitor_interval_spin.value(), + 'click_wait': self.monitor_click_wait_spin.value(), + 'offset': self.monitor_offset_spin.value() + } + if 'monitor_presets' not in self.config: + self.config['monitor_presets'] = {} + self.config['monitor_presets'][name.strip()] = preset + self.save_config() + self.load_monitor_presets() + + def delete_monitor_preset(self): + preset_name = self.monitor_preset_combo.currentData() + if preset_name: + if 'monitor_presets' in self.config and preset_name in self.config['monitor_presets']: + del self.config['monitor_presets'][preset_name] + self.save_config() + self.load_monitor_presets() + + def update_monitor_config(self): + try: + if self.cfg_monitor_left.value() >= 0: + monitor_config = { + "left": self.cfg_monitor_left.value(), + "top": self.cfg_monitor_top.value(), + "width": self.cfg_monitor_width.value(), + "height": self.cfg_monitor_height.value() + } + elif 'monitor' in self.config: + monitor_config = self.config['monitor'] + else: + monitor_config = {"left": 450, "top": 240, "width": 1490, "height": 1000} + except (RuntimeError, AttributeError): + if 'monitor' in self.config: + monitor_config = self.config['monitor'] + else: + monitor_config = {"left": 450, "top": 240, "width": 1490, "height": 1000} + self.screen_capture = ScreenCapture(monitor_config) + + def get_current_task_params(self): + current_tab = self.tabs.currentIndex() + + if current_tab == 0: + task_type = self.task_type_combo.currentData() + threshold = self.threshold_spin.value() + cycle_times = self.cycle_spin.value() + wait_time = self.wait_time_spin.value() + max_offset = self.offset_spin.value() + if task_type == "monitor_click": + task_images = [edit.text() for edit in self.multi_image_targets if edit.text()] + interval = self.monitor_interval_spin.value() + wait_time = self.monitor_click_wait_spin.value() + max_offset = self.monitor_offset_spin.value() + else: + task_images = [] + interval = 2 + max_fail = 0 + elif current_tab == 1: + task_type = "kun28" + threshold = self.kun28_threshold_spin.value() + cycle_times = self.kun28_cycle_spin.value() + wait_time = self.kun28_wait_spin.value() + max_offset = self.kun28_offset_spin.value() + task_images = { + '281': self.kun28_281_edit.text() if self.kun28_281_edit.text() else '281.png', + 'ts': self.kun28_ts_edit.text() if self.kun28_ts_edit.text() else 'ts.png', + 'ss': self.kun28_ss_edit.text() if self.kun28_ss_edit.text() else 'ss.png', + 'yd': self.kun28_yd_edit.text() if self.kun28_yd_edit.text() else 'yd.png' + } + else: + task_type = "sequence" + threshold = self.seq_threshold_spin.value() + cycle_times = self.seq_cycle_spin.value() + wait_time = self.seq_wait_spin.value() + max_offset = self.seq_offset_spin.value() + task_images = [edit.text() for edit in self.sequence_images if edit.text()] + interval = self.seq_interval_spin.value() + max_fail = self.seq_max_fail_spin.value() + + return { + 'task_type': task_type, + 'threshold': threshold, + 'cycle_times': cycle_times, + 'wait_time': wait_time, + 'max_offset': max_offset, + 'task_images': task_images, + 'interval': interval, + 'max_fail': max_fail + } + + def start_task(self): + if self.task_thread and self.task_thread.isRunning(): + self.logger.warning("任务已在运行") + return + + self.save_settings() + self.update_monitor_config() + + params = self.get_current_task_params() + + self.task_thread = SafeTaskThread( + task_type=params['task_type'], + screenshot_path=self.config.get('screenshot_path', 'full_screenshot.png'), + target_path=self.target_edit.text(), + target_path2='', + threshold=params['threshold'], + is_cycle=params['cycle_times'] > 0, + cycle_times=params['cycle_times'], + wait_time=params['wait_time'], + max_offset=params['max_offset'], + screen_capture=self.screen_capture, + jg_wait_time=params['wait_time'], + task_images=params['task_images'], + interval=params.get('interval', 2), + max_fail=params.get('max_fail', 0) + ) + + self.task_thread.log_signal.connect(lambda msg, level: self.logger.log(level, msg)) + self.task_thread.finish_signal.connect(self.on_task_finished) + self.task_thread.stats_signal.connect(self.update_stats) + self.task_thread.start() + + self.start_btn.setEnabled(False) + self.stop_btn.setEnabled(True) + self.pause_btn.setEnabled(True) + self.status_label.setText("运行中") + self.logger.info("=" * 50) + self.logger.info(f"任务已启动 - 类型: {params['task_type']}") + self.logger.info("=" * 50) + + def pause_task(self): + if not self.task_thread: + return + if self.pause_btn.text() == "暂停": + self.task_thread.pause() + self.pause_btn.setText("恢复") + self.status_label.setText("已暂停") + else: + self.task_thread.resume() + self.pause_btn.setText("暂停") + self.status_label.setText("运行中") + + def stop_task(self): + if not self.task_thread: + return + self.task_thread.stop() + self.logger.info("正在停止任务...") + + def update_stats(self, stats): + duration = int(stats.get('duration_seconds', 0)) + self.stats_label.setText( + f"运行时长: {duration}s | 循环: {stats.get('total_cycles', 0)} | " + f"成功: {stats.get('successful_cycles', 0)} | 失败: {stats.get('failed_cycles', 0)} | " + f"找到图片: {stats.get('images_found', 0)} | 点击: {stats.get('total_clicks', 0)}" + ) + + def on_task_finished(self): + self.start_btn.setEnabled(True) + self.stop_btn.setEnabled(False) + self.pause_btn.setEnabled(False) + self.pause_btn.setText("暂停") + self.status_label.setText("已完成") + self.logger.info("任务已结束") + + def save_log_to_file(self): + try: + timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") + log_path = os.path.join(self.current_dir, f"task_log_{timestamp}.txt") + with open(log_path, 'w', encoding='utf-8') as f: + f.write(self.log_text.toPlainText()) + self.logger.info(f"日志已保存:{log_path}") + QMessageBox.information(self, "成功", f"日志已保存到:{log_path}") + except Exception as e: + self.logger.error(f"保存日志失败:{str(e)}") + QMessageBox.warning(self, "错误", f"保存日志失败:{str(e)}") + +def main(): + app = QApplication(sys.argv) + window = MainWindow() + window.show() + sys.exit(app.exec_()) + +if __name__ == '__main__': + main() diff --git a/task_config.json b/task_config.json new file mode 100644 index 0000000..cc42a12 --- /dev/null +++ b/task_config.json @@ -0,0 +1,69 @@ +{ + "screenshot_path": "/Users/peak/yysscript/screenshot.png", + "target_path": "/Users/peak/yysscript/ss.png", + "threshold": 0.8, + "monitor": { + "left": 450, + "top": 240, + "width": 1490, + "height": 1000 + }, + "kun28_281": "", + "kun28_ts": "", + "kun28_ss": "", + "kun28_yd": "", + "monitor_presets": { + "困288": { + "images": [ + "/Users/peak/yysscript/281.png", + "/Users/peak/yysscript/kun28_boss.png", + "/Users/peak/yysscript/kun28_gift.png", + "/Users/peak/yysscript/kun28_normal.png", + "/Users/peak/yysscript/ts.png", + "/Users/peak/yysscript/ltwc.png", + "/Users/peak/yysscript/yd.png" + ], + "interval": 2, + "click_wait": 3 + } + }, + "sequence_presets": { + "寮突": { + "images": [ + "/Users/peak/yysscript/tp1.png", + "/Users/peak/yysscript/jg.png", + "/Users/peak/yysscript/ltwc.png" + ], + "cycle_times": 0, + "wait_time": 3, + "interval": 5, + "max_fail": 20, + "threshold": 0.8, + "max_offset": 15 + }, + "困28": { + "images": [ + "/Users/peak/yysscript/kun28_normal.png", + "/Users/peak/yysscript/ltwc.png" + ], + "cycle_times": 0, + "wait_time": 3, + "interval": 10, + "max_fail": 0, + "threshold": 0.8, + "max_offset": 15 + } + }, + "monitor_click_images": [ + "/Users/peak/yysscript/281.png", + "/Users/peak/yysscript/kun28_boss.png", + "/Users/peak/yysscript/kun28_gift.png", + "/Users/peak/yysscript/kun28_normal.png", + "/Users/peak/yysscript/ts.png", + "/Users/peak/yysscript/ltwc.png", + "/Users/peak/yysscript/yd.png" + ], + "monitor_interval": 2, + "monitor_click_wait": 3, + "monitor_offset": 15 +} \ No newline at end of file