Merge branch 'master' of https://github.com/pur1fying/blue_archive_au…

…to_script

core/color.py

@@ -2,19 +2,14 @@
 import time
 
 
-def wait_loading(self, skip_first_screenshot=False):
+def wait_loading(self):
     t_start = time.time()
     while 1:
         screenshot_interval = time.time() - self.latest_screenshot_time
         if screenshot_interval < self.screenshot_interval:
             time.sleep(self.screenshot_interval - screenshot_interval)
         threading.Thread(target=self.screenshot_worker_thread).start()
-        if not self.screenshot_updated:  # wait for screenshot
-            if skip_first_screenshot:
-                skip_first_screenshot = False
-            else:
-                self.wait_screenshot_updated()
-                self.screenshot_updated = False
+        self.wait_screenshot_updated()
         if not judge_rgb_range(self.latest_img_array, 937, 648, 200, 255, 200, 255, 200, 255) or not \
                 judge_rgb_range(self.latest_img_array, 919, 636, 200, 255, 200, 255, 200, 255):
             loading_pos = [[929, 664], [941, 660], [979, 662], [1077, 665], [1199, 665]]
@@ -68,6 +63,8 @@ def common_rgb_detect_method(self, click, possible_los, ends, skip_first_screens
 
 def detect_rgb_one_time(self, click=None, possible_los=None, ends=None):
     for i in range(0, len(ends)):
+        if ends[i] not in self.rgb_feature:
+            continue
         for j in range(0, len(self.rgb_feature[ends[i]][0])):
             if not judge_rgb_range(self.latest_img_array,
                                    self.rgb_feature[ends[i]][0][j][0],
@@ -83,6 +80,8 @@ def detect_rgb_one_time(self, click=None, possible_los=None, ends=None):
             self.logger.info("end : " + ends[i])  # 出现end中的任意一个，返回对应的位置字符串
             return "end", ends[i]
     for i in range(0, len(possible_los)):  # 可能的图标
+        if possible_los[i] not in self.rgb_feature:
+            continue
         for j in range(0, len(self.rgb_feature[possible_los[i]][0])):  # 每个图标多个，判断rgb
             if not judge_rgb_range(self.latest_img_array,
                                    self.rgb_feature[possible_los[i]][0][j][0],
@@ -125,7 +124,7 @@ def check_sweep_availability(img, server):
                 judge_rgb_range(img, 211, 434, 225, 255, 200, 255, 20, 60):
             return "pass"
         return "UNKNOWN"
-    elif server == "Global":
+    elif server == "Global" or server == "JP":
         if judge_rgb_range(img, 169, 369, 192, 212, 192, 212, 192, 212) and \
                 judge_rgb_range(img, 169, 405, 192, 212, 192,212, 192, 212) and \
                 judge_rgb_range(img, 169, 439, 192, 212, 192, 212, 192, 212):

core/default_config.py

@@ -599,7 +599,33 @@
                         "椿",
                         "晴",
                         "响"
-                        ]
-
+                        ],
+    "current_game_activity": {
+        "CN": "no_227_kinosaki_spa",
+        "Global": null,
+        "JP": null
+    },
+    "common_shop_price_list": {
+        "CN": [30,30,30,30,10000,40000,96000,128000,10000,40000,96000,128000,8000,8000,25000,25000],
+        "JP": [12500, 125000, 300000, 500000, 10000, 40000, 96000, 128000, 10000, 40000, 96000, 128000, 20000, 80000, 192000, 256000, 8000, 8000, 25000, 25000],
+        "Global": [12500, 125000, 300000, 500000, 10000, 40000, 96000, 128000, 10000, 40000, 96000, 128000, 20000, 80000, 192000, 256000, 8000, 8000, 25000, 25000]
+    },
+    "tactical_challenge_shop_price_list": {
+        "CN": [50, 50, 50, 50, 15, 30, 5, 25, 60, 100, 4, 20, 60, 100],
+        "JP": [50, 50, 50, 50, 50, 15, 30, 5, 25, 60, 100, 4, 20, 60, 100],
+        "Global": [50, 50, 50, 50, 50, 15, 30, 5, 25, 60, 100, 4, 20, 60, 100]
+    },
+    "package_name": {
+        "官服": "com.RoamingStar.BlueArchive",
+        "B服": "com.RoamingStar.BlueArchive.bilibili",
+        "国际服": "com.nexon.bluearchive",
+        "日服": "com.YostarJP.BlueArchive"
+    },
+    "activity_name": {
+        "官服": "com.yostar.sdk.bridge.YoStarUnityPlayerActivity",
+        "B服": "com.yostar.sdk.bridge.YoStarUnityPlayerActivity",
+        "国际服": ".MxUnityPlayerActivity",
+        "日服": "com.yostarjp.bluearchive.MxUnityPlayerActivity"
+    }
 }
 '''

core/image.py

@@ -21,9 +21,11 @@ def screenshot_cut(self, area, image=None):
 def compare_image(self, name, threshold=3, need_loading=False, image=None, need_log=True):
     if need_loading:
         color.wait_loading(self)
+    if name not in position.image_dic:
+        return False
     area = get_area(name)
+    res_img = position.image_dic[name]
     ss_img = screenshot_cut(self, area=area, image=image)
-    res_img = position.iad[name]
     diff = cv2.absdiff(ss_img, res_img)
     mean_diff = np.mean(diff)
     compare = mean_diff <= threshold
@@ -80,7 +82,9 @@ def detect(self, end=None, possibles=None, pre_func=None, pre_argv=None, skip_fi
 
 def get_area(name):
     module, name = name.rsplit("_", 1)
-    return position.ibd[module][name]
+    if position.image_x_y_range[module][name] is None:
+        return False
+    return position.image_x_y_range[module][name]
 
 
 def process_image(self, img, name, threshold=10, step=5):

core/ocr.py

@@ -0,0 +1,153 @@
+import time
+
+import cv2
+from cnocr import CnOcr
+
+
+class Baas_ocr:
+    def __init__(self, logger, ocr_needed):
+        self.logger = logger
+        self.ocrEN = None
+        self.ocrCN = None
+        self.ocrJP = None
+        self.ocrNUM = None
+        try:
+            if 'CN' in ocr_needed:
+                self.init_CNocr()
+            if 'Global' in ocr_needed:
+                self.init_ENocr()
+            if 'JP' in ocr_needed:
+                self.init_JPocr()
+            if 'NUM' in ocr_needed:
+                self.init_NUMocr()
+        except Exception as e:
+            self.logger.error("OCR init error: " + str(e))
+            raise e
+
+    def init_ENocr(self):
+        self.ocrEN = CnOcr(det_model_name="en_PP-OCRv3_det",
+                           det_model_fp='src/ocr_models/en_PP-OCRv3_det_infer.onnx',
+                           rec_model_name='en_number_mobile_v2.0',
+                           rec_model_fp='src/ocr_models/en_number_mobile_v2.0_rec_infer.onnx', )
+        img_EN = cv2.imread('src/test_ocr/EN.png')
+        self.logger.info("Test ocrEN : " + self.ocrEN.ocr_for_single_line(img_EN)['text'])
+        return True
+
+    def init_CNocr(self):
+        if self.ocrCN is None:
+            self.ocrCN = CnOcr(det_model_name='ch_PP-OCRv3_det',
+                               det_model_fp='src/ocr_models/ch_PP-OCRv3_det_infer.onnx',
+                               rec_model_name='densenet_lite_114-fc',
+                               rec_model_fp='src/ocr_models/cn_densenet_lite_136.onnx')
+            img_CN = cv2.imread('src/test_ocr/CN.png')
+            self.logger.info("Test ocrCN : " + self.ocrCN.ocr_for_single_line(img_CN)['text'])
+        return True
+
+    def init_NUMocr(self):
+        if self.ocrNUM is None:
+            self.ocrNUM = CnOcr(det_model_name='en_PP-OCRv3_det',
+                                det_model_fp='src/ocr_models/en_PP-OCRv3_det_infer.onnx',
+                                rec_model_name='number-densenet_lite_136-fc',
+                                rec_model_fp='src/ocr_models/number-densenet_lite_136.onnx')
+
+            img_NUM = cv2.imread('src/test_ocr/NUM.png')
+            self.logger.info("Test ocrNUM : " + self.ocrNUM.ocr_for_single_line(img_NUM)['text'])
+        return True
+
+    def init_JPocr(self):
+        pass
+
+    def get_region_num(self, img, region, category=int):
+        img = img[region[1]:region[3], region[0]:region[2]]
+        t1 = time.time()
+        res = self.ocrNUM.ocr_for_single_line(img)['text']
+        ocr_time = round(time.time() - t1, 3)
+        res.replace('<unused3>', '')
+        res.replace('<unused2>', '')
+        self.logger.info("ocr res : " + res + " time: " + str(ocr_time))
+        temp = ''
+        for i in range(0, len(res)):
+            if res[i].isdigit():
+                temp += res[i]
+            elif res[i] == '.' and category == float:
+                temp += res[i]
+
+        if temp == '':
+            return "UNKNOWN"
+        return category(temp)
+
+    def get_region_pure_english(self, img, region):
+        img = img[region[1]:region[3], region[0]:region[2]]
+        t1 = time.time()
+        res = self.ocrEN.ocr_for_single_line(img)['text']
+        ocr_time = round(time.time() - t1, 3)
+        res.replace('<unused3>', '')
+        res.replace('<unused2>', '')
+        self.logger.info("ocr res : " + res + " time: " + str(ocr_time))
+        temp = ''
+        for i in range(0, len(res)):
+            if self.is_english(res[i]):
+                temp += res[i]
+        return temp
+
+    def get_region_pure_chinese(self, img, region):
+        img = img[region[1]:region[3], region[0]:region[2]]
+        t1 = time.time()
+        res = self.ocrCN.ocr_for_single_line(img)['text']
+        ocr_time = round(time.time() - t1, 3)
+        res.replace('<unused3>', '')
+        res.replace('<unused2>', '')
+        self.logger.info("ocr res : " + res + " time: " + str(ocr_time))
+        temp = ''
+        for i in range(0, len(res)):
+            if self.is_chinese_char(res[i]):
+                temp += res[i]
+        return temp
+
+    def is_upper_english(self, char):
+        if 'A' <= char <= 'Z':
+            return True
+        return False
+
+    def is_lower_english(self, char):
+        if 'a' <= char <= 'z':
+            return True
+        return False
+
+    def is_english(self, char):
+        return self.is_upper_english(char) or self.is_lower_english(char)
+
+    def is_chinese_char(self, char):
+        return 0x4e00 <= ord(char) <= 0x9fff
+
+    def get_region_res(self, img, region, model='CN'):
+        img = img[region[1]:region[3], region[0]:region[2]]
+        t1 = time.time()
+        res = ""
+        if model == 'CN':
+            res = self.ocrCN.ocr_for_single_line(img)['text']
+        elif model == 'Global':
+            res = self.ocrEN.ocr_for_single_line(img)['text']
+        elif model == 'NUM':
+            res = self.ocrNUM.ocr_for_single_line(img)['text']
+        ocr_time = round(time.time() - t1, 3)
+        res.replace('<unused3>', '')
+        res.replace('<unused2>', '')
+        self.logger.info("ocr res : " + res + " time: " + str(ocr_time))
+        return res
+
+    def get_region_raw_res(self, img, region, model='CN'):
+        img = img[region[1]:region[3], region[0]:region[2]]
+        t1 = time.time()
+        res = ""
+        if model == 'CN':
+            res = self.ocrCN.ocr(img)
+        elif model == 'Global':
+            res = self.ocrEN.ocr(img)
+        elif model == 'NUM':
+            res = self.ocrNUM.ocr(img)
+        ocr_time = round(time.time() - t1, 3)
+        for i in range(0, len(res)):
+            res[i]['text'] = res[i]['text'].replace('<unused3>', '')
+            res[i]['text'] = res[i]['text'].replace('<unused2>', '')
+        return res

core/picture.py

@@ -0,0 +1,83 @@
+import time
+from core import color, image
+
+
+def co_detect(self, rgb_ends=None,rgb_possibles=None,  img_ends=None,img_possibles=None,  skip_first_screenshot=False, tentitive_click=False, tentitivex=1238,tentitivey=45):
+    fail_cnt = 0
+    while True:
+        if not self.flag_run:
+            return False
+        if skip_first_screenshot:
+            skip_first_screenshot = False
+        else:
+            color.wait_loading(self)
+        if rgb_ends is not None:
+            if type(rgb_ends) is str:
+                rgb_ends = [rgb_ends]
+            for i in range(0, len(rgb_ends)):
+                if rgb_ends[i] not in self.rgb_feature:
+                    continue
+                for j in range(0, len(self.rgb_feature[rgb_ends[i]][0])):
+                    if not color.judge_rgb_range(self.latest_img_array,
+                                                 self.rgb_feature[rgb_ends[i]][0][j][0],
+                                                 self.rgb_feature[rgb_ends[i]][0][j][1],
+                                                 self.rgb_feature[rgb_ends[i]][1][j][0],
+                                                 self.rgb_feature[rgb_ends[i]][1][j][1],
+                                                 self.rgb_feature[rgb_ends[i]][1][j][2],
+                                                 self.rgb_feature[rgb_ends[i]][1][j][3],
+                                                 self.rgb_feature[rgb_ends[i]][1][j][4],
+                                                 self.rgb_feature[rgb_ends[i]][1][j][5]):
+                        break
+                else:
+                    self.logger.info("end : " + rgb_ends[i])
+                    return rgb_ends[i]
+        if img_ends is not None:
+            if type(img_ends) is str:
+                img_ends = [img_ends]
+            for i in range(0, len(img_ends)):
+                if image.compare_image(self, img_ends[i], 3, image=self.latest_img_array, need_log=False):
+                    self.logger.info('end : ' + img_ends[i])
+                    return img_ends[i]
+        f = 0
+        if rgb_possibles is not None:
+            for position, click in rgb_possibles.items():
+                if position not in self.rgb_feature:
+                    continue
+                for j in range(0, len(self.rgb_feature[position][0])):
+                    if not color.judge_rgb_range(self.latest_img_array,
+                                                 self.rgb_feature[position][0][j][0],
+                                                 self.rgb_feature[position][0][j][1],
+                                                 self.rgb_feature[position][1][j][0],
+                                                 self.rgb_feature[position][1][j][1],
+                                                 self.rgb_feature[position][1][j][2],
+                                                 self.rgb_feature[position][1][j][3],
+                                                 self.rgb_feature[position][1][j][4],
+                                                 self.rgb_feature[position][1][j][5]):
+                        break
+                else:
+                    fail_cnt = 0
+                    self.logger.info("find : " + position)
+                    self.click(click[0], click[1], False)
+                    self.latest_screenshot_time = time.time()
+                    f = 1
+                    break
+        if f == 0:
+            if img_possibles is not None:
+                for position, click in img_possibles.items():
+                    threshold = 3
+                    if len(position) == 3:
+                        threshold = position[2]
+                    if image.compare_image(self, position, threshold, need_loading=False, image=self.latest_img_array,
+                                           need_log=False):
+                        self.logger.info("find " + position)
+                        self.click(click[0], click[1], False)
+                        self.latest_screenshot_time = time.time()
+                        fail_cnt = 0
+                        break
+            if tentitive_click:
+                fail_cnt += 1
+                if fail_cnt > 20:
+                    self.logger.info("tentative clicks")
+                    self.click(tentitivex,tentitivey, False)
+                    time.sleep(self.screenshot_interval)
+                    fail_cnt = 0