AlasGG

campaign/campaign_main/campaign_15_base.py

@@ -0,0 +1,218 @@
+from module.base.mask import Mask
+from module.base.timer import Timer
+from module.campaign.campaign_base import CampaignBase as CampaignBase_
+from module.handler.assets import STRATEGY_OPENED
+from module.logger import logger
+from module.map.map_grids import SelectedGrids
+from module.map.utils import location_ensure
+from module.map_detection.grid import GridInfo
+from module.map_detection.utils_assets import ASSETS
+
+MASK_MAP_UI_W15 = Mask(file='./assets/mask/MASK_MAP_UI_W15.png')
+
+
+class Config:
+    # Ambushes can be avoid by having more DDs.
+    MAP_WALK_OPTIMIZE = False
+    MAP_HAS_MYSTERY = False
+    MAP_ENEMY_TEMPLATE = ['Light', 'Main', 'Carrier', 'CarrierSpecial']
+    INTERNAL_LINES_FIND_PEAKS_PARAMETERS = {
+        'height': (80, 255 - 33),
+        'width': (0.9, 10),
+        'prominence': 10,
+        'distance': 35,
+    }
+    HOMO_CANNY_THRESHOLD = (50, 100)
+    MAP_SWIPE_MULTIPLY = (0.993, 1.011)
+    MAP_SWIPE_MULTIPLY_MINITOUCH = (0.960, 0.978)
+    MAP_SWIPE_MULTIPLY_MAATOUCH = (0.932, 0.949)
+
+
+class W15GridInfo(GridInfo):
+    def merge(self, info, mode='normal'):
+        # Consider boss as siren
+        if info.is_boss:
+            if not self.is_land and self.may_siren:
+                self.is_siren = True
+                self.enemy_scale = 0
+                self.enemy_genre = ''
+                return True
+
+        return super().merge(info, mode=mode)
+
+
+class CampaignBase(CampaignBase_):
+    ENEMY_FILTER = '1T > 1L > 1E > 1M > 2T > 2L > 2E > 2M > 3T > 3L > 3E > 3M'
+
+    def map_data_init(self, map_):
+        super().map_data_init(map_)
+        # Patch ui_mask, get rid of supporting fleet
+        _ = ASSETS.ui_mask
+        ASSETS.ui_mask = MASK_MAP_UI_W15.image
+
+    map_has_mob_move = True
+
+    def strategy_set_execute(self, formation_index=None, sub_view=None, sub_hunt=None):
+        super().strategy_set_execute(
+            formation_index=formation_index,
+            sub_view=sub_view,
+            sub_hunt=sub_hunt,
+        )
+        logger.attr("Map has mob move", self.strategy_has_mob_move())
+
+    def _map_swipe(self, vector, box=(239, 159, 1175, 628)):
+        # Left border to 239, avoid swiping on support fleet
+        return super()._map_swipe(vector, box=box)
+
+    def mob_movable(self, location, target):
+        """
+        Check if mob is movable from location to target.
+        This requires that:
+            1. both location and target are grids in the map (not exceeding the boundaries)
+            2. Manhattan distance between location and target is 1.
+            3. location is a mob fleet
+            4. target is a sea grid
+        
+        Args:
+            location (tuple): Location of mob.
+            target (tuple): Destination.
+        
+        Returns:
+            bool: if movable.
+        """
+        location = location_ensure(location)
+        target = location_ensure(target)
+        movable = True
+
+        try:
+            logger.info(f'location: {self.map[location]}, target: {self.map[target]}')
+        except KeyError as e:
+            logger.exception(f'Given coordinates are outside the map.')
+            raise e
+
+        if abs(location[0] - target[0]) + abs(location[1] - target[1]) != 1:
+            logger.error(f'{self.map[target]} is not adjacent from {self.map[location]}.')
+            movable = False
+
+        if not self.map[location].is_enemy:
+            logger.error(f'{self.map[location]} is not a mob fleet.')
+            movable = False
+
+        if not self.map[target].is_sea:
+            logger.error(f'{self.map[target]} is not a sea grid.')
+            movable = False
+
+        if not movable:
+            logger.error(f'Cannot move from {self.map[location]} to {self.map[target]}.')
+
+        return movable
+
+    def _mob_move(self, location, target):
+        """
+        Move mob from location to target, and confirm if successfully moved.
+
+        Args: 
+            location (tuple, str, GridInfo): Location of mob.
+            target (tuple, str, GridInfo): Destination.
+        
+        Returns:
+            bool: If mob moved.
+        
+        Pages:
+            in: MOB_MOVE_CANCEL
+            out: STRATEGY_OPENED
+        """
+        location = location_ensure(location)
+        target = location_ensure(target)
+
+        view_target = SelectedGrids([self.map[location], self.map[target]]) \
+            .sort_by_camera_distance(self.camera)[1]
+        self.in_sight(view_target)
+        origin_grid = self.convert_global_to_local(location)
+        origin_grid.__str__ = location
+        target_grid = self.convert_global_to_local(target)
+        target_grid.__str__ = target
+
+        logger.info('Select mob to move')
+        skip_first_screenshot = True
+        interval = Timer(2, count=4)
+        while 1:
+            if skip_first_screenshot:
+                skip_first_screenshot = False
+            else:
+                self.device.screenshot()
+
+            # End
+            if self.is_in_strategy_mob_move():
+                self.view.update(image=self.device.image)
+            if origin_grid.predict_mob_move_icon():
+                break
+            # Click
+            if interval.reached() and self.is_in_strategy_mob_move():
+                self.device.click(origin_grid)
+                interval.reset()
+                continue
+
+        logger.info('Select target grid')
+        skip_first_screenshot = True
+        interval = Timer(2, count=4)
+        while 1:
+            if skip_first_screenshot:
+                skip_first_screenshot = False
+            else:
+                self.device.screenshot()
+
+            # End
+            if self.appear(STRATEGY_OPENED, offset=(120, 120)):
+                break
+            # Click
+            if interval.reached() and self.is_in_strategy_mob_move():
+                self.device.click(target_grid)
+                interval.reset()
+                continue
+            if self.handle_popup_confirm('MOB_MOVE'):
+                continue
+
+    def _mob_move_info_change(self, location, target):
+        location = location_ensure(location)
+        target = location_ensure(target)
+        self.map[target].enemy_scale = self.map[location].enemy_scale
+        self.map[location].enemy_scale = 0
+        self.map[target].enemy_genre = self.map[location].enemy_genre
+        self.map[location].enemy_genre = None
+        self.map[target].is_boss = self.map[location].is_boss
+        self.map[location].is_boss = False
+        self.map[target].is_enemy = True
+        self.map[target].may_enemy = True
+        self.map[location].is_enemy = False
+
+    def mob_move(self, location, target):
+        """
+        Open strategy, move mob fleet from location to target, close strategy.
+
+        Args:
+            location (tuple, str, GridInfo): Location of mob.
+            target (tuple, str, GridInfo): Destination.
+            
+        Returns:
+            bool: If mob moved
+
+        Pages:
+            in: IN_MAP
+            out: IN_MAP
+        """
+        if not self.mob_movable(location, target):
+            return False
+
+        self.strategy_open()
+        if not self.strategy_has_mob_move():
+            logger.warning(f'No remain mob move trials, will abandon moving')
+            self.strategy_close()
+            return False
+        self.strategy_mob_move_enter()
+        self._mob_move(location, target)
+        self.strategy_close(skip_first_screenshot=False)
+
+        self._mob_move_info_change(location, target)
+        self.find_path_initial()
+        self.map.show()