Merge pull request #348 from mrmin123/staging

7.3.0 to master

CHANGELOG.md

@@ -1,3 +1,10 @@
+#### 7.3.0
+
+* Archive 2019 Winter Event assets
+* Add support for 2019 Setsubun PvP quest
+* Add support for whitescreen crash recovery
+* Refactor Recovery module
+
 #### 7.2.1
 
 * Add support for node ZZ to webUI

kcauto.sikuli/kca_globals.py

@@ -25,10 +25,10 @@ class Globals(object):
     SHIP_LIST_SIMILARITY = 0.96  # suggested lower value: 0.7?
 
     # types of recoveries enabled for the recovery module. Valid options are
-    # 'catbomb' and 'chrome'. Enabled recoveries mean that the script will
-    # attempt to restart the game when encountering a relevant crash; otherwise
-    # the script will halt.
-    ENABLED_RECOVERIES = ('chrome')
+    # 'catbomb', 'chrome', and 'whitescreen'. Enabled recoveries mean that the
+    # script will attempt to restart the game when encountering a relevant
+    # crash; otherwise the script will halt.
+    ENABLED_RECOVERIES = ('chrome', 'whitescreen')
 
     # how many minutes to wait between sorties to allow for natural fatigue
     # recovery

kcauto.sikuli/quest.sikuli/quest.py

@@ -396,7 +396,8 @@ def _define_quest_list(self):
                 get_quest_info('c3'),
                 get_quest_info('c4'),
                 get_quest_info('c8'),
-                get_quest_info('c15')])
+                get_quest_info('c15'),
+                get_quest_info('c_sc01')])
         if self.config.expeditions['enabled']:
             # define expedition quests if expedition is enabled
             self.active_quest_types.append('d')
@@ -570,3 +571,7 @@ def get_quest_info(quest):
     elif quest == 'e4':
         return {
             'name': 'e4', 'wait': (15, 10, 15), 'rewards': (50, 50, 50, 50)}
+    elif quest == 'c_sc01':
+        # 2019 Setsubun daily PvP quest
+        return {
+            'name': 'c_sc01', 'wait': (0, 4, 0), 'rewards': (23, 23, 0, 0)}

kcauto.sikuli/recovery.py

@@ -12,8 +12,8 @@ class Recovery(object):
     chrome tab crashes.
     """
 
-    @staticmethod
-    def recover(kcauto, config, e):
+    @classmethod
+    def recover(cls, kcauto, config, e):
         """Attempts very basic recovery actions on a FindFailed exception.
 
         Args:
@@ -50,6 +50,7 @@ def recover(kcauto, config, e):
             # reference point exists, so we are in-game
             Util.log_success("Recovery successful.")
             kcauto.stats.increment_recoveries()
+            kcauto.stats.increment_basic_recoveries()
             return True
         elif kc_region.exists('next.png') or kc_region.exists('next_alt.png'):
             # crashed at some results screen; try to click it away until we see
@@ -64,72 +65,200 @@ def recover(kcauto, config, e):
                 # reference point exists, so we are back in-game
                 Util.log_success("Recovery successful.")
                 kcauto.stats.increment_recoveries()
+                kcauto.stats.increment_basic_recoveries()
                 return True
 
-        # Chrome crash recovery
+        # check viable recoveries
         if kc_region.exists('chrome_crash.png', 30):
-            if ('chrome' in Globals.ENABLED_RECOVERIES):
-                Util.log_warning("** Chrome crash detected. **")
-                Region.type(kc_region, Key.F5)
-                sleep(1)
-                Region.type(kc_region, Key.SPACE)
-                Util.wait_and_click(
-                    kc_region, Pattern('game_start.png').similar(0.999), 120)
-                Util.log_success("Re-starting game.")
-                kc_region.wait('home_menu_resupply.png', 60)
-                Util.log_success("Chrome crash recovery successful.")
-                kcauto.stats.increment_recoveries()
+            if cls._handle_chrome(kcauto, kc_region):
                 return True
-            else:
-                Util.log_error(
-                    "** Chrome crash detected, but Chrome crash recovery is "
-                    "disabled. **")
-
-        # catbomb recovery
         if kc_region.exists('catbomb.png', 30):
