Forráskód Böngészése

feat(Dokan): 优化绿标检测和战斗流程

- 重构了绿标检测逻辑,支持根据自定义式神名称绿标
ChengRanORZ 1 éve
szülő
commit
359b4fc860
4 módosított fájl, 381 hozzáadás és 104 törlés
  1. 4 1
      tasks/Dokan/config.py
  2. 266 100
      tasks/Dokan/ex_green_mark.py
  3. 98 1
      tasks/Dokan/script_task.py
  4. 13 2
      tasks/Dokan/utils.py

+ 4 - 1
tasks/Dokan/config.py

@@ -58,7 +58,7 @@ class AttackDokanMasterType(str, Enum):
 
 class AttackAccountConfig(BaseModel):
     # 当天可攻击次数,用以记录当天运行历史,用作状态恢复,不用配置
-    remain_attack_count: int = Field(default=2,description='remain_attack_count_help')
+    remain_attack_count: int = Field(default=2, description='remain_attack_count_help')
     # remain_attack_count 值记录的时间,不用配置
     attack_date: str = Field(default='2023-01-01', description='attack_date_help')
     # 每日最大攻击次数(1-2,默认2次),建议:僵尸寮配置2,其他寮配置1
@@ -155,6 +155,9 @@ class DokanConfig(BaseModel):
     # 挂机阵容
     preset_group_2: str = Field(default="", description='preset_group_2_help')
 
+    # 按式神名字绿标
+    green_mark_shikigami_name: str = Field(default="", description='green_mark_shikigami_name_help')
+
     def parse_preset_group(self, value: str):
         re_str = r"([1-7])\,([1-5])"
         tmp = re.match(re_str, value)

+ 266 - 100
tasks/Dokan/ex_green_mark.py

@@ -1,131 +1,301 @@
 import threading
+from enum import Enum
+
 import cv2
 import numpy as np
+from pydantic import BaseModel
 
 from module.base.timer import Timer
 from module.logger import logger
 from tasks.Component.GeneralBattle.config_general_battle import GreenMarkType
 from tasks.Component.GeneralBattle.general_battle import GeneralBattle
