Merge pull request #269 from cc004/dev

Author: Lanly109

autopcr/core/datamgr.py

@@ -60,12 +60,14 @@ class datamgr(BaseModel, Component[apiclient]):
     cleared_byway_quest_id_set: Set[int] = set({})
     return_fes_info_list: List[ReturnFesInfo] = None
     data_time: int = 0
-    version: int = 3
+    version: int = 4
     caravan_dishes: typing.Counter[int] = Counter()
     user_clan_battle_ex_equip_restriction: Dict[int, RestrictionExtraEquip] = {}
     talent_quest_area_info: Dict[int, TalentQuestAreaInfo] = {}
     cleared_talent_quest_ids: Dict[int, int] = {}
     princess_knight_info: PrincessKnightInfo = None
+    cleared_abyss_quests: Set[int] = set()
+    abyss_quest_info: Dict[int, AbyssDailyClearCountList] = {}
 
     @staticmethod
     async def try_update_database(ver: int):
@@ -587,7 +589,7 @@ def get_not_enough_item(self, demand: typing.Counter[ItemType]) -> typing.Counte
         return bad
 
     def get_unit_power(self, unit_id: int) -> int:
-        power = db.calc_unit_power(self.unit[unit_id], set(self.read_story_ids))
+        power = db.calc_unit_power(self.unit[unit_id], set(self.read_story_ids), self.ex_equips)
         return int(power + 0.5)
 
     def is_quest_cleared(self, quest: int) -> bool:

autopcr/core/pcrclient.py

@@ -732,6 +732,18 @@ async def read_story(self, story_id: int):
         await self.story_check(story_id)
         return await self.story_view(story_id)
 
+    async def tpr_register_success(self, panel_id: int, correct_type: int, parts_id_list: List[int]):
+        req = SubStoryTprRegisterSuccessRequest()
+        req.panel_id = panel_id
+        req.correct_type = correct_type
+        req.parts_id_list = parts_id_list
+        return await self.request(req)
+
+    async def read_tpr_story(self, sub_story_id: int):
+        req = SubStoryTprReadStoryRequest()
+        req.sub_story_id = sub_story_id
+        return await self.request(req)
+
     async def apg_story_top(self):
         req = SubStoryApgTopRequest()
         return await self.request(req)
@@ -1135,6 +1147,30 @@ async def training_quest_skip(self, quest: int, times: int):
         req.random_count = times
         return await self.request(req)
 
+    async def abyss_top(self, abyss_id: int):
+        req = AbyssTopRequest()
+        req.abyss_id = abyss_id
+        req.is_first = 1
+        return await self.request(req)
+
+    async def abyss_boss_skip(self, abyss_id: int, boss_id: int, enemy_index: int, exec_skip_num: int, current_boss_ticket_num: int):
+        req = AbyssBossSkipRequest()
+        req.abyss_id = abyss_id
+        req.boss_id = boss_id
+        req.enemy_index = enemy_index
+        req.exec_skip_num = exec_skip_num
+        req.current_skip_ticket_num = self.data.get_inventory((eInventoryType.Item, 23001))
+        req.current_boss_ticket_num = current_boss_ticket_num
+        return await self.request(req)
+
+    async def abyss_quest_skip(self, quest_id: int, times: int):
+        req = AbyssQuestSkipMultipleRequest()
+        req.abyss_id = db.quest_info[quest_id].abyss_id
+        req.skip_list = [QuestSkipInfo(quest_id=quest_id, skip_count=times)]
+        req.current_ticket_num = self.data.get_inventory((eInventoryType.Item, 23001))
+        req.exec_type = 1 # for single 2 for multiple
+        return await self.request(req)
+
     async def talent_quest_skip(self, quest_id: int, use_ticket_num: int):
         req = TalentQuestSkipRequest()
         req.quest_id = quest_id
@@ -1383,7 +1419,7 @@ async def unlock_quest_id(self, quest: int):
             (quest in db.tower_quest and self.data.tower_status and self.data.tower_status.cleared_floor_num >= db.tower_quest[quest].floor_num)
         )
 
-    async def quest_skip_aware(self, quest: int, times: int, recover: bool = False, is_total: bool = False):
+    async def quest_skip_aware(self, quest: int, times: int, recover: bool = False, is_total: bool = False) -> Tuple[List[InventoryInfo], int, bool]:
         name = db.get_quest_name(quest)
         if db.is_hatsune_quest(quest):
             if not quest in db.quest_to_event:
@@ -1407,6 +1443,14 @@ async def quest_skip_aware(self, quest: int, times: int, recover: bool = False,
                 daily_clear_count = 0,
                 daily_recovery_count = 0,
             ))
