Jelajahi Sumber

fix(RealmRaid): retry ticket OCR and count successful challenges

unknown 1 bulan lalu
induk
melakukan
34dfbfacb9

+ 2 - 2
module/config/i18n/zh_CN.xml

@@ -571,13 +571,13 @@ mode_3策略是刷到五个契灵后开始结契,选择高级、中级盘来
 </context>		
 <context>
     <name>Args</name>
-	<message><source>Number Attack</source><translation>挑战次数</translation></message>	
+	<message><source>Number Attack</source><translation>成功挑战次数</translation></message>
 	<message><source>Exit Four</source><translation>当进攻到左上角第一个的时候先退四次再进攻</translation></message>	
 	<message><source>Order Attack</source><translation>挑战顺序</translation></message>
 	<message><source>WhenAttackFail</source><translation>挑战失败时</translation></message>
 	<message><source>Three Refresh</source><translation>每三次就刷新</translation></message>
 	<message><source>Number Base</source><translation>突破卷数量大于等于 X 时才会挑战</translation></message>
-	<message><source>number_attack_help</source><translation>默认30,可选范围[1~30],没有挑战卷自动退出任务(标记为成功)</translation></message>
+	<message><source>number_attack_help</source><translation>默认30,可选范围[1~30],仅统计胜利场次,失败和主动退出不计数。没有挑战卷时自动退出任务(标记为成功)</translation></message>
 	<message><source>exit_four_help</source><translation>为了支持打九退四,保证稳定57级</translation></message>	
 	<message><source>order_attack_help</source><translation>使用过滤器,保持默认即可</translation></message>
 	<message><source>when_attack_fail_help</source><translation>Exit:直接退出任务,标记为失败

+ 5 - 0
module/exception.py

@@ -31,6 +31,11 @@ class GameStuckError(Exception):
     pass
 
 
+class GameOcrError(GameStuckError):
+    """Repeated OCR failures require an immediate game restart."""
+    pass
+
+
 class GameBugError(Exception):
     # An error has occurred in Azur Lane game client. Alas is unable to handle.
     # A restart should fix it.

+ 15 - 0
script.py

@@ -572,6 +572,21 @@ class Script:
             self.exception_handler(e=e, command=command)
             self.config.task_call('Restart')
             return True
+        except GameOcrError as e:
+            logger.error(e)
+            try:
+                self.save_error_log()
+            except Exception:
+                logger.exception('Failed to save OCR error log')
+            logger.warning('Restarting game after repeated OCR failures')
+            # 定时 Restart 可能被禁用,故障恢复直接执行重启任务。
+            running_task = self.config.model.running_task
+            try:
+                self.config.model.running_task = 'Restart'
+                self.run('Restart')
+            finally:
+                self.config.model.running_task = running_task
+            return False
         except (GameStuckError, GameTooManyClickError) as e:
             logger.error(e)
             self.save_error_log()

+ 52 - 55
tasks/RealmRaid/script_task.py

@@ -16,7 +16,7 @@ from tasks.Component.GeneralBattle.battle_wait import battle_wait_strategy
 
 
 from module.logger import logger
-from module.exception import TaskEnd
+from module.exception import GameOcrError, TaskEnd
 from module.atom.image_grid import ImageGrid
 from module.atom.image import RuleImage
 from module.atom.click import RuleClick
@@ -24,6 +24,7 @@ from module.atom.click import RuleClick
 
 class ScriptTask(GeneralBattle, GameUi, SwitchSoul, RealmRaidAssets):
     medal_grid: ImageGrid = None
+    TICKET_OCR_RETRIES = 10
 
     def run(self):
         self.run_2()
@@ -33,13 +34,7 @@ class ScriptTask(GeneralBattle, GameUi, SwitchSoul, RealmRaidAssets):
         如果没有票了,那么就返回False
         :return:
         """
-        self.wait_until_appear(self.I_BACK_RED)
-        self.screenshot()
-        cu, res, total = self.O_NUMBER.ocr(self.device.image)
-        if cu == 0 and cu + res == total:
-            logger.warning(f'Execute round failed, no ticket')
-            return False
-        return True
+        return self.check_ticket()
 
     def medal_fire(self) -> bool:
         """
