Răsfoiți Sursa

Merge pull request #604 from ChengRanORZ/autodokan_new_green_mark

feat(dokan):绿标
huangrunheng 1 an în urmă
părinte
comite
6b17892209

+ 3 - 13
module/config/config.py

@@ -26,9 +26,6 @@ from module.exception import RequestHumanTakeover, ScriptError
 from module.logger import logger
 
 
-
-
-
 class Function:
     def __init__(self, key: str, data: dict):
         """
@@ -258,8 +255,7 @@ class Config(ConfigState, ConfigManual, ConfigWatcher, ConfigMenu):
         data = {"running": running, "pending": pending, "waiting": waiting}
         return data
 
-
-    def task_call(self, task: str=None, force_call=True):
+    def task_call(self, task: str = None, force_call=True):
         """
         回调任务,这会是在任务结束后调用
         :param task: 调用的任务的大写名称
@@ -284,7 +280,7 @@ class Config(ConfigState, ConfigManual, ConfigWatcher, ConfigMenu):
             return False
 
     def task_delay(self, task: str, start_time: datetime = None,
-                   success: bool=None, server: bool=True, target: datetime=None) -> None:
+                   success: bool = None, server: bool = True, target: datetime = None) -> None:
         """
         设置下次运行时间  当然这个也是可以重写的
         :param target: 可以自定义的下次运行时间
@@ -348,7 +344,7 @@ class Config(ConfigState, ConfigManual, ConfigWatcher, ConfigMenu):
         run = min(run).replace(microsecond=0)
         next_run = run
 
-        if server and hasattr(scheduler, 'server_update'):
+        if server and hasattr(scheduler, 'server_update') and target is None:
             # 加入随机延迟时间
             float_seconds = (scheduler.float_time.hour * 3600 +
                              scheduler.float_time.minute * 60 +
@@ -385,14 +381,8 @@ class Config(ConfigState, ConfigManual, ConfigWatcher, ConfigMenu):
         logger.attr(f'{task}.scheduler.next_run', next_run)
 
 
-
-
 if __name__ == '__main__':
     config = Config(config_name='oas1')
     config.notifier.push(title="0000", content="dddddddd")
 
     # print(config.get_next())
-
-
-
-

+ 19 - 11
tasks/Component/GeneralBattle/assets.py

@@ -27,27 +27,27 @@ class GeneralBattleAssets:
 
 	# Click Rule Assets
 	# 预设队伍1 
-	C_PRESET_TEAM_1 = RuleClick(roi_front=(196,234,464,114), roi_back=(196,234,464,114), name="preset_team_1")
+	C_PRESET_TEAM_1 = RuleClick(roi_front=(195,235,465,110), roi_back=(195,235,465,110), name="preset_team_1")
 	# 预设队伍2 
-	C_PRESET_TEAM_2 = RuleClick(roi_front=(197,358,465,103), roi_back=(197,358,465,103), name="preset_team_2")
+	C_PRESET_TEAM_2 = RuleClick(roi_front=(195,355,465,110), roi_back=(195,355,465,110), name="preset_team_2")
 	# 预设队伍3 
-	C_PRESET_TEAM_3 = RuleClick(roi_front=(195,480,462,100), roi_back=(195,480,462,100), name="preset_team_3")
+	C_PRESET_TEAM_3 = RuleClick(roi_front=(195,475,465,110), roi_back=(195,475,465,110), name="preset_team_3")
 	# 预设队伍4 
-	C_PRESET_TEAM_4 = RuleClick(roi_front=(193,596,464,35), roi_back=(193,596,464,35), name="preset_team_4")
+	C_PRESET_TEAM_4 = RuleClick(roi_front=(195,595,465,35), roi_back=(195,595,465,35), name="preset_team_4")
 	# 预设组1 
-	C_PRESET_GROUP_1 = RuleClick(roi_front=(28,238,134,56), roi_back=(28,238,134,56), name="preset_group_1")
+	C_PRESET_GROUP_1 = RuleClick(roi_front=(35,240,25,50), roi_back=(35,240,25,50), name="preset_group_1")
 	# 预设组2 
-	C_PRESET_GROUP_2 = RuleClick(roi_front=(31,298,132,60), roi_back=(31,298,132,60), name="preset_group_2")
+	C_PRESET_GROUP_2 = RuleClick(roi_front=(35,305,25,50), roi_back=(35,305,25,50), name="preset_group_2")
 	# 预设组3 
-	C_PRESET_GROUP_3 = RuleClick(roi_front=(31,362,135,59), roi_back=(31,362,135,59), name="preset_group_3")
+	C_PRESET_GROUP_3 = RuleClick(roi_front=(35,365,25,50), roi_back=(35,365,25,50), name="preset_group_3")
 	# 预设组4 
-	C_PRESET_GROUP_4 = RuleClick(roi_front=(29,427,133,57), roi_back=(29,427,133,57), name="preset_group_4")
+	C_PRESET_GROUP_4 = RuleClick(roi_front=(35,430,25,50), roi_back=(35,430,25,50), name="preset_group_4")
 	# 预设组5 
-	C_PRESET_GROUP_5 = RuleClick(roi_front=(31,489,133,60), roi_back=(31,489,133,60), name="preset_group_5")
+	C_PRESET_GROUP_5 = RuleClick(roi_front=(35,495,25,50), roi_back=(35,495,25,50), name="preset_group_5")
 	# 预设组6 
-	C_PRESET_GROUP_6 = RuleClick(roi_front=(31,549,132,63), roi_back=(31,549,132,63), name="preset_group_6")
+	C_PRESET_GROUP_6 = RuleClick(roi_front=(35,555,25,50), roi_back=(35,555,25,50), name="preset_group_6")
 	# 预设组7 
-	C_PRESET_GROUP_7 = RuleClick(roi_front=(29,615,137,63), roi_back=(29,615,137,63), name="preset_group_7")
+	C_PRESET_GROUP_7 = RuleClick(roi_front=(35,615,25,50), roi_back=(35,615,25,50), name="preset_group_7")
 	# 从左开始第一个绿标 
 	C_GREEN_LEFT_1 = RuleClick(roi_front=(128,433,90,150), roi_back=(128,433,90,150), name="green_left_1")
 	# 从左开始第二个绿标 
@@ -60,6 +60,8 @@ class GeneralBattleAssets:
 	C_GREEN_LEFT_5 = RuleClick(roi_front=(1059,416,85,145), roi_back=(1059,416,85,145), name="green_left_5")
 	# 绿标阴阳师 
 	C_GREEN_MAIN = RuleClick(roi_front=(590,454,88,178), roi_back=(590,454,88,178), name="green_main")
+	# 绿标点击 区域,默认为全屏,需要在代码中更新其区域 
+	C_GREEN_MARK_AREA = RuleClick(roi_front=(0,0,1280,720), roi_back=(0,0,1280,720), name="green_mark_area")
 	# 战斗的时候有一定的概率随机点击 
 	C_RANDOM_CLICK = RuleClick(roi_front=(104,79,1050,507), roi_back=(255,65,100,100), name="random_click")
 
@@ -115,6 +117,10 @@ class GeneralBattleAssets:
 	I_DE_GOLD = RuleImage(roi_front=(61,52,30,25), roi_back=(45,33,65,64), threshold=0.8, method="Template matching", file="./tasks/Component/GeneralBattle/gb/gb_de_gold.png")
 	# 绿标 
 	I_GREEN_MARKER = RuleImage(roi_front=(0,0,1280,720), roi_back=(0,0,1280,720), threshold=0.8, method="Template matching", file="./tasks/Component/GeneralBattle/gb/gb_green_marker.png")
+	# 绿标-左上角部分 
+	I_GREEN_MARKER_LEFT_TOP = RuleImage(roi_front=(0,0,1280,720), roi_back=(0,0,1280,720), threshold=0.8, method="Template matching", file="./tasks/Component/GeneralBattle/gb/gb_green_marker_left_top.png")
+	# 绿标-下半部分 
+	I_GREEN_MARKER_BOTTOM = RuleImage(roi_front=(0,0,1280,720), roi_back=(0,0,1280,720), threshold=0.8, method="Template matching", file="./tasks/Component/GeneralBattle/gb/gb_green_marker_bottom.png")
 
 
 	# Image Rule Assets
@@ -125,6 +131,8 @@ class GeneralBattleAssets:
 	# Ocr Rule Assets
 	# 准备 
 	O_BATTLE_PREPARE = RuleOcr(roi=(1122,546,92,51), area=(1122,546,92,51), mode="Single", method="Default", keyword="准备", name="battle_prepare")
+	# 预设,部分场景预设按钮上的文字为'预设'+数字,导致点击preset失败 
+	O_PRESET = RuleOcr(roi=(20,620,60,80), area=(20,620,60,80), mode="Single", method="Default", keyword="预", name="preset")
 
 
 	# Swipe Rule Assets

+ 114 - 108
tasks/Component/GeneralBattle/gb/click.json

@@ -1,110 +1,116 @@
 [
-    {
-        "itemName": "preset_team_1",
-        "roiFront": "196,234,464,114",
-        "roiBack": "196,234,464,114",
-        "description": "预设队伍1"
-    },
-    {
-        "itemName": "preset_team_2",
-        "roiFront": "197,358,465,103",
-        "roiBack": "197,358,465,103",
-        "description": "预设队伍2"
-    },
-    {
-        "itemName": "preset_team_3",
-        "roiFront": "195,480,462,100",
-        "roiBack": "195,480,462,100",
-        "description": "预设队伍3"
-    },
-    {
-        "itemName": "preset_team_4",
-        "roiFront": "193,596,464,35",
-        "roiBack": "193,596,464,35",
-        "description": "预设队伍4"
-    },
-    {
-        "itemName": "preset_group_1",
-        "roiFront": "28,238,134,56",
-        "roiBack": "28,238,134,56",
-        "description": "预设组1"
-    },
-    {
-        "itemName": "preset_group_2",
-        "roiFront": "31,298,132,60",
-        "roiBack": "31,298,132,60",
-        "description": "预设组2"
-    },
-    {
-        "itemName": "preset_group_3",
-        "roiFront": "31,362,135,59",
-        "roiBack": "31,362,135,59",
-        "description": "预设组3"
-    },
-    {
-        "itemName": "preset_group_4",
-        "roiFront": "29,427,133,57",
-        "roiBack": "29,427,133,57",
-        "description": "预设组4"
-    },
-    {
-        "itemName": "preset_group_5",
-        "roiFront": "31,489,133,60",
-        "roiBack": "31,489,133,60",
-        "description": "预设组5"
-    },
-    {
-        "itemName": "preset_group_6",
-        "roiFront": "31,549,132,63",
-        "roiBack": "31,549,132,63",
-        "description": "预设组6"
-    },
-    {
-        "itemName": "preset_group_7",
-        "roiFront": "29,615,137,63",
-        "roiBack": "29,615,137,63",
-        "description": "预设组7"
-    },
-    {
-        "itemName": "green_left_1",
-        "roiFront": "128,433,90,150",
-        "roiBack": "128,433,90,150",
-        "description": "从左开始第一个绿标"
-    },
-    {
-        "itemName": "green_left_2",
-        "roiFront": "371,385,81,145",
-        "roiBack": "371,385,81,145",
-        "description": "从左开始第二个绿标"
-    },
-    {
-        "itemName": "green_left_3",
-        "roiFront": "586,328,100,76",
-        "roiBack": "586,328,100,76",
-        "description": "从左开始第三个绿标"
-    },
-    {
-        "itemName": "green_left_4",
-        "roiFront": "817,379,77,133",
-        "roiBack": "817,379,77,133",
-        "description": "从左开始第四个绿标"
-    },
-    {
-        "itemName": "green_left_5",
-        "roiFront": "1059,416,85,145",
-        "roiBack": "1059,416,85,145",
-        "description": "从左开始第五个绿标"
-    },
-    {
-        "itemName": "green_main",
-        "roiFront": "590,454,88,178",
-        "roiBack": "590,454,88,178",
-        "description": "绿标阴阳师"
-    },
-    {
-        "itemName": "random_click",
-        "roiFront": "104,79,1050,507",
-        "roiBack": "255,65,100,100",
-        "description": "战斗的时候有一定的概率随机点击"
-    }
+  {
+    "itemName": "preset_team_1",
+    "roiFront": "195,235,465,110",
+    "roiBack": "195,235,465,110",
+    "description": "预设队伍1"
+  },
+  {
+    "itemName": "preset_team_2",
+    "roiFront": "195,355,465,110",
+    "roiBack": "195,355,465,110",
+    "description": "预设队伍2"
+  },
+  {
+    "itemName": "preset_team_3",
+    "roiFront": "195,475,465,110",
+    "roiBack": "195,475,465,110",
+    "description": "预设队伍3"
+  },
+  {
+    "itemName": "preset_team_4",
+    "roiFront": "195,595,465,35",
+    "roiBack": "195,595,465,35",
+    "description": "预设队伍4"
+  },
+  {
+    "itemName": "preset_group_1",
+    "roiFront": "35,240,25,50",
+    "roiBack": "35,240,25,50",
+    "description": "预设组1"
+  },
+  {
+    "itemName": "preset_group_2",
+    "roiFront": "35,305,25,50",
+    "roiBack": "35,305,25,50",
+    "description": "预设组2"
+  },
+  {
+    "itemName": "preset_group_3",
+    "roiFront": "35,365,25,50",
+    "roiBack": "35,365,25,50",
+    "description": "预设组3"
+  },
+  {
+    "itemName": "preset_group_4",
+    "roiFront": "35,430,25,50",
+    "roiBack": "35,430,25,50",
+    "description": "预设组4"
+  },
+  {
+    "itemName": "preset_group_5",
+    "roiFront": "35,495,25,50",
+    "roiBack": "35,495,25,50",
+    "description": "预设组5"
+  },
+  {
+    "itemName": "preset_group_6",
+    "roiFront": "35,555,25,50",
+    "roiBack": "35,555,25,50",
+    "description": "预设组6"
+  },
+  {
+    "itemName": "preset_group_7",
+    "roiFront": "35,615,25,50",
+    "roiBack": "35,615,25,50",
+    "description": "预设组7"
+  },
+  {
+    "itemName": "green_left_1",
+    "roiFront": "128,433,90,150",
+    "roiBack": "128,433,90,150",
+    "description": "从左开始第一个绿标"
+  },
+  {
+    "itemName": "green_left_2",
+    "roiFront": "371,385,81,145",
+    "roiBack": "371,385,81,145",
+    "description": "从左开始第二个绿标"
+  },
+  {
+    "itemName": "green_left_3",
+    "roiFront": "586,328,100,76",
+    "roiBack": "586,328,100,76",
+    "description": "从左开始第三个绿标"
+  },
+  {
+    "itemName": "green_left_4",
+    "roiFront": "817,379,77,133",
+    "roiBack": "817,379,77,133",
+    "description": "从左开始第四个绿标"
+  },
+  {
+    "itemName": "green_left_5",
+    "roiFront": "1059,416,85,145",
+    "roiBack": "1059,416,85,145",
+    "description": "从左开始第五个绿标"
+  },
+  {
+    "itemName": "green_main",
+    "roiFront": "590,454,88,178",
+    "roiBack": "590,454,88,178",
+    "description": "绿标阴阳师"
+  },
+  {
+    "itemName": "green_mark_area",
+    "roiFront": "0,0,1280,720",
+    "roiBack": "0,0,1280,720",
+    "description": "绿标点击 区域,默认为全屏,需要在代码中更新其区域"
+  },
+  {
+    "itemName": "random_click",
+    "roiFront": "104,79,1050,507",
+    "roiBack": "255,65,100,100",
+    "description": "战斗的时候有一定的概率随机点击"
+  }
 ]

BIN
tasks/Component/GeneralBattle/gb/gb_green_marker_bottom.png


BIN
tasks/Component/GeneralBattle/gb/gb_green_marker_left_top.png


+ 18 - 0
tasks/Component/GeneralBattle/gb/image.json

@@ -223,5 +223,23 @@
     "method": "Template matching",
     "threshold": 0.8,
     "description": "绿标"
+  },
+  {
+    "itemName": "green_marker_left_top",
+    "imageName": "gb_green_marker_left_top.png",
+    "roiFront": "0,0,1280,720",
+    "roiBack": "0,0,1280,720",
+    "method": "Template matching",
+    "threshold": 0.8,
+    "description": "绿标-左上角部分"
+  },
+  {
+    "itemName": "green_marker_bottom",
+    "imageName": "gb_green_marker_bottom.png",
+    "roiFront": "0,0,1280,720",
+    "roiBack": "0,0,1280,720",
+    "method": "Template matching",
+    "threshold": 0.8,
+    "description": "绿标-下半部分"
   }
 ]

+ 9 - 0
tasks/Component/GeneralBattle/gb/ocr.json

@@ -7,5 +7,14 @@
     "method": "Default",
     "keyword": "准备",
     "description": "准备"
+  },
+  {
+    "itemName": "preset",
+    "roiFront": "20,620,60,80",
+    "roiBack":  "20,620,60,80",
+    "mode": "Single",
+    "method": "Default",
+    "keyword": "预",
+    "description": "预设,部分场景预设按钮上的文字为'预设'+数字,导致点击preset失败"
   }
 ]

+ 101 - 35
tasks/Component/GeneralBattle/general_battle.py

@@ -3,7 +3,11 @@
 # github https://github.com/runhey
 import time
 import random
+from time import sleep
 
+import cv2
+
+from module.base.utils import get_color, color_similar
 from tasks.base_task import BaseTask
 from tasks.Component.GeneralBattle.config_general_battle import GreenMarkType, GeneralBattleConfig
 from tasks.Component.GeneralBattle.assets import GeneralBattleAssets
@@ -293,54 +297,80 @@ class GeneralBattle(GeneralBuff, GeneralBattleAssets):
                 break
             if self.appear_then_click(self.I_PRESET, threshold=0.8, interval=1):
                 continue
+            if self.ocr_appear(self.O_PRESET):
+                self.click(self.O_PRESET, interval=1)
+                continue
         logger.info("Click preset button")
 
+        def get_unselect_color(tmp1, tmp2, tmp3, size):
+            # 获取未选择分组的颜色,3组之中必定存在两个颜色相似
+            # area 参数格式是(x1,y1,x2,y2)
+            color_1 = get_color(self.device.image,
+                                (tmp1.roi_back[0], tmp1.roi_back[1],
+                                 tmp1.roi_back[0] + size[0], tmp1.roi_back[1] + size[1]))
+            color_2 = get_color(self.device.image,
+                                (tmp2.roi_back[0], tmp2.roi_back[1],
+                                 tmp2.roi_back[0] + size[0], tmp2.roi_back[1] + size[1]))
+            color_3 = get_color(self.device.image,
+                                (tmp3.roi_back[0], tmp3.roi_back[1],
+                                 tmp3.roi_back[0] + size[0], tmp3.roi_back[1] + size[1]))
+
+            if color_similar(color_1, color_2):
+                return color_1
+            if color_similar(color_2, color_3):
+                return color_2
+            return color_3
+
         # 选择预设组
-        x, y = None, None
-        match preset_group:
-            case 1:
-                x, y = self.C_PRESET_GROUP_1.coord()
-            case 2:
-                x, y = self.C_PRESET_GROUP_2.coord()
-            case 3:
-                x, y = self.C_PRESET_GROUP_3.coord()
-            case 4:
-                x, y = self.C_PRESET_GROUP_4.coord()
-            case 5:
-                x, y = self.C_PRESET_GROUP_5.coord()
-            case 6:
-                x, y = self.C_PRESET_GROUP_6.coord()
-            case 7:
-                x, y = self.C_PRESET_GROUP_7.coord()
-            case _:
-                x, y = self.C_PRESET_GROUP_1.coord()
-        self.device.click(x, y)
+        tmp = self.__getattribute__("C_PRESET_GROUP_" + str(preset_group))
+        if tmp is None:
+            tmp = self.C_PRESET_GROUP_1
+        color_size = [self.C_PRESET_GROUP_1.roi_back[2],
+                      self.C_PRESET_GROUP_1.roi_back[3]]
+        # unselected_color = get_unselect_color(self.C_PRESET_GROUP_1, self.C_PRESET_GROUP_2, self.C_PRESET_GROUP_3, size=color_size)
+        # 考虑到有些预设组没有预设,所以这里取一个比较固定的颜色
+        unselected_color = (224.9, 208.3, 187.4)
+        while True:
+            self.screenshot()
+            color_tmp = get_color(self.device.image,
+                                  (tmp.roi_back[0], tmp.roi_back[1], tmp.roi_back[0] + color_size[0],
+                                   tmp.roi_back[1] + color_size[1]))
+            if color_similar(color_tmp, unselected_color):
+                self.click(tmp, interval=0.2)
+                continue
+            break
+
         logger.info("Select preset group")
 
         # 选择预设的队伍
         time.sleep(0.5)
-        match preset_team:
-            case 1:
-                x, y = self.C_PRESET_TEAM_1.coord()
-            case 2:
-                x, y = self.C_PRESET_TEAM_2.coord()
-            case 3:
-                x, y = self.C_PRESET_TEAM_3.coord()
-            case 4:
-                x, y = self.C_PRESET_TEAM_4.coord()
-            case _:
-                x, y = self.C_PRESET_TEAM_1.coord()
-        self.device.click(x, y)
+        tmp = self.__getattribute__("C_PRESET_TEAM_" + str(preset_team))
+        if tmp is None:
+            tmp = self.C_PRESET_TEAM_1
+        color_size = [5, 5]
+        # unselected_color = get_unselect_color(self.C_PRESET_TEAM_1, self.C_PRESET_TEAM_2, self.C_PRESET_TEAM_3, size=color_size )
+        unselected_color = (216.8, 185.0, 146.8)
+        while True:
+            self.screenshot()
+            color_tmp = get_color(self.device.image,
+                                  (tmp.roi_back[0], tmp.roi_back[1], tmp.roi_back[0] + color_size[0],
+                                   tmp.roi_back[1] + color_size[1]))
+            if color_similar(color_tmp, unselected_color):
+                self.click(tmp, interval=0.2)
+                continue
+            break
+
+        self.click(tmp)
         logger.info("Select preset team")
 
         # 点击预设确认
         self.wait_until_appear(self.I_PRESET_ENSURE, wait_time=1)
         while 1:
             self.screenshot()
-            if self.appear_then_click(self.I_PRESET_ENSURE, threshold=0.8):
-                continue
             if not self.appear(self.I_PRESET_ENSURE):
                 break
+            if self.appear_then_click(self.I_PRESET_ENSURE, threshold=0.8, interval=0.2):
+                continue
         logger.info("Click preset ensure")
 
     def random_click_swipt(self):
@@ -488,5 +518,41 @@ if __name__ == '__main__':
     c = Config('oas1')
     d = Device(c)
     t = GeneralBattle(c, d)
-
-    t.check_buff([BuffClass.EXP_50, BuffClass.GOLD_50])
+    self = t
+    # t.check_buff([BuffClass.EXP_50, BuffClass.GOLD_50])
+
+    img = cv2.imread(r"E:\preset3.png")
+    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+    self.device.image = img
+
+
+    def get_unselect_color(tmp1, tmp2, tmp3, size):
+        # 获取未选择分组的颜色,3组之中必定存在两个颜色相似
+        # area 参数格式是(x1,y1,x2,y2)
+        color_1 = get_color(self.device.image,
+                            (tmp1.roi_back[0], tmp1.roi_back[1],
+                             tmp1.roi_back[0] + size[0], tmp1.roi_back[1] + size[1]))
+        color_2 = get_color(self.device.image,
+                            (tmp2.roi_back[0], tmp2.roi_back[1],
+                             tmp2.roi_back[0] + size[0], tmp2.roi_back[1] + size[1]))
+        color_3 = get_color(self.device.image,
+                            (tmp3.roi_back[0], tmp3.roi_back[1],
+                             tmp3.roi_back[0] + size[0], tmp3.roi_back[1] + size[1]))
+
+        if color_similar(color_1, color_2):
+            return color_1
+        if color_similar(color_2, color_3):
+            return color_2
+        return color_3
+
+
+    color_size = [self.C_PRESET_GROUP_1.roi_back[2],
+                  self.C_PRESET_GROUP_1.roi_back[3]]
+    unselected_color = get_unselect_color(self.C_PRESET_GROUP_1, self.C_PRESET_GROUP_2, self.C_PRESET_GROUP_3,
+                                          size=color_size)
+    print("")
+    color_size = [5, 5]
+    unselected_color = get_unselect_color(self.C_PRESET_TEAM_1, self.C_PRESET_TEAM_2, self.C_PRESET_TEAM_3,
+                                          size=color_size
+                                          )
+    print("")

+ 1 - 1
tasks/Dokan/assets.py

@@ -81,7 +81,7 @@ class DokanAssets:
 	# 放弃突破 
 	I_DOKAN_ABANDONED_TOPPA_TITLE = RuleImage(roi_front=(1020,160,260,80), roi_back=(1020,160,260,80), threshold=0.8, method="Template matching", file="./tasks/Dokan/res/res_ryou_dokan_abandoned_toppa_title.png")
 	# 状态:道馆胜利 
-	I_RYOU_DOKAN_WIN = RuleImage(roi_front=(628,60,45,33), roi_back=(628,60,45,33), threshold=0.8, method="Template matching", file="./tasks/Dokan/res/res_ryou_dokan_win.png")
+	I_RYOU_DOKAN_WIN = RuleImage(roi_front=(620,50,100,80), roi_back=(620,50,100,80), threshold=0.8, method="Template matching", file="./tasks/Dokan/res/res_ryou_dokan_win.png")
 	# 状态:进入战斗,待开始,右下角图标。 
 	I_RYOU_DOKAN_IN_FIELD2 = RuleImage(roi_front=(1131,562,88,48), roi_back=(1131,562,88,48), threshold=0.8, method="Template matching", file="./tasks/Dokan/res/res_ryou_dokan_in_field2.png")
 	# 馆主战,第一阵容 

+ 6 - 3
tasks/Dokan/config.py

@@ -58,7 +58,7 @@ class AttackDokanMasterType(str, Enum):
 
 class AttackAccountConfig(BaseModel):
     # 当天可攻击次数,用以记录当天运行历史,用作状态恢复,不用配置
-    remain_attack_count: int = Field(default=2)
+    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
@@ -151,9 +151,12 @@ class DokanConfig(BaseModel):
     switch_preset_enable: bool = Field(default=False, description='switch_preset_enable_help')
 
     # 速攻阵容 格式:n,n
-    preset_group_1: str = Field(default="", description='preset_group_help')
+    preset_group_1: str = Field(default="", description='preset_group_1_help')
     # 挂机阵容
-    preset_group_2: str = Field(default="", description='preset_group_help')
+    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])"

+ 6 - 1
tasks/Dokan/dokan_scene.py

@@ -38,9 +38,11 @@ class DokanScene(Enum):
     RYOU_DOKAN_SCENE_MASTER_BATTLING = 14
     # 弹出窗口,道馆打完后,出现的排名
     RYOU_DOKAN_SCENE_TOPPA_RANK = 15
+    # 道馆胜利后,出现的界面
+    RYOU_DOKAN_SCENE_WIN=16
 
     # 阴阳寮神社界面
-    RYOU_DOKAN_SHENSHE = 16
+    RYOU_DOKAN_SHENSHE = 17
 
     # 正在查找道馆,处于地图界面
     RYOU_DOKAN_SCENE_FINDING_DOKAN = 97
@@ -131,6 +133,9 @@ class DokanSceneDetector(DokanAssets, BaseTask, GeneralBattleAssets):
         # 放弃后投票,右侧俩按钮: 保留赏金/再战道馆
         if self.appear(self.I_RYOU_DOKAN_FAILED_VOTE_KEEP_BOUNTY):
             return True, DokanScene.RYOU_DOKAN_SCENE_FAILED_VOTE
+        # 状态:胜利
+        if self.appear(self.I_RYOU_DOKAN_WIN):
+            return True, DokanScene.RYOU_DOKAN_SCENE_WIN
 
         # 状态:道馆已经结束 在寮境,底部有 "今日可挑战机会" 字样
         if (self.appear(self.I_RYOU_DOKAN_CENTER_TOP) and

+ 306 - 100
tasks/Dokan/ex_green_mark.py

@@ -1,131 +1,341 @@
 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,
+    # 备用
+    MARKED = 2,
+    DISAPPEARED = 3
 
 
 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, names: str = None, green_mark_type: GreenMarkType = None):
+        self._shikigami_name = names
+        if self._shikigami_name is None or self._shikigami_name == "":
+            # 使用默认的绿标模式
+            tmp = self.generate_green_mark_area(green_mark_type)
+            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, 3)
+
+        #
+        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, names: 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)
+
+        name_list = names.split(',')
+        for name in name_list:
+            # 此处为了获取到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:
+                continue
+            box = res[0].box
+            logger.info(f"detect{res[0].ocr_text} with name:{name} in {box}")
+            # 经实验,点击式神名称位置,可能点击不到,故此做一个修正
+            offset = [5, 30, -10, 0]
+            # x,y,w,h
+            return [box[0, 0] + offset[0], box[0, 1] + offset[1], box[2, 0] - box[0, 0] + offset[2],
+                    box[2, 1] - box[0, 1] + offset[3]]
+        return None
+
+    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:
+
+        """
+        if roi is None:
+            return [0, 0, 1280, 720]
+        result = [0, 0, 0, 0]
+        if margin is None:
+            margin = [160, 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):
+        def init_green_marker_roi(roi):
+            self.I_GREEN_MARKER.roi_back = roi
+            self.I_GREEN_MARKER_LEFT_TOP.roi_back = roi
+            self.I_GREEN_MARKER_BOTTOM.roi_back = roi
+
+        # 初始化绿标相关变量的roi信息
+        if area is not None:
+            init_green_marker_roi(area)
+        elif self._green_mark_detect_area is not None:
+            init_green_marker_roi(self._green_mark_detect_area)
+        else:
+            init_green_marker_roi((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_LEFT_TOP.match(result)
+                   or self.I_GREEN_MARKER_BOTTOM.match(result)
+                   or 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 or self._state is None:
+            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()
+            if self._state != GreenMarkState.MARKED:
+                logger.info("green mark appear")
+                self._state = GreenMarkState.MARKED
+            return self.device.image
 
-        return self.green_mark_without_check(enable, mark_mode)
+        if self._state != GreenMarkState.DISAPPEARED:
+            logger.info("green mark DISappear")
+            self._state = GreenMarkState.DISAPPEARED
+        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
+        if area is None:
+            logger.warn("Green Mark with area None,give up")
+            return False
+        self.C_GREEN_MARK_AREA.roi_front = area
+        if self.click(self.C_GREEN_MARK_AREA, interval=interval):
+            # NOTE 防止式神死亡导致的连续点击,程序退出
+            self.device.click_record_clear()
+            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
+        self._disappear_timer.clear()
+        self._disappear_count = 0
+
+    def stop_green_mark(self):
+        self._state = GreenMarkState.NOT_INIT
+
+    def set_disappear_count(self, count):
+        # 设置消失次数,用于(主动触发执行绿标)
+        self._disappear_count = count
 
 
 def change_green_mark(obj):
@@ -179,10 +389,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]

+ 2 - 2
tasks/Dokan/res/image.json

@@ -209,8 +209,8 @@
   {
     "itemName": "ryou_dokan_win",
     "imageName": "res_ryou_dokan_win.png",
-    "roiFront": "628,60,45,33",
-    "roiBack": "628,60,45,33",
+    "roiFront": "620,50,100,80",
+    "roiBack": "620,50,100,80",
     "method": "Template matching",
     "threshold": 0.8,
     "description": "状态:道馆胜利"

+ 131 - 7
tasks/Dokan/script_task.py

@@ -117,7 +117,8 @@ class ScriptTask(ExtendGreenMark, GameUi, SwitchSoul, DokanSceneDetector):
             out_dokan_timer.clear()
 
             # 战斗结束
-            if current_scene == DokanScene.RYOU_DOKAN_SCENE_BATTLE_OVER:
+            if (current_scene == DokanScene.RYOU_DOKAN_SCENE_BATTLE_OVER or
+                    current_scene == DokanScene.RYOU_DOKAN_SCENE_WIN):
                 # 随便点击个地方退出奖励界面
                 self.click(self.C_DOKAN_TOPPA_RANK_CLOSE_AREA, interval=2)
                 sleep(2)
@@ -181,7 +182,7 @@ class ScriptTask(ExtendGreenMark, GameUi, SwitchSoul, DokanSceneDetector):
                 logger.info(f"{current_scene} dokan_master_count:{count},first_master_killed:{first_master_killed}")
                 if (count - (1 if first_master_killed else 0)) > 0:
                     logger.info("start Master_first")
-                    self.ui_click_until_disappear(self.I_RYOU_DOKAN_START_CHALLENGE, interval=2)
+                    self.click(self.I_RYOU_DOKAN_START_CHALLENGE, interval=2)
                     continue
                 # 放弃突破
                 if cfg.dokan_config.try_start_dokan:
@@ -190,7 +191,7 @@ class ScriptTask(ExtendGreenMark, GameUi, SwitchSoul, DokanSceneDetector):
                 continue
             # 场景状态:检查右下角有没有挑战?通常是失败了,并退出来到集结界面,可重新开始点击右下角挑战进入战斗
             if current_scene == DokanScene.RYOU_DOKAN_SCENE_START_CHALLENGE:
-                self.ui_click_until_disappear(self.I_RYOU_DOKAN_START_CHALLENGE, interval=1)
+                self.click(self.I_RYOU_DOKAN_START_CHALLENGE, interval=1)
                 continue
             # 场景状态:馆主第一阵容 且战斗未开始
             if current_scene == DokanScene.RYOU_DOKAN_SCENE_BATTLE_MASTER_FIRST:
@@ -303,7 +304,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):
         """ 道馆战斗
         道馆集结结束后会自动进入战斗,打完一个也会自动进入下一个,因此直接点击右下角的开始
 
@@ -688,6 +689,7 @@ class ScriptTask(ExtendGreenMark, GameUi, SwitchSoul, DokanSceneDetector):
 
         while num_fresh < self.config.dokan.dokan_config.find_dokan_refresh_count:
             for i in range(3):
+                sleep(3)
                 if find_challengeable():
                     logger.info("find challengeable dokan")
                     self.ui_click(self.I_CENTER_CHALLENGE, self.I_CHALLENGE_ENSURE, interval=1)
@@ -699,12 +701,13 @@ class ScriptTask(ExtendGreenMark, GameUi, SwitchSoul, DokanSceneDetector):
                     return True
                 # 滑动道馆列表
                 self.swipe(self.S_DOKAN_LIST_UP)
-                sleep(3)
+
             # 恢复初始位置信息,防止下次使用出错
             restore_roi()
             logger.info("=========refresh dokan list=========")
             self.ui_click(self.C_DOKAN_REFRESH, self.I_REFRESH_ENSURE, interval=1)
             self.ui_click_until_disappear(self.I_REFRESH_ENSURE, interval=1)
+
             logger.info("Refresh Done")
             num_fresh += 1
 
@@ -897,14 +900,14 @@ class ScriptTask(ExtendGreenMark, GameUi, SwitchSoul, DokanSceneDetector):
                 return
             # 时间在道馆开启时间附近,3分钟后执行
 
-            self.set_next_run(task="Dokan", target=now + config.dokan.scheduler.failure_interval)
+            self.set_next_run(task="Dokan", target=now + self.config.dokan.scheduler.failure_interval)
         # 道馆已开启
         if is_dokan_activated:
             # 如果打两次,当前是第一次,设置为3分钟后运行
             #   # 本来以为server为False(finish=True,success=False,server=False)就不会变成明天,谁知道还是变成明天
             #   # 逻辑太复杂,不如直接target,简单点
             if self.config.dokan.attack_count_config.remain_attack_count == 1 and self.config.dokan.attack_count_config.daily_attack_count == 2:
-                self.set_next_run(task="Dokan", target=now + config.dokan.scheduler.failure_interval)
+                self.set_next_run(task="Dokan", target=now + self.config.dokan.scheduler.failure_interval)
                 return
             # 其余情况当作成功
             self.set_next_run(task="Dokan", finish=False, success=True, server=True)
@@ -955,6 +958,127 @@ class ScriptTask(ExtendGreenMark, GameUi, SwitchSoul, DokanSceneDetector):
                 continue
         return False
 
+    def dokan_battle(self, cfg: Dokan, battle_count_limit=None):
+        """ 道馆战斗
+        道馆集结结束后会自动进入战斗,打完一个也会自动进入下一个,因此直接点击右下角的开始
+
+        :return: 战斗成功(True) or 战斗失败(False) or 区域不可用(False)
+        @type battle_count_limit: int 战斗次数限制
+        """
+
+        def anti_wait_long_time():
+            self.device.stuck_record_add("BATTLE_STATUS_S")
+
+        battle_config: GeneralBattleConfig = cfg.general_battle_config
+        if not battle_count_limit:
+            battle_count_limit = 999
+
+        # 上面可能睡了一觉,重新截图
+        self.screenshot()
+        win = False
+
+        # 等待准备按钮的出现
+        self.wait_until_appear(self.I_PREPARE_HIGHLIGHT)
+
+        # 战斗刚开始,需要添加绿标
+        need_green_mark = battle_config.green_enable
+        # 绿标区域初始化标识,只初始化一次绿标区域
+        need_init_green_mark_area = battle_config.green_enable
+
+        while True:
+            if cfg.general_battle_config.green_enable:
+                self.green_mark_screenshot(anti_wait_long_time)
+            else:
+                self.screenshot()
+
+            def is_battle_end() -> (bool, bool):
+
+                if battle_count_limit < 0:
+                    logger.info(f"battle_count_limit:{battle_count_limit}")
+                    win = True
+                    return win, True
+
+                # 如果出现赢 就点击
+                if self.appear(GeneralBattle.I_WIN):
+                    logger.info("Dokan guards eliminated, boss is on the way")
+                    win = True
+                    return win, True
+
+                # 如果出现打败馆主的赢,就点击
+                if self.appear(self.I_RYOU_DOKAN_WIN):
+                    logger.info("We've defeated the boss, and win the final game.")
+                    win = True
+                    return win, True
+
+                # 如果出现失败 就点击,返回False。 TODO 不知道挑战馆主失败是不是同一个画面?
+                if self.appear(GeneralBattle.I_FALSE):
+                    logger.info("Battle failed")
+                    win = False
+                    return win, True
+
+                # 如果领奖励
+                if self.appear(self.I_RYOU_DOKAN_BATTLE_OVER, threshold=0.6):
+                    logger.info("Battle over")
+                    win = True
+                    return win, True
+
+                # 如果领奖励出现金币
+                if self.appear(GeneralBattle.I_REWARD_GOLD):
+                    logger.info("Reward gold")
+                    win = True
+                    return win, True
+
+                return False, False
+
+            win, is_battle_end_and_exit = is_battle_end()
+            if is_battle_end_and_exit:
+                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 and not battle_config.green_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()
+
+                logger.info("--------New battle starts---------")
+
+                if need_init_green_mark_area:
+                    need_init_green_mark_area = False
+                    # 初始化 green_mark
+                    self.init_green_mark_from_cfg(self.config.dokan.dokan_config.green_mark_shikigami_name,
+                                                  self.config.dokan.general_battle_config.green_mark)
+                if need_green_mark:
+                    need_green_mark = False
+                    # 缩短第一次绿标的检测时间,在短时间内触发标记动作
+                    self.set_disappear_count(self.MAX_DISAPPEAR_COUNT - 10)
+
+                # 正式进攻会设定 2s - 10s 的随机延迟,避免攻击间隔及其相近被检测为脚本。
+                if cfg.dokan_config.random_delay:
+                    self.anti_detect(False, False, True)
+
+                self.ui_click_until_disappear(self.I_RYOU_DOKAN_IN_FIELD, interval=0.4)
+                anti_wait_long_time()
+                battle_count_limit -= 1
+                continue
+
+            sleep(0.02)
+            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()
-
-