-            if ('catbomb' in Globals.ENABLED_RECOVERIES):
-                Util.log_warning("** Catbomb detected. **")
-                catbombed = True
-                catbomb_n = 0
-                while catbombed and catbomb_n < 7:
-                    # generic f5-space-tab-space keystrokes to mimick refresh
-                    # attempt
-                    Region.type(kc_region, Key.F5)
-                    sleep(1)
-                    Region.type(kc_region, Key.SPACE)
-                    sleep(1)
-                    Region.type(kc_region, Key.TAB)
-                    sleep(1)
-                    Region.type(kc_region, Key.SPACE)
-                    sleep(3)
-                    # clear mouse
-                    kc_region.mouseMove(Location(1, 1))
-                    if kc_region.exists('catbomb.png'):
-                        sleep_len = pow(2, catbomb_n + 4)
-                        Util.log_warning(
-                            "Catbomb recovery attempt {} failed; trying again "
-                            "in {} seconds!".format(catbomb_n + 1, sleep_len))
-                        sleep(sleep_len)
-                        catbomb_n += 1
-                    else:
-                        catbombed = False
-                sleep(5)
-                Util.wait_and_click(
-                    kc_region, Pattern('game_start.png').similar(0.999), 120)
-                Util.log_success("Re-starting game.")
-                kc_region.wait('home_menu_resupply.png', 60)
-                Util.log_success("Catbomb recovery successful.")
-                kcauto.stats.increment_recoveries()
+            if cls._handle_catbomb(kcauto, kc_region):
+                return True
+        if kc_region.exists('whitescreen.png', 30):
+            if cls._handle_whitescreen(kcauto, kc_region):
                 return True
-        else:
-            Util.log_error(
-                "** Catbomb detected, but catbomb recovery is disabled. **")
 
         # recovery failed
         Util.log_error("** Irrecoverable crash. **")
         print(e)
         raise
 
+    @classmethod
+    def _handle_catbomb(cls, kcauto, kc_region):
+        """Checks whether or not catbomb recovery is enabled, and starts or
+        defers recovery accordingly.
+
+        Args:
+            kcauto (KCAuto): KCAuto instance
+            kc_region (Region): Sikuli game region
+
+        Returns:
+            bool: True if a successful recovery was done; False otherwise
+        """
+        if ('catbomb' in Globals.ENABLED_RECOVERIES):
+            return cls._perform_catbomb_recovery(kcauto, kc_region)
+        else:
+            Util.log_error(
+                "** Catbomb detected, but catbomb recovery is disabled. **")
+            return False
+
+    @classmethod
+    def _handle_chrome(cls, kcauto, kc_region):
+        """Checks whether or not chrome crash recovery is enabled, and starts
+        or defers recovery accordingly.
+
+        Args:
+            kcauto (KCAuto): KCAuto instance
+            kc_region (Region): Sikuli game region
+
+        Returns:
+            bool: True if a successful recovery was done; False otherwise
+        """
+        if ('chrome' in Globals.ENABLED_RECOVERIES):
+            return cls._perform_chrome_recovery(kcauto, kc_region)
+        else:
+            Util.log_error(
+                "** Chrome crash detected, but Chrome crash recovery is "
+                "disabled. **")
+            return False
+
+    @classmethod
+    def _handle_whitescreen(cls, kcauto, kc_region):
+        """Checks whether or not whitescreen recovery is enabled, and starts or
+        defers recovery accordingly.
+
+        Args:
+            kcauto (KCAuto): KCAuto instance
+            kc_region (Region): Sikuli game region
+
+        Returns:
+            bool: True if a successful recovery was done; False otherwise
+        """
+        if ('whitescreen' in Globals.ENABLED_RECOVERIES):
+            return cls._perform_whitescreen_recovery(kcauto, kc_region)
+        else:
+            Util.log_error(
+                "** Whitescreen detected, but whitescreen recovery is "
+                "disabled.")
+            return False
+
+    @classmethod
+    def _perform_catbomb_recovery(cls, kcauto, kc_region):
+        """Method to perform catbomb recovery.
+
+        Args:
+            kcauto (KCAuto): KCAuto instance
+            kc_region (Region): Sikuli game region
+
+        Returns:
+            bool: True if a successful recovery was done; False otherwise
+        """
+        Util.log_warning("** Catbomb detected. **")
+        catbombed = True
+        catbomb_n = 0
+        while catbombed and catbomb_n < 7:
+            cls._refresh_keystrokes(kc_region)
+            if kc_region.exists('catbomb.png'):
+                sleep_len = pow(2, catbomb_n + 4)
+                Util.log_warning(
+                    "Catbomb recovery attempt {} failed; trying again "
+                    "in {} seconds!".format(catbomb_n + 1, sleep_len))
+                sleep(sleep_len)
+                catbomb_n += 1
+            else:
+                catbombed = False
+        sleep(5)
+        if cls._start_kancolle(kcauto, kc_region):
+            Util.log_success("Catbomb recovery successful.")
+            kcauto.stats.increment_recoveries()
+            kcauto.stats.increment_catbomb_recoveries()
+            return True
+        return False
+
+    @classmethod
+    def _perform_chrome_recovery(cls, kcauto, kc_region):
+        """Method to perform chrome tab crash recovery.
+
+        Args:
+            kcauto (KCAuto): KCAuto instance
+            kc_region (Region): Sikuli game region
+
+        Returns:
+            bool: True if a successful recovery was done; False otherwise
+        """
+        Util.log_warning("** Chrome crash detected. **")
+        cls._refresh_keystrokes(kc_region)
+        if cls._start_kancolle(kcauto, kc_region):
+            Util.log_success("Chrome crash recovery successful.")
+            kcauto.stats.increment_recoveries()
+            kcauto.stats.increment_chrome_recoveries()
+            return True
+        return False
+
+    @classmethod
+    def _perform_whitescreen_recovery(cls, kcauto, kc_region):
+        """Method to perform whitescreen crash recovery.
+
+        Args:
+            kcauto (KCAuto): KCAuto instance
+            kc_region (Region): Sikuli game region
+
+        Returns:
+            bool: True if a successful recovery was done; False otherwise
+        """
+        Util.log_warning("** Whitescreen crash detected. **")
+        cls._refresh_keystrokes(kc_region)
+        if cls._start_kancolle(kcauto, kc_region):
+            Util.log_success("Whitescreen crash recovery successful.")
+            kcauto.stats.increment_recoveries()
+            kcauto.stats.increment_whitescreen_recoveries()
+            return True
+        return False
+
+    @classmethod
+    def _start_kancolle(cls, kcauto, kc_region):
+        """Method to check and restart the game from the splash screen. If a
+        whitescreen is detected at this point, whitescreen recovery will be
+        performed, if enabled.
+
+        Args:
+            kcauto (KCAuto): KCAuto instance
+            kc_region (Region): Sikuli game region
+
+        Returns:
+            bool: True if a game was successfully restarted; False otherwise
+        """
+        if kc_region.exists(Pattern('game_start.png').similar(0.999), 120):
+            # game refreshed properly
+            Util.check_and_click(kc_region, 'game_start.png')
+            Util.log_success("Restarting game.")
+            kc_region.wait('home_menu_resupply.png', 60)
+            Util.log_success("Game restarted.")
+            return True
+        elif kc_region.exists('whitescreen.png', 30):
+            return cls._handle_whitescreen(kcauto, kc_region)
+        return False
+
+    @staticmethod
+    def _refresh_keystrokes(kc_region):
+        """Fires off generic F5-space-tab-space keystrokes to mimick a refresh
+        attempt applicable to most browsers/viewers.
+
+        Args:
+            kc_region (Region): Sikuli game region
+        """
+        Region.type(kc_region, Key.F5)
+        sleep(1)
+        Region.type(kc_region, Key.SPACE)
+        sleep(1)
+        Region.type(kc_region, Key.TAB)
+        sleep(1)
+        Region.type(kc_region, Key.SPACE)
+        sleep(5)
+        # clear mouse
+        kc_region.mouseMove(Location(1, 1))
+
 
 class RecoverableModule:
     """Abstract class used by modules that need a background observer to detect
@@ -146,6 +275,7 @@ def _start_crash_observer(self):
         """
         self.kc_region.onAppear('catbomb.png', self._set_crash_detected)
         self.kc_region.onAppear('chrome_crash.png', self._set_crash_detected)