@@ -150,6 +145,7 @@ class ScriptTask(GeneralBattle, GameUi, SwitchSoul, RealmRaidAssets):
         # 开始循环
         success = True
         last_battle = True  # 记录上一次战斗的结果
+        successful_count = 0
         # 更改循环顺序
         while 1:
             self.screenshot()
@@ -158,12 +154,12 @@ class ScriptTask(GeneralBattle, GameUi, SwitchSoul, RealmRaidAssets):
                 logger.info("Pop-up detected: Refresh Confirmation. Clicking Confirm.")
                 self.appear_then_click(self.I_FRESH_ENSURE, interval=1.5)
                 continue
-            # 检查票数
+            # 检查票数,同时确认奖励已领取且已返回突破列表。
             if not self.check_ticket(con.raid_config.number_base):
                 break
-            # 挑战次数
-            if self.current_count >= con.raid_config.number_attack:
-                logger.info(f'Current count {self.current_count}, max count {con.raid_config.number_attack}')
+            # 仅胜利场次计入上限,通用战斗的 current_count 仍用于战前配置。
+            if successful_count >= con.raid_config.number_attack:
+                logger.info(f'Successful count {successful_count}, max count {con.raid_config.number_attack}')
                 break
             # ----------------------------------------开始进攻
             medal, index = self.find_one(False)
@@ -204,12 +200,18 @@ class ScriptTask(GeneralBattle, GameUi, SwitchSoul, RealmRaidAssets):
                 con.general_battle_config.lock_team_enable = False
             self.fire(index)
             last_battle = self.run_general_battle(con.general_battle_config)
+            if last_battle:
+                successful_count += 1
+                logger.info(f'Successful raids: {successful_count}/{con.raid_config.number_attack}')
             if lock_before:
                 con.general_battle_config.lock_team_enable = lock_before
             # 检查是否每三次领一个奖励
             if self.reward_detect_click(False):
                 logger.info('Rewards of three wins')
                 continue
+            # 战斗返回时可能还在过渡画面,先有限重试确认页面,再判断刷新或退出。
+            if not self.is_realm_raid_page() and not self.check_ticket(con.raid_config.number_base):
+                break
             # 刷新 >> 如果勾选了三次刷新并且到达了三次,就刷新
             if con.raid_config.three_refresh and self.appear(self.I_RR_THREE, threshold=0.8):
                 logger.info('Three refresh')
@@ -298,21 +300,40 @@ class ScriptTask(GeneralBattle, GameUi, SwitchSoul, RealmRaidAssets):
         if base < 0 or base > 30:
             logger.warning(f'It is not a valid base {base}')
             base = 0
-        self.wait_until_appear(self.I_BACK_RED)
-        self.screenshot()
-        cu, res, total = self.O_NUMBER.ocr(self.device.image)
-
-        if total == 0:
-            self.reward_detect_click(True)
-            # 增加出现聊天框遮挡,处理奖励之后,重新识别票数
-            cu, res, total = self.O_NUMBER.ocr(self.device.image)
-        if cu == 0 and cu + res == total:
-            logger.warning(f'Execute raid failed, no ticket')
-            return False
-        elif cu + res == total and cu < base:
-            logger.warning(f'Execute raid failed, ticket is not enough')
-            return False
-        return True
+        # 初次识别失败后,每隔一秒重新截图,最多重试十次。
+        for retry in range(self.TICKET_OCR_RETRIES + 1):
+            if retry:
+                time.sleep(1)
+            self.screenshot()
+            if self.reward_detect_click(False):
+                logger.info('Claim raid reward before reading tickets')
+            elif self.is_realm_raid_page():
+                cu, res, total = self.O_NUMBER.ocr(self.device.image)
+                # DigitCounter 识别失败会返回 (0, 0, 0),不能当作没票。
+                if total == 30 and 0 <= cu <= total and cu + res == total:
+                    if cu == 0:
+                        logger.warning('Execute raid failed, no ticket')
+                        return False
+                    if cu < base:
+                        logger.warning('Execute raid failed, ticket is not enough')
+                        return False
+                    return True
+                logger.warning(f'Invalid raid ticket OCR: {(cu, res, total)}')
+            else:
+                logger.warning('Not on the realm raid page; cannot read tickets')
+            logger.warning(f'Raid ticket recognition failed (retry {retry}/{self.TICKET_OCR_RETRIES})')
+
+        logger.error('Raid ticket recognition exhausted; saving screenshot to log/screenshots')
+        try:
+            self.device.save_screenshot(genre='realm_raid_ticket_ocr', interval=0)
+        except Exception:
+            logger.exception('Failed to save raid ticket screenshot')
+        raise GameOcrError(f'Realm raid ticket OCR failed after {self.TICKET_OCR_RETRIES} retries')
+
+    def is_realm_raid_page(self) -> bool:
+        return (not self.is_in_real_battle(False)
+                and self.appear(self.I_CHECK_REALM_RAID)
+                and self.appear(self.I_BACK_RED))
 
     @cached_property
     def order_medal(self) -> ImageGrid:
