Merge branch 'main' of https://git.zhaozuohong.vip/mower-ng/mower-ng

mower/solvers/infra/base_choose.py

@@ -1,11 +1,11 @@
 # import lzma
 # import pickle
 
-import time
+# import time
 import cv2
 
 # from matplotlib import pyplot as plt
-from matplotlib import pyplot as plt
+# from matplotlib import pyplot as plt
 import numpy as np
 
 from mower.models import secret_front
@@ -18,19 +18,19 @@ from mower.utils.character_recognize import (
     operator_room_select,
 )
 from mower.utils.graph import SceneGraphSolver
-from mower.utils.image import cropimg, loadres
+from mower.utils.image import cropimg  # ,loadres
 from mower.utils.log import logger
 
 # from mower import __rootdir__
 from mower.utils.scene import Scene
-from mower.utils.vector import sa, va
+from mower.utils.vector import va  # ,sa
 
 # with lzma.open(f"{__rootdir__}/models/professior.pkl", "rb") as f:
 #     pro_list = pickle.load(f)
 
 
 class RIIC_ChooseSolver(SceneGraphSolver, BaseMixin):
-    def run(self, room: str, agent_list: list):
+    def run(self, room: str, agent_list: list) -> bool:
         self.room = room
         self.agent_list = agent_list
         self.wait_choose = {}
@@ -48,6 +48,7 @@ class RIIC_ChooseSolver(SceneGraphSolver, BaseMixin):
         except ValueError as e:
             logger.error(e.__traceback__)
             return False