+        self.kc_region.onAppear('whitescreen.png', self._set_crash_detected)
         self.kc_region.observeInBackground(FOREVER)
 
     def _stop_crash_observer(self):

kcauto.sikuli/stats.sikuli/stats.py

@@ -35,6 +35,10 @@ def reset_stats(self):
         self.quests_started = 0
         self.quests_finished = 0
         self.recoveries = 0
+        self.basic_recoveries = 0
+        self.catbomb_recoveries = 0
+        self.chrome_recoveries = 0
+        self.whitescreen_recoveries = 0
 
     def _pretty_timedelta(self, delta):
         """Generate a human-readable time delta representation of how long the
@@ -186,3 +190,15 @@ def increment_quests_finished(self):
 
     def increment_recoveries(self):
         self.recoveries += 1
+
+    def increment_basic_recoveries(self):
+        self.basic_recoveries += 1
+
+    def increment_catbomb_recoveries(self):
+        self.catbomb_recoveries += 1
+
+    def increment_chrome_recoveries(self):
+        self.chrome_recoveries += 1
+
+    def increment_whitescreen_recoveries(self):
+        self.whitescreen_recoveries += 1

package.json

@@ -1,6 +1,6 @@
 {
   "name": "kcauto",
-  "version": "7.2.1",
+  "version": "7.3.0",
   "main": "index.js",
   "repository": "git@gitlab.com:mrmin123/kcauto.git",
   "author": "mrmin123 <minyoung.choi@gmail.com>",