Upd: Fix bugs.

Author: PPPlatelet

alas.py

@@ -26,6 +26,7 @@ def __init__(self, config_name='alas'):
         # Failure count of tasks
         # Key: str, task name, value: int, failure count
         self.failure_record = {}
+        self.first_check = True
 
     @cached_property
     def config(self):
@@ -62,11 +63,11 @@ def checker(self):
             logger.exception(e)
             exit(1)
 
-    def run(self, command, skip_first_screenshot=False):
+    def run(self, command, *args, skip_first_screenshot=False, **kwargs):
         try:
             if not skip_first_screenshot:
                 self.device.screenshot()
-            self.__getattribute__(command)()
+            getattr(self, command)(*args, **kwargs)
             return True
         except TaskEnd:
             return True
@@ -90,47 +91,42 @@ def run(self, command, skip_first_screenshot=False):
             self.config.task_call('Restart')
             self.device.sleep(10)
             return False
-        except GamePageUnknownError:
+        except GamePageUnknownError as e:
             logger.info('Game server may be under maintenance or network may be broken, check server status now')
             self.checker.check_now()
             if self.checker.is_available():
-                logger.critical('Game page unknown')
-                self.save_error_log()
-                handle_notify(
-                    self.config.Error_OnePushConfig,
-                    title=f"Alas <{self.config_name}> crashed",
-                    content=f"<{self.config_name}> GamePageUnknownError",
-                )
-                exit(1)
-            else:
-                self.checker.wait_until_available()
-                return False
+                self.crash_exit(e, save=True)
+            self.checker.wait_until_available()
+            return False
         except ScriptError as e:
-            logger.exception(e)
-            logger.critical('This is likely to be a mistake of developers, but sometimes just random issues')
-            handle_notify(
-                self.config.Error_OnePushConfig,
-                title=f"Alas <{self.config_name}> crashed",
-                content=f"<{self.config_name}> ScriptError",
-            )
-            exit(1)
-        except RequestHumanTakeover:
-            logger.critical('Request human takeover')
-            handle_notify(
-                self.config.Error_OnePushConfig,
-                title=f"Alas <{self.config_name}> crashed",
-                content=f"<{self.config_name}> RequestHumanTakeover",
-            )
-            exit(1)
+            self.crash_exit(e, 'This is likely to be a mistake of developers, but sometimes just random issues',
+                            log_exc=True)
+        except ALASBaseError as e:
+            if not self.device.emulator_check():
+                self.reboot()
+                return False
+            self.crash_exit(e)
         except Exception as e:
+            if not self.device.emulator_check():
+                self.reboot()
+                return False
+            self.crash_exit(e, log_exc=True, save=True)
+
+    def crash_exit(self, e, *args, log_exc=False, save=False, msg=''):
+        if log_exc:
             logger.exception(e)
+        else:
+            logger.critical(e)
+        for arg in args:
+            logger.critical(arg)
+        if save:
             self.save_error_log()