@@ -413,37 +434,13 @@ class ScriptTask(GeneralBattle, GameUi, SwitchSoul, RealmRaidAssets):
 
     def reward_detect_click(self, screenshot: bool=True) -> bool:
         """
-        检测是否出现 每三次就有奖励的界面, 有就领取
-        :return:
+        领取三胜奖励;票数和页面恢复由 check_ticket 有限重试。
         """
         if screenshot:
             self.screenshot()
-        # 由于更改识别顺序,退出战斗之后,需要先等待回到个人突破界面,即识别到红色退出按钮,再进行奖励判断
-        self.wait_until_appear(self.I_BACK_RED)
-        text = self.O_TEXT.ocr(self.device.image)
-        # 识别突破卷区域,如果识别到了且其中含有文字,即有聊天框遮挡则进入循环,等待三胜奖励出现并点击,循环退出条件为识别到票(即*/*的形式)
-        if text != "":
-            if re.search(r'[\u4e00-\u9fff]', text):
-                while 1:
-                    self.screenshot()
-                    result = self.O_TEXT.ocr(self.device.image)
-                    if not re.search(r'[\u4e00-\u9fff]', result) and re.search(r'(\d+)/(\d+)', result):
-                        return True
-                    if self.appear_then_click(self.I_SOUL_RAID, interval=1.5):
-                        continue
-
-        # if self.appear(self.I_SOUL_RAID):
-        #     self.screenshot()
-        #     # 稳定一次的截图时间
-        #     # 再次判断是否出现的
-        #     if not self.appear(self.I_SOUL_RAID):
-        #         return False
-        #     while 1:
-        #         self.screenshot()
-        #         if not self.appear(self.I_SOUL_RAID, threshold=0.7):
-        #             return True
-        #         if self.appear_then_click(self.I_SOUL_RAID, interval=1.5):
-        #             continue
+        if self.is_in_real_battle(False):
+            return False
+        return self.appear_then_click(self.I_SOUL_RAID, interval=1.5)
 
     def check_refresh(self, screenshot: bool=True) -> bool:
         """

+ 98 - 0
tests/tasks/RealmRaid/test_success_count.py

@@ -0,0 +1,98 @@
+from types import SimpleNamespace
+from unittest.mock import Mock
+
+import pytest
+
+from module.exception import GameOcrError, TaskEnd
+from tasks.RealmRaid.config import RealmRaid, WhenAttackFail
+from tasks.RealmRaid.script_task import ScriptTask
+
+
+def raid_replay(results, *, limit=30, exit_four=False, reward=False,
+                failure_policy=WhenAttackFail.REFRESH):
+    task = object.__new__(ScriptTask)
+    config = RealmRaid()
+    config.switch_soul_config.enable = False
+    config.switch_soul_config.enable_switch_by_name = False
+    config.raid_config.number_attack = limit
+    config.raid_config.exit_four = exit_four
+    config.raid_config.when_attack_fail = failure_policy
+    task.config = SimpleNamespace(realm_raid=config)
+    task.current_count = 0
+    task.screenshot = Mock()
+    task.goto_page = Mock()
+    task.appear = Mock(return_value=False)
+    task.ensure_lock = Mock()
+    task.is_frog = Mock(return_value=False)
+    task.check_ticket = Mock(return_value=True)
+    task.find_one = Mock(return_value=(object(), 1 if exit_four else 2))
+    task.check_medal_is_frog = Mock(return_value=False)
+    task.fire = Mock()
+    task.battle_before = Mock()
+    task.is_in_battle = Mock(return_value=False)
+    task.battle_wait = Mock(side_effect=results)
+    task.run_general_battle_back = Mock(return_value=True)
+    task.reward_detect_click = Mock(return_value=reward)
+    task.is_realm_raid_page = Mock(return_value=True)
+    task.check_refresh = Mock(return_value=True)
+    task.ui_click = Mock()
+    task.set_next_run = Mock()
+    return task
+
+
+@pytest.mark.parametrize('reward', [False, True])
+def test_thirty_wins_allow_more_than_thirty_attempts(reward):
+    task = raid_replay([True] * 12 + [False] + [True] * 18, reward=reward)
+    with pytest.raises(TaskEnd):
+        task.run_2()
+    assert task.current_count == task.battle_wait.call_count == 31
+    assert task.check_ticket.call_count == 32
+    task.set_next_run.assert_called_once_with(task='RealmRaid', success=True, finish=True)
+
+
+def test_retreat_four_does_not_consume_success_limit():
+    task = raid_replay([True, False, True], limit=2, exit_four=True)
+    with pytest.raises(TaskEnd):
+        task.run_2()
+    assert task.battle_wait.call_count == 3
+    assert task.run_general_battle_back.call_count == 12
+
+
+def test_no_tickets_can_still_end_before_success_limit():
+    task = raid_replay([True])
+    task.check_ticket.side_effect = [True, False]
+    with pytest.raises(TaskEnd):
+        task.run_2()
+    assert task.battle_wait.call_count == 1
+    task.set_next_run.assert_called_once_with(task='RealmRaid', success=True, finish=True)
+
+
+def test_configured_exit_on_defeat_still_applies():
+    task = raid_replay([False], failure_policy=WhenAttackFail.EXIT)
+    with pytest.raises(TaskEnd):
+        task.run_2()
+    assert task.battle_wait.call_count == 1
+    task.check_refresh.assert_not_called()
+
+
+def test_transition_after_defeat_is_checked_before_refresh():
+    task = raid_replay([False, True], limit=1)
+    task.is_realm_raid_page.side_effect = [False, True]
+    # 初次读票、战后页面恢复、下一轮读票、达到上限前确认页面。
+    task.check_ticket.side_effect = [True, True, True, True]
+    with pytest.raises(TaskEnd):
+        task.run_2()
+    assert task.battle_wait.call_count == 2
+    task.check_refresh.assert_called_once_with()
+    assert task.check_ticket.call_count == 4
+
+
+def test_wrong_screen_after_battle_raises_recovery_before_refresh_or_exit():
+    task = raid_replay([False])
+    task.is_realm_raid_page.return_value = False
+    task.check_ticket.side_effect = [True, GameOcrError('Wrong screen')]
+    with pytest.raises(GameOcrError):
+        task.run_2()
+    task.check_refresh.assert_not_called()
+    task.ui_click.assert_not_called()
+    task.set_next_run.assert_not_called()

+ 144 - 0
tests/tasks/RealmRaid/test_ticket.py

@@ -0,0 +1,144 @@
+from types import SimpleNamespace
+from unittest.mock import Mock, call
+
+import pytest
+
+from module.exception import GameOcrError
+from tasks.RealmRaid import script_task
+
+
+def frame(reading=(23, 7, 30), *, page=True, battle=False, reward=False):
+    return SimpleNamespace(reading=reading, page=page, battle=battle, reward=reward)
+
+
+def ticket_replay(frames):
+    task = object.__new__(script_task.ScriptTask)
+    frames = iter(frames)
+    task.device = SimpleNamespace(image=None, save_screenshot=Mock())
+
+    def screenshot():
+        task.device.image = next(frames)
+
+    def appear(asset, **kwargs):
+        current = task.device.image
+        if asset is task.I_BATTLE_INFO:
+            return current.battle
+        if asset is task.I_CHECK_REALM_RAID or asset is task.I_BACK_RED:
+            return current.page
+        if asset is task.I_SOUL_RAID:
+            return current.reward
+        return False
+
+    task.screenshot = Mock(side_effect=screenshot)
+    task.appear = Mock(side_effect=appear)
+    task.appear_then_click = Mock(side_effect=appear)
+    task.wait_until_appear = Mock(side_effect=AssertionError('Unbounded page wait'))
+    task.O_NUMBER = SimpleNamespace(ocr=Mock(side_effect=lambda image: image.reading))
+    task.O_TEXT = SimpleNamespace(ocr=Mock(side_effect=AssertionError('Unbounded text wait')))
+    return task
+
+
+@pytest.fixture
+def sleep(monkeypatch):
+    sleep = Mock()
+    monkeypatch.setattr(script_task.time, 'sleep', sleep)
+    return sleep
+
+
+@pytest.mark.parametrize('reading,base,expected', [
+    ((0, 30, 30), 0, False),
+    ((1, 29, 30), 0, True),
+    ((30, 0, 30), 0, True),
+    ((5, 25, 30), 6, False),
+    ((5, 25, 30), 5, True),
+    ((1, 29, 30), -1, True),
+    ((1, 29, 30), 31, True),
+])
+def test_valid_ticket_count_controls_empty_and_minimum(reading, base, expected, sleep):
+    task = ticket_replay([frame(reading)])
+    assert task.check_ticket(base) is expected
+    assert task.screenshot.call_count == 1
+    sleep.assert_not_called()
+    task.device.save_screenshot.assert_not_called()
+
+
+@pytest.mark.parametrize('invalid', [
+    (0, 0, 0), (0, 3, 3), (23, 7, 0), (31, -1, 30), (-1, 31, 30), (23, 0, 30),
+])
+def test_invalid_ocr_retries_with_a_new_frame(invalid, sleep):
+    first, second = frame(invalid), frame()
+    task = ticket_replay([first, second])
+    assert task.check_ticket() is True
+    assert task.O_NUMBER.ocr.call_args_list == [call(first), call(second)]
+    sleep.assert_called_once_with(1)
+    task.device.save_screenshot.assert_not_called()
+
+
+def test_tenth_retry_can_still_succeed(sleep):
+    task = ticket_replay([frame((0, 0, 0)) for _ in range(10)] + [frame()])
+    assert task.check_ticket() is True
+    assert task.screenshot.call_count == 11
+    assert sleep.call_args_list == [call(1)] * 10
+    task.device.save_screenshot.assert_not_called()
+
+
+@pytest.mark.parametrize('save_fails', [False, True])
+def test_exhausted_retries_save_last_failed_frame_and_raise_restart_error(sleep, save_fails):
+    frames = [frame((0, 0, 0)) for _ in range(11)]
+    task = ticket_replay(frames)
+    if save_fails:
+        task.device.save_screenshot.side_effect = OSError('Disk unavailable')
+    with pytest.raises(GameOcrError, match='after 10 retries'):
+        task.check_ticket()
+    assert task.screenshot.call_count == task.O_NUMBER.ocr.call_count == 11
+    assert sleep.call_args_list == [call(1)] * 10
+    assert task.device.image is frames[-1]
+    task.device.save_screenshot.assert_called_once_with(genre='realm_raid_ticket_ocr', interval=0)
+
+
+@pytest.mark.parametrize('page,battle', [(False, False), (False, True), (True, True)])
+def test_wrong_screen_does_not_read_tickets_or_click_rewards(page, battle, sleep):
+    first, second = frame((0, 30, 30), page=page, battle=battle), frame()
+    task = ticket_replay([first, second])
+    assert task.check_ticket() is True
+    task.O_NUMBER.ocr.assert_called_once_with(second)
+    sleep.assert_called_once_with(1)
+
+
+@pytest.mark.parametrize('battle', [False, True])
+def test_persistent_wrong_screen_uses_the_same_bounded_recovery(battle, sleep):
+    task = ticket_replay([frame(page=False, battle=battle) for _ in range(11)])
+    with pytest.raises(GameOcrError):
+        task.check_ticket()
+    task.O_NUMBER.ocr.assert_not_called()
+    assert task.screenshot.call_count == 11
+    assert sleep.call_args_list == [call(1)] * 10
+    assert task.device.save_screenshot.call_count == 1
+
+
+def test_reward_is_claimed_even_when_it_covers_the_page_anchor(sleep):
+    reward, ready = frame(page=False, reward=True), frame()
+    task = ticket_replay([reward, ready])
+    assert task.check_ticket() is True
+    task.O_NUMBER.ocr.assert_called_once_with(ready)
+    sleep.assert_called_once_with(1)
+
+
+def test_reward_match_is_ignored_while_still_in_battle(sleep):
+    task = ticket_replay([frame(battle=True, reward=True)])
+    assert task.reward_detect_click() is False
+    task.appear_then_click.assert_not_called()
+
+
+def test_reward_detection_does_not_wait_for_banner_text_to_disappear(sleep):
+    task = ticket_replay([frame()])
+    assert task.reward_detect_click() is False
+    assert task.screenshot.call_count == 1
+    task.O_TEXT.ocr.assert_not_called()
+    task.wait_until_appear.assert_not_called()
+
+
+def test_legacy_ticket_check_uses_the_same_recovery(sleep):
+    task = ticket_replay([frame((0, 0, 0)), frame()])
+    assert task.is_ticket() is True
+    assert task.O_NUMBER.ocr.call_count == 2

+ 48 - 0
tests/test_script_ocr_recovery.py

@@ -0,0 +1,48 @@
+from pathlib import Path
+from types import SimpleNamespace
+from unittest.mock import Mock
+
+import pytest
+
+import script as script_module
+from module.exception import GameOcrError, TaskEnd
+
+
+@pytest.mark.parametrize('save_fails', [False, True])
+@pytest.mark.parametrize('restart_enabled', [False, True])
+def test_ocr_error_runs_restart_even_when_scheduled_restart_is_disabled(
+        monkeypatch, save_fails, restart_enabled):
+    script = object.__new__(script_module.Script)
+    script.instance_guard = None
+    script._try_acquire_queue_token = Mock(return_value=True)
+    script.device = SimpleNamespace(screenshot=Mock())
+    script.config = SimpleNamespace(
+        model=SimpleNamespace(running_task='RealmRaid'),
+        restart=SimpleNamespace(scheduler=SimpleNamespace(enable=restart_enabled)),
+        task_call=Mock(side_effect=AssertionError('Recovery must not depend on scheduling')),
+    )
+    script.save_error_log = Mock(side_effect=OSError('Disk unavailable') if save_fails else None)
+    commands = []
+
+    def load_module(name, path):
+        command = Path(path).parent.name
+
+        class Task:
+            def __init__(self, config, device):
+                assert config.model.running_task == command
+
+            def run(self):
+                commands.append(command)
+                if command == 'RealmRaid':
+                    raise GameOcrError('Ticket OCR exhausted')
+                assert command == 'Restart'
+                raise TaskEnd
+
+        return SimpleNamespace(ScriptTask=Task)
+
+    monkeypatch.setattr(script_module, 'load_module', load_module)
+    assert script.run('RealmRaid') is False
+    assert commands == ['RealmRaid', 'Restart']
+    assert script.config.model.running_task == 'RealmRaid'
+    assert script.config.restart.scheduler.enable is restart_enabled
+    script.save_error_log.assert_called_once_with()