def get_next_task(self):
"""
Calculate tasks, set pending_task and waiting_task
"""
pending = []
waiting = []
now = datetime.now()
if AzurLaneConfig.is_hoarding_task:
now -= self.hoarding
for func in self.data.values():
func = Function(func)
if not func.enable:
continue
if func.next_run < now:
pending.append(func)
else:
waiting.append(func)
if pending:
f = Filter(regex=r'(.*)', attr=['command'])
f.load(self.SCHEDULER_PRIORITY)
pending = f.apply(pending, func=lambda x: x.enable)
if waiting:
waiting = sorted(waiting, key=operator.attrgetter('next_run'))
self.pending_task = pending
self.waiting_task = waiting
class Food:
def __init__(self, feed, amount):
self.feed = feed
self.amount = amount
def __str__(self):
return f'Food_{self.feed}'
def __eq__(self, other):
return str(self) == str(other)
FOOD_FEED_AMOUNT = [1000, 2000, 3000, 5000, 10000, 20000]
FOOD_FILTER = Filter(regex=re.compile('(\d+)'), attr=['feed'])
class RewardDorm(UI):
def _dorm_receive_click(self):
"""
Click coins and loves in dorm.
Returns:
int: Receive count.
Pages:
in: page_dorm
out: page_dorm, with info_bar
"""
image = MASK_DORM.apply(self.device.image)
from module.logger import logger
from module.raid.raid import raid_ocr
from module.raid.run import RaidRun
from module.ui.page import page_raid
class RaidStage:
def __init__(self, name):
self.name = name
def __str__(self):
return self.name
STAGES = ['easy', 'normal', 'hard']
STAGE_FILTER = Filter(regex=re.compile('(\w+)'), attr=['name'])
class RaidDaily(RaidRun):
def get_remain(self, mode, skip_first_screenshot=True):
"""
Args:
mode (str): easy, normal, hard
skip_first_screenshot (bool):
Returns:
int:
"""
confirm_timer = Timer(0.3, count=0)
prev = 30
while 1:
def pre_process(self, image):
r, g, b = cv2.split(image)
image = cv2.max(cv2.max(r, g), b)
return 255 - image
SKILL_EXP = SkillExp(buttons=OCR_SKILL_EXP)
BOOKS_GRID = ButtonGrid(origin=(239, 288),
delta=(140, 120),
button_shape=(98, 98),
grid_shape=(6, 2))
BOOK_FILTER = Filter(regex=re.compile('(same)?'
'(red|blue|yellow)?'
'-?'
'(t[123])?'),
attr=('same_str', 'genre_str', 'tier_str'),
preset=('first', ))
class Book:
color_genre = {
1: (214, 69, 74), # Offensive, red
2: (115, 178, 255), # Defensive, blue
3: (247, 190, 99), # Support, yellow
}
genre_name = {
1: 'Red', # Offensive, red
2: 'Blue', # Defensive, blue
3: 'Yellow', # Support, yellow
}
from module.guild.base import GuildBase
from module.logger import logger
from module.ocr.ocr import Digit
from module.statistics.item import ItemGrid
EXCHANGE_GRIDS = ButtonGrid(origin=(470, 470),
delta=(198.5, 0),
button_shape=(83, 83),
grid_shape=(3, 1),
name='EXCHANGE_GRIDS')
EXCHANGE_BUTTONS = ButtonGrid(origin=(440, 609),
delta=(198.5, 0),
button_shape=(144, 31),
grid_shape=(3, 1),
name='EXCHANGE_BUTTONS')
EXCHANGE_FILTER = Filter(regex=re.compile('^(.*?)$'), attr=('name', ))
class ExchangeLimitOcr(Digit):
def pre_process(self, image):
"""
Args:
image (np.ndarray): Shape (height, width, channel)
Returns:
np.ndarray: Shape (width, height)
"""
return 255 - color_mapping(rgb2gray(image), max_multiply=2.5)
GUILD_EXCHANGE_LIMIT = ExchangeLimitOcr(OCR_GUILD_EXCHANGE_LIMIT, threshold=64)
from module.exception import MapWalkError
from module.logger import logger
from module.map.fleet import Fleet
from module.map.map_grids import SelectedGrids
from module.map.utils import location_ensure
from module.map_detection.utils import *
from module.ocr.ocr import Ocr
from module.os.assets import TEMPLATE_EMPTY_HP, STRONGHOLD_PERCENTAGE
from module.os.camera import OSCamera
from module.os.map_base import OSCampaignMap
from module.os_ash.ash import OSAsh
from module.os_combat.combat import Combat
from module.os_handler.assets import IN_MAP
FLEET_FILTER = Filter(regex=re.compile('fleet-?(\d)'),
attr=('fleet', ),
preset=('callsubmarine', ))
def limit_walk(location, step=3):
x, y = location
if abs(x) > 0:
x = min(abs(x), step - abs(y)) * x // abs(x)
return x, y
class BossFleet:
def __init__(self, fleet_index):
self.fleet_index = fleet_index
self.fleet = str(fleet_index)
self.standby_loca = (0, 0)
from datetime import datetime, timedelta
from module.base.decorator import Config
from module.base.filter import Filter
from module.base.utils import *
from module.commission.project_data import *
from module.logger import logger
from module.ocr.ocr import Ocr, Duration
from module.reward.assets import *
COMMISSION_FILTER = Filter(
regex=re.compile(
'(major|daily|extra|urgent|night)?'
'-?'
'(resource|chip|event|drill|part|cube|oil|book|retrofit|box|gem|ship)?'
'-?'
'(\d\d?:\d\d)?'
'(\d\d?.\d\d?|\d\d?)?'
),
attr=('category_str', 'genre_str', 'duration_hm', 'duration_hour'),
preset=('shortest',)
)
SHORTEST_FILTER = """
0:20 > 0:30
> 1 > 1:10 > 1:20 > 1:30 > 1:40 > 1:45
> 2 > 2:15 > 2:30 > 2:40
> 3 > 3:20
> 4 > 5 > 5:20
> 6 > 7 > 8 > 9 > 10 > 12
"""
RESEARCH_DETAIL_GENRE = [
DETAIL_GENRE_B, DETAIL_GENRE_C, DETAIL_GENRE_D, DETAIL_GENRE_E,
DETAIL_GENRE_G, DETAIL_GENRE_H_0, DETAIL_GENRE_H_1, DETAIL_GENRE_Q,
DETAIL_GENRE_T
]
FILTER_REGEX = re.compile(
'(s[123])?'
'-?'
'(neptune|monarch|ibuki|izumo|roon|saintlouis|seattle|georgia|kitakaze|azuma|friedrich|gascogne|champagne|cheshire|drake|mainz|odin)?'
'(dr|pry)?'
'([bcdeghqt])?'
'-?'
'(\d.\d|\d\d?)?')
FILTER_ATTR = ('series', 'ship', 'ship_rarity', 'genre', 'duration')
FILTER_PRESET = ('shortest', 'cheapest', 'reset')
FILTER = Filter(FILTER_REGEX, FILTER_ATTR, FILTER_PRESET)
def get_research_series(image):
"""
Get research series using a simple color detection.
May not be able to detect 'IV' and 'V' in the future research series.
Args:
image (PIL.Image.Image):
Returns:
list[int]: Such as [1, 1, 1, 2, 3]
"""
result = []
parameters = {'height': 200}
import re
from module.base.filter import Filter
from module.campaign.run import CampaignRun
STAGE_FILTER = Filter(regex=re.compile('^(.*?)$'), attr=('stage', ))
class EventStage:
def __init__(self, filename):
self.filename = filename
self.stage = 'unknown'
if filename[-3:] == '.py':
self.stage = filename[:-3]
def __str__(self):
return self.stage
def __eq__(self, other):
return str(self) == str(other)
class EventBase(CampaignRun):
def load_campaign(self, *args, **kwargs):
super().load_campaign(*args, **kwargs)
self.campaign.config.temporary(MAP_IS_ONE_TIME_STAGE=False)
import itertools
import re
from module.base.filter import Filter
from module.exception import MapEnemyMoved
from module.logger import logger
from module.map.fleet import Fleet
from module.map.map_grids import RoadGrids, SelectedGrids
from module.map_detection.grid_info import GridInfo
ENEMY_FILTER = Filter(regex=re.compile('^(.*?)$'), attr=('str',))
class Map(Fleet):
def clear_chosen_enemy(self, grid, expected=''):
"""
Args:
grid (GridInfo):
expected (str):
"""
logger.info('targetEnemyScale:%s' % (self.config.EnemyPriority_EnemyScaleBalanceWeight))
logger.info('Clear enemy: %s' % grid)
expected = f'combat_{expected}' if expected else 'combat'
self.show_fleet()
if self.config.Emotion_CalculateEmotion and self.config.Campaign_UseFleetLock:
self.emotion.wait(fleet_index=self.fleet_current_index)
self.goto(grid, expected=expected)
self.full_scan()
self.find_path_initial()
self.map.show_cost()
FILTER_REGEX = re.compile(
'^(cube|drill|chip|array|pr|dr|box|bulin|book|food|plate|retrofit|cat)'
'(neptune|monarch|ibuki|izumo|roon|saintlouis'
'|seattle|georgia|kitakaze|azuma|friedrich'
'|gascogne|champagne|cheshire|drake|mainz|odin'
'|anchorage|hakuryu|agir|august|marcopolo'
'|red|blue|yellow'
'|general|gun|torpedo|antiair|plane|wild'
'|dd|cl|bb|cv)?'
'(s[1-4]|t[1-6])?$',
flags=re.IGNORECASE)
FILTER_ATTR = ('group', 'sub_genre', 'tier')
FILTER = Filter(FILTER_REGEX, FILTER_ATTR)
class ShopItemGrid(ItemGrid):
def predict(self, image, name=True, amount=True, cost=False, price=False, tag=False):
"""
Define new attributes to predicted Item obj for shop item filtering
"""
super().predict(image, name, amount, cost, price, tag)
for item in self.items:
# Set defaults
item.group, item.sub_genre, item.tier = None, None, None
# Can use regular expression to quickly populate
# the new attributes