Merge pull request #246 from cc004/dev

Dev

Author: Lanly109

autopcr/core/pcrclient.py

@@ -724,44 +724,55 @@ async def read_story(self, story_id: int):
         await self.story_check(story_id)
         return await self.story_view(story_id)
 
+    async def draw_fpc_story(self, period: eFpcPeriod, fpc_operation_type: eFpcOperationType):
+        req = SubStoryFpcDrawStoryRequest()
+        req.period = period
+        req.fpc_operation_type = fpc_operation_type
+        return await self.request(req)
+
+    async def read_fpc_story(self, sub_story_id: int):
+        req = SubStoryFpcReadStoryRequest()
+        req.sub_story_id = sub_story_id
+        return await self.request(req)
+
     async def read_ais_story(self, sub_story_id: int):
         req = SubStoryAisReadStoryRequest()
         req.sub_story_id = sub_story_id
-        await self.request(req)
+        return await self.request(req)
 
     async def confirm_ais_story(self):
         req = SubStoryAisConfirmRequest()
-        await self.request(req)
+        return await self.request(req)
 
     async def read_nyd_story(self, sub_story_id: int):
         req = SubStoryNydReadStoryRequest()
         req.sub_story_id = sub_story_id
-        await self.request(req)
+        return await self.request(req)
 
     async def read_xac_story(self, sub_story_id: int):
         req = SubStoryXacReadStoryRequest()
         req.sub_story_id = sub_story_id
-        await self.request(req)
+        return await self.request(req)
 
     async def read_asb_story(self, sub_story_id: int):
         req = SubStoryAsbReadStoryRequest()
         req.sub_story_id = sub_story_id
-        await self.request(req)
+        return await self.request(req)
 
     async def read_wtm_story(self, sub_story_id: int):
         req = SubStoryWtmReadStoryRequest()
         req.sub_story_id = sub_story_id
-        await self.request(req)
+        return await self.request(req)
 
     async def read_wts_story(self, sub_story_id: int):
         req = SubStoryWtsReadStoryRequest()
         req.sub_story_id = sub_story_id
-        await self.request(req)
+        return await self.request(req)
 
     async def read_bmy_story(self, sub_story_id: int):
         req = SubStoryBmyReadStoryRequest()
         req.sub_story_id = sub_story_id
-        await self.request(req)
+        return await self.request(req)
 
     async def put_mme_piece(self, sub_story_id: int):
         req = SubStoryMmePutPieceRequest()
@@ -776,66 +787,66 @@ async def read_mme_story(self, sub_story_id: int):
     async def read_xeh_story(self, sub_story_id: int):
         req = SubStoryXehReadStoryRequest()
         req.sub_story_id = sub_story_id
-        await self.request(req)
+        return await self.request(req)
 
     async def read_lsv_story(self, sub_story_id: int):
         req = SubStoryLsvReadStoryRequest()
         req.sub_story_id = sub_story_id
-        await self.request(req)
+        return await self.request(req)
 
     async def read_dsb_story(self, sub_story_id: int):
         req = SubStoryDsbReadStoryRequest()
         req.sub_story_id = sub_story_id
-        await self.request(req)
+        return await self.request(req)
 
     async def read_ysn_story(self, sub_story_id: int):
         req = SubStoryYsnReadStoryRequest()
         req.sub_story_id = sub_story_id
-        await self.request(req)
+        return await self.request(req)
 
     async def read_nop_story(self, sub_story_id: int):
         req = SubStoryNopReadStoryRequest()
         req.sub_story_id = sub_story_id
-        await self.request(req)
+        return await self.request(req)
 
     async def read_mhp_story(self, sub_story_id: int):
         req = SubStoryMhpReadStoryRequest()
         req.sub_story_id = sub_story_id
-        await self.request(req)
+        return await self.request(req)
 
     async def read_svd_story(self, sub_story_id: int):
         req = SubStorySvdReadStoryRequest()
         req.sub_story_id = sub_story_id
-        await self.request(req)
+        return await self.request(req)
 
     async def read_ssp_story(self, sub_story_id: int):
         req = SubStorySspReadSspStoryRequest()
         req.sub_story_id = sub_story_id
-        await self.request(req)
+        return await self.request(req)
 
     async def read_ske_story(self, sub_story_id: int):
         req = SubStorySkeReadStoryRequest()
         req.sub_story_id = sub_story_id
-        await self.request(req)
+        return await self.request(req)
 
     async def read_dvs_story(self, sub_story_id: int):
         req = SubStoryDvsReadStoryRequest()
         req.sub_story_id = sub_story_id