+        elif db.is_abyss_quest(quest):
+            if quest not in self.data.cleared_abyss_quests:
+                raise AbortError(f"任务{name}未通关或不存在")
+            qinfo = self.data.abyss_quest_info.get(quest, AbyssDailyClearCountList(
+                quest_id = quest,
+                daily_clear_count = 0,
+            ))
+            qinfo.__dict__['daily_recovery_count'] = 0
         else:
             if not quest in self.data.quest_dict:
                 raise AbortError(f"任务{name}未通关或不存在")
@@ -1418,26 +1462,47 @@ async def quest_skip_aware(self, quest: int, times: int, recover: bool = False,
         info = db.quest_info[quest]
         if db.is_talent_quest(quest): # fix
             setattr(info, 'daily_limit', self.data.settings.talent_quest.daily_clear_limit_count)
+        elif db.is_abyss_quest(quest):
+            setattr(info, 'daily_limit', self.data.settings.abyss.daily_clear_limit_count)
 
         stamina_coefficient = self.data.get_quest_stamina_half_campaign_times(quest)
         if not stamina_coefficient: stamina_coefficient = 100
         result: List[InventoryInfo] = []
-        async def skip(times):
+        clear_count = 0
+        async def skip(times) -> Tuple[bool, List[InventoryInfo]]:
             while self.data.stamina < int(math.floor((info.stamina * (stamina_coefficient / 100)))) * times:
                 if self.stamina_recover_cnt > self.data.recover_stamina_exec_count:
                     await self.recover_stamina()
                 else:
-                    raise AbortError(f"任务{name}体力不足")
+                    return True, []
             if db.is_shiori_quest(quest):
                 event = db.quest_to_event[quest].event_id
-                return await self.shiori_quest_skip(event, quest, times)
+                resp = await self.shiori_quest_skip(event, quest, times)
             elif db.is_hatsune_quest(quest):
                 event = db.quest_to_event[quest].event_id
-                return await self.hatsune_quest_skip(event, quest, times)
+                resp = await self.hatsune_quest_skip(event, quest, times)
             elif db.is_talent_quest(quest):
-                return await self.talent_quest_skip(quest, times)
+                resp = await self.talent_quest_skip(quest, times)
+            elif db.is_abyss_quest(quest):
+                resp = await self.abyss_quest_skip(quest, times)
             else:
-                return await self.quest_skip(quest, times)
+                resp = await self.quest_skip(quest, times)
+
+            nonlocal clear_count
+            clear_count += times
+            result = []
+            if resp.quest_result_list:
+                for result_list in resp.quest_result_list:
+                    if hasattr(result_list, 'quest_result'):
+                        for quest_result in result_list.quest_result:
+                            result = result + quest_result.reward_list
+                    else:
+                        result = result + result_list.reward_list
+            if resp.bonus_reward_list:
+                result = result + resp.bonus_reward_list
+            return False, result
+
+        no_stamina = False
         if info.daily_limit:
             if is_total:
                 times -= qinfo.daily_clear_count
@@ -1454,24 +1519,19 @@ async def skip(times):
                         await self.recover_challenge(quest)
                     remain = info.daily_limit
                 t = min(times, remain)
-                resp = await skip(t)
-                if resp.quest_result_list:
-                    for result_list in resp.quest_result_list:
-                        result = result + result_list.reward_list
-                if resp.bonus_reward_list:
-                    result = result + resp.bonus_reward_list
-                    
+                no_stamina, resp = await skip(t)
+                if no_stamina:
+                    break
+
+                result = result + resp
+
                 times -= t
                 remain -= t
         else:
-            resp = await skip(times)
-            if resp.quest_result_list:
-                for result_list in resp.quest_result_list:
-                    result = result + result_list.reward_list
-            if resp.bonus_reward_list:
-                result = result + resp.bonus_reward_list
+            no_stamina, resp = await skip(times)
+            result = result + resp
 
-        return result
+        return result, clear_count, no_stamina
 
     async def refresh(self):
         req = HomeIndexRequest()

autopcr/db/database.py

@@ -1,8 +1,8 @@
 from typing import List, Dict, Set, Tuple, Union
 import typing
 from ..model.enums import eCampaignCategory
-from ..model.common import UnitData, eInventoryType, RoomUserItem, InventoryInfo
-from ..model.custom import ItemType
+from ..model.common import ExtraEquipInfo, UnitData, eInventoryType, RoomUserItem, InventoryInfo
+from ..model.custom import ItemType, eDifficulty
 import datetime
 from collections import Counter, defaultdict
 from .dbmgr import dbmgr
@@ -14,6 +14,7 @@
 from ..core.apiclient import apiclient
 from typing import TypeVar, Generic
 from ..util.pcr_data import CHARA_NICKNAME
+from ..util.logger import instance as logger
 
 T = TypeVar("T")
 
@@ -664,9 +665,27 @@ def quest_info(self) -> Dict[int, QuestDatum]:
                 .concat(HatsuneQuest.query(db))
                 .concat(ShioriQuest.query(db))
                 .concat(TalentQuestDatum.query(db))
+                .concat(AbyssQuestDatum.query(db))
                 .to_dict(lambda x: x.quest_id, lambda x: x)
             )
 
