PyClickerRPA 0.1.0__py3-none-any.whl

autoclicker/runner.py

@@ -0,0 +1,666 @@
+"""Task execution engine — faithful port of taskrunner.cpp.
+
+Qt-free: runs on a ``threading.Thread`` with a callbacks object and injectable
+capture / clicker / matcher backends (so control flow is unit-testable without a
+screen). Semantics mirror the C++ TaskRunner exactly: variables, loop/goto/
+while/do-until/if-skip control flow, retry/repeat/until wrappers, subtasks.
+"""
+from __future__ import annotations
+
+import os
+import random
+import threading
+import time
+from enum import Enum
+
+from autoclicker.models import Step, StepType, Task, UntilCondition, RetryPolicy
+
+
+class StepResult(Enum):
+    Success = 0
+    Fail = 1
+    Abort = 2
+
+
+class RunnerCallbacks:
+    """Override to receive engine events (all no-ops by default)."""
+    def step_started(self, index: int, description: str) -> None: ...
+    def step_completed(self, index: int, success: bool) -> None: ...
+    def match_found(self, x: int, y: int, confidence: float) -> None: ...
+    def log(self, msg: str) -> None: ...
+    def var_changed(self, name: str, value: str) -> None: ...
+    def finished(self) -> None: ...
+
+
+def _now_ms() -> float:
+    return time.monotonic() * 1000.0
+
+
+class TaskRunner(threading.Thread):
+    def __init__(self, task: Task, target_hwnd=None, callbacks: RunnerCallbacks | None = None,
+                 capture=None, clicker=None, matcher=None):
+        super().__init__(daemon=True)
+        self.task = task
+        self.target_hwnd = target_hwnd
+        self.cb = callbacks or RunnerCallbacks()
+
+        # Injectable backends (default to the real ones; tests pass fakes)
+        if capture is None:
+            from autoclicker import capture as capture
+        if clicker is None:
+            from autoclicker.clicker import Clicker
+            clicker = Clicker()
+        if matcher is None:
+            from autoclicker import matcher as matcher
+        self.capture = capture
+        self.clicker = clicker
+        self.matcher = matcher
+
+        self._running = False
+        self._paused = False
+        self._loop_counters: dict[int, int] = {}
+        self._vars: dict[str, str] = {}
+        self._last_condition = False
+
+        # Optional: save a screenshot whenever a step fails (debugging aid)
+        self.screenshot_on_fail = False
+        self.screenshot_dir = ".failures"
+
+    # ---- control ----
+    def stop(self) -> None:
+        self._running = False
+
+    def pause(self) -> None:
+        self._paused = True
+
+    def resume(self) -> None:
+        self._paused = False
+
+    def get_var(self, name: str) -> str:
+        return self._vars.get(name, "")
+
+    # ---- helpers ----
+    def _sleep_ms(self, ms: int) -> None:
+        """Sleep in 100ms chunks, bailing out early if stopped."""
+        elapsed = 0
+        while self._running and elapsed < ms:
+            time.sleep(0.1)
+            elapsed += 100
+
+    def _wait_if_paused(self) -> None:
+        while self._paused and self._running:
+            time.sleep(0.1)
+
+    def _template_list(self, step: Step) -> list[str]:
+        if step.imagePaths:
+            return list(step.imagePaths)
+        if step.imagePath:
+            return [step.imagePath]
+        return []
+
+    def _screenshot(self):
+        if self.target_hwnd:
+            try:
+                import win32gui
+                alive = win32gui.IsWindow(self.target_hwnd)
+            except Exception:
+                alive = True
+            if alive:
+                return self.capture.capture_window(self.target_hwnd)
+        return self.capture.capture_screen()
+
+    def _save_failure_shot(self, index: int) -> None:
+        try:
+            import cv2
+            screen = self._screenshot()
+            if screen is None or screen.size == 0:
+                return
+            os.makedirs(self.screenshot_dir, exist_ok=True)
+            path = os.path.join(self.screenshot_dir, f"fail_step{index + 1}_{int(time.time())}.png")
+            cv2.imwrite(path, screen)
+            self.cb.log(f"  已保存失败截图: {path}")
+        except Exception as e:
+            self.cb.log(f"  保存失败截图出错: {e}")
+
+    def _load_template(self, path: str, desc: str):
+        import cv2
+        if not path:
+            self.cb.log(f"  错误: 未指定图片路径 (步骤: {desc})")
+            return None
+        if not os.path.exists(path):
+            self.cb.log(f"  错误: 图片文件不存在: {path}\n    请检查路径是否正确，建议使用绝对路径")
+            return None
+        templ = cv2.imread(path)
+        if templ is None or templ.size == 0:
+            self.cb.log(f"  错误: 无法解码图片: {path}\n    文件存在但可能已损坏或格式不支持 (支持 PNG/JPG/BMP)")
+            return None
+        return templ
+
+    def _rand_offset(self, v: int, off: int) -> int:
+        return v + random.randint(-off, off) if off > 0 else v
+
+    # ---- run loop ----
+    def run(self) -> None:
+        self._running = True
+        self._loop_counters.clear()
+        self._vars.clear()
+        self._last_condition = False
+        self.cb.log(f"开始执行任务: {self.task.name} ({len(self.task.steps)} 步)")
+        self._run_steps()
+        self.cb.log("任务完成" if self._running else "任务已停止")
+        self._running = False
+        self.cb.finished()
+
+    def _run_steps(self, log_prefix: str = "") -> StepResult:
+        steps = self.task.steps
+        i = 0
+        while self._running and i < len(steps):
+            self._wait_if_paused()
+            if not self._running:
+                break
+            step = steps[i]
+
+            if step.type == StepType.GroupBegin and step.disabled:
+                depth = 1
+                skip = i + 1
+                while skip < len(steps) and depth > 0:
+                    if steps[skip].type == StepType.GroupBegin:
+                        depth += 1
+                    elif steps[skip].type == StepType.GroupEnd:
+                        depth -= 1
+                    skip += 1
+                self.cb.log(f"  跳过禁用分组: {step.groupName}")
+                i = skip
+                continue
+
+            self.cb.step_started(i, log_prefix + step.display_name())
+            result = self._execute_with_repeat(i)
+            self.cb.step_completed(i, result == StepResult.Success)
+
+            if result != StepResult.Success and self.screenshot_on_fail:
+                self._save_failure_shot(i)
+
+            if result == StepResult.Abort:
+                self.cb.log(f"任务中止 (步骤 {i + 1} 失败)")
+                return StepResult.Abort
+            if not self._running:
+                break
+
+            if step.type == StepType.Loop:
+                key = i
+                self._loop_counters[key] = self._loop_counters.get(key, 0) + 1
+                if step.loopCount < 0 or self._loop_counters[key] < step.loopCount:
+                    cnt = self._loop_counters[key]
+                    i = step.loopTarget
+                    self.cb.log(f"  循环回到步骤 {step.loopTarget + 1} (第 {cnt} 次)")
+                    continue
+                else:
+                    self._loop_counters.pop(key, None)
+
+            if step.type == StepType.DoUntil:
+                if not self._check_until(step.until):
+                    self._loop_counters[i] = self._loop_counters.get(i, 0) + 1
+                    cnt = self._loop_counters[i]
+                    i = step.loopTarget
+                    self.cb.log(f"  条件未满足，循环回到步骤 {step.loopTarget + 1} (第 {cnt} 次)")
+                    continue
+                else:
+                    self.cb.log("  条件已满足，结束循环")
+                    self._loop_counters.pop(i, None)
+
+            if step.type == StepType.WhileCondition:
+                met = False
+                if step.until.type != UntilCondition.NoneCond:
+                    met = self._check_until(step.until)
+                elif step.varName:
+                    met = self._compare(self._vars.get(step.varName, "0"), step.compareOp, step.compareValue)
+                if not met:
+                    self.cb.log(f"  While 条件为假，跳到步骤 {step.loopTarget + 1}")
+                    i = step.loopTarget
+                    continue
+                self.cb.log("  While 条件为真，继续执行")
+
+            if step.type == StepType.Goto:
+                self.cb.log(f"  跳转到步骤 {step.gotoTarget + 1}")
+                i = step.gotoTarget
+                continue
+
+            if step.type in (StepType.IfImageFound, StepType.IfTextFound, StepType.IfElse,
+                             StepType.IfColorMatch, StepType.IfImageCount, StepType.IfVar):
+                if not self._last_condition:
+                    self.cb.log(f"  条件为假，跳过 {step.elseSkip} 步")
+                    i += step.elseSkip
+
+            i += 1
+        return StepResult.Success
+
+    # ---- wrappers ----
+    def _execute_with_repeat(self, index: int) -> StepResult:
+        step = self.task.steps[index]
+        has_repeat = step.repeat.times != 1
+        has_until = step.until.type != UntilCondition.NoneCond
+        if not has_repeat and not has_until:
+            return self._execute_with_retry(index)
+
+        start = _now_ms()
+        iteration = 0
+        last = StepResult.Success
+        while self._running:
+            last = self._execute_with_retry(index)
+            iteration += 1
+            if last == StepResult.Abort:
+                return StepResult.Abort
+            if has_until:
+                if self._check_until(step.until):
+                    self.cb.log(f"  终止条件已满足 (第 {iteration} 次)")
+                    return last
+                if _now_ms() - start >= step.until.timeoutMs:
+                    self.cb.log(f"  终止条件超时 ({step.until.timeoutMs}ms)")
+                    return last
+            if has_repeat and step.repeat.times > 0 and iteration >= step.repeat.times:
+                self.cb.log(f"  重复执行完成 ({iteration} 次)")
+                return last
+            self._wait_if_paused()
+            if not self._running:
+                break
+            self._sleep_ms(step.repeat.delayMs)
+        return last
+
+    def _execute_with_retry(self, index: int) -> StepResult:
+        step = self.task.steps[index]
+        policy = step.retry.policy
+        if policy in (RetryPolicy.NoneP, RetryPolicy.Skip):
+            r = self._execute_step(index)
+            if r == StepResult.Fail and policy == RetryPolicy.Skip:
+                self.cb.log("  步骤失败，跳过")
+                return StepResult.Success
+            return r
+        if policy == RetryPolicy.Abort:
+            r = self._execute_step(index)
+            return StepResult.Abort if r == StepResult.Fail else r
+        # Retry
+        for attempt in range(step.retry.count + 1):
+            if not self._running:
+                return StepResult.Fail
+            if attempt > 0:
+                self.cb.log(f"  重试第 {attempt} 次...")
+                self._sleep_ms(step.retry.delayMs)
+            if self._execute_step(index) == StepResult.Success:
+                return StepResult.Success
+        self.cb.log(f"  重试 {step.retry.count} 次后仍失败")
+        return StepResult.Fail
+
+    def _compare(self, val: str, op: str, cmp: str) -> bool:
+        try:
+            a, b = float(val), float(cmp)
+        except ValueError:
+            a = b = None
+        if a is not None:
+            return {"==": a == b, "!=": a != b, ">": a > b,
+                    "<": a < b, ">=": a >= b, "<=": a <= b}.get(op, False)
+        return {"==": val == cmp, "!=": val != cmp}.get(op, False)
+
+    def _check_until(self, cfg) -> bool:
+        import cv2
+        if cfg.type == UntilCondition.ImageFound:
+            templ = cv2.imread(cfg.image) if cfg.image else None
+            if templ is None:
+                return False
+            return bool(self.matcher.find_image(self._screenshot(), templ, cfg.threshold))
+        if cfg.type == UntilCondition.ImageGone:
+            templ = cv2.imread(cfg.image) if cfg.image else None
+            if templ is None:
+                return True
+            return not self.matcher.find_image(self._screenshot(), templ, cfg.threshold)
+        if cfg.type == UntilCondition.TextFound:
+            return bool(self.matcher.find_text(self._screenshot(), cfg.text))
+        if cfg.type == UntilCondition.ColorMatch:
+            screen = self._screenshot()
+            if screen.size == 0 or cfg.x >= screen.shape[1] or cfg.y >= screen.shape[0]:
+                return False
+            return self._color_at_matches(screen, cfg.x, cfg.y, cfg.color, cfg.colorTolerance)
+        return True
+
+    @staticmethod
+    def _parse_color(name: str):
+        """Parse #RRGGBB (or #RGB) into (r, g, b); None if invalid."""
+        if not name:
+            return None
+        s = name.strip().lstrip("#")
+        if len(s) == 3:
+            s = "".join(c * 2 for c in s)
+        if len(s) != 6:
+            return None
+        try:
+            return int(s[0:2], 16), int(s[2:4], 16), int(s[4:6], 16)
+        except ValueError:
+            return None
+
+    def _color_at_matches(self, screen, x: int, y: int, color: str, tol: int) -> bool:
+        rgb = self._parse_color(color)
+        if rgb is None:
+            return False
+        b, g, r = (int(v) for v in screen[y, x][:3])  # OpenCV is BGR
+        return abs(r - rgb[0]) <= tol and abs(g - rgb[1]) <= tol and abs(b - rgb[2]) <= tol
+
+    def _run_subtask(self, path: str) -> StepResult:
+        sub = Task.load_from_file(path) if os.path.exists(path) else Task()
+        if not sub.steps:
+            self.cb.log(f"  子任务加载失败: {path}")
+            return StepResult.Fail
+        self.cb.log(f"  >>> 进入子任务: {sub.name}")
+        saved_task, saved_counters = self.task, self._loop_counters
+        self.task, self._loop_counters = sub, {}
+        result = self._run_steps("[子] ")
+        self.task, self._loop_counters = saved_task, saved_counters
+        self.cb.log("  <<< 子任务结束")
+        return result
+
+    # ---- per-step execution (port of executeStep) ----
+    def _execute_step(self, index: int) -> StepResult:  # noqa: C901 - faithful 1:1 port
+        step = self.task.steps[index]
+        t = step.type
+
+        if t in (StepType.ClickImage, StepType.WaitImage, StepType.WaitImageGone, StepType.MergeImage):
+            return self._exec_image_poll(step, t)
+        if t == StepType.ClickText:
+            return self._exec_click_text(step)
+        if t == StepType.ClickPosition:
+            cx, cy = step.x, step.y
+            if step.varName == "use_var":
+                cx = int(self._vars.get("last_x", "0"))
+                cy = int(self._vars.get("last_y", "0"))
+            cx, cy = self._rand_offset(cx, step.randomOffset), self._rand_offset(cy, step.randomOffset)
+            self.cb.log(f"  点击 ({cx}, {cy})")
+            self.clicker.click(self.target_hwnd, cx, cy)
+            return StepResult.Success
+        if t == StepType.Wait:
+            self.cb.log(f"  等待 {step.waitMs}ms")
+            self._sleep_ms(step.waitMs)
+            return StepResult.Success
+        if t == StepType.RandomWait:
+            lo, hi = step.waitMs, step.waitMsMax
+            if hi <= lo:
+                hi = lo + 1
+            actual = random.randint(lo, hi - 1)
+            self.cb.log(f"  随机等待 {actual}ms (范围 {lo}~{hi})")
+            self._sleep_ms(actual)
+            return StepResult.Success
+        if t == StepType.ClickRelative:
+            bx = int(self._vars.get("last_x", "0")) + step.x
+            by = int(self._vars.get("last_y", "0")) + step.y
+            cx, cy = self._rand_offset(bx, step.randomOffset), self._rand_offset(by, step.randomOffset)
+            self.cb.log(f"  相对点击 last+({step.x},{step.y}) = ({cx}, {cy})")
+            self.clicker.click(self.target_hwnd, cx, cy)
+            return StepResult.Success
+        if t == StepType.ReadText:
+            return self._exec_read_text(step)
+        if t in (StepType.Loop, StepType.DoUntil, StepType.Goto,
+                 StepType.GroupBegin, StepType.GroupEnd, StepType.WhileCondition):
+            return StepResult.Success
+        if t == StepType.IfImageFound:
+            return self._exec_if_image(step)
+        if t == StepType.IfTextFound:
+            self._last_condition = bool(self.matcher.find_text(self._screenshot(), step.text))
+            self.cb.log(f"  条件(文字): {'true' if self._last_condition else 'false'}")
+            return StepResult.Success
+        if t == StepType.IfElse:
+            self.cb.log(f"  If/Else 分支 (上次条件: {'true' if self._last_condition else 'false'})")
+            return StepResult.Success
+        if t == StepType.CallSub:
+            if not step.subTaskPath:
+                self.cb.log("  错误: 未指定子任务路径")
+                return StepResult.Fail
+            return self._run_subtask(step.subTaskPath)
+        if t == StepType.SetVar:
+            value = step.varValue
+            if value.startswith("++"):
+                value = str(int(self._vars.get(step.varName, "0")) + 1)
+            elif value.startswith("--"):
+                value = str(int(self._vars.get(step.varName, "0")) - 1)
+            self._vars[step.varName] = value
+            self.cb.var_changed(step.varName, value)
+            self.cb.log(f"  变量 {step.varName} = {value}")
+            return StepResult.Success
+        if t == StepType.KeyPress:
+            from autoclicker.clicker import parse_vk
+            vk = parse_vk(step.keyName)
+            if vk == 0:
+                self.cb.log(f'  错误: 无效按键 "{step.keyName}"')
+                return StepResult.Fail
+            self.cb.log(f"  按键: {step.keyName}")
+            self.clicker.key_press(vk)
+            return StepResult.Success
+        if t == StepType.TypeText:
+            self.cb.log(f'  输入文字: "{step.text}"')
+            self.clicker.type_text(step.text)
+            return StepResult.Success
+        if t == StepType.Hotkey:
+            from autoclicker.clicker import parse_vk
+            mod, vk = parse_vk(step.modifierKey), parse_vk(step.keyName)
+            if vk == 0:
+                self.cb.log("  错误: 无效按键")
+                return StepResult.Fail
+            self.cb.log(f"  快捷键: {step.modifierKey}+{step.keyName}")
+            self.clicker.hotkey(mod, vk)
+            return StepResult.Success
+        if t == StepType.LongPress:
+            self.cb.log(f"  长按 ({step.x}, {step.y}) {step.holdMs}ms")
+            self.clicker.long_press(self.target_hwnd, step.x, step.y, step.holdMs)
+            return StepResult.Success
+        if t == StepType.Drag:
+            self.cb.log(f"  拖拽 ({step.x},{step.y}) → ({step.x2},{step.y2}) {step.durationMs}ms")
+            self.clicker.drag(self.target_hwnd, step.x, step.y, step.x2, step.y2, step.durationMs)
+            return StepResult.Success
+        if t == StepType.Pinch:
+            self.cb.log(f"  捏合 中心({step.x},{step.y}) {step.pinchStartDist}→{step.pinchEndDist}")
+            self.clicker.pinch(self.target_hwnd, step.x, step.y, step.pinchStartDist, step.pinchEndDist, step.durationMs)
+            return StepResult.Success
+        if t == StepType.Scroll:
+            self.cb.log(f"  滚轮 ({step.x},{step.y}) {step.scrollAmount}格")
+            self.clicker.scroll(self.target_hwnd, step.x, step.y, step.scrollAmount)
+            return StepResult.Success
+        if t == StepType.IfColorMatch:
+            screen = self._screenshot()
+            if screen.size == 0 or step.x >= screen.shape[1] or step.y >= screen.shape[0]:
+                self._last_condition = False
+                return StepResult.Success
+            self._last_condition = self._color_at_matches(screen, step.x, step.y, step.targetColor, step.colorTolerance)
+            self.cb.log(f"  条件(颜色): ({step.x},{step.y}) vs {step.targetColor} → "
+                        f"{'true' if self._last_condition else 'false'}")
+            return StepResult.Success
+        if t == StepType.MultiDrag:
+            return self._exec_multidrag(step)
+        if t == StepType.IfImageCount:
+            return self._exec_if_image_count(step)
+        if t == StepType.IfVar:
+            val = self._vars.get(step.varName, "0")
+            self._last_condition = self._compare(val, step.compareOp, step.compareValue)
+            self.cb.log(f"  条件(变量): {step.varName}={val} {step.compareOp} {step.compareValue} → "
+                        f"{'true' if self._last_condition else 'false'}")
+            return StepResult.Success
+        if t == StepType.ClickAll:
+            return self._exec_click_all(step)
+        return StepResult.Fail
+
+    # ---- step helpers ----
+    def _exec_image_poll(self, step: Step, t: StepType) -> StepResult:
+        templates = self._template_list(step)
+        if not templates:
+            self.cb.log("  错误: 未指定图片路径")
+            return StepResult.Fail
+        templs = [x for x in (self._load_template(p, step.display_name()) for p in templates) if x is not None]
+        if not templs:
+            return StepResult.Fail
+
+        if t == StepType.MergeImage:
+            return self._exec_merge(step, templs)
+
+        start = _now_ms()
+        while self._running and _now_ms() - start < step.timeoutMs:
+            screen = self._screenshot()
+            if t == StepType.WaitImageGone:
+                any_found = any(self.matcher.find_image_roi(screen, tm, step.threshold, step.roiRect, step.multiScale) for tm in templs)
+                if not any_found:
+                    self.cb.log(f"  图片已消失 ({int(_now_ms() - start)}ms)")
+                    return StepResult.Success
+            else:
+                for tm in templs:
+                    results = self.matcher.find_image_roi(screen, tm, step.threshold, step.roiRect, step.multiScale)
+                    if results:
+                        if t == StepType.WaitImage:
+                            self.cb.log(f"  图片已出现 ({int(_now_ms() - start)}ms)")
+                            return StepResult.Success
+                        best = results[0]
+                        cx = self._rand_offset(best.cx + step.x, step.randomOffset)
+                        cy = self._rand_offset(best.cy + step.y, step.randomOffset)
+                        self.cb.match_found(cx, cy, best.confidence)
+                        self.cb.log(f"  匹配成功 ({cx}, {cy}) 置信度: {best.confidence:.3f}")
+                        self.clicker.click(self.target_hwnd, cx, cy)
+                        self._vars["last_x"] = str(cx)
+                        self._vars["last_y"] = str(cy)
+                        return StepResult.Success
+            self._sleep_ms(500)
+        self.cb.log("  超时: 图片未出现" if t == StepType.WaitImage
+                    else ("  超时: 图片仍存在" if t == StepType.WaitImageGone else "  超时: 未找到图片"))
+        return StepResult.Fail
+
+    def _exec_merge(self, step: Step, templs) -> StepResult:
+        merge_count = 0
+        start = _now_ms()
+        while self._running and _now_ms() - start < step.timeoutMs:
+            screen = self._screenshot()
+            all_m = []
+            for tm in templs:
+                all_m += self.matcher.find_image_roi(screen, tm, step.threshold, step.roiRect, step.multiScale)
+            if len(all_m) < 2:
+                self.cb.log(f"  合成完成: 剩余 {len(all_m)} 个目标, 共合成 {merge_count} 次")
+                return StepResult.Success
+            a, b = all_m[0], all_m[1]
+            self.cb.log(f"  合成拖拽: ({a.cx},{a.cy}) → ({b.cx},{b.cy}) [找到 {len(all_m)} 个]")
+            self.clicker.drag(self.target_hwnd, a.cx, a.cy, b.cx, b.cy, step.durationMs)
+            merge_count += 1
+            self._sleep_ms(step.mergeDelayMs)
+        self.cb.log(f"  合成超时, 已合成 {merge_count} 次")
+        return StepResult.Success if merge_count > 0 else StepResult.Fail
+
+    def _exec_click_text(self, step: Step) -> StepResult:
+        start = _now_ms()
+        first = True
+        while self._running and _now_ms() - start < step.timeoutMs:
+            screen = self._screenshot()
+            all_ocr = self.matcher.ocr_all(screen)
+            if first:
+                self.cb.log(f"  OCR返回: {len(all_ocr)} 处文字")
+                first = False
+            results = self.matcher.match_text(all_ocr, step.text, True)
+            if results:
+                best = results[0]
+                cx = self._rand_offset(best.cx + step.x, step.randomOffset)
+                cy = self._rand_offset(best.cy + step.y, step.randomOffset)
+                self.cb.match_found(cx, cy, best.confidence)
+                self.cb.log(f'  OCR匹配: "{best.text}" ({cx}, {cy})')
+                self.clicker.click(self.target_hwnd, cx, cy)
+                self._vars["last_x"] = str(best.cx)
+                self._vars["last_y"] = str(best.cy)
+                self._vars["last_text"] = best.text
+                return StepResult.Success
+            self._sleep_ms(500)
+        self.cb.log(f'  超时: 未找到文字 "{step.text}"')
+        return StepResult.Fail
+
+    def _exec_read_text(self, step: Step) -> StepResult:
+        import re
+        screen = self._screenshot()
+        region, _, _ = self.matcher.apply_roi(screen, step.roiRect)
+        texts = [r.text for r in self.matcher.ocr_all(region)]
+        if step.text:
+            texts = [t for t in texts if step.text in t]
+        joined = " ".join(texts)
+        value = joined
+        if step.varValue == "number":
+            m = re.search(r"-?\d+(?:\.\d+)?", joined)
+            value = m.group(0) if m else ""
+        if step.varName:
+            self._vars[step.varName] = value
+            self.cb.var_changed(step.varName, value)
+        self._vars["last_text"] = joined
+        self.cb.log(f'  读取文字→{step.varName} = "{value}"')
+        return StepResult.Success
+
+    def _exec_if_image(self, step: Step) -> StepResult:
+        templates = self._template_list(step)
+        if not templates:
+            self._last_condition = False
+            return StepResult.Success
+        screen = self._screenshot()
+        self._last_condition = False
+        for p in templates:
+            templ = self._load_template(p, step.display_name())
+            if templ is None:
+                continue
+            if self.matcher.find_image_roi(screen, templ, step.threshold, step.roiRect, step.multiScale):
+                self._last_condition = True
+                break
+        self.cb.log(f"  条件(图片): {'true' if self._last_condition else 'false'}")
+        return StepResult.Success
+
+    def _exec_if_image_count(self, step: Step) -> StepResult:
+        templates = self._template_list(step)
+        if not templates:
+            self._last_condition = False
+            return StepResult.Success
+        screen = self._screenshot()
+        total = 0
+        for p in templates:
+            templ = self._load_template(p, step.display_name())
+            if templ is None:
+                continue
+            total += len(self.matcher.find_image_roi(screen, templ, step.threshold, step.roiRect, step.multiScale))
+        self._last_condition = total >= step.minMatchCount
+        self.cb.log(f"  条件(图片数量): 找到 {total} 个, 需要≥{step.minMatchCount} → "
+                    f"{'true' if self._last_condition else 'false'}")
+        return StepResult.Success
+
+    def _exec_click_all(self, step: Step) -> StepResult:
+        templates = self._template_list(step)
+        if not templates:
+            self.cb.log("  错误: 未指定图片路径")
+            return StepResult.Fail
+        screen = self._screenshot()
+        all_m = []
+        for p in templates:
+            templ = self._load_template(p, step.display_name())
+            if templ is None:
+                continue
+            all_m += self.matcher.find_image_roi(screen, templ, step.threshold, step.roiRect, step.multiScale)
+        if not all_m:
+            self.cb.log("  未找到任何匹配")
+            return StepResult.Fail
+        self.cb.log(f"  找到 {len(all_m)} 个匹配, 逐个点击")
+        for i, m in enumerate(all_m):
+            if not self._running:
+                break
+            cx = self._rand_offset(m.cx + step.x, step.randomOffset)
+            cy = self._rand_offset(m.cy + step.y, step.randomOffset)
+            self.cb.log(f"  点击 {i + 1}/{len(all_m)}: ({cx}, {cy})")
+            self.clicker.click(self.target_hwnd, cx, cy)
+            if i < len(all_m) - 1:
+                self._sleep_ms(step.clickDelayMs)
+        self._vars["last_click_count"] = str(len(all_m))
+        return StepResult.Success
+
+    def _exec_multidrag(self, step: Step) -> StepResult:
+        if len(step.dragPoints) < 2:
+            self.cb.log("  错误: 多点拖拽至少需要2个点")
+            return StepResult.Fail
+        pts = step.dragPoints
+        for i in range(len(pts) - 1):
+            if not self._running:
+                break
+            (x1, y1), (x2, y2) = pts[i], pts[i + 1]
+            self.cb.log(f"  拖拽 {i + 1}/{len(pts) - 1}: ({x1},{y1}) → ({x2},{y2})")
+            self.clicker.drag(self.target_hwnd, x1, y1, x2, y2, step.durationMs)
+            if i < len(pts) - 2:
+                self._sleep_ms(step.dragStepDelay)
+        return StepResult.Success