♻️ refactor(tasks): 改进任务技能和状态管理

- 引入`skill_ticker`机制，统一管理技能冷却和释放
- 将任务运行时变量整合至`runtime_state`字典，提高状态管理清晰度
- 统一任务初始化方法`init_all`，并细化回合和运行时状态重置

Author: BnanZ0

src/tasks/AutoSkill.py

@@ -32,6 +32,7 @@ def __init__(self, *args, **kwargs):
             '超时时间': '超时后将发出提示',
         })
 
+        self.skill_tick = self.create_skill_ticker()
         self.action_timeout = 10
 
     def run(self):
@@ -46,11 +47,11 @@ def run(self):
 
     def do_run(self):
         self.load_char()
-        _skill_time = 0
+        self.init_all()
         self.wait_until(self.in_team, time_out=30)
         while True:
             if self.in_team():
-                _skill_time = self.use_skill(_skill_time)
+                self.skill_tick()
             else:
                 if self.config.get('主画面侦测', False):
                     self.log_info_notify('任务完成')
@@ -61,3 +62,6 @@ def do_run(self):
                 self.soundBeep()
                 return
             self.sleep(0.2)
+
+    def init_all(self):
+        self.skill_tick.reset()

src/tasks/BaseDNATask.py

@@ -1,5 +1,5 @@
 import time
-from typing import Union, Callable
+from typing import Protocol, Callable, Union
 import numpy as np
 import cv2
 import winsound
@@ -17,6 +17,51 @@
     'b': (0, 20)  # Blue range
 }
 
+class Ticker(Protocol):
+    """
+    技能循环计时器接口。
+    
+    这是一个可调用的对象（类似函数），用于控制动作的执行频率，
+    并提供了额外的方法来手动干预计时器的状态。
+    """
+    
+    def __call__(self) -> None:
+        """
+        尝试执行动作（Tick）。
+        
+        如果距离上次执行的时间超过了设定的间隔（Interval），
+        则执行绑定的 Action，并更新最后执行时间。
+        """
+        ...
+
+    def reset(self) -> None:
+        """
+        重置计时器状态。
+        
+        将“上次执行时间”归零。这意味着下一次调用 tick() 时，
+        几乎肯定会立即触发动作（视为初次运行）。
+        """
+        ...
+
+    def touch(self) -> None:
+        """
+        刷新计时器（将最后执行时间设为当前时间）。
+        
+        用于“欺骗”计时器刚刚执行过动作。
+        效果：强制动作进入冷却，直到经过一个完整的 interval 周期。
+        """
+        ...
+
+    def start_next_tick(self) -> None:
+        """
+        重置下一帧的计时起点（同步延迟）。
+        
+        标记计时器。下一次调用 tick() 时，不会检查间隔，也不会执行动作，
+        而是直接将“上次执行时间”对齐到那一刻的时间。
+        
+        用途：通常用于在手动释放技能后，告诉计时器从下一帧开始重新倒计时。
+        """
+        ...
 
 class BaseDNATask(BaseTask):
 
@@ -269,7 +314,7 @@ def rel_move_if_in_win(self, x=0.5, y=0.5, box=None):
         win32api.SetCursorPos(abs_pos)
         return True
 
-    def create_ticker(self, action: Callable, interval: Union[float, int, Callable] = 1.0) -> Callable:
+    def create_ticker(self, action: Callable, interval: Union[float, int, Callable] = 1.0) -> Ticker:
         last_time = 0
         armed = False
 

src/tasks/fullauto/ImportTask.py

@@ -70,6 +70,7 @@ def __init__(self, *args, **kwargs):
             # '使用内建解密': '使用ok内建解密功能',
         })
 
+        self.skill_tick = self.create_skill_ticker()
         self.action_timeout = 10
         self.quick_move_task = QuickMoveTask(self)
 
@@ -99,58 +100,60 @@ def run(self):
             raise
 
     def do_run(self):
-        self.init_param()
+        self.init_all()
         self.load_char()
-        _wave = -1
-        _wave_start = 0
-        _delay_task_start = 0
         if self.in_team():
             self.open_in_mission_menu()
             self.sleep(0.5)
         while True:
             if self.in_team():
                 self.get_wave_info()
                 if self.current_wave != -1:
-                    if self.current_wave != _wave:
-                        _wave = self.current_wave
-                self.skill_time = self.use_skill(self.skill_time)
-                if time.time() - _wave_start >= self.config.get('超时时间', 180):
+                    if self.current_wave != self.runtime_state["wave"]:
+                        self.runtime_state["wave"] = self.current_wave
+                self.skill_tick()
+                if time.time() - self.runtime_state["wave_start_time"] >= self.config.get('超时时间', 180):
                     self.log_info('任务超时')
                     self.open_in_mission_menu()
                     self.sleep(0.5)
-                if self.delay_index is not None and time.time() > _delay_task_start:
-                    _delay_task_start += 1
+                if self.delay_index is not None and time.time() > self.runtime_state["delay_task_start"]:
+                    self.runtime_state["delay_task_start"] += 1
                     if self.match_map(self.delay_index):
                         self.walk_to_aim(self.delay_index)
             _status = self.handle_mission_interface(stop_func=self.stop_func)
             if _status == Mission.START or _status == Mission.STOP:
                 if _status == Mission.STOP:
                     self.quit_mission()
                     self.log_info('任务中止')
-                    self.init_param()
+                    self.init_all()
                     continue
-                else:
-                    self.log_info('任务完成')
                 self.wait_until(self.in_team, time_out=30)
-                self.init_param()
+                self.log_info('任务开始')
+                self.init_all()
                 self.sleep(2)
                 self.walk_to_aim()
-                _wave_start = time.time()
-                _delay_task_start = _wave_start + 1
-                self.reset_wave_info()
+                now = time.time()
+                self.runtime_state.update({"wave_start_time": now, "delay_task_start": now + 1})
             elif _status == Mission.CONTINUE:
                 self.log_info('任务继续')
                 self.wait_until(self.in_team, time_out=30)
-                self.reset_wave_info()
-                _wave_start = time.time()
+                self.init_for_next_round()
+                now = time.time()
+                self.runtime_state.update({"wave_start_time": now, "delay_task_start": now + 1})
             self.sleep(0.2)
 
-    def init_param(self):
+    def init_all(self):
+        self.init_for_next_round()
         self.delay_index = None
-        self.stop_mission = False
+        self.skill_tick.reset()
         self.current_round = 0
+
+    def init_for_next_round(self):
+        self.init_runtime_state()
+
+    def init_runtime_state(self):
+        self.runtime_state = {"wave_start_time": 0, "wave": -1, "delay_task_start": 0}
         self.reset_wave_info()
-        self.skill_time = 0
 
     def stop_func(self):
         self.get_round_info()