+    @lazy_property
+    def abyss_quest_info(self) -> Dict[int, List[AbyssQuestDatum]]:
+        with self.dbmgr.session() as db:
+            return (
+                AbyssQuestDatum.query(db)
+                .group_by(lambda x: x.abyss_id)
+                .to_dict(lambda x: x.key, lambda x: x.to_list())
+            )
+
+    @lazy_property
+    def abyss_boss_data(self) -> Dict[int, AbyssBossDatum]:
+        with self.dbmgr.session() as db:
+            return (
+                AbyssBossDatum.query(db)
+                .to_dict(lambda x: x.boss_id, lambda x: x)
+            )
+
     @lazy_property
     def chara_story_status(self) -> Dict[int, CharaStoryStatus]:
         with self.dbmgr.session() as db:
@@ -1070,6 +1089,22 @@ def colosseum_schedule_data(self) -> Dict[int, ColosseumScheduleDatum]:
                 .to_dict(lambda x: x.schedule_id, lambda x: x)
             )
 
+    @lazy_property
+    def dome_schedule_data(self) -> Dict[int, DomeScheduleDatum]:
+        with self.dbmgr.session() as db:
+            return (
+                DomeScheduleDatum.query(db)
+                .to_dict(lambda x: x.schedule_id, lambda x: x)
+            )
+
+    @lazy_property
+    def abyss_schedule(self) -> Dict[int, AbyssSchedule]:
+        with self.dbmgr.session() as db:
+            return (
+                AbyssSchedule.query(db)
+                .to_dict(lambda x: x.abyss_id, lambda x: x)
+            )
+
     @lazy_property
     def tower_schedule(self) -> Dict[int, TowerSchedule]:
         with self.dbmgr.session() as db:
@@ -1228,6 +1263,22 @@ def hatsune_item(self) -> Dict[int, HatsuneItem]:
                 .to_dict(lambda x: x.event_id, lambda x: x)
             )
 
+    @lazy_property
+    def tpr_story_data(self) -> Dict[int, TprStoryDatum]:
+        with self.dbmgr.session() as db:
+            return (
+                TprStoryDatum.query(db)
+                .to_dict(lambda x: x.sub_story_id, lambda x: x)
+            )
+
+    @lazy_property
+    def tpr_panel_data(self) -> Dict[int, TprPanelDatum]:
+        with self.dbmgr.session() as db:
+            return (
+                TprPanelDatum.query(db)
+                .to_dict(lambda x: x.panel_id, lambda x: x)
+            )
+
     @lazy_property
     def apg_story_data(self) -> Dict[int, ApgStoryDatum]:
         with self.dbmgr.session() as db:
@@ -1516,6 +1567,9 @@ def quest_name(self) -> Dict[int, str]:
         ret.update(
             {x.travel_quest_id :x.travel_quest_name for x in self.travel_quest_data.values()}
         )
+        ret.update(
+            {x.quest_id: f"{x.quest_name}-{eDifficulty(x.difficulty).name}" for xs in self.abyss_quest_info.values() for x in xs}
+        )
         return ret
 
     @lazy_property
@@ -1675,9 +1729,9 @@ def get_inventory_name_san(self, item: ItemType) -> str:
         except:
             return f"未知物品({item[0]}, {item[1]})"
 
-    def get_ex_equip_name(self, item: int, rank: int = 0) -> str:
+    def get_ex_equip_name(self, item: int, rank: int = -1) -> str:
         try:
-            return f"{self.ex_rarity_name[self.ex_equipment_data[item].rarity]}{rank}-" + self.inventory_name[(eInventoryType.ExtraEquip, item)] 
+            return f"{self.ex_rarity_name[self.ex_equipment_data[item].rarity]}{rank if rank != -1 else ''}-" + self.inventory_name[(eInventoryType.ExtraEquip, item)] 
         except:
             return f"未知ex装备({item})"
 
@@ -1791,6 +1845,9 @@ def is_talent_quest(self, quest_id: int) -> bool:
         top = quest_id // 1000000
         return top >= 81 and top <= 85
 
+    def is_abyss_quest(self, quest_id: int) -> bool:
+        return quest_id // 1000000 == 92
+
     def is_hatsune_normal_quest(self, quest_id: int) -> bool:
         return self.is_hatsune_quest(quest_id) and (quest_id // 100) % 10 == 1
 
@@ -1878,6 +1935,17 @@ def get_open_hatsune(self) -> List[HatsuneSchedule]:
                 .where(lambda x: now >= self.parse_time(x.start_time) and now <= self.parse_time(x.close_time)) \
                 .to_list()
 
+    def get_active_abyss(self) -> List[AbyssSchedule]:
+        now = apiclient.datetime
+        return flow(self.abyss_schedule.values()) \
+                .where(lambda x: now >= self.parse_time(x.start_time) and now <= self.parse_time(x.end_time)) \
+                .to_list()
+
+    def get_abyss_bosses(self, abyss_id: int) -> List[AbyssBossDatum]:
+        return flow(self.abyss_boss_data.values()) \
+                .where(lambda x: x.abyss_id == abyss_id) \
+                .to_list()
+
     def get_active_seasonpass(self) -> List[SeasonpassFoundation]:
         now = apiclient.datetime
         return flow(self.seasonpass_foundation.values()) \
@@ -2301,7 +2369,7 @@ def get_gacha_prize_name(self, gacha_id: int, prize_rarity: int) -> str:
     def is_unit_rank_bonus(self, unit_id: int, promotion_level: int) -> bool:
         return unit_id in self.promote_bonus and promotion_level in self.promote_bonus[unit_id]
 
-    def calc_unit_attribute(self, unit_data: UnitData, read_story: Set[int]) -> UnitAttribute:
+    def calc_unit_attribute(self, unit_data: UnitData, read_story: Set[int], ex_equips: Dict[int, ExtraEquipInfo]) -> UnitAttribute:
         unit_id = unit_data.id
         promotion_level = unit_data.promotion_level.value
         rarity = unit_data.battle_rarity if unit_data.battle_rarity else unit_data.unit_rarity
@@ -2342,10 +2410,22 @@ def calc_unit_attribute(self, unit_data: UnitData, read_story: Set[int]) -> Unit
                 kizuna_attribute += story.get_unit_attribute()
 
         unit_attribute = base_attribute.round() + rb_attribute.round() + equip_attribute.round() + unique_equip_attribute.ceil() + kizuna_attribute.round()
+
+        # EX装备
+        ex_attribute = UnitAttribute()
+        for ex_equip in unit_data.ex_equip_slot:
+            if ex_equip.serial_id:
+                ex_equip_data = ex_equips[ex_equip.serial_id]
+                star = self.get_ex_equip_star_from_pt(ex_equip_data.ex_equipment_id, ex_equip_data.enhancement_pt)
+                attr = self.ex_equipment_data[ex_equip_data.ex_equipment_id].get_unit_attribute(star)
+                bonus = unit_attribute.ex_equipment_mul(attr).ceil()
+                ex_attribute += bonus
+        unit_attribute += ex_attribute
+
         return unit_attribute
 
-    def calc_unit_attribute_power(self, unit_data: UnitData, read_story: Set[int], coefficient: UnitStatusCoefficient) -> float:
-        unit_attribute = self.calc_unit_attribute(unit_data, read_story)
+    def calc_unit_attribute_power(self, unit_data: UnitData, read_story: Set[int], ex_equips: Dict[int, ExtraEquipInfo], coefficient: UnitStatusCoefficient) -> float:
+        unit_attribute = self.calc_unit_attribute(unit_data, read_story, ex_equips)
         return unit_attribute.get_power(coefficient)
 
     def calc_skill_power(self, unit_data: UnitData, coefficient: UnitStatusCoefficient) -> float:
@@ -2374,9 +2454,9 @@ def calc_skill_power(self, unit_data: UnitData, coefficient: UnitStatusCoefficie
 
         return skill_power * coefficient.skill_lv_coefficient
 
-    def calc_unit_power(self, unit_data: UnitData, read_story: Set[int]) -> float:
+    def calc_unit_power(self, unit_data: UnitData, read_story: Set[int], ex_equips: Dict[int, ExtraEquipInfo]) -> float:
         coefficient = self.unit_status_coefficient[1]
-        attribute_power = self.calc_unit_attribute_power(unit_data, read_story, coefficient)
+        attribute_power = self.calc_unit_attribute_power(unit_data, read_story, ex_equips, coefficient)
         skill_power = self.calc_skill_power(unit_data, coefficient)
         return attribute_power + skill_power