-        await self.request(req)
+        return await self.request(req)
 
     async def read_won_story(self, sub_story_id: int):
         req = SubStoryWonReadStoryRequest()
         req.sub_story_id_list = [sub_story_id]
-        await self.request(req)
+        return await self.request(req)
 
     async def confirm_ske_story(self):
         req = SubStorySkeConfirmRequest()
-        await self.request(req)
+        return await self.request(req)
 
     async def read_lto_story(self, sub_story_id: int):
         req = SubStoryLtoReadStoryRequest()
         req.sub_story_id = sub_story_id
-        await self.request(req)
+        return await self.request(req)
 
     async def read_hatsune_dear(self, event_id: int, story_id: int):
         req = HatsuneDearFinishRequest()

autopcr/db/database.py

@@ -1203,6 +1203,14 @@ def hatsune_item(self) -> Dict[int, HatsuneItem]:
                 .to_dict(lambda x: x.event_id, lambda x: x)
             )
 
+    @lazy_property
+    def fpc_story_data(self) -> Dict[int, FpcStoryDatum]:
+        with self.dbmgr.session() as db:
+            return (
+                FpcStoryDatum.query(db)
+                .to_dict(lambda x: x.sub_story_id, lambda x: x)
+            )
+
     @lazy_property
     def ais_story_data(self) -> Dict[int, AisStoryDatum]:
         with self.dbmgr.session() as db:

autopcr/model/handlers.py

@@ -727,6 +727,9 @@ async def update(self, mgr: datamgr, request):
         if self.rewards:
             for reward in self.rewards:
                 mgr.update_inventory(reward)
+        if self.exchange_rewards:
+            for reward in self.exchange_rewards:
+                mgr.update_inventory(reward)
 
 @handles
 class SubStoryAisReadStoryResponse(responses.SubStoryAisReadStoryResponse):

autopcr/module/accountmgr.py