-            handle_notify(
-                self.config.Error_OnePushConfig,
-                title=f"Alas <{self.config_name}> crashed",
-                content=f"<{self.config_name}> Exception occured",
-            )
-            exit(1)
+        handle_notify(
+            self.config.Error_OnePushConfig,
+            title=f"Alas <{self.config_name}> crashed",
+            content=f"<{self.config_name}> {e.__class__.__name__}{msg}"
+        )
+        exit(1)
 
     def save_error_log(self):
         """
@@ -162,7 +158,16 @@ def save_error_log(self):
             with open(f'{folder}/log.txt', 'w', encoding='utf-8') as f:
                 f.writelines(lines)
 
-    def restart(self):
+    def reboot(self, use_log=True):
+        if use_log:
+            logger.warning('Emulator is not running')
+        self.device.emulator_stop()
+        self.device.emulator_start()
+        del_cached_property(self, 'config')
+
+    def restart(self, reboot=False):
+        if reboot:
+            self.reboot(use_log=False)
         from module.handler.login import LoginHandler
         LoginHandler(self.config, device=self.device).app_restart()
 
@@ -455,42 +460,76 @@ def get_next_task(self):
             if self.config.task.command != 'Alas':
                 release_resources(next_task=task.command)
 
-            if task.next_run > datetime.now():
-                logger.info(f'Wait until {task.next_run} for task `{task.command}`')
-                self.is_first_task = False
-                method = self.config.Optimization_WhenTaskQueueEmpty
-                if method == 'close_game':
-                    logger.info('Close game during wait')
-                    self.device.app_stop()
-                    release_resources()
-                    self.device.release_during_wait()
-                    if not self.wait_until(task.next_run):
-                        del_cached_property(self, 'config')
-                        continue
-                    if task.command != 'Restart':
-                        self.run('start')
-                elif method == 'goto_main':
-                    logger.info('Goto main page during wait')
-                    self.run('goto_main')
-                    release_resources()
-                    self.device.release_during_wait()
-                    if not self.wait_until(task.next_run):
-                        del_cached_property(self, 'config')
-                        continue
-                elif method == 'stay_there':
-                    logger.info('Stay there during wait')
-                    release_resources()
-                    self.device.release_during_wait()
-                    if not self.wait_until(task.next_run):
-                        del_cached_property(self, 'config')
-                        continue
-                else:
-                    logger.warning(f'Invalid Optimization_WhenTaskQueueEmpty: {method}, fallback to stay_there')
-                    release_resources()
-                    self.device.release_during_wait()
-                    if not self.wait_until(task.next_run):
-                        del_cached_property(self, 'config')
-                        continue
+            if task.next_run <= datetime.now():
+                break
+
+            logger.info(f'Wait until {task.next_run} for task `{task.command}`')
+            self.is_first_task = False
+
+            method: str             = self.config.Optimization_WhenTaskQueueEmpty
+            remainingtime: float    = (task.next_run - datetime.now()).total_seconds() / 60
+            buffertime: int         = self.config.Optimization_ProcessBufferTime
+            if (
+                method == 'stop_emulator' and
+                self.device.emulator_check() and
+                remainingtime <= buffertime
+            ):
+                method = self.config.Optimization_BufferMethod
+                logger.info(
+                    f"The time to next task `{task.command}` is {remainingtime:.2f} minutes, "
+                    f"less than {buffertime} minutes, fallback to \"{method}\""
+                )
+
+            if method == 'close_game':
+                logger.info('Close game during wait')
+                self.device.app_stop()
+                release_resources()
+                self.device.release_during_wait()
+                if not self.wait_until(task.next_run):
+                    del_cached_property(self, 'config')
+                    continue
+                if task.command != 'Restart':
+                    self.run('start')
+            elif method == 'goto_main':
+                logger.info('Goto main page during wait')
+                self.run('goto_main')
+                release_resources()
+                self.device.release_during_wait()
+                if not self.wait_until(task.next_run):
+                    del_cached_property(self, 'config')
+                    continue
+            elif method == 'stay_there':
+                logger.info('Stay there during wait')
+                release_resources()
+                self.device.release_during_wait()
+                if not self.wait_until(task.next_run):
+                    del_cached_property(self, 'config')
+                    continue
+            elif method == 'stop_emulator':
+                logger.info('Stop emulator during wait')
+                self.device.emulator_stop()
+                release_resources()
+                self.device.release_during_wait()
+                if not self.wait_until(task.next_run):
+                    del_cached_property(self, 'config')
+                    method: str = self.config.Optimization_WhenTaskQueueEmpty
+                    if (
+                        not self.device.emulator_check() and
+                        method != 'stop_emulator'
+                    ):
+                        self.run('reboot', skip_first_screenshot=True, use_log=False)
+                    continue
+                if not self.device.emulator_check():
+                    self.run('reboot', skip_first_screenshot=True, use_log=False)
+                    self.run('start', skip_first_screenshot=True)
+            else:
+                logger.warning(f'Invalid Optimization_WhenTaskQueueEmpty: {method}, fallback to stay_there')
+                release_resources()
+                self.device.release_during_wait()
+                if not self.wait_until(task.next_run):
+                    del_cached_property(self, 'config')
+                    continue
+
             break
 
         AzurLaneConfig.is_hoarding_task = False
@@ -502,11 +541,10 @@ def loop(self):
 
         while 1:
             # Check update event from GUI
-            if self.stop_event is not None:
-                if self.stop_event.is_set():
-                    logger.info("Update event detected")
-                    logger.info(f"Alas [{self.config_name}] exited.")
-                    break
+            if self.stop_event is not None and self.stop_event.is_set():
+                logger.info("Update event detected")
+                logger.info(f"Alas [{self.config_name}] exited.")
+                break
             # Check game server maintenance
             self.checker.wait_until_available()
             if self.checker.is_recovered():
@@ -517,10 +555,14 @@ def loop(self):
                 del_cached_property(self, 'config')
                 logger.info('Server or network is recovered. Restart game client')
                 self.config.task_call('Restart')
-            # Get task
-            task = self.get_next_task()
             # Init device and change server
             _ = self.device
+            # Get task
+            task = self.get_next_task()
+            if self.first_check:
+                if not self.device.emulator_check():
+                    self.run('reboot', skip_first_screenshot=True)
+                self.first_check = False
             self.device.config = self.config
             # Skip first restart
             if self.is_first_task and task == 'Restart':
@@ -548,13 +590,8 @@ def loop(self):
                                 "Please read the help text of the options.")
                 logger.critical("Possible reason #2: There is a problem with this task. "
                                 "Please contact developers or try to fix it yourself.")
-                logger.critical('Request human takeover')
-                handle_notify(
-                    self.config.Error_OnePushConfig,
-                    title=f"Alas <{self.config_name}> crashed",
-                    content=f"<{self.config_name}> RequestHumanTakeover\nTask `{task}` failed 3 or more times.",
-                )
-                exit(1)
+                self.crash_exit(RequestHumanTakeover('Request human takeover'),
+                                msg=f"\nTask `{task}` failed 3 or more times.")
 
             if success:
                 del_cached_property(self, 'config')

campaign/campaign_war_archives/campaign_base.py

@@ -110,7 +110,7 @@ def ui_goto_archives_campaign(self, mode='ex'):
             else:
                 logger.critical('Respective server may not yet support the chosen War Archives campaign, '
                                 'check back in the next app update')
-                raise RequestHumanTakeover
+                raise RequestHumanTakeover('Request human takeover')
 
         # Subsequent runs all set False
         if self.first_run:

config/template.json

@@ -7,7 +7,8 @@
       "ScreenshotMethod": "auto",
       "ControlMethod": "MaaTouch",
       "ScreenshotDedithering": false,
-      "AdbRestart": false
+      "AdbRestart": false,
+      "SilentStart": "normal"
     },
     "EmulatorInfo": {
       "Emulator": "auto",
@@ -24,7 +25,9 @@
       "ScreenshotInterval": 0.3,
       "CombatScreenshotInterval": 1.0,
       "TaskHoardingDuration": 0,
-      "WhenTaskQueueEmpty": "goto_main"
+      "WhenTaskQueueEmpty": "goto_main",
+      "ProcessBufferTime": 10,
+      "BufferMethod": "stay_there"
     },
     "DropRecord": {
       "SaveFolder": "./screenshots",

deploy/Windows/config.py

@@ -6,9 +6,10 @@
 
 from deploy.Windows.logger import logger
 from deploy.Windows.utils import DEPLOY_CONFIG, DEPLOY_TEMPLATE, cached_property, poor_yaml_read, poor_yaml_write
+from module.exception import ALASBaseError
 
 
-class ExecutionError(Exception):
+class ExecutionError(ALASBaseError):
     pass
 
 

deploy/config.py

@@ -3,9 +3,10 @@
 
 from deploy.logger import logger
 from deploy.utils import *
+from module.exception import ALASBaseError
 
 
-class ExecutionError(Exception):
+class ExecutionError(ALASBaseError):
     pass
 
 

module/campaign/run.py

@@ -59,7 +59,7 @@ def load_campaign(self, name, folder='campaign_main'):
             logger.critical(f'Possible reason #1: This event ({folder}) does not have {name}')
             logger.critical(f'Possible reason #2: You are using an old Alas, '
                             'please check for update, or make map files yourself using dev_tools/map_extractor.py')
-            raise RequestHumanTakeover
+            raise RequestHumanTakeover('Request human takeover')
 
         config = copy.deepcopy(self.config).merge(self.module.Config())
         device = self.device

module/coalition/ui.py

@@ -196,19 +196,19 @@ def enter_map(self, event, stage, mode, skip_first_screenshot=True):
             if campaign_click > 5:
                 logger.critical(f"Failed to enter {button}, too many click on {button}")
                 logger.critical("Possible reason #1: You haven't cleared previous stage to unlock the stage.")
-                raise RequestHumanTakeover
+                raise RequestHumanTakeover('Request human takeover')
             if fleet_click > 5:
                 logger.critical(f"Failed to enter {button}, too many click on FLEET_PREPARATION")
                 logger.critical("Possible reason #1: "
                                 "Your fleets haven't satisfied the stat restrictions of this stage.")
                 logger.critical("Possible reason #2: "
                                 "This stage can only be farmed once a day, "
                                 "but it's the second time that you are entering")
-                raise RequestHumanTakeover
+                raise RequestHumanTakeover('Request human takeover')
             if self.appear(FLEET_NOT_PREPARED, offset=(20, 20)):
                 logger.critical('FLEET_NOT_PREPARED')
                 logger.critical('Please prepare you fleets before running coalition battles')
-                raise RequestHumanTakeover
+                raise RequestHumanTakeover('Request human takeover')
 
             # End
             if self.appear(BATTLE_PREPARATION, offset=(20, 20)):

module/combat/emotion.py

@@ -132,7 +132,7 @@ def get_recovered(self, expected_reduce=0):
             logger.critical(f'Fleet {self.fleet} Emotion Control=\"Keep Happy Bonus\" and '
                             f'Fleet {self.fleet} Recover Location=\"Docks\" can not be used together, '
                             'please check your emotion settings')
-            raise RequestHumanTakeover
+            raise RequestHumanTakeover('Request human takeover')
         # In 14-4 with 2X book, expected emotion reduce is 32, can't keep happy bonus (>120),
         # otherwise will infinite task delay
         if self.control == 'keep_exp_bonus' and expected_reduce >= 29: