Merge pull request #276 from cc004/dev

Dev

Author: Lanly109

autopcr/core/datamgr.py

@@ -60,14 +60,16 @@ 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 = 4
+    version: int = 5
     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] = {}
+    alces_appear_story_flag: int = 0
+    alces_receive_tutorial_item_flag: int = 0
 
     @staticmethod
     async def try_update_database(ver: int):
@@ -534,7 +536,9 @@ def filter_inventory(self, filter: Callable) -> List[ItemType]:
         return [item for item in self.inventory if filter(item) and self.inventory[item] > 0]
 
     def get_inventory(self, item: ItemType) -> int:
-        if item == db.mana:
+        if item == db.zmana:
+            return self.gold.gold_id_free + self.gold.gold_id_pay
+        elif item == db.mana:
             return self.gold.gold_id_free + self.gold.gold_id_pay
         elif item == db.jewel:
             return self.jewel.free_jewel + self.jewel.jewel

autopcr/core/pcrclient.py

@@ -59,6 +59,69 @@ async def clan_battle_top(self):
         req.current_clan_battle_coin = self.data.get_shop_gold(eSystemId.CLAN_BATTLE_SHOP)
         return await self.request(req)
 
+    async def alces_top(self):
+        if not self.data.is_quest_cleared(11018002):
+            raise SkipError("究极炼成未解锁")
+        req = AlcesTopRequest()
+        return await self.request(req)
+
+    async def alces_receive_tutorial_item(self):
+        req = AlcesReceiveTutorialItemRequest()
+        return await self.request(req)
+
+    async def alces_read_story(self, story_id: int):
+        req = AlcesReadStoryRequest()
+        req.story_id = story_id
+        return await self.request(req)
+
+    async def alces_exec(self, serial_id: int):
+        req = AlcesExecRequest()
+        req.serial_id = serial_id
+        req.current_alces_point = self.data.get_inventory((eInventoryType.Item, 26202))
+        req.current_gold = self.data.get_mana()
+        return await self.request(req)
+
+    async def alces_lock_slot(self, serial_id: int, slot_number: int, is_lock: int):
+        req = AlcesLockSlotRequest()
+        req.lock_list = [
+            AlcesDataPost(
+                serial_id=serial_id,
+                sub_status=[ExtraEquipSubStatusPost(
+                    slot_number=slot_number,
+                    is_lock=is_lock
+                )]
+            )
+        ]
+        return await self.request(req)
+
+    async def alces_cancel_result(self, serial_id: int):
+        req = AlcesCancelResultRequest()
+        req.serial_id = serial_id
+        return await self.request(req)
+
+    async def alces_fix_result(self, serial_id: int):
+        req = AlcesFixResultRequest()
+        req.serial_id = serial_id
+        return await self.request(req)
+
+    async def mirage_top(self):
+        if not self.data.is_quest_cleared(11072001):
+            raise SkipError("追忆战未解锁")
+        req = MirageTopRequest()
+        return await self.request(req)
+
+    async def mirage_receive_reward(self, from_system_id: int):
+        req = MirageReceiveRewardRequest()
+        req.from_system_id = from_system_id
+        return await self.request(req)
+
+    async def mirage_nemesis_skip_multiple(self, skip_list: List[QuestSkipInfo]):
+        req = MirageNemesisSkipMultipleRequest()
+        req.skip_list = skip_list
+        req.current_skip_ticket_num = self.data.get_inventory((eInventoryType.Item, 23001))
+        req.exec_type = 2
+        return await self.request(req)
+
     async def emblem_top(self):
         req = EmblemTopRequest()
         return await self.request(req)
@@ -739,6 +802,19 @@ async def tpr_register_success(self, panel_id: int, correct_type: int, parts_id_
         req.parts_id_list = parts_id_list
         return await self.request(req)
 
+    async def abd_top(self):
+        req = SubStoryAbdTopRequest()
+        return await self.request(req)
+
+    async def read_abd_story(self, sub_story_id: int):
+        req = SubStoryAbdReadStoryRequest()
+        req.sub_story_id = sub_story_id
+        req.skip_info = StorySkipInfo(
+                skip_type = eStorySkipType.MENU_SKIP,
+                scroll_coordinate = ""
+        )
+        return await self.request(req)
+
     async def read_lss_story(self, sub_story_id: int):
         req = SubStoryLssReadStoryRequest()
         req.sub_story_id = sub_story_id

autopcr/db/database.py

@@ -1,7 +1,7 @@
 from typing import List, Dict, Set, Tuple, Union
 import typing
-from ..model.enums import eCampaignCategory
-from ..model.common import ExtraEquipInfo, UnitData, eInventoryType, RoomUserItem, InventoryInfo
+from ..model.enums import eCampaignCategory, eParamType
+from ..model.common import ExtraEquipInfo, ExtraEquipSubStatus, UnitData, eInventoryType, RoomUserItem, InventoryInfo
 from ..model.custom import ItemType, eDifficulty
 import datetime
 from collections import Counter, defaultdict
@@ -65,6 +65,7 @@ class database():
     wind_ball: ItemType = (eInventoryType.Item, 25013)
     sun_ball: ItemType = (eInventoryType.Item, 25014)
     dark_ball: ItemType = (eInventoryType.Item, 25015)
+    ex_rainbow_enhance_pt: ItemType = (eInventoryType.Item, 26202)
 
     def update(self, dbmgr):
         self.dbmgr = dbmgr
@@ -931,6 +932,7 @@ def inventory_name(self) -> Dict[ItemType, str]:
         ret[(eInventoryType.TeamExp, 92001)] = "经验"
         ret[(eInventoryType.Jewel, 91002)] = "宝石"
         ret[(eInventoryType.Gold, 94002)] = "mana"
+        ret[(eInventoryType.Gold, 94000)] = "mana"
         ret[(eInventoryType.SeasonPassPoint, 98002)] = "祝福经验值"
         ret[(eInventoryType.SeasonPassStamina, 93002)] = "星尘体力药剂"
         return ret
@@ -1263,6 +1265,14 @@ def hatsune_item(self) -> Dict[int, HatsuneItem]:
                 .to_dict(lambda x: x.event_id, lambda x: x)
             )
 
+    @lazy_property
+    def abd_story_data(self) -> Dict[int, AbdStoryDatum]:
+        with self.dbmgr.session() as db:
+            return (
+                AbdStoryDatum.query(db)
+                .to_dict(lambda x: x.sub_story_id, lambda x: x)
+            )
+
     @lazy_property
     def lss_story_data(self) -> Dict[int, LssStoryDatum]:
         with self.dbmgr.session() as db:
@@ -1471,6 +1481,25 @@ def ex_equipment_data(self) -> Dict[int, ExEquipmentDatum]:
                 .to_dict(lambda x: x.ex_equipment_id, lambda x: x)
             )
 
+    @lazy_property
+    def ex_equipment_sub_status(self) -> Dict[int, Dict[int, ExEquipmentSubStatus]]:
+        with self.dbmgr.session() as db:
+            return (
+                ExEquipmentSubStatus.query(db)
+                .group_by(lambda x: x.group_id)
+                .to_dict(lambda x: x.key, lambda x: x.to_dict(
+                    lambda x: x.status, lambda x: x
+                ))
+            )
+
+    @lazy_property
+    def ex_equipment_sub_status_group(self) -> Dict[int, ExEquipmentSubStatusGroup]:
+        with self.dbmgr.session() as db:
+            return (
+                ExEquipmentSubStatusGroup.query(db)
+                .to_dict(lambda x: x.ex_equipment_id, lambda x: x)
+            )
+
     @lazy_property
     def ex_equipment_rankup_data(self) -> Dict[int, Dict[int, ExEquipmentRankupDatum]]:
         with self.dbmgr.session() as db:
@@ -1570,6 +1599,8 @@ def quest_name(self) -> Dict[int, str]:
                 .concat(ShioriQuest.query(db))
                 .concat(TrainingQuestDatum.query(db))
                 .concat(TalentQuestDatum.query(db))
+                .concat(MirageNemesisQuestDisplay.query(db))
+                .concat(MirageFloorQuestDisplay.query(db))
                 .to_dict(lambda x: x.quest_id, lambda x: x.quest_name)
             )
         ret.update(
@@ -1593,7 +1624,8 @@ def shop_static_price_group(self) -> Dict[int, List[ShopStaticPriceGroup]]:
         1: '铜',
         2: '银',
         3: '金',
-        4: '粉'
+        4: '粉',
+        5: '彩'
     }
 
     @lazy_property
@@ -1686,6 +1718,61 @@ def experience_talent_level(self) -> Dict[int, ExperienceTalentLevel]:
                 .to_dict(lambda x: x.talent_level, lambda x: x)
             )
 
+    @lazy_property
+    def mirage_setting(self) -> Dict[int, MirageSetting]:
+        with self.dbmgr.session() as db:
+            return (
+                MirageSetting.query(db)
+                .to_dict(lambda x: x.id, lambda x: x)
+            )
+
+    @lazy_property
+    def mirage_nemesis_quest(self) -> Dict[int, Dict[int, MirageNemesisQuest]]:
+        with self.dbmgr.session() as db:
+            return (
+                MirageNemesisQuest.query(db)
+                .group_by(lambda x: x.nemesis_id)
+                .to_dict(lambda x: x.key, lambda x: x.to_dict(
+                    lambda x: x.area_level, lambda x: x
+                ))
+            )
+
+    @lazy_property
+    def mirage_floor_setting(self) -> Dict[int, MirageFloorSetting]:
+        with self.dbmgr.session() as db:
+            return (
+                MirageFloorSetting.query(db)
+                .to_dict(lambda x: x.floor_num, lambda x: x)
+            )
+
+    @lazy_property
+    def mirage_nemesis_area(self) -> Dict[int, MirageNemesisArea]:
+        with self.dbmgr.session() as db:
+            return (
+                MirageNemesisArea.query(db)
+                .to_dict(lambda x: x.nemesis_id, lambda x: x)
+            )
+
+    @lazy_property
+    def alces_story(self) -> Dict[int, AlcesStory]:
+        with self.dbmgr.session() as db:
+            return (
+                AlcesStory.query(db)
+                .to_dict(lambda x: x.story_id, lambda x: x)
+            )
+
+    @lazy_property
+    def alces_cost(self) -> Dict[ItemType, AlcesCost]:
+        with self.dbmgr.session() as db:
+            return (
+                AlcesCost.query(db)
+                .to_dict(lambda x: (x.type, x.item_id), lambda x: x)
+            )
+
+    def get_mirage_setting(self) -> MirageSetting:
+        max_id = max(self.mirage_setting.keys(), default=1)
+        return self.mirage_setting[max_id]
+
     def get_ex_equip_star_from_pt(self, id: int, pt: int) -> int:
         rarity = self.get_ex_equip_rarity(id)
         star = max([star for star, enhancement_data in self.ex_equipment_enhance_data[rarity].items() if enhancement_data.total_point <= pt], default=0)
@@ -1717,6 +1804,31 @@ def get_ex_equip_max_rank(self, id: int) -> int:
     def get_ex_equip_rarity_name(self, id: int) -> str:
         return self.ex_rarity_name[self.get_ex_equip_rarity(id)]
 
+    def get_ex_equip_sub_status(self, ex_equip_id: int, sub_status: List[ExtraEquipSubStatus]) -> Dict[int, int]:
+        data = Counter()
+        group = self.ex_equipment_sub_status_group[ex_equip_id]
+        sub_status_data = self.ex_equipment_sub_status[group.group_id]
+        for status in sub_status or []:
+            data[status.status] += sub_status_data[status.status].step_value(status.step)
+        return data
+
+    def get_ex_equip_sub_status_str(self, ex_equip_id: int, sub_status: List[ExtraEquipSubStatus]) -> str:
+        data = self.get_ex_equip_sub_status(ex_equip_id, sub_status)
+        msg = []
+        for param, count in sorted(data.items()):
+            en_name = UnitAttribute.index2name.get(eParamType(param), f"unknown_param_{param}")
+            name = UnitAttribute.index2ch.get(eParamType(param), f"未知属性{param}")
+            is_present = UnitAttribute.is_present.get(en_name, False)
+            if is_present:
+                count /= 100
+                msg.append(f"{name}x{count:.2f}%")
+            else:
+                msg.append(f"{name}x{count}")
+
+        if not msg:
+            return '空'
+        return '/'.join(msg)
+
     def get_ex_equip_rankup_cost(self, id: int, start_rank: int, end_rank: int) -> int:
         rarity = self.get_ex_equip_rarity(id)
         if rarity not in self.ex_equipment_rankup_data:
@@ -2426,6 +2538,14 @@ def calc_unit_attribute(self, unit_data: UnitData, read_story: Set[int], ex_equi
                 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)
+                if ex_equip_data.sub_status:
+                    group = self.ex_equipment_sub_status_group[ex_equip_data.ex_equipment_id]
+                    sub_status_data = db.ex_equipment_sub_status[group.group_id]
+                    for status in ex_equip_data.sub_status:
+                        value = sub_status_data[status.status].step_value(status.step)
+                        a = UnitAttribute()
+                        a.set_value(status.status, value)
+                        attr += a
                 bonus = unit_attribute.ex_equipment_mul(attr).ceil()
                 ex_attribute += bonus
         unit_attribute += ex_attribute
@@ -2491,5 +2611,9 @@ def free_gacha_ids_candidate(self):
         free_gacha_campaign = min(free_gacha_campaigns)
         return [gacha.gacha_id for gacha in self.campaign_free_gacha_data[free_gacha_campaign]]
 
+    def ex_equip_sub_status_candidate(self) -> List[int]:
+        ids = list(set(j.status for i in self.ex_equipment_sub_status.values() for j in i.values()))
+        ids.append(0)
+        return sorted(ids)
 
 db = database()

autopcr/db/methods.py

@@ -41,7 +41,8 @@ def get_unit_attribute(self, level: int) -> UnitAttribute:
         min_val = UnitAttribute.load(self, pre='default_')
         max_val = UnitAttribute.load(self, pre='max_')
         max_rank = db.get_ex_equip_max_rank(self.ex_equipment_id)
-        return min_val + (max_val - min_val) * (level / db.get_ex_equip_max_star(self.ex_equipment_id, max_rank))
+        max_star = db.get_ex_equip_max_star(self.ex_equipment_id, max_rank)
+        return (min_val + (max_val - min_val) * (level / max_star)) if max_star > 0 else min_val
 
 @method
 class EquipmentDatum(models.EquipmentDatum):
@@ -241,3 +242,7 @@ def get_another_parts(self):
         if self.another_parts_id_4 != 0:
             yield self.another_parts_id_4
 
+@method
+class ExEquipmentSubStatus(models.ExEquipmentSubStatus):
+    def step_value(self, step: int) -> int:
+        return getattr(self, f"value_{step}")

autopcr/model/custom.py

@@ -32,6 +32,26 @@ class UnitAttribute:
     energy_reduce_rate: Decimal = Decimal(0)
     accuracy: Decimal = Decimal(0)
 
+    index2ch = {
+        eParamType.HP: "血量",
+        eParamType.ATK: "物攻",
+        eParamType.MAGIC_ATK: "魔攻",
+        eParamType.DEF: "物防",
+        eParamType.MAGIC_DEF: "魔防",
+        eParamType.PHYSICAL_CRITICAL: "物爆",
+        eParamType.MAGIC_CRITICAL: "法爆",
+        eParamType.WAVE_HP_RECOVERY: "wave_hp_recovery",
+        eParamType.WAVE_ENERGY_RECOVERY: "wave_energy_recovery",
+        eParamType.DODGE: "闪避",
+        eParamType.PHYSICAL_PENETRATE: "物贯",
+        eParamType.MAGIC_PENETRATE: "法贯",
+        eParamType.LIFE_STEAL: "吸血",
+        eParamType.HP_RECOVERY_RATE: "hp_recovery_rate",
+        eParamType.ENERGY_RECOVERY_RATE: "物爆提升",
+        eParamType.ENERGY_REDUCE_RATE: "法爆提升",
+        eParamType.ACCURACY: "命中"
+    }
+
     index2name = {
         eParamType.HP: "hp",
         eParamType.ATK: "atk",