-
-
-def green_marker_detector(func):
-    def wrapper(self, *args, **kwargs):
-        event = threading.Event()
-
-        def detect_green_marker(image):
-            hsv_image = cv2.cvtColor(image, cv2.COLOR_RGB2HSV)
-            lower_green = np.array([67, 115, 110])
-            upper_green = np.array([80, 255, 232])
-            mask = cv2.inRange(hsv_image, lower_green, upper_green)
-            result = cv2.bitwise_and(image, image, mask=mask)
-            res = self.I_GREEN_MARKER.match(result)
-            return res
-
-        def emit_exists():
-            logger.info("Green marker detected!")
-            unpack_screenshot()
-            event.set()
-
-        def screenshot_and_detect():
-            self.just_screenshot()
-            exists = detect_green_marker(self.device.image)
-            if exists:
-                emit_exists()
-            return self.device.image
-
-        def pack_screenshot():
-            self.just_screenshot = self.screenshot
-            self.screenshot = screenshot_and_detect
-
-        def unpack_screenshot():
-            self.screenshot = self.just_screenshot
-
-        def thread_run(self, detect_time=3, cb=None, cbargs=None):
-            logger.info("detect thread running...")
-            t = Timer(detect_time)
-            t.start()
-            while event.wait(detect_time):
-                logger.info("detect thread quit")
-                return
-            unpack_screenshot()
-            if cb:
-                logger.info(f"didn't detect green mark ,start running callback with arg:{cbargs}")
-                try:
-                    cb(**cbargs)
-                except Exception as e:
-                    logger.error(f"callback error:{e}")
-
-        # wrapper
-        callback = kwargs.get('callback', None)
-        cbargs = kwargs.get('cbargs', None)
-        detect_time = kwargs.get('detect_time', 3.0)
-
-        if callback:
-            logger.info("Green marker detector running...")
-            pack_screenshot()
-        # green mark 函数的参数列表
-        kwarg_key = ['enable', 'mark_mode']
-        func_kwargs = {key: kwargs[key] for key in kwarg_key if key in kwargs}
-        if not event.is_set():
-            func(self, *args, **func_kwargs)
-
-        if callback:
-            thread = threading.Thread(target=thread_run, args=(self, detect_time, callback, cbargs), daemon=True)
-            thread.start()
-        return
-
-    return wrapper
+from tasks.Dokan.utils import retry
+
+
+#
+# def green_marker_detector(func):
+#     def wrapper(self, *args, **kwargs):
+#         event = threading.Event()
+#
+#         def detect_green_marker(image):
+#             hsv_image = cv2.cvtColor(image, cv2.COLOR_RGB2HSV)
+#             lower_green = np.array([67, 115, 110])
+#             upper_green = np.array([80, 255, 232])
+#             mask = cv2.inRange(hsv_image, lower_green, upper_green)
+#             result = cv2.bitwise_and(image, image, mask=mask)
+#             res = self.I_GREEN_MARKER.match(result)
+#             return res
+#
+#         def emit_exists():
+#             logger.info("Green marker detected!")
+#             unpack_screenshot()
+#             event.set()
+#
+#         def screenshot_and_detect():
+#             self.just_screenshot()
+#             exists = detect_green_marker(self.device.image)
+#             if exists:
+#                 emit_exists()
+#             return self.device.image
+#
+#         def pack_screenshot():
+#             self.just_screenshot = self.screenshot
+#             self.screenshot = screenshot_and_detect
+#
+#         def unpack_screenshot():
+#             self.screenshot = self.just_screenshot
+#
+#         def thread_run(self, detect_time=3, cb=None, cbargs=None):
+#             logger.info("detect thread running...")
+#             t = Timer(detect_time)
+#             t.start()
+#             while event.wait(detect_time):
+#                 logger.info("detect thread quit")
+#                 return
+#             unpack_screenshot()
+#             if cb:
+#                 logger.info(f"didn't detect green mark ,start running callback with arg:{cbargs}")
+#                 try:
+#                     cb(**cbargs)
+#                 except Exception as e:
+#                     logger.error(f"callback error:{e}")
+#
+#         # wrapper
+#         callback = kwargs.get('callback', None)
+#         cbargs = kwargs.get('cbargs', None)
+#         detect_time = kwargs.get('detect_time', 3.0)
+#
+#         if callback:
+#             logger.info("Green marker detector running...")
+#             pack_screenshot()
+#         # green mark 函数的参数列表
+#         kwarg_key = ['enable', 'mark_mode']
+#         func_kwargs = {key: kwargs[key] for key in kwarg_key if key in kwargs}
+#         if not event.is_set():
+#             func(self, *args, **func_kwargs)
+#
+#         if callback:
+#             thread = threading.Thread(target=thread_run, args=(self, detect_time, callback, cbargs), daemon=True)
+#             thread.start()
+#         return
+#
+#     return wrapper
+
+
+class GreenMarkState(int, Enum):
+    #
+    NOT_INIT = 0,
+    INITED = 1
 
 
 class ExtendGreenMark(GeneralBattle):
+    # 式神名称
+    _shikigami_name = ""
+    # 绿标检测范围,x,y,w,h
+    _green_mark_detect_area: list[int] = None
+    # 式神名称范围,OCR检测出的式神名位置,x,y,w,h
+    _green_mark_click_roi: list[int] = None
+    # 绿标消失临界值
+    MAX_DISAPPEAR_COUNT = 40
+    MAX_DISAPPEAR_TIME = 4
+    # 尝试生成绿标的间隔
+    GREEN_MARK_INTERVAL = 1
+    # 绿标消失后,screenshot的次数
+    _disappear_count = 0
+    # 绿标消失的时间
+    _disappear_timer = Timer(MAX_DISAPPEAR_TIME)
+    # 判断是否开始检测绿标
+    _state = GreenMarkState.NOT_INIT
 
     def __init__(self, config, device):
         super().__init__(config, device)
         self.super_green_mark = self.green_mark
 