+        return True
 
     def riic_agent_choose(self):
         if (

mower/solvers/infra/drone.py

@@ -40,6 +40,8 @@ class DroneSolver(SceneGraphSolver, BaseMixin):
 
         if count is None and not all_in:
             count = cur_count - config.conf.drone_count_limit
+        if count <= 0:
+            return
 
         self.count = count
         self.all_in = all_in

mower/solvers/infra/run_order/__init__.py

@@ -1,37 +1,67 @@
+from datetime import datetime
+
 from mower.solvers.infra.base_choose import RIIC_ChooseSolver
+from mower.solvers.infra.drone import DroneSolver
 from mower.solvers.infra.get_agent_from_room import GetAgentFromRoomSolver
 from mower.solvers.infra.get_order_remaining_time import (
     GetOrderRemainingTimeSolver,
 )
 from mower.utils import config
+from mower.utils.digit_reader import DigitReader
 from mower.utils.graph import SceneGraphSolver
 from mower.utils.log import logger
+from mower.utils.scene import Scene
 
+from .read_original_order_remaining_time import ReadOriginalOrderRemainTimeSolver
 from .wait_for_order import WaitForOrderSolver
 
-limit_time = 3600
+limit_time = 1800
 
 
 class RunOrderSolver(SceneGraphSolver):
-    def run(self, room: str, agent_list: list):
+    def run(
+        self,
+        room: str,
+        agent_list: list,
+        drone: bool = False,
+    ) -> None:
         logger.info("Start:跑单插拔")
+        # 读取原来的干员列表
         original_agent_list = [
             data["agent"] for data in GetAgentFromRoomSolver().run(room)
         ]
+        if drone:
+            # 读取当前无人机数量避免重复开关
+            cur_drone_count = DigitReader().get_drone(config.recog.gray)
+            drone_count = ReadOriginalOrderRemainTimeSolver().run(room) // 180 - 1
+            DroneSolver().run(room, drone_count, cur_count=cur_drone_count)
+
         wait_time = max(
-            GetOrderRemainingTimeSolver().run(room) - config.conf.run_order_delay * 60,
+            GetOrderRemainingTimeSolver().run(room) - config.conf.run_order_buffer_time,
             0,
         )
         if wait_time > limit_time:
             logger.error("检测到漏单")
             return
         logger.info(f"等待时间:{wait_time}")
-        self.sleep(wait_time)
-        RIIC_ChooseSolver().run(room, agent_list)
+        start_time = datetime.now()
+        if RIIC_ChooseSolver().run(room, agent_list):
+            wait_time = wait_time - (datetime.now() - start_time).total_seconds()
+            self.sleep(wait_time)
+            while self.scene() == Scene.RIIC_OPERATOR_SELECT:
+                self.tap_element("confirm_blue")
+        else:
+            logger.error("跑单选人失败")
+            return
 
-        if wait_time := GetOrderRemainingTimeSolver().run(room) > limit_time:
+        if (wait_time := GetOrderRemainingTimeSolver().run(room)) > limit_time:
             logger.error("检测到漏单")
             return
         logger.info(f"等待时间:{wait_time}")
         WaitForOrderSolver().run(room, wait_time)
-        RIIC_ChooseSolver().run(room, original_agent_list)
+        if RIIC_ChooseSolver().run(room, original_agent_list):
+            while self.scene() == Scene.RIIC_OPERATOR_SELECT:
+                self.tap_element("confirm_blue")
+        else:
+            logger.error("跑单选人失败")
+            return

mower/solvers/infra/run_order/read_original_order_remaining_time.py

@@ -0,0 +1,80 @@
+import cv2
+
+from mower.models import riic_base_digits
+from mower.solvers.infra.base_mixin import BaseMixin
+from mower.solvers.infra.enter_room import EnterRoomSolver
+from mower.utils import config
+from mower.utils import typealias as tp
+from mower.utils.graph import SceneGraphSolver
+from mower.utils.image import cropimg, thres2
+from mower.utils.recognize import Scene
+
+
+class ReadOriginalOrderRemainTimeSolver(SceneGraphSolver, BaseMixin):
+    """
+    返回剩余时间,换算为秒
+    """
+
+    def run(
+        self,
+        room: str,
+    ):
+        self.room = room
+        if (
+            self.scene() == Scene.DRONE_ACCELERATE
+            and not self.detect_room_inside() == self.room
+        ):
+            EnterRoomSolver().run(self.room, detail=False)
+        super().run()
+        return self.res
+
+    def number(self, scope: tp.Scope, height: int, thres: int) -> str:
+        "数字识别"
+        img = cropimg(config.recog.gray, scope)
+        default_height = 25
+        if height != default_height:
+            scale = 25 / height
+            img = cv2.resize(img, None, None, scale, scale)
+        img = thres2(img, thres)
+        contours, _ = cv2.findContours(img, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        rect = [cv2.boundingRect(c) for c in contours]
+        rect.sort(key=lambda c: c[0])
+
+        value = ""
+        for x, y, w, h in rect:
+            if h < 7 and w < 7:
+                value += ":"
+                continue
+            digit = cropimg(img, ((x, y), (x + w, y + h)))
+            digit = cv2.copyMakeBorder(
+                digit, 10, 10, 10, 10, cv2.BORDER_CONSTANT, None, (0,)
+            )
+            score = []
+            for i in range(10):
+                im = riic_base_digits[i]
+                result = cv2.matchTemplate(digit, im, cv2.TM_SQDIFF_NORMED)
+                min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(result)
+                score.append(min_val)
+            value += str(score.index(min(score)))
+
+        return value
+
+    def read_remain_time(self) -> int:
+        h, m, s = self.number(((758, 670), (960, 705)), 30, 100).split("::")
+        return int(h) * 3600 + int(m) * 60 + int(s)
+
+    def transition(self) -> bool:
+        if (scene := self.scene()) == Scene.INFRA_DETAILS:
+            self.ctap((200, 1000), 1, config.screenshot_avg / 1000)
+        elif scene == Scene.ORDER_LIST:
+            if pos := self.find("bill_accelerate"):
+                self.tap(pos)
+
+        elif scene == Scene.DRONE_ACCELERATE:
+            if res := self.read_remain_time():
+                self.res = res
+                return True
+        elif scene in self.waiting_scene:
+            self.waiting_solver()
+        else:
+            EnterRoomSolver().run(self.room, detail=False)