@@ -77,7 +77,7 @@ def __init__(self, parent: 'AccountManager', qid: str, account: str, readonly: b
         self.qq = qid
         self.alias = account
         self.token = f"{self.qq}_{self.alias}"
-        super().__init__(self.data.config)
+        super().__init__(deepcopy(self.data.config))
 
     async def _do_aenter(self):
         if not self.readonly:

autopcr/module/modules/autosweep.py

@@ -14,7 +14,7 @@
 @conditional_execution1("lazy_sweep_run_time", ["n庆典"])
 @singlechoice("lazy_sweep_strategy", "刷取策略", "刷最缺", ["刷最缺", "均匀刷"])
 @UnitListConfig('lazy_sweep_consider_units', "考虑角色")
-@description('根据【刷图推荐】结果刷n图，均匀刷指每次刷取的图覆盖所缺的需求装备，若无缺装备则刷取推荐的第一张图')
+@description('根据【刷图推荐】结果刷n图，均匀刷指每次刷取的图覆盖所缺的需求装备，无缺装备则停止刷')
 @name('懒人刷n图')
 @default(False)
 @tag_stamina_consume

autopcr/module/modules/caravan.py

@@ -381,15 +381,22 @@ def process_effect_turn(self):
         for effect in self.get_effect():
             effect.exec_count = 0
 
-    def is_effect_execable(self, effect: eBuddyEffectType) -> bool:
-        buddys = self.get_effect(effect)
+    def is_dice_retryable(self) -> bool:
+        buddys = self.get_effect(eBuddyEffectType.RETRY)
         for buddy in buddys:
             if not buddy.exec_count: 
                 buddy.exec_count = 0
             if buddy.exec_count < db.caravan_buddy[buddy.buddy_id].effect_value_1:
                 return True
         return False
 
+    def is_effect_exist(self, effect: eBuddyEffectType) -> bool:
+        buddys = self.get_effect(effect)
+        for buddy in buddys:
+            if buddy.turn > 0:
+                return True
+        return False
+
     def exec_effect(self, effect: eBuddyEffectType) -> int:
         buddys = self.get_effect(effect)
         for buddy in buddys:
@@ -563,7 +570,7 @@ async def update_rival_info(self, rival_info: RivalInfo):
 
         assert isinstance(self.rival_info, RivalInfo), "rival_info must be an instance of RivalInfo"
         self.rival_info.block_id = rival_info.after_block_id
-        self._log(f"若菜掷出了{rival_info.spots}，到达格子 {self.rival_info.block_id}")
+        self._log(f"若菜掷出了{rival_info.spots_list}，到达格子 {self.rival_info.block_id}")
         if self.current_block_id == self.rival_info.block_id:
             self._log("若菜在当前格子，开始小游戏")
             self.state = eState.RIVAL_MINI_GAME
@@ -877,7 +884,7 @@ async def step(self):
 
         elif self.state == eState.SELECT_RESULT:
             roll_num = self.dish_effect_manager.get_effect_influence_value(eDishEffectType.MULTI_DICE) or 1
-            while not self.dish_effect_manager.is_dice_fix() and self.buddy_effect_manager.is_effect_execable(eBuddyEffectType.RETRY):
+            while not self.dish_effect_manager.is_dice_fix() and self.buddy_effect_manager.is_dice_retryable():
                 exec_count = self.buddy_effect_manager.exec_effect(eBuddyEffectType.RETRY)
                 if sum(self.spots_list) >= 3 * roll_num:
                     self._log(f"骰子结果 {self.spots_list} >= 3 * {roll_num}, 不低于期望，不重投")
@@ -910,7 +917,8 @@ async def step(self):
                 if repeat_count:
                     self._log(f"当前骰子结果 {self.spots_list}, 达到 {self.buddy_effect_manager.get_repeat_count()}，停止投")
 
-            if self.buddy_effect_manager.is_effect_execable(eBuddyEffectType.SELECT_DICE_RESULT):
+            if self.buddy_effect_manager.is_effect_exist(eBuddyEffectType.SELECT_DICE_RESULT) \
+                or self.buddy_effect_manager.is_effect_exist(eBuddyEffectType.SELECT_FRONT_OR_BACK):
                 choice = 1 + (self.spots_choices_1 < self.spots_choices_2)
                 self._log(f"{self.spots_choices_1} vs {self.spots_choices_2}，选择骰子结果 {choice}")
                 await self.client.caravan_spots_choice(
@@ -1075,9 +1083,9 @@ async def do_task(self, client: pcrclient):
         to_buy = Counter()
         for item in limit_expend_items[:]:
             coin = client.data.get_inventory((eInventoryType.Item, item.currency_id))
-            if coin < item.price:
+            if coin < cost + item.price:
                 if not rewards:
-                    self._log(f"商店币不足{coin} < {item.price}，无法购买 {db.get_inventory_name_san((item.reward_type, item.reward_id))}")
+                    self._log(f"商店币不足{coin} < {cost + item.price}，无法购买 {db.get_inventory_name_san((item.reward_type, item.reward_id))}及以后的物品")
                 break
             if not is_enable_buy_bulk:
                 resp = await client.caravan_coin_shop_buy(

autopcr/module/modules/exequip.py

@@ -95,7 +95,7 @@ async def do_task(self, client: pcrclient):
 @default(True)
 @inttype('ex_equip_rank_max_num', '满突破个数', 5, list(range(-1, 51)))
 @MultiChoiceConfig('ex_equip_rank_up_kind', '合成种类', [], ['粉', '会战金', '普通金', '会战银'])
-@description('忽略已装备和锁定的EX装，满突破个数指同类满突破EX装超过阈值则不突破，-1表示不限制')
+@description('合成忽略已装备和锁定的EX装，满突破个数指同类满突破EX装超过阈值则不突破，-1表示不限制')
 class ex_equip_rank_up(Module):
     async def do_task(self, client: pcrclient):
         use_ex_equip = {ex_slot.serial_id: [unit.id, frame, ex_slot.slot]
@@ -120,7 +120,7 @@ async def do_task(self, client: pcrclient):
                     .group_by(lambda ex: ex.ex_equipment_id) \
                     .to_dict(lambda ex: ex.key, lambda ex: ex.to_list())
 
-        ex_equips_max_rank_cnt = Counter(flow(consider_ex_equips) \
+        ex_equips_max_rank_cnt = Counter(flow(client.data.ex_equips.values()) \
                 .where(lambda ex: ex.rank == db.get_ex_equip_max_rank(ex.ex_equipment_id)) \
                 .group_by(lambda ex: ex.ex_equipment_id) \
                 .to_dict(lambda ex: ex.key, lambda ex: ex.count()))

autopcr/module/modules/hatsune.py

@@ -164,13 +164,14 @@ async def do_task(self, client: pcrclient):
         if is_abort: raise AbortError("")
         if is_skip: raise SkipError("")
 
-@singlechoice("hatsune_gacha_strategy", "兑换策略", "全部兑换", ["前两轮尽早重置", "全部兑换"])
-@description('自动兑换，前两轮兑换处目标物品可选择重置')
+# @singlechoice("hatsune_gacha_strategy", "兑换策略", "全部兑换", ["全部兑换"])
+@description('自动兑换')
 @name('讨伐证交换')
 @default(True)
 class hatsune_gacha_exchange(Module):
     async def do_task(self, client: pcrclient):
-        early_stop = False if self.get_config('hatsune_gacha_strategy') == "全部兑换" else True
+        # early_stop = False if self.get_config('hatsune_gacha_strategy') == "全部兑换" else True
+        early_stop = False
         event_active = False
 
         for event in db.get_open_hatsune():

autopcr/module/modules/story.py

@@ -188,6 +188,10 @@ async def do_task(self, client: pcrclient):
                 self._warn(f"暂不支持的活动{db.event_name[sub_storys.event_id]}")
                 continue
 
+            if reader.special:
+                await reader.special_read(sub_storys, self._log)
+                continue
+
             if any(sub_story.status == eEventSubStoryStatus.ADDED for sub_story in sub_storys.sub_story_info_list):
                 await reader.confirm()
             for sub_story in sub_storys.sub_story_info_list:

autopcr/util/substory.py

@@ -1,4 +1,10 @@
-from typing import Union
+from enum import IntEnum
+from typing import Callable, List, Union
+
+from ..model.enums import eFpcOperationType, eFpcPeriod
+from ..model.enums import eEventSubStoryStatus
+
+from .linq import flow
 from ..core.pcrclient import pcrclient
 from ..core.apiclient import apiclient
 from ..model.common import EventSubStory
@@ -16,6 +22,7 @@ def decorator(cls):
 class SubStoryReader:
 
     client: pcrclient
+    special: bool = False
 
     def is_readable(self, sub_story_id: int) -> bool:
         return True # it seems to be readable when it appear in the substory list
@@ -25,6 +32,7 @@ def is_puzzle_piece(self, sub_story_id: int) -> bool:
     def title(self, sub_story_id: int) -> str: ...
     async def read(self, sub_story_id: int): ...
     async def place_piece(self, sub_story_id: int): ...
+    async def special_read(self, sub_storys: List[EventSubStory], _log: Callable): ...
     async def confirm(self): ...
 
     def __init__(self, client: pcrclient):
@@ -35,6 +43,43 @@ def GetSubStoryReader(sub_story_data: EventSubStory, client: pcrclient) -> Union
         return constructor[sub_story_data.event_id](client)
     return None
 
+@EventId(10140)
+class fpc_substory(SubStoryReader):
+    special = True
+
+    def title(self, sub_story_id: int) -> str:
+        return db.fpc_story_data[sub_story_id].title
+
+    async def read(self, sub_story_id: int):
+        await self.client.read_fpc_story(sub_story_id)
+
+    async def special_read(self, sub_storys: EventSubStory, _log: Callable):
+        all_ids = set(s.sub_story_id for s in sub_storys.sub_story_info_list)
+        unread_ids = set(s.sub_story_id for s in sub_storys.sub_story_info_list if s.status == eEventSubStoryStatus.UNREAD)
+        cnt = 0;
+        last_period = eFpcPeriod.DAY
+        for period in eFpcPeriod:
+            unread_in_period = flow(unread_ids).where(lambda id: db.fpc_story_data[id].period == period).to_list()
+            fpc_op = eFpcOperationType.DAY_NIGHT_CHANGE if last_period != period else eFpcOperationType.SKIP
+            last_period = period
+            for _ in range(80): # should not be more than 80 times
+                if len(unread_in_period) == 0:
+                    break
+                resp = await self.client.draw_fpc_story(period, fpc_op)
+                fpc_op = eFpcOperationType.SKIP
+                cnt += 1
+                if resp.hit_sub_story_id in all_ids:
+                    if resp.hit_sub_story_id in unread_in_period:
+                        await self.read(resp.hit_sub_story_id)
+                        _log(f'阅读了{self.title(resp.hit_sub_story_id)}')
+                        unread_in_period.remove(resp.hit_sub_story_id)
+                        next((s for s in sub_storys.sub_story_info_list if s.sub_story_id == resp.hit_sub_story_id)).status = eEventSubStoryStatus.READED
+            else:
+                _log(f'80次未能完成故事阅读，下次再试吧')
+        if cnt:
+            _log(f'观看了{cnt}次表演')
+
+
 @EventId(10137)
 @EventId(10136)
 class ais_substory(SubStoryReader):