-    @green_marker_detector
-    def ex_green_mark(self, enable=True, mark_mode=GreenMarkType.GREEN_MAIN):
-        if not enable:
-            return
-        return self.super_green_mark(enable=enable, mark_mode=mark_mode)
-
-    def ex_green_mark_3_retry(self, enable=True, mark_mode=GreenMarkType.GREEN_MAIN):
-        if not enable:
-            return
-        return self.ex_green_mark(enable=enable, mark_mode=mark_mode, detect_time=3, callback=self.super_green_mark,
-                                  cbargs={'enable': enable, 'mark_mode': mark_mode})
-
-    def green_mark_without_check(self, enable=True, mark_mode=GreenMarkType.GREEN_MAIN):
-        if not enable:
-            return
-        logger.info("Green is enable")
-        x, y = None, None
+    def init_green_mark_from_cfg(self, cfg: BaseModel):
+        self._shikigami_name = cfg.dokan.dokan_config.green_mark_shikigami_name
+        if self._shikigami_name is None or self._shikigami_name == "":
+            # 使用默认的绿标模式
+            tmp = self.generate_green_mark_area(cfg.dokan.general_battle_config.green_mark)
+            self._green_mark_click_roi = tmp.roi_front
+        else:
+            # 使用式神名称进行绿标
+            def detect_name_position_retry():
+                self.device.screenshot()
+                return self.detect_name_position(self.device.image, self._shikigami_name)
+
+            # 多试几次,避免识别失败
+            self._green_mark_click_roi = retry(detect_name_position_retry, 10)
+
+        #
+        self._green_mark_detect_area = self.calc_green_mark_locate_area(self._green_mark_click_roi)
+        self.start_green_mark()
+        return
+
+    # @green_marker_detector
+    # def ex_green_mark(self, enable=True, mark_mode=GreenMarkType.GREEN_MAIN):
+    #     if not enable:
+    #         return
+    #     return self.super_green_mark(enable=enable, mark_mode=mark_mode)
+    #
+    # def ex_green_mark_3_retry(self, enable=True, mark_mode=GreenMarkType.GREEN_MAIN):
+    #     if not enable:
+    #         return
+    #     return self.ex_green_mark(enable=enable, mark_mode=mark_mode, detect_time=3, callback=self.super_green_mark,
+    #                               cbargs={'enable': enable, 'mark_mode': mark_mode})
+
+    def generate_green_mark_area(self, mark_mode: GreenMarkType = GreenMarkType.GREEN_MAIN):
+        result = None
+        logger.info(mark_mode.name)
         match mark_mode:
             case GreenMarkType.GREEN_LEFT1:
-                x, y = self.C_GREEN_LEFT_1.coord()
+                result = self.C_GREEN_LEFT_1
                 logger.info("Green left 1")
             case GreenMarkType.GREEN_LEFT2:
-                x, y = self.C_GREEN_LEFT_2.coord()
+                result = self.C_GREEN_LEFT_2
                 logger.info("Green left 2")
             case GreenMarkType.GREEN_LEFT3:
-                x, y = self.C_GREEN_LEFT_3.coord()
+                result = self.C_GREEN_LEFT_3
                 logger.info("Green left 3")
             case GreenMarkType.GREEN_LEFT4:
-                x, y = self.C_GREEN_LEFT_4.coord()
+                result = self.C_GREEN_LEFT_4
                 logger.info("Green left 4")
             case GreenMarkType.GREEN_LEFT5:
-                x, y = self.C_GREEN_LEFT_5.coord()
+                result = self.C_GREEN_LEFT_5
                 logger.info("Green left 5")
             case GreenMarkType.GREEN_MAIN:
-                x, y = self.C_GREEN_MAIN.coord()
+                result = self.C_GREEN_MAIN
                 logger.info("Green main")
+        return result
+
+    def detect_name_position(self, img, name: str) -> list[int]:
+        def similarity(txt1, txt2):
+            txtset1 = set(txt1)
+            txtset2 = set(txt2)
+            intersection = txtset1.intersection(txtset2)
+            union = txtset1.union(txtset2)
+            return len(intersection) / len(union)
+
+        # 此处为了获取到OCR模型,随机选择一个了RuleOcr对象,可以使用任意的RuleOcr对象
+        res_list = self.O_EXP_50.model.detect_and_ocr(img, 0.7)
+        res = [item for item in res_list if similarity(item.ocr_text, name) > 0.5]
+        res = sorted(res, key=lambda x: x.score)
+        if len(res) <= 0:
+            return None
+        box = res[0].box
+        # x,y,w,h
+        return [box[0, 0], box[0, 1], box[2, 0] - box[0, 0], box[2, 1] - box[0, 1]]
+
+    def calc_green_mark_locate_area(self, roi, margin=None):
+        """
+        @param roi: 根据名字OCR得出的ROI,格式为x,y,w,h
+        @type roi: list[int]
+        @param margin: 扩展大小,格式为top,right,bottom,left,同CSS margin
+        @type margin:
+        @return:
+        @rtype:
+
+        """
+        result = [0, 0, 0, 0]
+        if margin is None:
+            margin = [150, 40, 20, 80]
+        result[0] = x if (x := roi[0] - margin[3]) > 0 else 0
+        result[1] = y if (y := roi[1] - margin[0]) > 0 else 0
+        result[2] = w if (w := roi[2] + margin[1] + margin[3]) + x <= 1280 else 1280 - x
+        result[3] = h if (h := roi[3] + margin[0] + margin[2]) + y <= 720 else 720 - y
+        return result
+
+    def detect_green_mark(self, img=None, area=None):
+        if area is not None:
+            self.I_GREEN_MARKER.roi_back = area
+        elif self._green_mark_detect_area is not None:
+            self.I_GREEN_MARKER.roi_back = self._green_mark_detect_area
+        else:
+            self.I_GREEN_MARKER.roi_back = (0, 0, 1280, 720)
+
+        if img is not None:
+            self.device.image = img
+
+        def detect_green_marker_base(image):
+            hsv_image = cv2.cvtColor(image, cv2.COLOR_RGB2HSV)
+            lower_green = np.array([67, 115, 110])
+            upper_green = np.array([80, 255, 232])
+            mask = cv2.inRange(hsv_image, lower_green, upper_green)
+            result = cv2.bitwise_and(image, image, mask=mask)
+            res = self.I_GREEN_MARKER.match(result)
+            return res
 
-        # 点击绿标
-        self.device.click(x, y)
+        if detect_green_marker_base(self.device.image):
+            return True
+        return False
+
+    def green_mark_screenshot(self, callback=None):
+        """
+            替代原有screenshot
+        @return:
+        @rtype:
+        """
+        self.screenshot()
+        # 若未初始化,直接返回,不检测绿标状态
+        if self._state == GreenMarkState.NOT_INIT:
+            return self.device.image
 
-    def custom_callback(self, enable=True, mark_mode=GreenMarkType.GREEN_MAIN):
+        # 检测式神名区域
+        if self._green_mark_click_roi is None and (self._shikigami_name is not None and self._shikigami_name != ""):
+            self._green_mark_click_roi = self.detect_name_position(self.device.image, self._shikigami_name)
+            if self._green_mark_click_roi is not None:
+                self._green_mark_detect_area = self.calc_green_mark_locate_area(self._green_mark_click_roi)
+
+        # 如果检测到绿标,直接返回
+        if self.detect_green_mark(self.device.image):
+            self._disappear_count = 0
+            self._disappear_timer.reset()
+            return self.device.image
 
-        return self.green_mark_without_check(enable, mark_mode)
+        self._disappear_count += 1
+        self._disappear_timer.start()
+        if self.need_green_mark():
+            if self.green_mark_with_area(interval=self.GREEN_MARK_INTERVAL):
+                self._disappear_timer.reset()
+                self._disappear_count = 0
+                if callback is not None:
+                    callback()
+        return self.device.image
+
+    def need_green_mark(self):
+        result = self._disappear_count > self.MAX_DISAPPEAR_COUNT
+        if result:
+            logger.info("MAX DISAPPEAR COUNT reached,Need Green Mark")
+            return True
+        result |= self._disappear_timer.reached()
+        if result:
+            logger.info("MAX DISAPPEAR TIME reached,Need Green Mark")
+            return True
+        return result
+
+    def green_mark_with_area(self, area=None, interval=1.5):
+        """
+            点击区域尝试添加绿标,不保证添加成功
+        @param area: 格式 x,y,w,h
+        @type area:
+        @return:
+        @rtype:
+        """
+        if area is None:
+            area = self._green_mark_click_roi
+        self.C_GREEN_MARK_AREA.roi_front = area
+        if self.click(self.C_GREEN_MARK_AREA, interval=interval):
+            logger.info(f"green mark with area:{area}")
+            return True
+        return False
+
+    def set_shikigami_name(self, name):
+        self._shikigami_name = name
+
+    def start_green_mark(self):
+        self._state = GreenMarkState.INITED
+
+    def stop_green_mark(self):
+        self._state = GreenMarkState.NOT_INIT
 
 
 def change_green_mark(obj):
@@ -179,10 +349,6 @@ if __name__ == '__main__':
         result = cv2.matchTemplate(image, template, cv2.TM_CCOEFF_NORMED)
         min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(result)
 
-
-
-
-
         # 获取匹配结果的位置和相似度
         top_left = max_loc
         h, w = template.shape[:2]

+ 98 - 1
tasks/Dokan/script_task.py

@@ -303,7 +303,7 @@ class ScriptTask(ExtendGreenMark, GameUi, SwitchSoul, DokanSceneDetector):
         self.next_run(skip_today=False, is_dokan_activated=is_dokan_activated)
         raise TaskEnd
 
-    def dokan_battle(self, cfg: Dokan, count=None):
+    def dokan_battle_1(self, cfg: Dokan, count=None):
         """ 道馆战斗
         道馆集结结束后会自动进入战斗,打完一个也会自动进入下一个,因此直接点击右下角的开始
 
@@ -955,6 +955,103 @@ class ScriptTask(ExtendGreenMark, GameUi, SwitchSoul, DokanSceneDetector):
                 continue
         return False
 
+    def dokan_battle(self, cfg: Dokan, count=None):
+        """ 道馆战斗
+        道馆集结结束后会自动进入战斗,打完一个也会自动进入下一个,因此直接点击右下角的开始
+
+        :return: 战斗成功(True) or 战斗失败(False) or 区域不可用(False)
+        @type count: int 战斗次数限制
+        """
+        def anti_wait_long_time():
+            self.device.stuck_record_add("BATTLE_STATUS_S")
+
+        battle_config: GeneralBattleConfig = cfg.general_battle_config
+        if not count:
+            count = 999
+        # 正式进攻会设定 2s - 10s 的随机延迟,避免攻击间隔及其相近被检测为脚本。
+        if cfg.dokan_config.random_delay:
+            self.anti_detect(False, False, True)
+            anti_wait_long_time()
+
+        # 上面可能睡了一觉,重新截图
+        self.screenshot()
+        win = False
+
+        # 等待准备按钮的出现
+        self.wait_until_appear(self.I_PREPARE_HIGHLIGHT)
+
+        while count >= 0:
+            self.green_mark_screenshot(anti_wait_long_time)
+
+            def is_end():
+
+                # 如果出现赢 就点击
+                if self.appear(GeneralBattle.I_WIN):
+                    logger.info("Dokan guards eliminated, boss is on the way")
+                    win = True
+                    return True
+
+                # 如果出现打败馆主的赢,就点击
+                if self.appear(self.I_RYOU_DOKAN_WIN):
+                    logger.info("We've defeated the boss, and win the final game.")
+                    win = True
+                    return True
+
+                # 如果出现失败 就点击,返回False。 TODO 不知道挑战馆主失败是不是同一个画面?
+                if self.appear(GeneralBattle.I_FALSE):
+                    logger.info("Battle failed")
+                    win = False
+                    return True
+
+                # 如果领奖励
+                if self.appear(self.I_RYOU_DOKAN_BATTLE_OVER, threshold=0.6):
+                    logger.info("Battle over")
+                    win = True
+                    return True
+
+                # 如果领奖励出现金币
+                if self.appear(GeneralBattle.I_REWARD_GOLD):
+                    win = True
+                    return True
+
+            if is_end():
+                break
+
+            # 击败馆主后出现的 带成功失败的 突破排名 列表
+            if self.appear(self.I_RYOU_DOKAN_TOPPA_RANK):
+                logger.info("Dokan challenge success / failed")
+                # 只是点击尝试关闭改弹窗
+                self.click(self.C_DOKAN_TOPPA_RANK_CLOSE_AREA, interval=2)
+                continue
+
+            # 如果开启战斗过程随机滑动
+            if battle_config.random_click_swipt_enable:
+                logger.info("random swipt ...")
+                self.random_click_swipt()
+
+            # 打完一个小朋友,自动进入下一个小朋友
+            if self.appear(self.I_RYOU_DOKAN_IN_FIELD):
+                self.device.click_record_clear()
+                self.device.stuck_record_clear()
+                if count > 0:
+                    logger.info("--------New battle starts---------")
+                    # 初始化 green_mark
+                    self.init_green_mark_from_cfg(self.config.model)
+                    # 长延时防止过快点击
+                    self.ui_click_until_disappear(self.I_RYOU_DOKAN_IN_FIELD, interval=1.3)
+                    anti_wait_long_time()
+                    count -= 1
+                    continue
+                if count <= 0:
+                    win = True
+                    break
+
+            continue
+
+        self.stop_green_mark()
+        logger.info(f"Win: {win}")
+        return win
+
 
 def test_goto_main():
     from module.config.config import Config

+ 13 - 2
tasks/Dokan/utils.py

@@ -4,6 +4,19 @@ import numpy as np
 from module.logger import logger
 
 
+def retry(func, max_retry=3, *args, **kwargs):
+    while True:
+        try:
+            result = func(*args, **kwargs)
+            if result is not None or max_retry <= 0:
+                return result
+            max_retry -= 1
+        except Exception as e:
+            if max_retry <= 0:
+                raise e
+            max_retry -= 1
+
+
 def detect_safe_area(image, target_gray_value=255, tolerance=0):
     """
     在灰度图片中查找与目标灰度值在容差范围内的纯色区块,并返回这些区块的坐标。
@@ -193,5 +206,3 @@ def test_anti_detect_random_click():
             cv2.imshow('Safe Area', image)
             cv2.waitKey(0)
             cv2.destroyAllWindows()
-
-