diff --git a/ArknightsUID/arkuid_utils/skd/__init__.py b/ArknightsUID/arkuid_utils/skd/__init__.py deleted file mode 100644 index 8b13789..0000000 --- a/ArknightsUID/arkuid_utils/skd/__init__.py +++ /dev/null @@ -1 +0,0 @@ - diff --git a/ArknightsUID/arkuid_utils/skd/api.py b/ArknightsUID/arkuid_utils/skd/api.py deleted file mode 100644 index e69de29..0000000 diff --git a/ArknightsUID/arkuid_utils/skd/requests.py b/ArknightsUID/arkuid_utils/skd/requests.py deleted file mode 100644 index e69de29..0000000 diff --git a/ArknightsUID/utils/models/gamedata/ActivityTable.py b/ArknightsUID/utils/models/gamedata/ActivityTable.py new file mode 100644 index 0000000..1d2cbae --- /dev/null +++ b/ArknightsUID/utils/models/gamedata/ActivityTable.py @@ -0,0 +1,2322 @@ +from pydantic import BaseModel, Field + + +class ActivityTableBasicData(BaseModel): + id_: str = Field(alias='id') + type_: str = Field(alias='type') + displayType: str | None = None + name: str + startTime: int + endTime: int + rewardEndTime: int + displayOnHome: bool + hasStage: bool + templateShopId: str | None + medalGroupId: str | None + ungroupedMedalIds: list[str] | None = None + isReplicate: bool + needFixedSync: bool + + +class ActivityTableHomeActivityConfig(BaseModel): + actId: str + isPopupAfterCheckin: bool + showTopBarMenu: bool + actTopBarColor: str | None + actTopBarText: str | None + + +class MissionDisplayRewards(BaseModel): + type_: str = Field(alias='type') + id_: str = Field(alias='id') + count: int + + +class MissionData(BaseModel): + id_: str = Field(alias='id') + sortId: int + description: str + type_: str = Field(alias='type') + itemBgType: str + preMissionIds: list[str] | None + template: str + templateType: str + param: list[str] + unlockCondition: str | None + unlockParam: list[str] | None + missionGroup: str + toPage: str | None + periodicalPoint: int + rewards: list[MissionDisplayRewards] | None + backImagePath: str | None + foldId: str | None + haveSubMissionToUnlock: bool + + +class MissionGroup(BaseModel): + id_: str = Field(alias='id') + title: str | None + type_: str = Field(alias='type') + preMissionGroup: str | None + period: list[int] | None + rewards: list[MissionDisplayRewards] | None + missionIds: list[str] + startTs: int + endTs: int + + +class DefaultZoneData(BaseModel): + zoneId: str + zoneIndex: str + zoneName: str + zoneDesc: str + itemDropList: list[str] + + +class ItemBundle(BaseModel): + id_: str = Field(alias='id') + count: int + type_: str = Field(alias='type') + + +class DefaultShopData(BaseModel): + goodId: str + slotId: int + price: int + availCount: int + overrideName: str + item: ItemBundle + + +class DefaultFirstData(BaseModel): + zoneList: list[DefaultZoneData] + shopList: list[DefaultShopData] | None + + +class DefaultCheckInDataCheckInDailyInfo(BaseModel): + itemList: list[ItemBundle] + order: int + color: int + keyItem: int + showItemOrder: int + isDynItem: bool + + +class DefaultCheckInDataDynCheckInDailyInfo(BaseModel): + questionDesc: str + preOption: str + optionList: list[str] + showDay: int + spOrderIconId: str + spOrderDesc: str + spOrderCompleteDesc: str + + +class DefaultCheckInDataOptionInfo(BaseModel): + optionDesc: str | None + showImageId1: str | None + showImageId2: str | None + optionCompleteDesc: str | None + isStart: bool + + +class DefaultCheckInDataDynamicCheckInConsts(BaseModel): + firstQuestionDesc: str + firstQuestionTipsDesc: str + expirationDesc: str + firstQuestionConfirmDesc: str + + +class DefaultCheckInDataDynamicCheckInData(BaseModel): + dynCheckInDict: dict[str, DefaultCheckInDataDynCheckInDailyInfo] + dynOptionDict: dict[str, DefaultCheckInDataOptionInfo] + dynItemDict: dict[str, list[ItemBundle]] + constData: DefaultCheckInDataDynamicCheckInConsts + initOption: str + + +class DefaultCheckInDataExtraCheckinDailyInfo(BaseModel): + order: int + blessing: str + absolutData: int + adTip: str + relativeData: int + itemList: list[ItemBundle] + + +class DefaultCheckInData(BaseModel): + checkInList: dict[str, DefaultCheckInDataCheckInDailyInfo] + apSupplyOutOfDateDict: dict[str, int] + dynCheckInData: DefaultCheckInDataDynamicCheckInData | None = None + extraCheckinList: list[DefaultCheckInDataExtraCheckinDailyInfo] | None + + +class AllPlayerCheckinDataDailyInfo(BaseModel): + itemList: list[ItemBundle] + order: int + keyItem: bool + showItemOrder: int + + +class AllPlayerCheckinDataPublicBehaviour(BaseModel): + sortId: int + allBehaviorId: str + displayOrder: int + allBehaviorDesc: str + requiringValue: int + requireRepeatCompletion: bool + rewardReceivedDesc: str + rewards: list[ItemBundle] + + +class AllPlayerCheckinDataPersonalBehaviour(BaseModel): + sortId: int + personalBehaviorId: str + displayOrder: int + requireRepeatCompletion: bool + desc: str + + +class AllPlayerCheckinDataConstData(BaseModel): + characterName: str + skinName: str + + +class AllPlayerCheckinData(BaseModel): + checkInList: dict[str, AllPlayerCheckinDataDailyInfo] + apSupplyOutOfDateDict: dict[str, int] + pubBhvs: dict[str, AllPlayerCheckinDataPublicBehaviour] + personalBhvs: dict[str, AllPlayerCheckinDataPersonalBehaviour] + constData: AllPlayerCheckinDataConstData + + +class VersusCheckInDataDailyInfo(BaseModel): + rewardList: list[ItemBundle] + order: int + + +class VersusCheckInDataVoteData(BaseModel): + plSweetNum: int + plSaltyNum: int + plTaste: int + + +class VersusCheckInDataTasteInfoData(BaseModel): + plTaste: int + tasteType: str + tasteText: str + + +class VersusCheckInDataTasteRewardData(BaseModel): + tasteType: str + rewardItem: ItemBundle + + +class VersusCheckInData(BaseModel): + checkInDict: dict[str, VersusCheckInDataDailyInfo] + voteTasteList: list[VersusCheckInDataVoteData] + tasteInfoDict: dict[str, VersusCheckInDataTasteInfoData] + tasteRewardDict: dict[str, VersusCheckInDataTasteRewardData] + apSupplyOutOfDateDict: dict[str, int] + versusTotalDays: int + ruleText: str + + +class Act3D0DataCampBasicInfo(BaseModel): + campId: str + campName: str + campDesc: str + rewardDesc: str | None + + +class Act3D0DataLimitedPoolDetailInfoPoolItemInfo(BaseModel): + goodId: str + itemInfo: ItemBundle | None + goodType: str + perCount: int + totalCount: int + weight: int + type_: str = Field(alias='type') + orderId: int + + +class Act3D0DataLimitedPoolDetailInfo(BaseModel): + poolId: str + poolItemInfo: list[Act3D0DataLimitedPoolDetailInfoPoolItemInfo] + + +class Act3D0DataInfinitePoolDetailInfoPoolItemInfo(BaseModel): + goodId: str + itemInfo: ItemBundle + goodType: str + perCount: int + weight: int + type_: str = Field(alias='type') + orderId: int + + +class Act3D0DataInfinitePoolDetailInfo(BaseModel): + poolId: str + poolItemInfo: list[Act3D0DataInfinitePoolDetailInfoPoolItemInfo] + + +class Act3D0DataInfinitePoolPercent(BaseModel): + percentDict: dict[str, int] + + +class Act3D0DataCampItemMapInfo(BaseModel): + goodId: str + itemDict: dict[str, ItemBundle] + + +class Act3D0DataClueInfo(BaseModel): + itemId: str + campId: str + orderId: int + imageId: str + + +class Act3D0DataMileStoneInfo(BaseModel): + mileStoneId: str + orderId: int + mileStoneType: int + normalItem: ItemBundle | None + specialItemDict: dict[str, ItemBundle] + tokenNum: int + + +class Act3D0DataGachaBoxInfo(BaseModel): + gachaBoxId: str + boxType: str + keyGoodId: str | None + tokenId: ItemBundle + tokenNumOnce: int + unlockImg: str | None + nextGachaBoxInfoId: str | None + + +class Act3D0DataCampInfo(BaseModel): + campId: str + campChineseName: str + + +class Act3D0DataZoneDescInfo(BaseModel): + zoneId: str + lockedText: str | None + + +class CommonFavorUpInfo(BaseModel): + charId: str + displayStartTime: int + displayEndTime: int + + +class Act3D0Data(BaseModel): + campBasicInfo: dict[str, Act3D0DataCampBasicInfo] + limitedPoolList: dict[str, Act3D0DataLimitedPoolDetailInfo] + infinitePoolList: dict[str, Act3D0DataInfinitePoolDetailInfo] + infinitePercent: dict[str, Act3D0DataInfinitePoolPercent] | None + campItemMapInfo: dict[str, Act3D0DataCampItemMapInfo] + clueInfo: dict[str, Act3D0DataClueInfo] + mileStoneInfo: list[Act3D0DataMileStoneInfo] + mileStoneTokenId: str + coinTokenId: str + etTokenId: str + gachaBoxInfo: list[Act3D0DataGachaBoxInfo] + campInfo: dict[str, Act3D0DataCampInfo] | None + zoneDesc: dict[str, Act3D0DataZoneDescInfo] + favorUpList: dict[str, CommonFavorUpInfo] | None + + +class Act4D0DataMileStoneItemInfo(BaseModel): + mileStoneId: str + orderId: int + tokenNum: int + item: ItemBundle + + +class Act4D0DataMileStoneStoryInfo(BaseModel): + mileStoneId: str + orderId: int + tokenNum: int + storyKey: str + desc: str + + +class Act4D0DataStoryInfo(BaseModel): + storyKey: str + storyId: str + storySort: str + storyName: str + lockDesc: str + storyDesc: str + + +class Act4D0DataStageJumpInfo(BaseModel): + stageKey: str + zoneId: str + stageId: str + unlockDesc: str + lockDesc: str + + +class Act4D0Data(BaseModel): + mileStoneItemList: list[Act4D0DataMileStoneItemInfo] + mileStoneStoryList: list[Act4D0DataMileStoneStoryInfo] + storyInfoList: list[Act4D0DataStoryInfo] + stageInfo: list[Act4D0DataStageJumpInfo] + tokenItem: ItemBundle + charStoneId: str + apSupplyOutOfDateDict: dict[str, int] + extraDropZones: list[str] + + +class MileStoneInfo(BaseModel): + mileStoneId: str + orderId: int + tokenNum: int + mileStoneType: int + normalItem: ItemBundle + IsBonus: int + + +class Act5D0DataZoneDescInfo(BaseModel): + zoneId: str + lockedText: str | None + + +class Act5D0DataMissionExtraInfo(BaseModel): + difficultLevel: int + levelDesc: str + sortId: int + + +class Act5D0Data(BaseModel): + mileStoneInfo: list[MileStoneInfo] + mileStoneTokenId: str + zoneDesc: dict[str, Act5D0DataZoneDescInfo] + missionExtraList: dict[str, Act5D0DataMissionExtraInfo] + spReward: str + + +class Act5D1DataRuneStageData(BaseModel): + stageId: str + levelId: str + code: str + name: str + loadingPicId: str + description: str + picId: str + + +class Act5D1DataRuneRecurrentStateData(BaseModel): + runeReId: str + stageId: str + slotId: int + startTime: int + endTime: int + runeList: list[str] + isAvail: bool + warningPoint: int + + +class Act5D1DataRuneUnlockData(BaseModel): + runeId: str + priceItem: ItemBundle + runeName: str + bgPic: str + runeDesc: str + sortId: int + iconId: str + + +class Act5D1DataRuneReleaseData(BaseModel): + runeId: str + stageId: str + releaseTime: int + + +class Act5D1DataShopGood(BaseModel): + goodId: str + slotId: int + price: int + availCount: int + item: ItemBundle + progressGoodId: str + goodType: str + + +class Act5D1DataProgessGoodItem(BaseModel): + order: int + price: int + displayName: str + item: ItemBundle + + +class Act5D1DataShopData(BaseModel): + shopGoods: dict[str, Act5D1DataShopGood] + progressGoods: dict[str, list[Act5D1DataProgessGoodItem]] + + +class RuneDataSelector(BaseModel): + professionMask: int | str + buildableMask: int + charIdFilter: list[str] | None + enemyIdFilter: list[str] | None + enemyIdExcludeFilter: list[str] | None + skillIdFilter: list[str] | None + tileKeyFilter: list[str] | None + groupTagFilter: list[str] | None + filterTagFilter: list[str] | None + + +class Blackboard(BaseModel): + key: str + value: float | None = None + valueStr: str | None = None + + +class RuneData(BaseModel): + key: str + selector: RuneDataSelector + blackboard: list[Blackboard] + + +class RuneTablePackedRuneData(BaseModel): + id_: str = Field(alias='id') + points: float + mutexGroupKey: str | None + description: str + runes: list[RuneData] + + +class RuneTableRuneStageExtraData(BaseModel): + stageId: str + runes: list[RuneTablePackedRuneData] + + +class Act5D1Data(BaseModel): + stageCommonData: list[Act5D1DataRuneStageData] + runeStageData: list[Act5D1DataRuneRecurrentStateData] + runeUnlockDict: dict[str, list[Act5D1DataRuneUnlockData]] + runeReleaseData: list[Act5D1DataRuneReleaseData] + missionData: list[MissionData] + missionGroup: list[MissionGroup] + useBenefitMissionDict: dict[str, bool] + shopData: Act5D1DataShopData + coinItemId: str + ptItemId: str + stageRune: list[RuneTableRuneStageExtraData] + showRuneMissionList: list[str] + + +class ActivityCollectionDataCollectionInfo(BaseModel): + id_: int = Field(alias='id') + itemType: str + itemId: str + itemCnt: int + pointId: str + pointCnt: int + isBonus: bool + pngName: str | None + pngSort: int + isShow: bool + showInList: bool + showIconBG: bool + + +class ActivityCollectionData(BaseModel): + collections: list[ActivityCollectionDataCollectionInfo] + apSupplyOutOfDateDict: dict[str, int] + + +class Act9D0DataZoneDescInfo(BaseModel): + zoneId: str + unlockText: str + displayStartTime: int + + +class Act9D0DataFavorUpInfo(BaseModel): + charId: str + displayStartTime: int + displayEndTime: int + + +class Act9D0DataSubMissionInfo(BaseModel): + missionId: str + missionTitle: str + sortId: int + missionIndex: str + + +class Act9D0DataActivityNewsStyleInfo(BaseModel): + typeId: str + typeName: str + typeLogo: str + typeMainLogo: str + + +class Act9D0DataActivityNewsLine(BaseModel): + lineType: int + content: str + + +class Act9D0DataActivityNewsInfo(BaseModel): + newsId: str + newsSortId: int + styleInfo: Act9D0DataActivityNewsStyleInfo + preposedStage: str | None + titlePic: str + newsTitle: str + newsInfShow: int + newsFrom: str + newsText: str + newsParam1: int + newsParam2: int + newsParam3: float + newsLines: list[Act9D0DataActivityNewsLine] + + +class Act9D0DataActivityNewsServerInfo(BaseModel): + newsId: str + preposedStage: str + + +class Act9D0Data(BaseModel): + tokenItemId: str + zoneDescList: dict[str, Act9D0DataZoneDescInfo] + favorUpList: dict[str, Act9D0DataFavorUpInfo] + subMissionInfo: dict[str, Act9D0DataSubMissionInfo] | None + hasSubMission: bool + apSupplyOutOfDateDict: dict[str, int] + newsInfoList: dict[str, Act9D0DataActivityNewsInfo] | None + newsServerInfoList: dict[str, Act9D0DataActivityNewsServerInfo] | None + miscHub: dict[str, str] + + +class Act12SideDataConstData(BaseModel): + recycleRewardThreshold: int + charmRepoUnlockStageId: str + recycleLowThreshold: int + recycleMediumThreshold: int + recycleHighThreshold: int + autoGetCharmId: str + fogStageId: str + fogUnlockStageId: str + fogUnlockTs: int + fogUnlockDesc: str + + +class Act12SideDataZoneAdditionData(BaseModel): + zoneId: str + unlockText: str + zoneClass: str + + +class Act12SideDataMissionDescInfo(BaseModel): + zoneClass: str + specialMissionDesc: str + needLock: bool + unlockHint: str | None + unlockStage: str | None + + +class Act12SideDataMileStoneInfo(BaseModel): + mileStoneId: str + orderId: int + tokenNum: int + item: ItemBundle + isPrecious: bool + mileStoneStage: int + + +class Act12SideDataPhotoInfo(BaseModel): + picId: str + picName: str + mileStoneId: str + picDesc: str + jumpStageId: str | None + + +class Act12SideDataRecycleDialogData(BaseModel): + dialogType: str + dialog: str + dialogExpress: str + + +class Act12SideData(BaseModel): + constData: Act12SideDataConstData + zoneAdditionDataList: list[Act12SideDataZoneAdditionData] + missionDescList: dict[str, Act12SideDataMissionDescInfo] + mileStoneInfoList: list[Act12SideDataMileStoneInfo] + photoList: dict[str, Act12SideDataPhotoInfo] + recycleDialogDict: dict[str, list[Act12SideDataRecycleDialogData]] + + +class Act13SideDataConstData(BaseModel): + prestigeDescList: list[str] + dailyRandomCount: list[list[int]] | None + dailyWeightInitial: int + dailyWeightComplete: int + agendaRecover: int + agendaMax: int + agendaHint: int + missionPoolMax: int + missionBoardMax: int + itemRandomList: list[ItemBundle] + unlockPrestigeCond: str + hotSpotShowFlag: int + + +class Act13SideDataPrestigeData(BaseModel): + rank: str + threshold: int + reward: ItemBundle | None + newsCount: int + archiveCount: int + avgCount: int + + +class Act13SideDataLongTermMissionGroupData(BaseModel): + groupId: str + groupName: str + orgId: str + missionList: list[str] + + +class Act13SideDataOrgSectionData(BaseModel): + sectionName: str + sortId: int + groupData: Act13SideDataLongTermMissionGroupData + + +class Act13SideDataOrgData(BaseModel): + orgId: str + orgName: str + orgEnName: str + openTime: int + principalIdList: list[str] + prestigeList: list[Act13SideDataPrestigeData] + agendaCount2PrestigeItemMap: dict[str, ItemBundle] + orgSectionList: list[Act13SideDataOrgSectionData] + prestigeItem: ItemBundle + + +class Act13SideDataPrincipalData(BaseModel): + principalId: str + principalName: str + principalEnName: str + avgCharId: str + principalDescList: list[str] + + +class Act13SideDataLongTermMissionData(BaseModel): + missionName: str + groupId: str + principalId: str + finishedDesc: str + sectionSortId: int + haveStageBtn: bool + jumpStageId: str | None + + +class Act13SideDataDailyMissionData(BaseModel): + id_: str = Field(alias='id') + sortId: int + description: str + missionName: str + template: str + templateType: str + param: list[str] + rewards: list[MissionDisplayRewards] | None + orgPool: list[str] | None + rewardPool: list[str] | None + jumpStageId: str + agendaCount: int + + +class Act13SideDataDailyMissionRewardGroupData(BaseModel): + groupId: str + rewards: list[ItemBundle] + + +class Act13SideDataArchiveItemUnlockData(BaseModel): + itemId: str + itemType: str + unlockCondition: str + param1: str | None + param2: str | None + + +class ActivityTableActHiddenAreaPreposeStageData(BaseModel): + stageId: str + unlockRank: int + + +class ActivityTableActivityHiddenAreaData(BaseModel): + name: str + desc: str + preposedStage: list[ActivityTableActHiddenAreaPreposeStageData] + preposedTime: int + + +class Act13SideDataZoneAdditionData(BaseModel): + unlockText: str + zoneClass: str + + +class Act13SideData(BaseModel): + constData: Act13SideDataConstData + orgDataMap: dict[str, Act13SideDataOrgData] + principalDataMap: dict[str, Act13SideDataPrincipalData] + longTermMissionDataMap: dict[str, Act13SideDataLongTermMissionData] + dailyMissionDataList: list[Act13SideDataDailyMissionData] + dailyRewardGroupDataMap: dict[str, Act13SideDataDailyMissionRewardGroupData] + archiveItemUnlockData: dict[str, Act13SideDataArchiveItemUnlockData] + hiddenAreaData: dict[str, ActivityTableActivityHiddenAreaData] + zoneAddtionDataMap: dict[str, Act13SideDataZoneAdditionData] + + +class Act17sideDataPlaceData(BaseModel): + placeId: str + placeDesc: str + lockEventId: str | None + zoneId: str + visibleCondType: str | None = None + visibleParams: list[str] | None = None + + +class Act17sideDataNodeInfoData(BaseModel): + nodeId: str + nodeType: str + sortId: int + placeId: str + isPointPlace: bool + chapterId: str + trackPointType: str + unlockCondType: str | None = None + unlockParams: list[str] | None = None + + +class Act17sideDataLandmarkNodeData(BaseModel): + nodeId: str + landmarkId: str + landmarkName: str + landmarkPic: str | None + landmarkSpecialPic: str + landmarkDesList: list[str] + + +class Act17sideDataStoryNodeData(BaseModel): + nodeId: str + storyId: str + storyKey: str + storyName: str + storyPic: str | None + confirmDes: str + storyDesList: list[str] + + +class Act17sideDataBattleNodeData(BaseModel): + nodeId: str + stageId: str + + +class Act17sideDataTreasureNodeData(BaseModel): + nodeId: str + treasureId: str + treasureName: str + treasurePic: str | None + treasureSpecialPic: str | None + endEventId: str + confirmDes: str + treasureDesList: list[str] + missionIdList: list[str] + rewardList: list[ItemBundle] + treasureType: str + + +class Act17sideDataEventNodeData(BaseModel): + nodeId: str + eventId: str + endEventId: str + + +class Act17sideDataTechNodeData(BaseModel): + nodeId: str + techTreeId: str + techTreeName: str + techPic: str | None + techSpecialPic: str + endEventId: str + confirmDes: str + techDesList: list[str] + missionIdList: list[str] + + +class Act17sideDataChoiceNodeOptionData(BaseModel): + canRepeat: bool + eventId: str + des: str + unlockDes: str | None + unlockCondType: str | None = None + unlockParams: str | None = None + + +class Act17sideDataChoiceNodeData(BaseModel): + nodeId: str + choicePic: str | None + isDisposable: bool + choiceSpecialPic: str | None + choiceName: str + choiceDesList: list[str] + cancelDes: str + choiceNum: int + optionList: list[Act17sideDataChoiceNodeOptionData] + + +class Act17sideDataEventData(BaseModel): + eventId: str + eventPic: str | None + eventSpecialPic: str | None + eventTitle: str + eventDesList: list[str] + + +class Act17sideDataArchiveItemUnlockData(BaseModel): + itemId: str + itemType: str + unlockCondition: str + nodeId: str | None + stageParam: str + chapterId: str | None + + +class Act17sideDataTechTreeData(BaseModel): + techTreeId: str + sortId: int + techTreeName: str + defaultBranchId: str + lockDes: str + + +class Act17sideDataTechTreeBranchData(BaseModel): + techTreeBranchId: str + techTreeId: str + techTreeBranchName: str + techTreeBranchIcon: str + techTreeBranchDesc: str + runeData: RuneTablePackedRuneData + + +class Act17sideDataMainlineChapterData(BaseModel): + chapterId: str + chapterDes: str + chapterIcon: str + unlockDes: str + id_: str = Field(alias='id') + + +class Act17sideDataMainlineData(BaseModel): + mainlineId: str + nodeId: str | None + sortId: int + missionSort: str + zoneId: str + mainlineDes: str + focusNodeId: str | None + + +class Act17sideDataZoneData(BaseModel): + zoneId: str + unlockPlaceId: str | None + unlockText: str + + +class Act17sideDataConstData(BaseModel): + techTreeUnlockEventId: str + + +class Act17sideData(BaseModel): + placeDataMap: dict[str, Act17sideDataPlaceData] + nodeInfoDataMap: dict[str, Act17sideDataNodeInfoData] + landmarkNodeDataMap: dict[str, Act17sideDataLandmarkNodeData] + storyNodeDataMap: dict[str, Act17sideDataStoryNodeData] + battleNodeDataMap: dict[str, Act17sideDataBattleNodeData] + treasureNodeDataMap: dict[str, Act17sideDataTreasureNodeData] + eventNodeDataMap: dict[str, Act17sideDataEventNodeData] + techNodeDataMap: dict[str, Act17sideDataTechNodeData] + choiceNodeDataMap: dict[str, Act17sideDataChoiceNodeData] + eventDataMap: dict[str, Act17sideDataEventData] + archiveItemUnlockDataMap: dict[str, Act17sideDataArchiveItemUnlockData] + techTreeDataMap: dict[str, Act17sideDataTechTreeData] + techTreeBranchDataMap: dict[str, Act17sideDataTechTreeBranchData] + mainlineChapterDataMap: dict[str, Act17sideDataMainlineChapterData] + mainlineDataMap: dict[str, Act17sideDataMainlineData] + zoneDataList: list[Act17sideDataZoneData] + constData: Act17sideDataConstData + + +class Act20SideDataResidentCartData(BaseModel): + residentPic: str + + +class Act20SideData(BaseModel): + zoneAdditionDataMap: dict[str, str] + residentCartDatas: dict[str, Act20SideDataResidentCartData] + + +class Act21SideDataZoneAddtionData(BaseModel): + zoneId: str + unlockText: str + stageUnlockText: str | None + entryId: str + + +class Act21SideDataConstData(BaseModel): + lineConnectZone: str + + +class Act21SideData(BaseModel): + zoneAdditionDataMap: dict[str, Act21SideDataZoneAddtionData] + constData: Act21SideDataConstData + + +class ActivityLoginData(BaseModel): + description: str + itemList: list[ItemBundle] + apSupplyOutOfDateDict: dict[str, int] + + +class ActivitySwitchCheckinConstData(BaseModel): + activityTime: str + activityRule: str + + +class ActivitySwitchCheckinData(BaseModel): + constData: ActivitySwitchCheckinConstData + rewards: dict[str, list[ItemBundle]] + apSupplyOutOfDateDict: dict[str, int] + rewardsTitle: dict[str, str] + + +class ActivityMiniStoryDataZoneDescInfo(BaseModel): + zoneId: str + unlockText: str + + +class ActivityMiniStoryDataFavorUpInfo(BaseModel): + charId: str + displayStartTime: int + displayEndTime: int + + +class ActivityMiniStoryData(BaseModel): + tokenItemId: str + zoneDescList: dict[str, ActivityMiniStoryDataZoneDescInfo] + favorUpList: dict[str, ActivityMiniStoryDataFavorUpInfo] + extraDropZoneList: list[str] + + +class ActivityRoguelikeDataOuterBuffUnlockInfo(BaseModel): + buffLevel: int + name: str + iconId: str + description: str + usage: str + itemId: str + itemType: str + cost: int + + +class ActivityRoguelikeDataOuterBuffUnlockInfoData(BaseModel): + buffId: str + buffUnlockInfos: dict[str, ActivityRoguelikeDataOuterBuffUnlockInfo] + + +class ActivityRoguelikeDataMileStoneItemInfo(BaseModel): + mileStoneId: str + orderId: int + tokenNum: int + item: ItemBundle + + +class ActivityTableCustomUnlockCond(BaseModel): + actId: str | None + stageId: str + + +class ActivityRoguelikeData(BaseModel): + outBuffInfos: dict[str, ActivityRoguelikeDataOuterBuffUnlockInfoData] + apSupplyOutOfDateDict: dict[str, int] + outerBuffToken: str + shopToken: str + relicUnlockTime: int + milestoneTokenRatio: float + outerBuffTokenRatio: float + relicTokenRatio: float + relicOuterBuffTokenRatio: float + reOpenCoolDown: int + tokenItem: ItemBundle + charStoneId: str + milestone: list[ActivityRoguelikeDataMileStoneItemInfo] + unlockConds: list[ActivityTableCustomUnlockCond] + + +class ActivityMultiplayDataStageData(BaseModel): + stageId: str + levelId: str + groupId: str + difficulty: str + loadingPicId: str + dangerLevel: str + unlockConds: list[str] + + +class ActivityMultiplayDataStageGroupData(BaseModel): + groupId: str + sortId: int + code: str + name: str + description: str + + +class ActivityMultiplayDataMissionExtraData(BaseModel): + missionId: str + isHard: bool + + +class ActivityMultiplayDataRoomMessageData(BaseModel): + sortId: int + picId: str + + +class ActivityMultiplayDataConstData(BaseModel): + linkActId: str + maxRetryTimeInTeamRoom: int + maxRetryTimeInMatchRoom: int + maxRetryTimeInBattle: int + maxOperatorDelay: float + maxPlaySpeed: float + delayTimeNeedTip: float + blockTimeNeedTip: float + hideTeamNameFlag: bool + settleRetryTime: float + + +class ActivityMultiplayData(BaseModel): + stages: dict[str, ActivityMultiplayDataStageData] + stageGroups: dict[str, ActivityMultiplayDataStageGroupData] + missionExtras: dict[str, ActivityMultiplayDataMissionExtraData] + roomMessages: list[ActivityMultiplayDataRoomMessageData] + constData: ActivityMultiplayDataConstData + unlockConds: list[ActivityTableCustomUnlockCond] + + +class ActivityInterlockDataStageAdditionData(BaseModel): + stageId: str + stageType: str + lockStageKey: str | None + lockSortIndex: int + + +class ActivityInterlockDataTreasureMonsterData(BaseModel): + lockStageKey: str + enemyId: str + enemyName: str + enemyIcon: str + enemyDescription: str + + +class SharedCharDataCharEquipInfo(BaseModel): + hide: int + locked: bool | int + level: int + + +class SharedCharDataSharedCharSkillData(BaseModel): + completeUpgradeTime: int | None = None + unlock: bool | int | None = None + skillId: str + specializeLevel: int + state: int | None = None + + +class SharedCharDataTmplData(BaseModel): + skinId: str + defaultSkillIndex: int + skills: list[SharedCharDataSharedCharSkillData] + currentEquip: str | None + equip: dict[str, SharedCharDataSharedCharSkillData] | None = None + + +class SharedCharData(BaseModel): + charId: str + potentialRank: int + skillIndex: int | None = None + skinId: str | None = None + skin: str | None = None + skills: list[SharedCharDataSharedCharSkillData] | None = None + currentEquip: str | None = Field(alias='currentEquip', default=None) + equips: dict[str, SharedCharDataCharEquipInfo] | None = Field(alias='equip', default={}) + mainSkillLvl: int + evolvePhase: int + level: int + favorPoint: int + crisisRecord: dict[str, int] | None = None + currentTmpl: str | None | None = None + tmpl: dict[str, SharedCharDataTmplData] | None = None + + +class ActivityInterlockDataMileStoneItemInfo(BaseModel): + mileStoneId: str + orderId: int + tokenNum: int + item: ItemBundle + + +class ActivityInterlockDataFinalStageProgressData(BaseModel): + stageId: str + killCnt: int + apCost: int + favor: int + exp: int + gold: int + + +class ActivityInterlockData(BaseModel): + stageAdditionInfoMap: dict[str, ActivityInterlockDataStageAdditionData] + treasureMonsterMap: dict[str, ActivityInterlockDataTreasureMonsterData] + specialAssistData: SharedCharData + mileStoneItemList: list[ActivityInterlockDataMileStoneItemInfo] + finalStageProgressMap: dict[str, list[ActivityInterlockDataFinalStageProgressData]] + + +class ActivityBossRushDataZoneAdditionData(BaseModel): + unlockText: str + displayStartTime: int + + +class ActivityBossRushDataBossRushStageGroupData(BaseModel): + stageGroupId: str + sortId: int + stageGroupName: str + stageIdMap: dict[str, str] + waveBossInfo: list[list[str]] + normalStageCount: int + isHardStageGroup: bool + unlockCondtion: str | None + + +class ActivityBossRushDataBossRushStageAdditionData(BaseModel): + stageId: str + stageType: str + stageGroupId: str + teamIdList: list[str] + unlockText: str | None + + +class ActivityBossRushDataDisplayDetailRewards(BaseModel): + occPercent: int + dropCount: int + type_: str = Field(alias='type') + id_: str = Field(alias='id') + dropType: int + + +class ActivityBossRushDataBossRushDropInfo(BaseModel): + clearWaveCount: int + displayDetailRewards: list[ActivityBossRushDataDisplayDetailRewards] + firstPassRewards: list[ItemBundle] + passRewards: list[ItemBundle] + + +class ActivityBossRushDataBossRushMissionAdditionData(BaseModel): + missionId: str + isRelicTask: bool + + +class ActivityBossRushDataBossRushTeamData(BaseModel): + teamId: str + teamName: str + charIdList: list[str] + teamBuffName: str | None + teamBuffDes: str | None + teamBuffId: str | None + maxCharNum: int + runeData: RuneTablePackedRuneData | None + + +class ActivityBossRushDataRelicData(BaseModel): + relicId: str + sortId: int + name: str + icon: str + relicTaskId: str + + +class ActivityBossRushDataRelicLevelInfo(BaseModel): + level: int + effectDesc: str + runeData: RuneTablePackedRuneData + + +class ActivityBossRushDataRelicLevelInfoData(BaseModel): + relicId: str + levelInfos: dict[str, ActivityBossRushDataRelicLevelInfo] + + +class ActivityBossRushDataBossRushMileStoneData(BaseModel): + mileStoneId: str + mileStoneLvl: int + needPointCnt: int + rewardItem: ItemBundle + + +class ActivityBossRushDataConstData(BaseModel): + maxProvidedCharNum: int + textMilestoneItemLevelDesc: str + milestonePointId: str + relicUpgradeItemId: str + defaultRelictList: list[str] + rewardSkinId: str + + +class ActivityBossRushData(BaseModel): + zoneAdditionDataMap: dict[str, ActivityBossRushDataZoneAdditionData] + stageGroupMap: dict[str, ActivityBossRushDataBossRushStageGroupData] + stageAdditionDataMap: dict[str, ActivityBossRushDataBossRushStageAdditionData] + stageDropDataMap: dict[str, dict[str, ActivityBossRushDataBossRushDropInfo]] + missionAdditionDataMap: dict[str, ActivityBossRushDataBossRushMissionAdditionData] + teamDataMap: dict[str, ActivityBossRushDataBossRushTeamData] + relicList: list[ActivityBossRushDataRelicData] + relicLevelInfoDataMap: dict[str, ActivityBossRushDataRelicLevelInfoData] + mileStoneList: list[ActivityBossRushDataBossRushMileStoneData] + bestWaveRuneList: list[RuneTablePackedRuneData] + constData: ActivityBossRushDataConstData + + +class ActivityFloatParadeDataConstData(BaseModel): + cityName: str + lowStandard: float + variationTitle: str + ruleDesc: str + + +class ActivityFloatParadeDataDailyData(BaseModel): + dayIndex: int + dateName: str + placeName: str + placeEnName: str + placePic: str + eventGroupId: int + extReward: ItemBundle | None + + +class ActivityFloatParadeDataRewardPool(BaseModel): + grpId: int + id_: int = Field(alias='id') + type_: str = Field(alias='type') + name: str + desc: str | None + reward: ItemBundle + + +class ActivityFloatParadeDataTactic(BaseModel): + id_: int = Field(alias='id') + name: str + packName: str + briefName: str + rewardVar: dict[str, float] + + +class ActivityFloatParadeDataGroupData(BaseModel): + groupId: int + name: str + startDay: int + endDay: int + extRewardDay: int + extRewardCount: int + + +class ActivityFloatParadeData(BaseModel): + constData: ActivityFloatParadeDataConstData + dailyDataDic: list[ActivityFloatParadeDataDailyData] + rewardPools: dict[str, dict[str, ActivityFloatParadeDataRewardPool]] + tacticList: list[ActivityFloatParadeDataTactic] + groupInfos: dict[str, ActivityFloatParadeDataGroupData] + + +class ActSandboxDataMilestoneData(BaseModel): + milestoneId: str + orderId: int + tokenId: str + tokenNum: int + item: ItemBundle + isPrecious: bool + + +class ActSandboxData(BaseModel): + milestoneDataList: list[ActSandboxDataMilestoneData] + milestoneTokenId: str + + +class ActivityMainlineBuffDataMissionGroupData(BaseModel): + id_: str = Field(alias='id') + bindBanner: str + sortId: int + zoneId: str + missionIdList: list[str] + + +class ActivityMainlineBuffDataPeriodDataStepData(BaseModel): + isBlock: bool + favorUpDesc: str | None + unlockDesc: str | None + bindStageId: str | None + blockDesc: str | None + + +class ActivityMainlineBuffDataPeriodData(BaseModel): + id_: str = Field(alias='id') + startTime: int + endTime: int + favorUpCharDesc: str + favorUpImgName: str + newChapterImgName: str + newChapterZoneId: str | None + stepDataList: list[ActivityMainlineBuffDataPeriodDataStepData] + + +class ActivityMainlineBuffDataConstData(BaseModel): + favorUpStageRange: str + + +class ActivityMainlineBuffData(BaseModel): + missionGroupList: dict[str, ActivityMainlineBuffDataMissionGroupData] + periodDataList: list[ActivityMainlineBuffDataPeriodData] + apSupplyOutOfDateDict: dict[str, int] + constData: ActivityMainlineBuffDataConstData + + +class Act24SideDataToolData(BaseModel): + toolId: str + sortId: int + toolName: str + toolDesc: str + toolIcon1: str + toolIcon2: str + toolUnlockDesc: str + toolBuffId: str + runeData: RuneTablePackedRuneData + + +class Act24SideDataMealData(BaseModel): + mealId: str + sortId: int + mealName: str + mealEffectDesc: str + mealDesc: str + mealIcon: str + mealCost: int + mealRewardAP: int + mealRewardItemInfo: ItemBundle + + +class Act24SideDataMeldingItemData(BaseModel): + meldingId: str + sortId: int + meldingPrice: int + rarity: int + + +class Act24SideDataMeldingGachaBoxData(BaseModel): + gachaBoxId: str + gachaSortId: int + gachaIcon: str + gachaBoxName: str + gachaCost: int + gachaTimesLimit: int + themeColor: str + remainItemBgColor: str + + +class Act24SideDataMeldingGachaBoxGoodData(BaseModel): + goodId: str + gachaBoxId: str + orderId: int + itemId: str + itemType: str + displayType: str + perCount: int + totalCount: int + gachaType: str + + +class Act24SideDataZoneAdditionData(BaseModel): + zoneId: str + zoneIcon: str + unlockText: str + displayTime: str + + +class QuestStageData(BaseModel): + stageId: str + stageRank: int + sortId: int + isUrgentStage: bool + isDragonStage: bool + + +class Act24SideDataMissionExtraData(BaseModel): + taskTypeName: str + taskTypeIcon: str + taskType: str + taskTitle: str + taskClient: str + taskClientDesc: str + + +class WeightItemBundle(BaseModel): + id_: str = Field(alias='id') + type_: str = Field(alias='type') + dropType: str + count: int + weight: int + + +class StageDataDisplayRewards(BaseModel): + type_: str = Field(alias='type') + id_: str = Field(alias='id') + dropType: int + + +class StageDataDisplayDetailRewards(BaseModel): + occPercent: int + type_: str = Field(alias='type') + id_: str = Field(alias='id') + dropType: int + + +class StageDataStageDropInfo(BaseModel): + firstPassRewards: list[ItemBundle] | None + firstCompleteRewards: list[ItemBundle] | None + passRewards: list[list[WeightItemBundle]] | None + completeRewards: list[list[WeightItemBundle]] | None + displayRewards: list[StageDataDisplayRewards] + displayDetailRewards: list[StageDataDisplayDetailRewards] + + +class Act24SideDataConstData(BaseModel): + stageUnlockToolDesc: str + mealLackMoney: str + mealDayTimesLimit: int + toolMaximum: int + stageCanNotUseToTool: list[str] + gachaExtraProb: float | int + + +class Act24SideData(BaseModel): + toolDataList: dict[str, Act24SideDataToolData] + mealDataList: dict[str, Act24SideDataMealData] + meldingDict: dict[str, Act24SideDataMeldingItemData] + meldingGachaBoxDataList: dict[str, Act24SideDataMeldingGachaBoxData] + meldingGachaBoxGoodDataMap: dict[str, list[Act24SideDataMeldingGachaBoxGoodData]] + mealWelcomeTxtDataMap: dict[str, str] + zoneAdditionDataMap: dict[str, Act24SideDataZoneAdditionData] + questStageList: list[QuestStageData] + missionDataList: dict[str, Act24SideDataMissionExtraData] + meldingDropDict: dict[str, StageDataStageDropInfo] + stageMapPreviewDict: dict[str, list[str]] + constData: Act24SideDataConstData + + +class Act25SideDataConstData(BaseModel): + getDailyCount: int + costName: str + costDesc: str + costLimit: int + rewardLimit: int + researchUnlockText: str + harvestReward: ItemBundle + costCount: int + costCountLimit: int + basicProgress: int + harvestDesc: str + + +class Act25SideDataZoneDescInfo(BaseModel): + zoneId: str + unlockText: str + displayStartTime: int + + +class Act25SideDataArchiveItemData(BaseModel): + itemId: str + itemType: int + itemUnlockType: int + itemUnlockParam: str + unlockDesc: str | None + iconId: str | None + itemName: str + + +class Act25SideDataArchiveMapInfoData(BaseModel): + objectId: str + type_: int = Field(alias='type') + numberId: str + areaId: str + sortId: int + position: int + hasDot: bool + + +class Act25SideDataAreaInfoData(BaseModel): + areaId: str + sortId: int + areaIcon: str + areaName: str + unlockText: str + preposedStage: str + areaInitialDesc: str + areaEndingDesc: str + areaEndingAud: str + reward: ItemBundle + finalId: str + + +class Act25SideDataAreaMissionData(BaseModel): + id_: str = Field(alias='id') + areaId: str + preposedMissionId: str | None + sortId: int + isZone: bool + stageId: str + costCount: int + transform: int + progress: int + progressPicId: str + template: str | None + templateType: int + desc: str + param: list[str] | None + rewards: list[ItemBundle] + archiveItems: list[str] + + +class Act25SideDataBattlePerformanceData(BaseModel): + itemId: str + sortId: int + itemName: str + itemIcon: str + itemDesc: str + itemTechType: str + runeData: RuneTablePackedRuneData + + +class Act25SideDataKeyData(BaseModel): + keyId: str + keyName: str + keyIcon: str + toastText: str + + +class Act25SideDataFogUnlockData(BaseModel): + lockId: str + lockedCollectionIconId: str + unlockedCollectionIconId: str + + +class Act25SideDataDailyFarmData(BaseModel): + transform: int + unitTime: int + + +class Act25SideData(BaseModel): + tokenItemId: str + constData: Act25SideDataConstData + zoneDescList: dict[str, Act25SideDataZoneDescInfo] + archiveItemData: dict[str, Act25SideDataArchiveItemData] + arcMapInfoData: dict[str, Act25SideDataArchiveMapInfoData] + areaInfoData: dict[str, Act25SideDataAreaInfoData] + areaMissionData: dict[str, Act25SideDataAreaMissionData] + battlePerformanceData: dict[str, Act25SideDataBattlePerformanceData] + keyData: dict[str, Act25SideDataKeyData] + fogUnlockData: dict[str, Act25SideDataFogUnlockData] + farmList: list[Act25SideDataDailyFarmData] + + +class Act38D1DataAct38D1NodeData(BaseModel): + slotId: str + groupId: str | None + isUpper: bool + adjacentSlotList: list[str] + + +class Act38D1DataAct38D1RoadData(BaseModel): + roadId: str + startSlotId: str + endSlotId: str + + +class Act38D1DataAct38D1RewardBoxData(BaseModel): + rewardBoxId: str + roadId: str + + +class Act38D1DataAct38D1ExclusionGroupData(BaseModel): + groupId: str + slotIdList: list[str] + + +class Act38D1DataAct38D1DimensionItemData(BaseModel): + desc: str + maxScore: int + + +class Act38D1DataAct38D1CommentData(BaseModel): + id_: str = Field(alias='id') + sortId: int + desc: str + + +class Act38D1DataAct38D1StageDetailData(BaseModel): + nodeDataMap: dict[str, Act38D1DataAct38D1NodeData] + roadDataMap: dict[str, Act38D1DataAct38D1RoadData] + rewardBoxDataMap: dict[str, Act38D1DataAct38D1RewardBoxData] + exclusionGroupDataMap: dict[str, Act38D1DataAct38D1ExclusionGroupData] + dimensionItemList: list[Act38D1DataAct38D1DimensionItemData] + commentDataMap: dict[str, Act38D1DataAct38D1CommentData] + + +class Act38D1DataAct38D1ConstData(BaseModel): + redScoreThreshold: int + detailBkgRedThreshold: int + voiceGrade: int + stageInfoTitle: str + missionListReceiveRewardText: str + missionListChangeMapText: str + missionListCompleteTagText: str + mapStartBattleText: str + mapJumpDailyMapText: str + mapRewardReceivedText: str + + +class Act38D1Data(BaseModel): + scoreLevelToAppraiseDataMap: dict[str, str] + detailDataMap: dict[str, Act38D1DataAct38D1StageDetailData] + constData: Act38D1DataAct38D1ConstData + trackPointPeriodData: list[int] + + +class Act27SideDataAct27SideGoodData(BaseModel): + id_: str = Field(alias='id') + name: str + typeDesc: str + iconId: str + launchIconId: str + purchasePrice: list[int] + sellingPriceList: list[int] + sellShopList: list[str] + isPermanent: bool + + +class Act27SideDataAct27SideMileStoneData(BaseModel): + mileStoneId: str + mileStoneLvl: int + needPointCnt: int + rewardItem: ItemBundle + + +class Act27SideDataAct27SideGoodLaunchData(BaseModel): + groupId: str + startTime: int + stageId: str | None + code: str | None + drinkId: str + foodId: str + souvenirId: str + + +class Act27SideDataAct27SideShopData(BaseModel): + shopId: str + sortId: int + name: str + iconId: str + + +class Act27SideDataAct27SideInquireData(BaseModel): + mileStonePt: int + inquireCount: int + + +class Act27SideDataAct27SideDynEntrySwitchData(BaseModel): + entryId: str + startHour: int + signalId: str + + +class Act27SideDataAct27sideZoneAdditionData(BaseModel): + zoneId: str + unlockText: str + displayTime: str + + +class Act27SideDataAct27SideMileStoneFurniRewardData(BaseModel): + furniId: str + pointNum: int + + +class Act27SideDataAct27SideConstData(BaseModel): + stageId: str + stageCode: str + purchasePriceName: list[str] + furniRewardList: list[Act27SideDataAct27SideMileStoneFurniRewardData] + prizeText: str + playerShopId: str + milestonePointName: str + inquirePanelTitle: str + inquirePanelDesc: str + gain123: list[float] + gain113: list[float] + gain122: list[float] + gain111: list[float] + gain11None: list[float] + gain12None: list[float] + campaignEnemyCnt: int + + +class Act27SideData(BaseModel): + goodDataMap: dict[str, Act27SideDataAct27SideGoodData] + mileStoneList: list[Act27SideDataAct27SideMileStoneData] + goodLaunchDataList: list[Act27SideDataAct27SideGoodLaunchData] + shopDataMap: dict[str, Act27SideDataAct27SideShopData] + inquireDataList: list[Act27SideDataAct27SideInquireData] + dynEntrySwitchData: list[Act27SideDataAct27SideDynEntrySwitchData] + zoneAdditionDataMap: dict[str, Act27SideDataAct27sideZoneAdditionData] + constData: Act27SideDataAct27SideConstData + + +class ActivityTableActivityDetailTable(BaseModel): + DEFAULT: dict[str, DefaultFirstData] + CHECKIN_ONLY: dict[str, DefaultCheckInData] + CHECKIN_ALL_PLAYER: dict[str, AllPlayerCheckinData] + CHECKIN_VS: dict[str, VersusCheckInData] + TYPE_ACT3D0: dict[str, Act3D0Data] + TYPE_ACT4D0: dict[str, Act4D0Data] + TYPE_ACT5D0: dict[str, Act5D0Data] + TYPE_ACT5D1: dict[str, Act5D1Data] + COLLECTION: dict[str, ActivityCollectionData] + TYPE_ACT9D0: dict[str, Act9D0Data] + TYPE_ACT12SIDE: dict[str, Act12SideData] + TYPE_ACT13SIDE: dict[str, Act13SideData] + TYPE_ACT17SIDE: dict[str, Act17sideData] + TYPE_ACT20SIDE: dict[str, Act20SideData] + TYPE_ACT21SIDE: dict[str, Act21SideData] + LOGIN_ONLY: dict[str, ActivityLoginData] + SWITCH_ONLY: dict[str, ActivitySwitchCheckinData] + MINISTORY: dict[str, ActivityMiniStoryData] + ROGUELIKE: dict[str, ActivityRoguelikeData] + MULTIPLAY: dict[str, ActivityMultiplayData] + INTERLOCK: dict[str, ActivityInterlockData] + BOSS_RUSH: dict[str, ActivityBossRushData] + FLOAT_PARADE: dict[str, ActivityFloatParadeData] + SANDBOX: dict[str, ActSandboxData] + MAIN_BUFF: dict[str, ActivityMainlineBuffData] + TYPE_ACT24SIDE: dict[str, Act24SideData] + TYPE_ACT25SIDE: dict[str, Act25SideData] + TYPE_ACT38D1: dict[str, Act38D1Data] + TYPE_ACT27SIDE: dict[str, Act27SideData] + + +class ActivityStageRewardData(BaseModel): + stageRewardsDict: dict[str, list[StageDataDisplayDetailRewards]] + + +class ActivityThemeDataTimeNode(BaseModel): + title: str + ts: int + + +class ActivityThemeData(BaseModel): + id_: str = Field(alias='id') + type_: str = Field(alias='type') + funcId: str + endTs: int + sortId: int + itemId: str | None + timeNodes: list[ActivityThemeDataTimeNode] + startTs: int + + +class StageDataConditionDesc(BaseModel): + stageId: str + completeState: int + + +class AprilFoolStageData(BaseModel): + stageId: str + levelId: str + code: str + name: str + appearanceStyle: int + loadingPicId: str + difficulty: str + unlockCondition: list[StageDataConditionDesc] + stageDropInfo: list[ItemBundle] + + +class AprilFoolScoreData(BaseModel): + stageId: str + sortId: int + playerName: str + playerScore: int + + +class AprilFoolConst(BaseModel): + battleFinishLoseDes: str + killEnemyDes: str + killBossDes: str + totalTime: str + + +class Act4funPerformGroupInfo(BaseModel): + performGroupId: str + performIds: list[str] + + +class Act4funPerformWordData(BaseModel): + text: str + picId: str + backgroundId: str + + +class Act4funPerformInfo(BaseModel): + performId: str + performFinishedPicId: str | None + fixedCmpGroup: str | None + cmpGroups: list[str | None] + words: list[Act4funPerformWordData] + + +class Act4funLiveMatEffectInfo(BaseModel): + liveMatEffectId: str + valueId: str + performGroup: str + + +class Act4funLiveMatInfoData(BaseModel): + liveMatId: str + stageId: str + name: str + picId: str + tagTxt: str + emojiIcon: str + selectedPerformId: str + effectInfos: dict[str, Act4funLiveMatEffectInfo] + + +class Act4funSpLiveMatInfoData(BaseModel): + spLiveMatId: str + spLiveEveId: str + stageId: str + name: str + picId: str + tagTxt: str + emojiIcon: str + accordingPerformId: str | None + selectedPerformId: str | None + valueEffectId: str + accordingSuperChatId: str | None + + +class Act4funValueEffectInfoData(BaseModel): + valueEffectId: str + effectParams: dict[str, int] + + +class Act4funLiveValueInfoData(BaseModel): + liveValueId: str + name: str + stageId: str + iconId: str + highEndingId: str + lowEndingId: str + increaseToastTxt: str + decreaseToastTxt: str + + +class Act4funSuperChatInfo(BaseModel): + superChatId: str + chatType: int + userName: str + iconId: str + valueEffectId: str + performId: str + superChatTxt: str + + +class Act4funCmtInfo(BaseModel): + iconId: str | None + name: str | None + cmtTxt: str + + +class Act4funCmtGroupInfo(BaseModel): + cmtGroupId: str + cmtList: list[Act4funCmtInfo] + + +class Act4funEndingInfo(BaseModel): + endingId: str + endingAvg: str + endingDesc: str | None + stageId: str | None + isGoodEnding: bool + + +class Act4funTokenInfoData(BaseModel): + tokenLevelId: str + levelDesc: str | None + skillDesc: str + tokenLevelNum: int + levelIconId: str + + +class Act4funMissionData(BaseModel): + missionId: str + sortId: int + missionDes: str + rewardIconIds: list[str] + rewards: list[ItemBundle] + + +class Act4funConst(BaseModel): + liveMatAmtLowerLimit: int + liveTurnUpperLimit: int + superChatCountDownNum: int + badEndingPerformEffectTitle: str + performEffectTitle: str + defaultPerformPicId: str + defaultTxtBackground: str + openingPerformGroup: str + forgetPerformGroup: str + runPerformGroup: str + liveMatDefaultUserIcon: str + liveMatAttributeIcon: str + liveMatAttribIconDiffNum: int + liveValueAbsLimit: int + cmtAppearTimeLowerLimit: float + cmtAppearTimeUpperLimit: float + subtitleIntervalTime: float + mainPageEventDes: str + spStageEndingTip: str + noLiveEndingTip: str + notEnoughEndingTip: str + enoughEndingTip: str + mainPagePersonal: str + mainPageJobDes: str + endingPageConfirmTxt: str + runConfirmTxt: str + mainPageDiamondMissionId: str + reconnectConfirmTxt: str + studyStageId: str + goodEndingToastTxt: str + tokenLevelUpToastTxt: str + studyStageToastTxt: str + matNotEnoughToastTxt: str + formalLevelUnlockToastTxt: str + + +class Act4funStageExtraData(BaseModel): + description: str + valueIconId: str | None + + +class Act4funData(BaseModel): + performGroupInfoDict: dict[str, Act4funPerformGroupInfo] + performInfoDict: dict[str, Act4funPerformInfo] + normalMatDict: dict[str, Act4funLiveMatInfoData] + spMatDict: dict[str, Act4funSpLiveMatInfoData] + valueEffectInfoDict: dict[str, Act4funValueEffectInfoData] + liveValueInfoDict: dict[str, Act4funLiveValueInfoData] + superChatInfoDict: dict[str, Act4funSuperChatInfo] + cmtGroupInfoDict: dict[str, Act4funCmtGroupInfo] + cmtUsers: list[str] + endingDict: dict[str, Act4funEndingInfo] + tokenLevelInfos: dict[str, Act4funTokenInfoData] + missionDatas: dict[str, Act4funMissionData] + constant: Act4funConst + stageExtraDatas: dict[str, Act4funStageExtraData] + randomMsgText: list[str] + randomUserIconId: list[str] + + +class AprilFoolTable(BaseModel): + stages: dict[str, AprilFoolStageData] + scoreDict: dict[str, list[AprilFoolScoreData]] + constant: AprilFoolConst + act4FunData: Act4funData + + +class CartComponents(BaseModel): + compId: str + sortId: int + type: str + posList: list[str] + posIdDict: dict[str, list[str]] + name: str + icon: str + showScores: int + itemUsage: str + itemDesc: str + itemObtain: str + rarity: int + detailDesc: str + price: int + specialObtain: str + obtainInRandom: bool + additiveColor: str | None + + +class CartDataCartConstData(BaseModel): + carItemUnlockStageId: str + carItemUnlockDesc: str + spLevelUnlockItemCnt: int + mileStoneBaseInterval: int + spStageIds: list[str] + carFrameDefaultColor: str + + +class CartData(BaseModel): + carDict: dict[str, CartComponents] + runeDataDict: dict[str, RuneTablePackedRuneData] + cartStages: list[str] + constData: CartDataCartConstData + + +class SiracusaDataAreaData(BaseModel): + areaId: str + areaName: str + areaSubName: str + unlockType: str + unlockStage: str | None + areaIconId: str + pointList: list[str] + + +class SiracusaDataPointData(BaseModel): + pointId: str + areaId: str + pointName: str + pointDesc: str + pointIconId: str + pointItaName: str + + +class SiracusaDataCharCardData(BaseModel): + charCardId: str + sortIndex: int + avgChar: str + avgCharOffsetY: float | int + charCardName: str + charCardItaName: str + charCardTitle: str + charCardDesc: str + fullCompleteDes: str + gainDesc: str + themeColor: str + taskRingList: list[str] + operaItemId: str + gainParamList: list[str] | None + + +class SiracusaDataTaskRingData(BaseModel): + taskRingId: str + sortIndex: int + charCardId: str + logicType: str + ringText: str + item: ItemBundle + isPrecious: bool + taskIdList: list[str] + + +class SiracusaDataTaskBasicInfoData(BaseModel): + taskId: str + taskRingId: str + sortIndex: int + placeId: str + npcId: str | None + taskType: str + + +class SiracusaDataBattleTaskData(BaseModel): + taskId: str + stageId: str + battleTaskDesc: str + + +class SiracusaDataAVGTaskData(BaseModel): + taskId: str + taskAvg: str + + +class SiracusaDataItemInfoData(BaseModel): + itemId: str + itemName: str + itemItalyName: str + itemDesc: str + itemIcon: str + + +class SiracusaDataItemCardInfoData(BaseModel): + cardId: str + cardName: str + cardDesc: str + optionScript: str + + +class SiracusaDataNavigationInfoData(BaseModel): + entryId: str + navigationType: str + entryIcon: str + entryName: str | None + entrySubName: str | None + + +class SiracusaDataOptionInfoData(BaseModel): + optionId: str + optionDesc: str + optionScript: str + optionGoToScript: str | None + isLeaveOption: bool + needCommentLike: bool + requireCardId: str | None + + +class SiracusaDataStagePointInfoData(BaseModel): + stageId: str + pointId: str + sortId: int + isTaskStage: bool + + +class SiracusaDataStoryBriefInfoData(BaseModel): + storyId: str + stageId: str + storyInfo: str + + +class SiracusaDataOperaInfoData(BaseModel): + operaId: str + sortId: int + operaName: str + operaSubName: str + operaScore: float + unlockTime: int + + +class SiracusaDataOperaCommentInfoData(BaseModel): + commentId: str + referenceOperaId: str + columnIndex: int + columnSortId: int + commentTitle: str + score: float + commentContent: str + commentCharId: str + + +class SiracusaDataConstData(BaseModel): + operaDailyNum: int + operaAllUnlockTime: int + defaultFocusArea: str + + +class SiracusaData(BaseModel): + areaDataMap: dict[str, SiracusaDataAreaData] + pointDataMap: dict[str, SiracusaDataPointData] + charCardMap: dict[str, SiracusaDataCharCardData] + taskRingMap: dict[str, SiracusaDataTaskRingData] + taskInfoMap: dict[str, SiracusaDataTaskBasicInfoData] + battleTaskMap: dict[str, SiracusaDataBattleTaskData] + avgTaskMap: dict[str, SiracusaDataAVGTaskData] + itemInfoMap: dict[str, SiracusaDataItemInfoData] + itemCardInfoMap: dict[str, SiracusaDataItemCardInfoData] + navigationInfoMap: dict[str, SiracusaDataNavigationInfoData] + optionInfoMap: dict[str, SiracusaDataOptionInfoData] + stagePointList: list[SiracusaDataStagePointInfoData] + storyBriefInfoDataMap: dict[str, SiracusaDataStoryBriefInfoData] + operaInfoMap: dict[str, SiracusaDataOperaInfoData] + operaCommentInfoMap: dict[str, SiracusaDataOperaCommentInfoData] + constData: SiracusaDataConstData + + +class KVSwitchInfo(BaseModel): + isDefault: bool + displayTime: int + zoneId: str | None + + +class ActivityKVSwitchData(BaseModel): + kvSwitchInfo: dict[str, KVSwitchInfo] + + +class DynEntrySwitchInfo(BaseModel): + entryId: str + sortId: int + stageId: str | None + + +class ActivityDynEntrySwitchData(BaseModel): + entrySwitchInfo: dict[str, DynEntrySwitchInfo] + + +class ActivityTableActivityHiddenStageUnlockConditionData(BaseModel): + unlockStageId: str + unlockTemplate: str + unlockParams: list[str] | None + missionStageId: str + unlockedName: str + lockedName: str + lockCode: str + unlockedDes: str + templateDesc: str + desc: str + riddle: str + + +class ActivityTableActivityHiddenStageData(BaseModel): + stageId: str + encodedName: str + showStageId: str + rewardDiamond: bool + missions: list[ActivityTableActivityHiddenStageUnlockConditionData] + + +class ActivityTable(BaseModel): + __version__ = '23-07-27-18-50-06-aeb568' + + basicInfo: dict[str, ActivityTableBasicData] + homeActConfig: dict[str, ActivityTableHomeActivityConfig] + zoneToActivity: dict[str, str] + missionData: list[MissionData] + missionGroup: list[MissionGroup] + replicateMissions: dict[str, str] | None + activity: ActivityTableActivityDetailTable + activityItems: dict[str, list[str]] + syncPoints: dict[str, list[int]] + dynActs: dict[str, dict[str, str | int | list[str | int] | dict[str, int] | ItemBundle]] + stageRewardsData: dict[str, ActivityStageRewardData] + actThemes: list[ActivityThemeData] + actFunData: AprilFoolTable + carData: CartData + siracusaData: SiracusaData + kvSwitchData: dict[str, ActivityKVSwitchData] + dynEntrySwitchData: dict[str, ActivityDynEntrySwitchData] + hiddenStageData: list[ActivityTableActivityHiddenStageData] + stringRes: dict[str, dict[str, str]] + + class Config: + extra = 'allow' diff --git a/ArknightsUID/utils/models/gamedata/AudioData.py b/ArknightsUID/utils/models/gamedata/AudioData.py new file mode 100644 index 0000000..e46ecb3 --- /dev/null +++ b/ArknightsUID/utils/models/gamedata/AudioData.py @@ -0,0 +1,86 @@ +from pydantic import BaseModel, Field + + +class Bank(BaseModel): + name: str + + +class BGMBank(Bank): + intro: str | None + loop: str | None + volume: float + crossfade: float + delay: float + + +class SoundFXBankSoundFX(BaseModel): + asset: str + weight: float + important: bool + is2D: bool + delay: float + minPitch: float + maxPitch: float + minVolume: float + maxVolume: float + ignoreTimeScale: bool + + +class SoundFXBank(Bank): + sounds: list[SoundFXBankSoundFX] | None + maxSoundAllowed: int + popOldest: bool + customMixerGroup: str | None + loop: bool + + +class SoundFXCtrlBank(Bank): + targetBank: str + ctrlStop: bool + ctrlStopFadetime: float + name: str + + +class SnapshotBank(Bank): + targetSnapshot: str + hookSoundFxBank: str + delay: float + duration: float + targetFxBank: Bank | None = None + + +class BattleVoiceOption(BaseModel): + voiceType: int + priority: int + overlapIfSamePriority: bool + cooldown: float + delay: float + + +class MusicData(BaseModel): + id_: str = Field(alias='id') + name: str + bank: str + + +class BattleVoiceData(BaseModel): + crossfade: float + minTimeDeltaForEnemyEncounter: float + minSpCostForImportantPassiveSkill: int + voiceTypeOptions: list[BattleVoiceOption] + + +class AudioData(BaseModel): + __version__ = '23-07-27-18-50-06-aeb568' + + bgmBanks: list[BGMBank] + soundFXBanks: list[SoundFXBank] + soundFXCtrlBanks: list[SoundFXCtrlBank] + snapshotBanks: list[SnapshotBank] + battleVoice: BattleVoiceData + musics: list[MusicData] + soundFxVoiceLang: dict[str, dict[str, dict[str, str]]] + bankAlias: dict[str, str] + + class Config: + extra = 'allow' diff --git a/ArknightsUID/utils/models/gamedata/BattleEquipTable.py b/ArknightsUID/utils/models/gamedata/BattleEquipTable.py new file mode 100644 index 0000000..00b7bb1 --- /dev/null +++ b/ArknightsUID/utils/models/gamedata/BattleEquipTable.py @@ -0,0 +1,80 @@ +from pydantic import BaseModel + + +class CharacterDataUnlockCondition(BaseModel): + phase: int + level: int + + +class Blackboard(BaseModel): + key: str + value: float | None = None + valueStr: str | None = None + + +class TalentData(BaseModel): + unlockCondition: CharacterDataUnlockCondition + requiredPotentialRank: int + prefabKey: str | None + name: str | None + description: str | None + rangeId: str | None + blackboard: list[Blackboard] + + +class EquipTalentData(TalentData): + displayRangeId: bool + upgradeDescription: str + talentIndex: int + + +class CharacterDataEquipTalentDataBundle(BaseModel): + candidates: list[EquipTalentData] | None + + +class CharacterDataTraitData(BaseModel): + unlockCondition: CharacterDataUnlockCondition + requiredPotentialRank: int + blackboard: list[Blackboard] + overrideDescripton: str | None + prefabKey: str | None + rangeId: str | None + + +class CharacterDataEquipTraitData(BaseModel): + additionalDescription: str | None + + +class CharacterDataEquipTraitDataBundle(BaseModel): + candidates: list[CharacterDataEquipTraitData] | None + + +class BattleUniEquipData(BaseModel): + resKey: str | None + target: str + isToken: bool + addOrOverrideTalentDataBundle: CharacterDataEquipTalentDataBundle + overrideTraitDataBundle: CharacterDataEquipTraitDataBundle + + +class BattleEquipPerLevelPack(BaseModel): + equipLevel: int + parts: list[BattleUniEquipData] + attributeBlackboard: list[Blackboard] + tokenAttributeBlackboard: dict[str, list[Blackboard]] + + +class BattleEquipData(BaseModel): + phases: list[BattleEquipPerLevelPack] + + +class BattleEquipTable(BaseModel): + __version__ = '23-07-27-18-50-06-aeb568' + + equips: dict[str, BattleEquipData] + + class Config: + extra = 'allow' + + def __init__(self, data: dict) -> None: + super().__init__(equips=data) diff --git a/ArknightsUID/utils/models/gamedata/BuildingData.py b/ArknightsUID/utils/models/gamedata/BuildingData.py new file mode 100644 index 0000000..bbb191a --- /dev/null +++ b/ArknightsUID/utils/models/gamedata/BuildingData.py @@ -0,0 +1,460 @@ +from pydantic import BaseModel, Field + + +class BuildingDataRoomUnlockCondCondItem(BaseModel): + type_: str = Field(alias='type') + level: int + count: int + + +class BuildingDataRoomUnlockCond(BaseModel): + id_: str = Field(alias='id') + number: dict[str, BuildingDataRoomUnlockCondCondItem] + + +class GridPosition(BaseModel): + row: int + col: int + + +class ItemBundle(BaseModel): + id_: str = Field(alias='id') + count: int + type_: str = Field(alias='type') + + +class BuildingDataRoomDataBuildCost(BaseModel): + items: list[ItemBundle] + time: int + labor: int + + +class BuildingDataRoomDataPhaseData(BaseModel): + overrideName: str | None + overridePrefabId: str | None + unlockCondId: str + buildCost: BuildingDataRoomDataBuildCost + electricity: int + maxStationedNum: int + manpowerCost: int + + +class BuildingDataRoomData(BaseModel): + id_: str = Field(alias='id') + name: str + description: str | None + defaultPrefabId: str + canLevelDown: bool + maxCount: int + category: str + size: GridPosition + phases: list[BuildingDataRoomDataPhaseData] + + +class BuildingDataLayoutDataRoomSlot(BaseModel): + id_: str = Field(alias='id') + cleanCostId: str + costLabor: int + provideLabor: int + size: GridPosition + offset: GridPosition + category: str + storeyId: str + + +class BuildingDataLayoutDataSlotCleanCostCountCost(BaseModel): + items: list[ItemBundle] + + +class BuildingDataLayoutDataSlotCleanCost(BaseModel): + id_: str = Field(alias='id') + number: dict[str, BuildingDataLayoutDataSlotCleanCostCountCost] + + +class BuildingDataLayoutDataStoreyData(BaseModel): + id_: str = Field(alias='id') + yOffset: int + unlockControlLevel: int + type_: str = Field(alias='type') + + +class BuildingDataLayoutData(BaseModel): + id_: str = Field(alias='id') + slots: dict[str, BuildingDataLayoutDataRoomSlot] + cleanCosts: dict[str, BuildingDataLayoutDataSlotCleanCost] + storeys: dict[str, BuildingDataLayoutDataStoreyData] + + +class BuildingDataPrefabInfo(BaseModel): + id_: str = Field(alias='id') + blueprintRoomOverrideId: str | None + size: GridPosition + floorGridSize: GridPosition + backWallGridSize: GridPosition + obstacleId: str | None + + +class BuildingDataManufactPhase(BaseModel): + speed: float | int + outputCapacity: int + + +class BuildingDataShopPhase(BaseModel): + counterNum: int + speed: float | int + moneyCapacity: int + + +class BuildingDataHirePhase(BaseModel): + economizeRate: float + resSpeed: int + refreshTimes: int + + +class BuildingDataDormPhase(BaseModel): + manpowerRecover: int + decorationLimit: int + + +class BuildingDataMeetingPhase(BaseModel): + friendSlotInc: int + maxVisitorNum: int + gatheringSpeed: int + + +class BuildingDataTradingPhase(BaseModel): + orderSpeed: float | int + orderLimit: int + orderRarity: int + + +class BuildingDataWorkshopPhase(BaseModel): + manpowerFactor: float | int + + +class BuildingDataTrainingPhase(BaseModel): + specSkillLvlLimit: int + + +class BuildingDataRoomBean(BaseModel): + phases: list[BuildingDataManufactPhase | BuildingDataShopPhase | BuildingDataHirePhase | BuildingDataDormPhase | BuildingDataMeetingPhase | BuildingDataTradingPhase | BuildingDataWorkshopPhase | BuildingDataTrainingPhase] | None # noqa: E501 + + +class BuildingDataControlRoomBean(BuildingDataRoomBean): + basicCostBuff: int + + +class BuildingDataManufactRoomBean(BuildingDataRoomBean): + basicSpeedBuff: float + + +class BuildingDataHireRoomBean(BuildingDataRoomBean): + basicSpeedBuff: float + + +class BuildingDataMeetingRoomBean(BuildingDataRoomBean): + basicSpeedBuff: float + + +class BuildingDataTradingRoomBean(BuildingDataRoomBean): + basicSpeedBuff: float + + +class BuildingDataTrainingBean(BuildingDataRoomBean): + basicSpeedBuff: float + + +class BuildingDataPowerRoomBean(BuildingDataRoomBean): + basicSpeedBuff: float + + +class CharacterDataUnlockCondition(BaseModel): + phase: int + level: int + + +class BuildingDataBuildingBuffCharSlotSlotItem(BaseModel): + buffId: str + cond: CharacterDataUnlockCondition + + +class BuildingDataBuildingBuffCharSlot(BaseModel): + buffData: list[BuildingDataBuildingBuffCharSlotSlotItem] + + +class BuildingDataBuildingCharacter(BaseModel): + charId: str + maxManpower: int + buffChar: list[BuildingDataBuildingBuffCharSlot] + + +class BuildingDataBuildingBuff(BaseModel): + buffId: str + buffName: str + buffIcon: str + skillIcon: str + sortId: int + buffColor: str + textColor: str + buffCategory: str + roomType: str + description: str + + +class BuildingDataCustomDataFurnitureData(BaseModel): + id_: str = Field(alias='id') + sortId: int + name: str + iconId: str + interactType: str | None = None + type_: str = Field(alias='type') + subType: str + location: str + category: str + validOnRotate: bool + enableRotate: bool + rarity: int + themeId: str + groupId: str + width: int + depth: int + height: int + comfort: int + usage: str + description: str + obtainApproach: str + processedProductId: str + processedProductCount: int + processedByProductPercentage: int + processedByProductGroup: list + canBeDestroy: bool + isOnly: int + quantity: int + + +class BuildingDataCustomDataThemeQuickSetupItem(BaseModel): + furnitureId: str + pos0: int + pos1: int + dir_: int = Field(alias='dir') + + +class BuildingDataCustomDataThemeData(BaseModel): + id_: str = Field(alias='id') + sortId: int + name: str + themeType: str + desc: str + quickSetup: list[BuildingDataCustomDataThemeQuickSetupItem] + groups: list[str] + furnitures: list[str] + + +class BuildingDataCustomDataGroupData(BaseModel): + id_: str = Field(alias='id') + sortId: int + name: str + themeId: str + comfort: int + count: int + furniture: list[str] + + +class BuildingDataCustomDataFurnitureTypeData(BaseModel): + type_: str = Field(alias='type') + name: str + + +class BuildingDataCustomDataFurnitureSubTypeData(BaseModel): + subType: str + name: str + type_: str = Field(alias='type') + sortId: int + + +class BuildingDataCustomDataDormitoryDefaultFurnitureItem(BaseModel): + furnitureId: str + xOffset: int + yOffset: int + defaultPrefabId: str + + +class BuildingDataCustomDataInteractItem(BaseModel): + skinId: str + + +class BuildingDataCustomDataDiyUISortTemplateListDataDiyUISortTemplateData(BaseModel): + name: str + sequences: list[str] + stableSequence: str + stableSequenceOrder: str + + +class BuildingDataCustomDataDiyUISortTemplateListData(BaseModel): + diyUIType: str + expandState: str + defaultTemplateIndex: int + defaultTemplateOrder: str + templates: list[BuildingDataCustomDataDiyUISortTemplateListDataDiyUISortTemplateData] + + +class BuildingDataCustomData(BaseModel): + furnitures: dict[str, BuildingDataCustomDataFurnitureData] + themes: dict[str, BuildingDataCustomDataThemeData] + groups: dict[str, BuildingDataCustomDataGroupData] + types: dict[str, BuildingDataCustomDataFurnitureTypeData] + subTypes: dict[str, BuildingDataCustomDataFurnitureSubTypeData] + defaultFurnitures: dict[str, list[BuildingDataCustomDataDormitoryDefaultFurnitureItem]] + interactGroups: dict[str, list[BuildingDataCustomDataInteractItem]] + diyUISortTemplates: dict[str, dict[str, BuildingDataCustomDataDiyUISortTemplateListData]] + + +class BuildingDataManufactFormulaUnlockRoom(BaseModel): + roomId: str + roomLevel: int + roomCount: int + + +class BuildingDataManufactFormulaUnlockStage(BaseModel): + stageId: str + rank: int + + +class BuildingDataManufactFormula(BaseModel): + formulaId: str + itemId: str + count: int + weight: int + costPoint: int + formulaType: str + buffType: str + costs: list[ItemBundle] + requireRooms: list[BuildingDataManufactFormulaUnlockRoom] + requireStages: list[BuildingDataManufactFormulaUnlockStage] + + +class BuildingDataShopFormulaUnlockRoom(BaseModel): + roomId: str + roomLevel: int + + +class BuildingDataShopFormula(BaseModel): + formulaId: str + itemId: str + formulaType: str + costPoint: int + gainItem: ItemBundle + requireRooms: list[BuildingDataShopFormulaUnlockRoom] + + +class BuildingDataWorkshopExtraWeightItem(BaseModel): + weight: int + itemId: str + itemCount: int + + +class BuildingDataWorkshopFormulaUnlockRoom(BaseModel): + roomId: str + roomLevel: int + roomCount: int + + +class BuildingDataWorkshopFormulaUnlockStage(BaseModel): + stageId: str + rank: int + + +class BuildingDataWorkshopFormula(BaseModel): + sortId: int + formulaId: str + rarity: int + itemId: str + count: int + goldCost: int + apCost: int + formulaType: str + buffType: str + extraOutcomeRate: float + extraOutcomeGroup: list[BuildingDataWorkshopExtraWeightItem] + costs: list[ItemBundle] + requireRooms: list[BuildingDataWorkshopFormulaUnlockRoom] + requireStages: list[BuildingDataWorkshopFormulaUnlockStage] + + +class BuildingDataCreditFormulaValueModel(BaseModel): + basic: int + addition: int + + +class BuildingDataCreditFormula(BaseModel): + initiative: BuildingDataCreditFormulaValueModel | dict + passive: BuildingDataCreditFormulaValueModel | dict + + +class BuildingData(BaseModel): + __version__ = '23-07-27-18-50-06-aeb568' + + controlSlotId: str + meetingSlotId: str + initMaxLabor: int + laborRecoverTime: int + manufactInputCapacity: int + shopCounterCapacity: int + comfortLimit: int + creditInitiativeLimit: int + creditPassiveLimit: int + creditComfortFactor: int + creditGuaranteed: int + creditCeiling: int + manufactUnlockTips: str + shopUnlockTips: str + manufactStationBuff: float + comfortManpowerRecoverFactor: int + manpowerDisplayFactor: int + shopOutputRatio: dict[str, int] | None + shopStackRatio: dict[str, int] | None + basicFavorPerDay: int + humanResourceLimit: int + tiredApThreshold: int + processedCountRatio: int + tradingStrategyUnlockLevel: int + tradingReduceTimeUnit: int + tradingLaborCostUnit: int + manufactReduceTimeUnit: int + manufactLaborCostUnit: int + laborAssistUnlockLevel: int + apToLaborUnlockLevel: int + apToLaborRatio: int + socialResourceLimit: int + socialSlotNum: int + furniDuplicationLimit: int + assistFavorReport: int + manufactManpowerCostByNum: list[int] + tradingManpowerCostByNum: list[int] + roomUnlockConds: dict[str, BuildingDataRoomUnlockCond] + rooms: dict[str, BuildingDataRoomData] + layouts: dict[str, BuildingDataLayoutData] + prefabs: dict[str, BuildingDataPrefabInfo] + controlData: BuildingDataControlRoomBean + manufactData: BuildingDataManufactRoomBean + shopData: BuildingDataRoomBean + hireData: BuildingDataHireRoomBean + dormData: BuildingDataRoomBean + meetingData: BuildingDataMeetingRoomBean + tradingData: BuildingDataTradingRoomBean + workshopData: BuildingDataRoomBean + trainingData: BuildingDataTrainingBean + powerData: BuildingDataPowerRoomBean + chars: dict[str, BuildingDataBuildingCharacter] + buffs: dict[str, BuildingDataBuildingBuff] + workshopBonus: dict[str, list[str]] + customData: BuildingDataCustomData + manufactFormulas: dict[str, BuildingDataManufactFormula] + shopFormulas: dict[str, BuildingDataShopFormula] + workshopFormulas: dict[str, BuildingDataWorkshopFormula] + creditFormula: BuildingDataCreditFormula + goldItems: dict[str, int] + assistantUnlock: list[int] + + class Config: + extra = 'allow' diff --git a/ArknightsUID/utils/models/gamedata/CampaignTable.py b/ArknightsUID/utils/models/gamedata/CampaignTable.py new file mode 100644 index 0000000..7b40fd0 --- /dev/null +++ b/ArknightsUID/utils/models/gamedata/CampaignTable.py @@ -0,0 +1,158 @@ +from pydantic import BaseModel, Field + + +class ItemBundle(BaseModel): + id_: str = Field(alias='id') + count: int + type_: str = Field(alias='type') + + +class CampaignDataBreakRewardLadder(BaseModel): + killCnt: int + breakFeeAdd: int + rewards: list[ItemBundle] + + +class WeightItemBundle(BaseModel): + id_: str = Field(alias='id') + type_: str = Field(alias='type') + dropType: str + count: int + weight: int + + +class StageDataDisplayRewards_(BaseModel): + type_: str = Field(alias='type') + id_: str = Field(alias='id') + dropType: int + + +class StageDataDisplayDetailRewards_(StageDataDisplayRewards_): + occPercent: int + GetPercent: float + CannotGetPercent: float + + +class CampaignDataCampaignDropInfo(BaseModel): + firstPassRewards: list[ItemBundle] | None + passRewards: list[list[WeightItemBundle]] | None + displayDetailRewards: list[StageDataDisplayDetailRewards_] | None + + +class CampaignDataDropLadder(BaseModel): + killCnt: int + dropInfo: CampaignDataCampaignDropInfo + + +class CampaignDataGainLadder(BaseModel): + killCnt: int + apFailReturn: int + favor: int + expGain: int + goldGain: int + displayDiamondShdNum: int + + +class StageDataDisplayRewards(BaseModel): + type_: str = Field(alias='type') + id_: str = Field(alias='id') + dropType: int + + +class StageDataDisplayDetailRewards(BaseModel): + occPercent: int + type_: str = Field(alias='type') + id_: str = Field(alias='id') + dropType: int + + +class CampaignDataDropGainInfo(BaseModel): + dropLadders: list[CampaignDataDropLadder] + gainLadders: list[CampaignDataGainLadder] + displayRewards: list[StageDataDisplayRewards] + displayDetailRewards: list[StageDataDisplayDetailRewards] + + +class CampaignData(BaseModel): + stageId: str + isSmallScale: int + breakLadders: list[CampaignDataBreakRewardLadder] + isCustomized: bool + dropGains: dict[str, CampaignDataDropGainInfo] + + +class CampaignGroupData(BaseModel): + groupId: str + activeCamps: list[str] + startTs: int + endTs: int + + +class CampaignRegionData(BaseModel): + id_: str = Field(alias='id') + isUnknwon: int + + +class CampaignZoneData(BaseModel): + id_: str = Field(alias='id') + name: str + regionId: str + templateId: str + + +class CampaignMissionData(BaseModel): + id_: str = Field(alias='id') + sortId: int + param: list[str] + description: str + breakFeeAdd: int + + +class CampaignConstTable(BaseModel): + systemPreposedStage: str + rotateStartTime: int + rotatePreposedStage: str + zoneUnlockStage: str + firstRotateRegion: str + sweepStartTime: int + + +class CampaignRotateOpenTimeData(BaseModel): + groupId: str + stageId: str + mapId: str + unknownRegions: list[str] + duration: int + startTs: int + endTs: int + + +class CampaignTrainingOpenTimeData(BaseModel): + groupId: str + stages: list[str] + startTs: int + endTs: int + + +class CampaignTrainingAllOpenTimeData(BaseModel): + groupId: str + startTs: int + endTs: int + + +class CampaignTable(BaseModel): + __version__ = '23-07-27-18-50-06-aeb568' + + campaigns: dict[str, CampaignData] + campaignGroups: dict[str, CampaignGroupData] + campaignRegions: dict[str, CampaignRegionData] + campaignZones: dict[str, CampaignZoneData] + campaignMissions: dict[str, CampaignMissionData] + stageIndexInZoneMap: dict[str, int] + campaignConstTable: CampaignConstTable + campaignRotateStageOpenTimes: list[CampaignRotateOpenTimeData] + campaignTrainingStageOpenTimes: list[CampaignTrainingOpenTimeData] + campaignTrainingAllOpenTimes: list[CampaignTrainingAllOpenTimeData] + + class Config: + extra = 'allow' diff --git a/ArknightsUID/utils/models/gamedata/ChapterTable.py b/ArknightsUID/utils/models/gamedata/ChapterTable.py new file mode 100644 index 0000000..902a600 --- /dev/null +++ b/ArknightsUID/utils/models/gamedata/ChapterTable.py @@ -0,0 +1,24 @@ +from pydantic import BaseModel + + +class ChapterData(BaseModel): + chapterId: str + chapterName: str + chapterName2: str + chapterIndex: int + preposedChapterId: str | None + startZoneId: str + endZoneId: str + chapterEndStageId: str + + +class ChapterTable(BaseModel): + __version__ = '23-07-27-18-50-06-aeb568' + + chapters: dict[str, ChapterData] + + class Config: + extra = 'allow' + + def __init__(self, data: dict) -> None: + super().__init__(chapters=data) diff --git a/ArknightsUID/utils/models/gamedata/CharMetaTable.py b/ArknightsUID/utils/models/gamedata/CharMetaTable.py new file mode 100644 index 0000000..6f9293e --- /dev/null +++ b/ArknightsUID/utils/models/gamedata/CharMetaTable.py @@ -0,0 +1,27 @@ +from pydantic import BaseModel, Field + + +class ItemBundle(BaseModel): + id_: str = Field(alias='id') + count: int + type_: str = Field(alias='type') + + +class SpCharMissionData(BaseModel): + charId: str + missionId: str + sortId: int + condType: str + param: list[str] + rewards: list[ItemBundle] + + +class CharMetaTable(BaseModel): + __version__ = '23-07-27-18-50-06-aeb568' + + class Config: + extra = 'allow' + + spCharGroups: dict[str, list[str]] + spCharMissions: dict[str, dict[str, SpCharMissionData]] + spCharVoucherSkinTime: dict[str, int] diff --git a/ArknightsUID/utils/models/gamedata/CharPatchTable.py b/ArknightsUID/utils/models/gamedata/CharPatchTable.py new file mode 100644 index 0000000..2171f9e --- /dev/null +++ b/ArknightsUID/utils/models/gamedata/CharPatchTable.py @@ -0,0 +1,195 @@ +from pydantic import BaseModel, Field + + +class CharPatchDataPatchInfo(BaseModel): + tmplIds: list[str] + default: str + + +class CharacterDataUnlockCondition(BaseModel): + phase: int + level: int + + +class Blackboard(BaseModel): + key: str + value: float | None = None + valueStr: str | None = None + + +class CharacterDataTraitData(BaseModel): + unlockCondition: CharacterDataUnlockCondition + requiredPotentialRank: int + blackboard: list[Blackboard] + overrideDescripton: str | None + prefabKey: str | None + rangeId: str | None + + +class CharacterDataTraitDataBundle(BaseModel): + candidates: list[CharacterDataTraitData] + + +class AttributesData(BaseModel): + maxHp: int + atk: int + def_: int = Field(alias='def') + magicResistance: float + cost: int + blockCnt: int + moveSpeed: float + attackSpeed: float + baseAttackTime: float + respawnTime: int + hpRecoveryPerSec: float + spRecoveryPerSec: float + maxDeployCount: int + maxDeckStackCnt: int + tauntLevel: int + massLevel: int + baseForceLevel: int + stunImmune: bool + silenceImmune: bool + sleepImmune: bool + frozenImmune: bool + levitateImmune: bool + + +class CharacterDataAttributesKeyFrame(BaseModel): + level: int + data: AttributesData + + +class ItemBundle(BaseModel): + id_: str = Field(alias='id') + count: int + type_: str = Field(alias='type') + + +class CharacterDataPhaseData(BaseModel): + characterPrefabKey: str + rangeId: str | None + maxLevel: int + attributesKeyFrames: list[CharacterDataAttributesKeyFrame] + evolveCost: list[ItemBundle] | None + + +class CharacterDataMainSkillSpecializeLevelData(BaseModel): + unlockCond: CharacterDataUnlockCondition + lvlUpTime: int + levelUpCost: list[ItemBundle] | None + + +class CharacterDataMainSkill(BaseModel): + skillId: str | None + overridePrefabKey: str | None + overrideTokenKey: str | None + levelUpCostCond: list[CharacterDataMainSkillSpecializeLevelData] + unlockCond: CharacterDataUnlockCondition + + +class TalentData(BaseModel): + unlockCondition: CharacterDataUnlockCondition + requiredPotentialRank: int + prefabKey: str + name: str | None + description: str | None + rangeId: str | None + blackboard: list[Blackboard] + + +class CharacterDataTalentDataBundle(BaseModel): + candidates: list[TalentData] | None + + +class AttributeModifierDataAttributeModifier(BaseModel): + attributeType: int + formulaItem: int + value: float + loadFromBlackboard: bool + fetchBaseValueFromSourceEntity: bool + + +class AttributeModifierData(BaseModel): + abnormalFlags: list[str] | None + abnormalImmunes: list[str] | None + abnormalAntis: list[str] | None + abnormalCombos: list[str] | None + abnormalComboImmunes: list[str] | None + attributeModifiers: list[AttributeModifierDataAttributeModifier] + + +class ExternalBuff(BaseModel): + attributes: AttributeModifierData + + +class CharacterDataPotentialRank(BaseModel): + type_: int = Field(alias='type') + description: str + buff: ExternalBuff | None + equivalentCost: ItemBundle | None + + +class CharacterDataSkillLevelCost(BaseModel): + unlockCond: CharacterDataUnlockCondition + lvlUpCost: list[ItemBundle] | None + + +class CharacterData(BaseModel): + name: str + description: str | None + canUseGeneralPotentialItem: bool + canUseActivityPotentialItem: bool + potentialItemId: str | None + activityPotentialItemId: str | None + nationId: str | None + groupId: str | None + teamId: str | None + displayNumber: str | None + tokenKey: str | None = None + appellation: str + position: str + tagList: list[str] | None + itemUsage: str | None + itemDesc: str | None + itemObtainApproach: str | None + isNotObtainable: bool + isSpChar: bool + maxPotentialLevel: int + rarity: int + profession: str + subProfessionId: str + trait: CharacterDataTraitDataBundle | None + phases: list[CharacterDataPhaseData] + skills: list[CharacterDataMainSkill] + talents: list[CharacterDataTalentDataBundle] | None + potentialRanks: list[CharacterDataPotentialRank] + favorKeyFrames: list[CharacterDataAttributesKeyFrame] | None + allSkillLvlup: list[CharacterDataSkillLevelCost] + + +class CharPatchDataUnlockCondItem(BaseModel): + stageId: str + completeState: int + + +class CharPatchDataUnlockCond(BaseModel): + conds: list[CharPatchDataUnlockCondItem] + + +class CharPatchDataPatchDetailInfo(BaseModel): + patchId: str + sortId: int + infoParam: str + + +class CharPatchTable(BaseModel): + __version__ = '23-07-27-18-50-06-aeb568' + + infos: dict[str, CharPatchDataPatchInfo] + patchChars: dict[str, CharacterData] + unlockConds: dict[str, CharPatchDataUnlockCond] + patchDetailInfoList: dict[str, CharPatchDataPatchDetailInfo] + + class Config: + extra = 'allow' diff --git a/ArknightsUID/utils/models/gamedata/CharacterTable.py b/ArknightsUID/utils/models/gamedata/CharacterTable.py new file mode 100644 index 0000000..730d9fd --- /dev/null +++ b/ArknightsUID/utils/models/gamedata/CharacterTable.py @@ -0,0 +1,175 @@ +from pydantic import BaseModel, Field + + +class CharacterDataUnlockCondition(BaseModel): + phase: int + level: int + + +class Blackboard(BaseModel): + key: str + value: float | None = None + valueStr: str | None = None + + +class CharacterDataTraitData(BaseModel): + unlockCondition: CharacterDataUnlockCondition + requiredPotentialRank: int + blackboard: list[Blackboard] + overrideDescripton: str | None + prefabKey: str | None + rangeId: str | None + + +class CharacterDataTraitDataBundle(BaseModel): + candidates: list[CharacterDataTraitData] + + +class AttributesData(BaseModel): + maxHp: int + atk: int + def_: int = Field(alias='def') + magicResistance: float + cost: int + blockCnt: int + moveSpeed: float + attackSpeed: float + baseAttackTime: float + respawnTime: int + hpRecoveryPerSec: float + spRecoveryPerSec: float + maxDeployCount: int + maxDeckStackCnt: int + tauntLevel: int + massLevel: int + baseForceLevel: int + stunImmune: bool + silenceImmune: bool + sleepImmune: bool + frozenImmune: bool + levitateImmune: bool + + +class CharacterDataAttributesKeyFrame(BaseModel): + level: int + data: AttributesData + + +class ItemBundle(BaseModel): + id_: str = Field(alias='id') + count: int + type_: str = Field(alias='type') + + +class CharacterDataPhaseData(BaseModel): + characterPrefabKey: str + rangeId: str | None + maxLevel: int + attributesKeyFrames: list[CharacterDataAttributesKeyFrame] + evolveCost: list[ItemBundle] | None + + +class CharacterDataMainSkillSpecializeLevelData(BaseModel): + unlockCond: CharacterDataUnlockCondition + lvlUpTime: int + levelUpCost: list[ItemBundle] | None + + +class CharacterDataMainSkill(BaseModel): + skillId: str | None + overridePrefabKey: str | None + overrideTokenKey: str | None + levelUpCostCond: list[CharacterDataMainSkillSpecializeLevelData] + unlockCond: CharacterDataUnlockCondition + + +class TalentData(BaseModel): + unlockCondition: CharacterDataUnlockCondition + requiredPotentialRank: int + prefabKey: str + name: str | None + description: str | None + rangeId: str | None + blackboard: list[Blackboard] + + +class CharacterDataTalentDataBundle(BaseModel): + candidates: list[TalentData] | None + + +class AttributeModifierDataAttributeModifier(BaseModel): + attributeType: int + formulaItem: int + value: float + loadFromBlackboard: bool + fetchBaseValueFromSourceEntity: bool + + +class AttributeModifierData(BaseModel): + abnormalFlags: list[str] | None + abnormalImmunes: list[str] | None + abnormalAntis: list[str] | None + abnormalCombos: list[str] | None + abnormalComboImmunes: list[str] | None + attributeModifiers: list[AttributeModifierDataAttributeModifier] + + +class ExternalBuff(BaseModel): + attributes: AttributeModifierData + + +class CharacterDataPotentialRank(BaseModel): + type_: int = Field(alias='type') + description: str + buff: ExternalBuff | None + equivalentCost: ItemBundle | None + + +class CharacterDataSkillLevelCost(BaseModel): + unlockCond: CharacterDataUnlockCondition + lvlUpCost: list[ItemBundle] | None + + +class CharacterData(BaseModel): + name: str + description: str | None + canUseGeneralPotentialItem: bool + canUseActivityPotentialItem: bool + potentialItemId: str | None + activityPotentialItemId: str | None + nationId: str | None + groupId: str | None + teamId: str | None + displayNumber: str | None + tokenKey: str | None = None + appellation: str + position: str + tagList: list[str] | None + itemUsage: str | None + itemDesc: str | None + itemObtainApproach: str | None + isNotObtainable: bool + isSpChar: bool + maxPotentialLevel: int + rarity: int + profession: str + subProfessionId: str + trait: CharacterDataTraitDataBundle | None + phases: list[CharacterDataPhaseData] + skills: list[CharacterDataMainSkill] + talents: list[CharacterDataTalentDataBundle] | None + potentialRanks: list[CharacterDataPotentialRank] + favorKeyFrames: list[CharacterDataAttributesKeyFrame] | None + allSkillLvlup: list[CharacterDataSkillLevelCost] + + +class CharacterTable(BaseModel): + __version__ = '23-07-27-18-50-06-aeb568' + + chars: dict[str, CharacterData] + + class Config: + extra = 'allow' + + def __init__(self, data: dict) -> None: + super().__init__(chars=data) diff --git a/ArknightsUID/utils/models/gamedata/CharmTable.py b/ArknightsUID/utils/models/gamedata/CharmTable.py new file mode 100644 index 0000000..90d4b83 --- /dev/null +++ b/ArknightsUID/utils/models/gamedata/CharmTable.py @@ -0,0 +1,61 @@ +from pydantic import BaseModel, Field + + +class RuneDataSelector(BaseModel): + professionMask: int | str + buildableMask: int + charIdFilter: list[str] | None + enemyIdFilter: list[str] | None + enemyIdExcludeFilter: list[str] | None + skillIdFilter: list[str] | None + tileKeyFilter: list[str] | None + groupTagFilter: list[str] | None + filterTagFilter: list[str] | None + + +class Blackboard(BaseModel): + key: str + value: float | None = None + valueStr: str | None = None + + +class RuneData(BaseModel): + key: str + selector: RuneDataSelector + blackboard: list[Blackboard] + + +class RuneTablePackedRuneData(BaseModel): + id_: str = Field(alias='id') + points: float + mutexGroupKey: str | None + description: str + runes: list[RuneData] + + +class CharmItemData(BaseModel): + id_: str = Field(alias='id') + sort: int + name: str + icon: str + itemUsage: str + itemDesc: str + itemObtainApproach: str + rarity: int + desc: str + price: int + specialObtainApproach: str | None + charmType: str + obtainInRandom: bool + dropStages: list[str] + runeData: RuneTablePackedRuneData + charmEffect: str + + +class CharmTable(BaseModel): + __version__ = '23-07-27-18-50-06-aeb568' + + class Config: + extra = 'allow' + + charmList: list[CharmItemData] diff --git a/ArknightsUID/utils/models/gamedata/CharwordTable.py b/ArknightsUID/utils/models/gamedata/CharwordTable.py new file mode 100644 index 0000000..938a197 --- /dev/null +++ b/ArknightsUID/utils/models/gamedata/CharwordTable.py @@ -0,0 +1,68 @@ +from pydantic import BaseModel, Field + + +class CharWordUnlockParam(BaseModel): + valueStr: str | None + valueInt: int + + +class CharWordData(BaseModel): + charWordId: str + wordKey: str + charId: str + voiceId: str + voiceText: str + voiceTitle: str + voiceIndex: int + voiceType: str + unlockType: str + unlockParam: list[CharWordUnlockParam] + lockDescription: str | None + placeType: str + voiceAsset: str + + +class VoiceLangInfoData(BaseModel): + wordkey: str + voiceLangType: str + cvName: list[str] + + +class VoiceLangData(BaseModel): + wordkeys: list[str] + charId: str + dict_: dict[str, VoiceLangInfoData] = Field(alias='dict') + + +class VoiceLangTypeData(BaseModel): + name: str + groupType: str + + +class VoiceLangGroupData(BaseModel): + name: str + members: list[str] + + +class NewVoiceTimeData(BaseModel): + timestamp: int + charSet: list[str] + + +class CharwordTable(BaseModel): + __version__ = '23-07-27-18-50-06-aeb568' + + charWords: dict[str, CharWordData] + voiceLangDict: dict[str, VoiceLangData] + defaultLangType: str + newTagList: list[str] + voiceLangTypeDict: dict[str, VoiceLangTypeData] + voiceLangGroupTypeDict: dict[str, VoiceLangGroupData] + charDefaultTypeDict: dict[str, str] + startTimeWithTypeDict: dict[str, list[NewVoiceTimeData]] + displayGroupTypeList: list[str] + displayTypeList: list[str] + playVoiceRange: str + + class Config: + extra = 'allow' diff --git a/ArknightsUID/utils/models/gamedata/CheckinTable.py b/ArknightsUID/utils/models/gamedata/CheckinTable.py new file mode 100644 index 0000000..0408e5d --- /dev/null +++ b/ArknightsUID/utils/models/gamedata/CheckinTable.py @@ -0,0 +1,42 @@ +from pydantic import BaseModel, Field + + +class ItemBundle(BaseModel): + id_: str = Field(alias='id') + count: int + type_: str = Field(alias='type') + + +class MonthlySignInData(BaseModel): + itemId: str + itemType: str + count: int + + +class MonthlySignInGroupData(BaseModel): + groupId: str + title: str + description: str + signStartTime: int + signEndTime: int + items: list[MonthlySignInData] + + +class MonthlyDailyBonusGroup(BaseModel): + groupId: str + startTime: int + endTime: int + items: list[ItemBundle] + imgId: str + backId: str + + +class CheckinTable(BaseModel): + __version__ = '23-07-27-18-50-06-aeb568' + + groups: dict[str, MonthlySignInGroupData] + monthlySubItem: dict[str, list[MonthlyDailyBonusGroup]] + currentMonthlySubId: str + + class Config: + extra = 'allow' diff --git a/ArknightsUID/utils/models/gamedata/ClimbTowerTable.py b/ArknightsUID/utils/models/gamedata/ClimbTowerTable.py new file mode 100644 index 0000000..3cce53d --- /dev/null +++ b/ArknightsUID/utils/models/gamedata/ClimbTowerTable.py @@ -0,0 +1,250 @@ +from pydantic import BaseModel, Field + + +class ItemBundle(BaseModel): + id_: str = Field(alias='id') + count: int + type_: str = Field(alias='type') + + +class ClimbTowerSingleTowerDataClimbTowerTaskRewardData(BaseModel): + levelNum: int + rewards: list[ItemBundle] + + +class ClimbTowerSingleTowerData(BaseModel): + id_: str = Field(alias='id') + sortId: int + stageNum: int + name: str + subName: str + desc: str + towerType: str + levels: list[str] + hardLevels: list[str] | None + taskInfo: list[ClimbTowerSingleTowerDataClimbTowerTaskRewardData] | None + preTowerId: str | None + medalId: str | None + hiddenMedalId: str | None + hardModeMedalId: str | None + bossId: str | None + cardId: str | None + curseCardIds: list[str] + dangerDesc: str + hardModeDesc: str | None + + +class WeightItemBundle(BaseModel): + id_: str = Field(alias='id') + type_: str = Field(alias='type') + dropType: str + count: int + weight: int + + +class StageDataDisplayRewards(BaseModel): + type_: str = Field(alias='type') + id_: str = Field(alias='id') + dropType: int + + +class StageDataDisplayDetailRewards(BaseModel): + occPercent: int + type_: str = Field(alias='type') + id_: str = Field(alias='id') + dropType: int + + +class ClimbTowerDropDisplayInfo(BaseModel): + itemId: str + type_: int = Field(alias='type') + maxCount: int + minCount: int + + +class ClimbTowerLevelDropInfo(BaseModel): + passRewards: list[list[WeightItemBundle]] | None = None + displayRewards: list[StageDataDisplayRewards] | None + displayDetailRewards: list[StageDataDisplayDetailRewards] | None + displayDropInfo: dict[str, ClimbTowerDropDisplayInfo] | None = None + + +class ClimbTowerSingleLevelData(BaseModel): + id_: str = Field(alias='id') + levelId: str + towerId: str + layerNum: int + code: str + name: str + desc: str + levelType: str + loadingPicId: str + dropInfo: ClimbTowerLevelDropInfo + + +class ClimbTowerTacticalBuffData(BaseModel): + id_: str = Field(alias='id') + desc: str + profession: str + isDefaultActive: bool + sortId: int + buffType: str + + +class RuneDataSelector(BaseModel): + professionMask: int | str + buildableMask: int + charIdFilter: list[str] | None + enemyIdFilter: list[str] | None + enemyIdExcludeFilter: list[str] | None + skillIdFilter: list[str] | None + tileKeyFilter: list[str] | None + groupTagFilter: list[str] | None + filterTagFilter: list[str] | None + + +class Blackboard(BaseModel): + key: str + value: float | None = None + valueStr: str | None = None + + +class RuneData(BaseModel): + key: str + selector: RuneDataSelector + blackboard: list[Blackboard] + + +class RuneTablePackedRuneData(BaseModel): + id_: str = Field(alias='id') + points: float + mutexGroupKey: str | None + description: str + runes: list[RuneData] + + +class ClimbTowerMainCardData(BaseModel): + id_: str = Field(alias='id') + type_: str = Field(alias='type') + linkedTowerId: str | None + sortId: int + name: str + desc: str + subCardIds: list[str] + runeData: RuneTablePackedRuneData + trapIds: list[str] + + +class ClimbTowerSubCardData(BaseModel): + id_: str = Field(alias='id') + mainCardId: str + sortId: int + name: str + desc: str + runeData: RuneTablePackedRuneData + trapIds: list[str] + + +class ClimbTowerCurseCardData(BaseModel): + id_: str = Field(alias='id') + towerIdList: list[str] + name: str + desc: str + trapId: str + + +class ClimbTowerSeasonInfoData(BaseModel): + id_: str = Field(alias='id') + name: str + startTs: int + endTs: int + towers: list[str] + seasonCards: list[str] + seasonColor: str + + +class ClimbTowerDetailConst(BaseModel): + unlockLevelId: str + unlockModuleNumRequirement: int + lowerItemId: str + lowerItemLimit: int + higherItemId: str + higherItemLimit: int + initCharCount: int + recruitStageSort: list[int] | None = None + charRecruitTimes: int + charRecruitChoiceCount: int + subcardStageSort: int + assistCharLimit: int + firstClearTaskDesc: str + subCardObtainDesc: str + subGodCardUnlockDesc: str + + +class ClimbTowerRewardInfo(BaseModel): + stageSort: int + lowerItemCount: int + higherItemCount: int + + +class MissionDisplayRewards(BaseModel): + type_: str = Field(alias='type') + id_: str = Field(alias='id') + count: int + + +class MissionData(BaseModel): + id_: str = Field(alias='id') + sortId: int + description: str + type_: str = Field(alias='type') + itemBgType: str + preMissionIds: list[str] | None + template: str + templateType: str + param: list[str] + unlockCondition: str | None + unlockParam: list[str] | None + missionGroup: str + toPage: str | None + periodicalPoint: int + rewards: list[MissionDisplayRewards] | None + backImagePath: str | None + foldId: str | None + haveSubMissionToUnlock: bool + + +class ClimbTowerMissionData(MissionData): + bindGodCardId: str | None + missionBkg: str + + +class MissionGroup(BaseModel): + id_: str = Field(alias='id') + title: str | None + type_: str = Field(alias='type') + preMissionGroup: str | None + period: list[int] | None + rewards: list[MissionDisplayRewards] + missionIds: list[str] + startTs: int + endTs: int + + +class ClimbTowerTable(BaseModel): + __version__ = '23-07-27-18-50-06-aeb568' + + towers: dict[str, ClimbTowerSingleTowerData] + levels: dict[str, ClimbTowerSingleLevelData] + tacticalBuffs: dict[str, ClimbTowerTacticalBuffData] + mainCards: dict[str, ClimbTowerMainCardData] + subCards: dict[str, ClimbTowerSubCardData] + curseCards: dict[str, ClimbTowerCurseCardData] + seasonInfos: dict[str, ClimbTowerSeasonInfoData] + detailConst: ClimbTowerDetailConst + rewardInfoList: list[ClimbTowerRewardInfo] + missionData: dict[str, ClimbTowerMissionData] + missionGroup: dict[str, MissionGroup] + + class Config: + extra = 'allow' diff --git a/ArknightsUID/utils/models/gamedata/ClueData.py b/ArknightsUID/utils/models/gamedata/ClueData.py new file mode 100644 index 0000000..610744f --- /dev/null +++ b/ArknightsUID/utils/models/gamedata/ClueData.py @@ -0,0 +1,40 @@ +from pydantic import BaseModel + + +class MeetingClueDataClueData(BaseModel): + clueId: str + clueName: str + clueType: str + number: int + + +class MeetingClueDataClueTypeData(BaseModel): + clueType: str + clueNumber: int + + +class MeetingClueDataReceiveTimeBonus(BaseModel): + receiveTimes: int + receiveBonus: int + + +class ClueData(BaseModel): + __version__ = '23-07-27-18-50-06-aeb568' + + clues: list[MeetingClueDataClueData] + clueTypes: list[MeetingClueDataClueTypeData] + receiveTimeBonus: list[MeetingClueDataReceiveTimeBonus] + inventoryLimit: int + outputBasicBonus: int + outputOperatorsBonus: int + cluePointLimit: int + expiredDays: int + transferBonus: int + recycleBonus: int + expiredBonus: int + communicationDuration: int + initiatorBonus: int + participantsBonus: int + + class Config: + extra = 'allow' diff --git a/ArknightsUID/utils/models/gamedata/CrisisTable.py b/ArknightsUID/utils/models/gamedata/CrisisTable.py new file mode 100644 index 0000000..53f2d41 --- /dev/null +++ b/ArknightsUID/utils/models/gamedata/CrisisTable.py @@ -0,0 +1,48 @@ +from pydantic import BaseModel, Field + + +class ItemBundle(BaseModel): + id_: str = Field(alias='id') + count: int + type_: str = Field(alias='type') + + +class StringKeyFrames(BaseModel): + level: int + data: str + + +class CrisisClientDataSeasonInfo(BaseModel): + seasonId: str + startTs: int + endTs: int + name: str + crisisRuneCoinUnlockItem: ItemBundle + permBgm: str + medalGroupId: str | None + bgmHardPoint: int + permBgmHard: str | None + + +class CrisisMapRankInfo(BaseModel): + rewards: list[ItemBundle] + unlockPoint: int + + +class CrisisTable(BaseModel): + __version__ = '23-07-27-18-50-06-aeb568' + + seasonInfo: list[CrisisClientDataSeasonInfo] + tempAppraise: list[StringKeyFrames] + permAppraise: list[StringKeyFrames] + mapRankInfo: dict[str, CrisisMapRankInfo] + meta: str + unlockCoinLv3: int + hardPointPerm: int + hardPointTemp: int + voiceGrade: int + crisisRuneCoinUnlockItemTitle: str + crisisRuneCoinUnlockItemDesc: str + + class Config: + extra = 'allow' diff --git a/ArknightsUID/utils/models/gamedata/DisplayMetaTable.py b/ArknightsUID/utils/models/gamedata/DisplayMetaTable.py new file mode 100644 index 0000000..75ff1d6 --- /dev/null +++ b/ArknightsUID/utils/models/gamedata/DisplayMetaTable.py @@ -0,0 +1,53 @@ +from pydantic import BaseModel + + +class PlayerAvatarPerData(BaseModel): + avatarId: str + avatarType: str + avatarIdSort: int + avatarIdDesc: str + avatarItemName: str + avatarItemDesc: str + avatarItemUsage: str + obtainApproach: str + + +class PlayerAvatarGroupData(BaseModel): + avatarType: str + typeName: str + avatarIdList: list[str] + + +class PlayerAvatarData(BaseModel): + defaultAvatarId: str + avatarList: list[PlayerAvatarPerData] + avatarTypeData: dict[str, PlayerAvatarGroupData] + + +class HomeBackgroundSingleData(BaseModel): + bgId: str + bgType: str + bgSortId: int + bgStartTime: int + bgName: str + bgMusicId: str + bgDes: str + bgUsage: str + obtainApproach: str + unlockDesList: list[str] + + +class HomeBackgroundData(BaseModel): + defaultBackgroundId: str + homeBgDataList: list[HomeBackgroundSingleData] + defaultBgMusicId: str + + +class DisplayMetaTable(BaseModel): + __version__ = '23-07-27-18-50-06-aeb568' + + playerAvatarData: PlayerAvatarData + homeBackgroundData: HomeBackgroundData + + class Config: + extra = 'allow' diff --git a/ArknightsUID/utils/models/gamedata/EnemyHandbookTable.py b/ArknightsUID/utils/models/gamedata/EnemyHandbookTable.py new file mode 100644 index 0000000..a03c53a --- /dev/null +++ b/ArknightsUID/utils/models/gamedata/EnemyHandbookTable.py @@ -0,0 +1,57 @@ +from pydantic import BaseModel, Field + + +class EnemyHandBookDataAbilty(BaseModel): + text: str + textFormat: str + + +class EnemyHandBookData(BaseModel): + enemyId: str + enemyIndex: str + enemyTags: list[str] | None + sortId: int + name: str + enemyLevel: str + description: str + attackType: str | None + ability: str | None + isInvalidKilled: bool + overrideKillCntInfos: dict[str, int] + hideInHandbook: bool + abilityList: list[EnemyHandBookDataAbilty] | None + linkEnemies: list[str] | None + damageType: list[str] | None + invisibleDetail: bool + + +class EnemyHandbookLevelInfoDataRangePair(BaseModel): + min_: float = Field(alias='min') + max_: float = Field(alias='max') + + +class EnemyHandbookLevelInfoData(BaseModel): + classLevel: str + attack: EnemyHandbookLevelInfoDataRangePair + def_: EnemyHandbookLevelInfoDataRangePair = Field(alias='def') + magicRes: EnemyHandbookLevelInfoDataRangePair + maxHP: EnemyHandbookLevelInfoDataRangePair + moveSpeed: EnemyHandbookLevelInfoDataRangePair + attackSpeed: EnemyHandbookLevelInfoDataRangePair + + +class EnemyHandbookRaceData(BaseModel): + id_: str = Field(alias='id') + raceName: str + sortId: int + + +class EnemyHandbookTable(BaseModel): + __version__ = '23-07-27-18-50-06-aeb568' + + levelInfoList: list[EnemyHandbookLevelInfoData] + enemyData: dict[str, EnemyHandBookData] + raceData: dict[str, EnemyHandbookRaceData] + + class Config: + extra = 'allow' diff --git a/ArknightsUID/utils/models/gamedata/FavorTable.py b/ArknightsUID/utils/models/gamedata/FavorTable.py new file mode 100644 index 0000000..944a139 --- /dev/null +++ b/ArknightsUID/utils/models/gamedata/FavorTable.py @@ -0,0 +1,19 @@ +from pydantic import BaseModel + + +class FavorData(BaseModel): + favorPoint: int + percent: int + battlePhase: int + + +class FavorDataFrames(BaseModel): + level: int + data: FavorData + + +class FavorTable(BaseModel): + __version__ = '23-07-27-18-50-06-aeb568' + + maxFavor: int + favorFrames: list[FavorDataFrames] diff --git a/ArknightsUID/utils/models/gamedata/GachaTable.py b/ArknightsUID/utils/models/gamedata/GachaTable.py new file mode 100644 index 0000000..d596ff9 --- /dev/null +++ b/ArknightsUID/utils/models/gamedata/GachaTable.py @@ -0,0 +1,153 @@ +from pydantic import BaseModel, Field + + +class GachaDataLinkageTenGachaTkt(BaseModel): + itemId: str + endTime: int + gachaPoolId: str + + +class GachaDataLimitTenGachaTkt(BaseModel): + itemId: str + endTime: int + + +class GachaDataFreeLimitGachaData(BaseModel): + poolId: str + openTime: int + endTime: int + freeCount: int + + +class GachaDataCarouselData(BaseModel): + poolId: str + index: int + startTime: int + endTime: int + spriteId: str + + +class ItemBundle(BaseModel): + id_: str = Field(alias='id') + count: int + type_: str = Field(alias='type') + + +class GachaDataRecruitRange(BaseModel): + rarityStart: int + rarityEnd: int + + +class PotentialMaterialConverterConfig(BaseModel): + items: dict[str, ItemBundle] + + +class RecruitPoolRecruitTime(BaseModel): + timeLength: int + recruitPrice: int + accumRate: float | None = None + + +class RecruitConstantsData(BaseModel): + rarityWeights: None = None + tagPriceList: dict[str, int] + recruitTimeFactorList: None = None + maxRecruitTime: int + + +class RecruitPool(BaseModel): + recruitTimeTable: list[RecruitPoolRecruitTime] + recruitCharacterList: None = None + recruitConstants: RecruitConstantsData + maskTypeWeightTable: None = None + + +class NewbeeGachaPoolClientData(BaseModel): + gachaPoolId: str + gachaIndex: int + gachaPoolName: str + gachaPoolDetail: str + gachaPrice: int + gachaTimes: int + gachaOffset: str | None = None + firstOpenDay: int | None = None + reOpenDay: int | None = None + gachaPoolItems: None = None + signUpEarliestTime: int | None = None + + +class GachaPoolClientData(BaseModel): + CDPrimColor: str | None + CDSecColor: str | None + dynMeta: dict[str, object] | None = None + endTime: int + gachaIndex: int + gachaPoolDetail: str | None + gachaPoolId: str + gachaPoolName: str + gachaPoolSummary: str + gachaRuleType: str + guarantee5Avail: int + guarantee5Count: int + linkageParam: dict[str, object] | None = None + linkageRuleId: str | None = None + LMTGSID: str | None + openTime: int + + +class GachaTag(BaseModel): + tagId: int + tagName: str + tagGroup: int + + +class SpecialRecruitPoolSpecialRecruitCostData(BaseModel): + itemCosts: ItemBundle + recruitPrice: int + timeLength: int + + +class SpecialRecruitPool(BaseModel): + endDateTime: int + order: int + recruitId: str + recruitTimeTable: list[SpecialRecruitPoolSpecialRecruitCostData] + startDateTime: int + tagId: int + tagName: str + CDPrimColor: str | None + CDSecColor: str | None + LMTGSID: str | None + gachaRuleType: str + + +class GachaDataFesGachaPoolRelateItem(BaseModel): + rarityRank5ItemId: str + rarityRank6ItemId: str + + +class GachaTable(BaseModel): + __version__ = '23-07-27-18-50-06-aeb568' + + gachaTags: list[GachaTag] + carousel: list[GachaDataCarouselData] + classicPotentialMaterialConverter: PotentialMaterialConverterConfig + dicRecruit6StarHint: dict[str, str] | None + fesGachaPoolRelateItem: dict[str, GachaDataFesGachaPoolRelateItem] | None + freeGacha: list[GachaDataFreeLimitGachaData] + gachaPoolClient: list[GachaPoolClientData] + gachaTagMaxValid: int | None = None + limitTenGachaItem: list[GachaDataLimitTenGachaTkt] + linkageTenGachaItem: list[GachaDataLinkageTenGachaTkt] + newbeeGachaPoolClient: list[NewbeeGachaPoolClientData] + potentialMaterialConverter: PotentialMaterialConverterConfig + recruitDetail: str + recruitPool: RecruitPool + recruitRarityTable: dict[str, GachaDataRecruitRange] + specialRecruitPool: list[SpecialRecruitPool] + specialTagRarityTable: dict[str, list[int]] + potentialMats: dict | None = None + classicPotentialMats: dict | None = None + + class Config: + extra = 'allow' diff --git a/ArknightsUID/utils/models/gamedata/GamedataConst.py b/ArknightsUID/utils/models/gamedata/GamedataConst.py new file mode 100644 index 0000000..a37ae8b --- /dev/null +++ b/ArknightsUID/utils/models/gamedata/GamedataConst.py @@ -0,0 +1,118 @@ +from pydantic import BaseModel, Field + + +class ItemBundle(BaseModel): + id_: str = Field(alias='id') + count: int + type_: str = Field(alias='type') + + +class GameDataConstsCharAssistRefreshTimeState(BaseModel): + Hour: int + Minute: int + + +class TermDescriptionData(BaseModel): + termId: str + termName: str + description: str + + +class GamedataConst(BaseModel): + __version__ = '23-07-27-18-50-06-aeb568' + + addedRewardDisplayZone: str + advancedGachaCrystalCost: int + announceWebBusType: str + apBuyCost: int + apBuyThreshold: int + assistBeUsedSocialPt: dict[str, int] + attackMax: float + baseMaxFriendNum: int + buyApTimeNoLimitFlag: bool + characterExpMap: list[list[int]] + characterUpgradeCostMap: list[list[int]] + charAssistRefreshTime: list[GameDataConstsCharAssistRefreshTimeState] + charmEquipCount: int + commonPotentialLvlUpCount: int + completeCrystalBonus: int + completeGainBonus: float + creditLimit: int + crisisUnlockStage: str + dataVersion: str + defCDPrimColor: str + defCDSecColor: str + defMax: float + diamondMaterialToShardExchangeRatio: int + diamondToShdRate: int + easyCrystalBonus: int + evolveGoldCost: list[list[int]] + friendAssistRarityLimit: list[int] + hardDiamondDrop: int + hpMax: float + initCampaignTotalFee: int + initCharIdList: list[str] + initPlayerDiamondShard: int + initPlayerGold: int + initRecruitTagList: list[int] + instFinDmdShdCost: int + isClassicGachaPoolFuncEnabled: bool + isClassicPotentialItemFuncEnabled: bool + isClassicQCShopEnabled: bool + isDynIllustEnabled: bool + isDynIllustStartEnabled: bool + isLMGTSEnabled: bool + isRoguelikeAvgAchieveFuncEnabled: bool + isRoguelikeTopicFuncEnabled: bool + isVoucherClassicItemDistinguishable: bool | None = None + legacyItemList: list[ItemBundle] + legacyTime: int + lMTGSDescConstOne: str + lMTGSDescConstTwo: str + LMTGSToEPGSRatio: int + mailBannerType: list[str] + mainlineCompatibleDesc: str + mainlineEasyDesc: str + mainlineNormalDesc: str + mainlineToughDesc: str + maxLevel: list[list[int]] + maxPlayerLevel: int + maxPracticeTicket: int + monthlySubRemainTimeLimitDays: int + monthlySubWarningTime: int + multiInComeByRank: list[str] + newBeeGiftEPGS: int + normalGachaUnlockPrice: list[int] + normalRecruitLockedString: list[str] + operatorRecordsStartTime: int | None = None + playerApMap: list[int] + playerApRegenSpeed: int + playerExpMap: list[int] + pullForces: list[float] + pullForceZeroIndex: int + pushForces: list[float] + pushForceZeroIndex: int + recruitPoolVersion: int + rejectSpCharMission: int + reMax: float + replicateShopStartTime: int + requestSameFriendCD: int + resPrefVersion: str + richTextStyles: dict[str, str] + storyReviewUnlockItemLackTip: str + subProfessionDamageTypePairs: dict[str, int] | None = None + termDescriptionDict: dict[str, TermDescriptionData] + UnlimitSkinOutOfTime: int + useAssistSocialPt: int + useAssistSocialPtMaxCount: int + v006RecruitTimeStep1Refresh: int + v006RecruitTimeStep2Check: int + v006RecruitTimeStep2Flush: int + voucherDiv: int + voucherSkinDesc: str + voucherSkinRedeem: int + weeklyOverrideDesc: str + TSO: int + + class Config: + extra = 'allow' diff --git a/ArknightsUID/utils/models/gamedata/HandbookInfoTable.py b/ArknightsUID/utils/models/gamedata/HandbookInfoTable.py new file mode 100644 index 0000000..8a64c8d --- /dev/null +++ b/ArknightsUID/utils/models/gamedata/HandbookInfoTable.py @@ -0,0 +1,131 @@ +from pydantic import BaseModel, Field + + +class HandbookUnlockParam(BaseModel): + unlockType: int + unlockParam1: str + unlockParam2: str | None + unlockParam3: str | None + + +class ItemBundle(BaseModel): + id_: str = Field(alias='id') + count: int + type_: str = Field(alias='type') + + +class HandbookStageTimeData(BaseModel): + timestamp: int + charSet: list[str] + + +class HandbookStoryStageData(BaseModel): + charId: str + code: str + description: str + levelId: str + loadingPicId: str + name: str + picId: str + rewardItem: list[ItemBundle] + stageGetTime: int + stageId: str + stageNameForShow: str + unlockParam: list[HandbookUnlockParam] + zoneId: str + zoneNameForShow: str + + +class HandbookDisplayCondition(BaseModel): + charId: str + conditionCharId: str + type_: str = Field(alias='type') + + +class HandbookTeamMission(BaseModel): + id_: str = Field(alias='id') + sort: int + powerId: str + powerName: str + item: ItemBundle + favorPoint: int + + +class NPCUnlock(BaseModel): + unLockType: int + unLockParam: str + unLockString: str | None = None + + +class NPCData(BaseModel): + appellation: str + cv: str + designerList: list[str] | None + displayNumber: str + groupId: str | None + illustList: list[str] + name: str + nationId: str + npcId: str + npcShowAudioInfoFlag: bool + profession: str + resType: str + teamId: None + unlockDict: dict[str, NPCUnlock] + minPowerId: str + + +class HandbookAvgData(BaseModel): + storyId: str + storySetId: str + storySort: int + storyCanShow: bool + storyIntro: str + storyInfo: str + storyTxt: str + + +class HandbookAvgGroupData(BaseModel): + storySetId: str + storySetName: str + sortId: int + storyGetTime: int + rewardItem: list[ItemBundle] + unlockParam: list[HandbookUnlockParam] + avgList: list[HandbookAvgData] + charId: str + + +class HandbookStoryData(BaseModel): + storyText: str + unLockType: int + unLockParam: str + unLockString: str + + +class HandBookStoryViewData(BaseModel): + stories: list[HandbookStoryData] + storyTitle: str + unLockorNot: bool + + +class HandbookInfoData(BaseModel): + charID: str + infoName: str + storyTextAudio: list[HandBookStoryViewData] + handbookAvgList: list[HandbookAvgGroupData] + isLimited: bool | None = None + + +class HandbookInfoTable(BaseModel): + __version__ = '23-07-27-18-50-06-aeb568' + + handbookDict: dict[str, HandbookInfoData] + npcDict: dict[str, NPCData] + teamMissionList: dict[str, HandbookTeamMission] + handbookDisplayConditionList: dict[str, HandbookDisplayCondition] + handbookStageData: dict[str, HandbookStoryStageData] + handbookStageTime: list[HandbookStageTimeData] + + class Config: + extra = 'allow' diff --git a/ArknightsUID/utils/models/gamedata/HandbookTable.py b/ArknightsUID/utils/models/gamedata/HandbookTable.py new file mode 100644 index 0000000..e87efe3 --- /dev/null +++ b/ArknightsUID/utils/models/gamedata/HandbookTable.py @@ -0,0 +1,43 @@ +from pydantic import BaseModel + + +class HandBookInfoTextViewDataInfoTextAudio(BaseModel): + infoText: str + audioName: str + + +class StoryTextAudioInfoListItem(BaseModel): + storyText: str | None + storyTitle: str | None + + +class StoryTextAudioItem(BaseModel): + stories: list[StoryTextAudioInfoListItem] + unLockorNot: bool + unLockType: int + unLockParam: str + unLockString: str + + +class HandBookInfoTextViewData(BaseModel): + infoList: list[HandBookInfoTextViewDataInfoTextAudio] + unLockorNot: bool + unLockType: int + unLockParam: str + unLockLevel: int + unLockLevelAdditive: int + unLockString: str + + +class CharHandbook(BaseModel): + charID: str + drawName: str + infoName: str + infoTextAudio: list[HandBookInfoTextViewData] + storyTextAudio: list[StoryTextAudioItem] + + +class HandbookTable(BaseModel): + __version__ = '23-07-27-18-50-06-aeb568' + + char_102_texas: CharHandbook diff --git a/ArknightsUID/utils/models/gamedata/HandbookTeamTable.py b/ArknightsUID/utils/models/gamedata/HandbookTeamTable.py new file mode 100644 index 0000000..bff8f5b --- /dev/null +++ b/ArknightsUID/utils/models/gamedata/HandbookTeamTable.py @@ -0,0 +1,21 @@ +from pydantic import BaseModel + + +class HandbookTeam(BaseModel): + powerId: str + orderNum: int + powerLevel: int + powerName: str + powerCode: str + color: str + isLimited: bool + isRaw: bool + + +class HandbookTeamTable(BaseModel): + __version__ = '23-07-27-18-50-06-aeb568' + + team: dict[str, HandbookTeam] + + def __init__(self, **data): + super().__init__(team=data) diff --git a/ArknightsUID/utils/models/gamedata/ItemTable.py b/ArknightsUID/utils/models/gamedata/ItemTable.py new file mode 100644 index 0000000..97460e3 --- /dev/null +++ b/ArknightsUID/utils/models/gamedata/ItemTable.py @@ -0,0 +1,107 @@ +from pydantic import BaseModel, Field + + +class ItemDataStageDropInfo(BaseModel): + stageId: str + occPer: str + + +class ItemDataBuildingProductInfo(BaseModel): + roomType: str + formulaId: str + + +class ItemBundle(BaseModel): + id_: str = Field(alias='id') + count: int + type_: str = Field(alias='type') + + +class FavorCharacterInfo(BaseModel): + itemId: str + charId: str + favorAddAmt: int + + +class ActivityPotentialCharacterInfo(BaseModel): + charId: str + + +class FullPotentialCharacterInfo(BaseModel): + itemId: str + ts: int + + +class ItemPackInfo(BaseModel): + packId: str + content: list[ItemBundle] + + +class UniCollectionInfo(BaseModel): + uniCollectionItemId: str + uniqueItem: list[ItemBundle] + + +class ApSupplyFeature(BaseModel): + id_: str = Field(alias='id') + ap: int + hasTs: bool + + +class ExpItemFeature(BaseModel): + id_: str = Field(alias='id') + gainExp: int + + +class ItemData(BaseModel): + itemId: str + name: str + description: str | None + rarity: int + iconId: str + overrideBkg: None + stackIconId: str | None + sortId: int + usage: str | None + obtainApproach: str | None + classifyType: str + itemType: str + stageDropList: list[ItemDataStageDropInfo] + buildingProductList: list[ItemDataBuildingProductInfo] + + +class CharVoucherItemFeature(BaseModel): + displayType: int + id_: str = Field(alias='id') + + +class ServerItemReminderMailData(BaseModel): + content: str + sender: str + title: str + + +class ServerItemReminderInfo(BaseModel): + paidItemIdList: list[str] + paidReminderMail: ServerItemReminderMailData + + +class ItemTable(BaseModel): + __version__ = '23-07-27-18-50-06-aeb568' + + activityPotentialCharacters: dict[str, ActivityPotentialCharacterInfo] + apSupplies: dict[str, ApSupplyFeature] + charVoucherItems: dict[str, CharVoucherItemFeature] | None = None + expItems: dict[str, ExpItemFeature] + favorCharacters: dict[str, FavorCharacterInfo] + fullPotentialCharacters: dict[str, FullPotentialCharacterInfo] + itemPackInfos: dict[str, ItemPackInfo] + items: dict[str, ItemData] + itemTimeLimit: dict[str, int] + potentialItems: dict[str, dict[str, str]] + reminderInfo: ServerItemReminderInfo | None = None + uniCollectionInfo: dict[str, UniCollectionInfo] + uniqueInfo: dict[str, int] + + class Config: + extra = 'allow' diff --git a/ArknightsUID/utils/models/gamedata/MedalTable.py b/ArknightsUID/utils/models/gamedata/MedalTable.py new file mode 100644 index 0000000..0773663 --- /dev/null +++ b/ArknightsUID/utils/models/gamedata/MedalTable.py @@ -0,0 +1,65 @@ +from pydantic import BaseModel, Field + + +class MedalExpireTime(BaseModel): + start: int + end: int + type_: str = Field(alias='type') + + +class ItemBundle(BaseModel): + id_: str = Field(alias='id') + count: int + type_: str = Field(alias='type') + + +class MedalGroupData(BaseModel): + groupId: str + groupName: str + groupDesc: str + medalId: list[str] + sortId: int + groupBackColor: str + groupGetTime: int + sharedExpireTimes: list[MedalExpireTime] | None + + +class MedalRewardGroupData(BaseModel): + groupId: str + slotId: int + itemList: list[ItemBundle] + + +class MedalTypeData(BaseModel): + medalGroupId: str + sortId: int + medalName: str + groupData: list[MedalGroupData] + + +class MedalPerData(BaseModel): + medalId: str | None + medalName: str | None + medalType: str | None + slotId: int | None + preMedalIdList: list[str] | None + rarity: int + template: str | None + unlockParam: list[str] + getMethod: str | None + description: str | None + advancedMedal: str | None + originMedal: str | None + displayTime: int + expireTimes: list[MedalExpireTime] + medalRewardGroup: list[MedalRewardGroupData] + + +class MedalTable(BaseModel): + __version__ = '23-07-27-18-50-06-aeb568' + + medalList: list[MedalPerData] + medalTypeData: dict[str, MedalTypeData] + + class Config: + extra = 'allow' diff --git a/ArknightsUID/utils/models/gamedata/MissionTable.py b/ArknightsUID/utils/models/gamedata/MissionTable.py new file mode 100644 index 0000000..e54c048 --- /dev/null +++ b/ArknightsUID/utils/models/gamedata/MissionTable.py @@ -0,0 +1,87 @@ +from pydantic import BaseModel, Field + + +class MissionDisplayRewards(BaseModel): + type_: str = Field(alias='type') + id_: str = Field(alias='id') + count: int + + +class DailyMissionGroupInfoperiodInfo(BaseModel): + missionGroupId: str + period: list[int] + rewardGroupId: str + + +class DailyMissionGroupInfo(BaseModel): + endTime: int + periodList: list[DailyMissionGroupInfoperiodInfo] + startTime: int + tagState: str | None + + +class MissionWeeklyRewardConf(BaseModel): + beginTime: int + endTime: int + groupId: str + id_: str = Field(alias='id') + periodicalPointCost: int + type_: str = Field(alias='type') + sortIndex: int + rewards: list[MissionDisplayRewards] + + +class MissionDailyRewardConf(BaseModel): + groupId: str + id_: str = Field(alias='id') + periodicalPointCost: int + type_: str = Field(alias='type') + sortIndex: int + rewards: list[MissionDisplayRewards] + + +class MissionGroup(BaseModel): + id_: str = Field(alias='id') + title: str | None + type_: str = Field(alias='type') + preMissionGroup: str | None + period: list[int] | None + rewards: list[MissionDisplayRewards] | None + missionIds: list[str] + startTs: int + endTs: int + + +class MissionData(BaseModel): + id_: str = Field(alias='id') + sortId: int + description: str + type_: str = Field(alias='type') + itemBgType: str + preMissionIds: list[str] | None + template: str + templateType: str + param: list[str] + unlockCondition: str | None + unlockParam: list[str] | None + missionGroup: str + toPage: None + periodicalPoint: int + rewards: list[MissionDisplayRewards] | None + backImagePath: str | None + foldId: str | None + haveSubMissionToUnlock: bool + + +class MissionTable(BaseModel): + __version__ = '23-07-27-18-50-06-aeb568' + + missions: dict[str, MissionData] + missionGroups: dict[str, MissionGroup] + periodicalRewards: dict[str, MissionDailyRewardConf] + weeklyRewards: dict[str, MissionWeeklyRewardConf] + dailyMissionGroupInfo: dict[str, DailyMissionGroupInfo] + dailyMissionPeriodInfo: list[DailyMissionGroupInfo] + + class Config: + extra = 'allow' diff --git a/ArknightsUID/utils/models/gamedata/OpenServerTable.py b/ArknightsUID/utils/models/gamedata/OpenServerTable.py new file mode 100644 index 0000000..053e4a2 --- /dev/null +++ b/ArknightsUID/utils/models/gamedata/OpenServerTable.py @@ -0,0 +1,154 @@ +from pydantic import BaseModel, Field + + +class ItemBundle(BaseModel): + type_: str = Field(alias='type') + id_: str = Field(alias='id') + count: int + + +class MissionDisplayRewards(BaseModel): + type_: str = Field(alias='type') + id_: str = Field(alias='id') + count: int + + +class OpenServerItemData(BaseModel): + itemId: str + itemType: str + count: int + + +class ReturnIntroData(BaseModel): + sort: int + pubTime: int + image: str + + +class ReturnCheckinData(BaseModel): + isImportant: bool + checkinRewardItems: list[ItemBundle] + + +class ReturnLongTermTaskData(BaseModel): + id_: str = Field(alias='id') + sortId: int + template: str + param: list[str] + desc: str + rewards: list[MissionDisplayRewards] + playPoint: int + + +class ReturnDailyTaskData(BaseModel): + groupId: str + id_: str = Field(alias='id') + groupSortId: int + taskSortId: int + template: str + param: list[str] + desc: str + rewards: list[MissionDisplayRewards] + playPoint: int + + +class ReturnConst(BaseModel): + startTime: int + systemTab_time: int + afkDays: int + unlockLv: int + unlockLevel: str + juniorClear: bool + ifvisitor: bool + permMission_time: int + needPoints: int + defaultIntro: str + pointId: str + + +class ReturnData(BaseModel): + constData: ReturnConst + onceRewards: list[ItemBundle] + intro: list[ReturnIntroData] + returnDailyTaskDic: dict[str, list[ReturnDailyTaskData]] + returnLongTermTaskList: list[ReturnLongTermTaskData] + creditsList: list[ItemBundle] + checkinRewardList: list[ReturnCheckinData] + + +class OpenServerConst(BaseModel): + firstDiamondShardMailCount: int + initApMailEndTs: int + + +class TotalCheckinData(BaseModel): + order: int + item: OpenServerItemData + colorId: int + + +class ChainLoginData(BaseModel): + order: int + item: OpenServerItemData + colorId: int + + +class MissionData(BaseModel): + id_: str = Field(alias='id') + sortId: int + description: str + type_: str = Field(alias='type') + itemBgType: str + preMissionIds: None + template: str + templateType: str + param: list[str] + unlockCondition: None + unlockParam: None + missionGroup: str + toPage: None + periodicalPoint: int + rewards: list[ItemBundle] + backImagePath: None + foldId: None + haveSubMissionToUnlock: bool + + +class MissionGroup(BaseModel): + id_: str = Field(alias='id') + title: None + type_: str = Field(alias='type') + preMissionGroup: None + period: None + rewards: None + missionIds: list[str] + startTs: int + endTs: int + + +class OpenServerData(BaseModel): + openServerMissionGroup: MissionGroup + openServerMissionData: list[MissionData] + checkInData: list[TotalCheckinData] + chainLoginData: list[ChainLoginData] + + +class OpenServerScheduleItem(BaseModel): + id_: str = Field(alias='id') + startTs: int + endTs: int + totalCheckinDescption: str + chainLoginDescription: str + charImg: str + + +class OpenServerTable(BaseModel): + __version__ = '23-07-27-18-50-06-aeb568' + + schedule: list[OpenServerScheduleItem] + dataMap: dict[str, OpenServerData] + constant: OpenServerConst + playerReturn: ReturnData + + class Config: + extra = 'allow' diff --git a/ArknightsUID/utils/models/gamedata/PlayerAvatarTable.py b/ArknightsUID/utils/models/gamedata/PlayerAvatarTable.py new file mode 100644 index 0000000..1c3e173 --- /dev/null +++ b/ArknightsUID/utils/models/gamedata/PlayerAvatarTable.py @@ -0,0 +1,26 @@ +from pydantic import BaseModel + + +class PlayerAvatarGroupData(BaseModel): + avatarType: str + typeName: str + avatarIdList: list[str] + + +class PlayerAvatarPerData(BaseModel): + avatarId: str + avatarType: str + avatarIdSort: int + avatarIdDesc: str + avatarItemName: str + avatarItemDesc: str + avatarItemUsage: str + obtainApproach: str + + +class PlayerAvatarTable(BaseModel): + __version__ = '23-07-27-18-50-06-aeb568' + + avatarList: list[PlayerAvatarPerData] + avatarTypeData: dict[str, PlayerAvatarGroupData] + defaultAvatarId: str diff --git a/ArknightsUID/utils/models/gamedata/RangeTable.py b/ArknightsUID/utils/models/gamedata/RangeTable.py new file mode 100644 index 0000000..c3c4653 --- /dev/null +++ b/ArknightsUID/utils/models/gamedata/RangeTable.py @@ -0,0 +1,29 @@ +from pydantic import BaseModel, Field + + +class GridPosition(BaseModel): + row: int + col: int + + +class ObscuredRect(BaseModel): + m_xMin: float + m_yMin: float + m_width: float + m_height: float + + +class Stage(BaseModel): + id_: str = Field(alias='id') + direction: int + grids: list[GridPosition] + boundingBoxes: list[ObscuredRect] | None = None + + +class RangeTable(BaseModel): + __version__ = '23-07-27-18-50-06-aeb568' + + range: dict[str, Stage] + + def __init__(self, **data): + super().__init__(range=data) diff --git a/ArknightsUID/utils/models/gamedata/ReplicateTable.py b/ArknightsUID/utils/models/gamedata/ReplicateTable.py new file mode 100644 index 0000000..0780cef --- /dev/null +++ b/ArknightsUID/utils/models/gamedata/ReplicateTable.py @@ -0,0 +1,28 @@ +from pydantic import BaseModel, Field + + +class ItemBundle(BaseModel): + id_: str = Field(alias='id') + count: int + type_: str = Field(alias='type') + + +class ReplicateData(BaseModel): + item: ItemBundle + replicateTokenItem: ItemBundle + + +class ReplicateList(BaseModel): + replicateList: list[ReplicateData] + + +class ReplicateTable(BaseModel): + __version__ = '23-07-27-18-50-06-aeb568' + + replicate: dict[str, ReplicateList] + + class Config: + extra = 'allow' + + def __init__(self, **data): + super().__init__(replicate=data) diff --git a/ArknightsUID/utils/models/gamedata/RetroTable.py b/ArknightsUID/utils/models/gamedata/RetroTable.py new file mode 100644 index 0000000..4c9292e --- /dev/null +++ b/ArknightsUID/utils/models/gamedata/RetroTable.py @@ -0,0 +1,428 @@ +from pydantic import BaseModel, Field + + +class ItemBundle(BaseModel): + id_: str = Field(alias='id') + count: int + type_: str = Field(alias='type') + + +class StageDataDisplayRewards(BaseModel): + type_: str = Field(alias='type') + id_: str = Field(alias='id') + dropType: int + + +class BlackboardStr(BaseModel): + key: str + valueStr: str + + +class BlackboardInt(BaseModel): + key: str + value: float + + +class Act17sideDataChoiceNodeOptionData(BaseModel): + canRepeat: bool + eventId: str + des: str + unlockDes: str | None + + +class StageDataDisplayDetailRewards(BaseModel): + occPercent: int + type_: str = Field(alias='type') + id_: str = Field(alias='id') + dropType: int + CannotGetPercent: float | None = None + GetPercent: float | None = None + + +class StageDataConditionDesc(BaseModel): + stageId: str + completeState: int + + +class Act17sideDataConstData(BaseModel): + techTreeUnlockEventId: str + + +class Act17sideDataZoneData(BaseModel): + zoneId: str + unlockPlaceId: str | None + unlockText: str + + +class Act17sideDataMainlineData(BaseModel): + mainlineId: str + nodeId: str | None + sortId: int + missionSort: str + zoneId: str + mainlineDes: str + focusNodeId: str | None + + +class Act17sideDataMainlineChapterData(BaseModel): + chapterId: str + chapterDes: str + chapterIcon: str + unlockDes: str + id_: str = Field(alias='id') + + +class RunesSelector(BaseModel): + professionMask: int + buildableMask: int + charIdFilter: None + enemyIdFilter: None + enemyIdExcludeFilter: None + skillIdFilter: None + tileKeyFilter: None + groupTagFilter: None + filterTagFilter: None + + +class TechTreeBranchRunes(BaseModel): + key: str + selector: RunesSelector + blackboard: list[BlackboardInt | BlackboardStr] + + +class BranchRuneData(BaseModel): + id_: str = Field(alias='id') + points: float + mutexGroupKey: None + description: str + runes: list[TechTreeBranchRunes] + + +class Act17sideDataTechTreeBranchData(BaseModel): + techTreeBranchId: str + techTreeId: str + techTreeBranchName: str + techTreeBranchIcon: str + techTreeBranchDesc: str + runeData: BranchRuneData + + +class Act17sideDataTechTreeData(BaseModel): + techTreeId: str + sortId: int + techTreeName: str + defaultBranchId: str + lockDes: str + + +class Act17sideDataArchiveItemUnlockData(BaseModel): + itemId: str + itemType: str + unlockCondition: str + nodeId: str | None + stageParam: str + chapterId: str | None + + +class Act17sideDataEventData(BaseModel): + eventId: str + eventPic: str | None = None + eventSpecialPic: str | None = None + eventTitle: str + eventDesList: list[str] + + +class Act17sideDataChoiceNodeData(BaseModel): + nodeId: str + choicePic: str | None = None + isDisposable: bool + choiceSpecialPic: str | None = None + choiceName: str + choiceDesList: list[str] + cancelDes: str + choiceNum: int + optionList: list[Act17sideDataChoiceNodeOptionData] + + +class Act17sideDataTechNodeData(BaseModel): + nodeId: str + techTreeId: str + techTreeName: str + techPic: None + techSpecialPic: str + endEventId: str + confirmDes: str + techDesList: list[str] + missionIdList: list[None] + + +class Act17sideDataEventNodeData(BaseModel): + nodeId: str + eventId: str + endEventId: str + + +class Act17sideDataTreasureNodeData(BaseModel): + nodeId: str + treasureId: str + treasureName: str + treasurePic: str | None + treasureSpecialPic: None + endEventId: str + confirmDes: str + treasureDesList: list[str] + missionIdList: list[str] + rewardList: list[ItemBundle] + + +class Act17sideDataBattleNodeData(BaseModel): + nodeId: str + stageId: str + + +class Act17sideDataStoryNodeData(BaseModel): + nodeId: str + storyId: str + storyKey: str + storyName: str + storyPic: str | None + confirmDes: str + storyDesList: list[str] + + +class Act17sideDataLandmarkNodeData(BaseModel): + nodeId: str + landmarkId: str + landmarkName: str + landmarkPic: str | None + landmarkSpecialPic: str + landmarkDesList: list[str] + + +class Act17sideDataNodeInfoData(BaseModel): + nodeId: str + nodeType: str + sortId: int + placeId: str + isPointPlace: bool + chapterId: str + trackPointType: str + + +class Act17sideDataPlaceData(BaseModel): + placeId: str + placeDesc: str + lockEventId: str | None + zoneId: str + + +class Act17sideData(BaseModel): + archiveItemUnlockDataMap: dict[str, Act17sideDataArchiveItemUnlockData] + battleNodeDataMap: dict[str, Act17sideDataBattleNodeData] + choiceNodeDataMap: dict[str, Act17sideDataChoiceNodeData] + constData: Act17sideDataConstData + eventDataMap: dict[str, Act17sideDataEventData] + eventNodeDataMap: dict[str, Act17sideDataEventNodeData] + landmarkNodeDataMap: dict[str, Act17sideDataLandmarkNodeData] + mainlineChapterDataMap: dict[str, Act17sideDataMainlineChapterData] + mainlineDataMap: dict[str, Act17sideDataMainlineData] + nodeInfoDataMap: dict[str, Act17sideDataNodeInfoData] + placeDataMap: dict[str, Act17sideDataPlaceData] + storyNodeDataMap: dict[str, Act17sideDataStoryNodeData] + techNodeDataMap: dict[str, Act17sideDataTechNodeData] + techTreeBranchDataMap: dict[str, Act17sideDataTechTreeBranchData] + techTreeDataMap: dict[str, Act17sideDataTechTreeData] + treasureNodeDataMap: dict[str, Act17sideDataTreasureNodeData] + zoneDataList: list[Act17sideDataZoneData] + + +class Blackboard(BaseModel): + key: str + value: float | None = None + valueStr: str | None = None + + +class RuneDataSelector(BaseModel): + buildableMask: int + charIdFilter: list[str] | None + enemyIdExcludeFilter: list[str] | None + enemyIdFilter: list[str] | None + filterTagFilter: list[str] | None + groupTagFilter: list[str] | None + professionMask: int + skillIdFilter: list[str] | None + tileKeyFilter: list[str] | None + + +class RuneData(BaseModel): + blackboard: list[Blackboard] + key: str + m_inited: bool | None = None + selector: RuneDataSelector + + +class RuneTablePackedRuneData(BaseModel): + description: str + id_: str = Field(alias='id') + mutexGroupKey: str | None = None + points: float + runes: list[RuneData] + + +class Act25SideDataBattlePerformanceData(BaseModel): + itemDesc: str + itemId: str + itemIcon: str + ItemName: str | None = None + itemTechType: str + runeData: RuneTablePackedRuneData + sortId: int + + +class ActivityCustomDataAct25sideCustomData(BaseModel): + battlePerformanceData: dict[str, Act25SideDataBattlePerformanceData] + + +class ActivityCustomData(BaseModel): + TYPE_ACT17SIDE: dict[str, Act17sideData] + TYPE_ACT25SIDE: dict[str, ActivityCustomDataAct25sideCustomData] + + +class RetroTrailRuleData(BaseModel): + title: list[str] + desc: list[str] + + +class WeightItemBundle(BaseModel): + count: int + dropType: str + id_: str = Field(alias='id') + type_: str = Field(alias='type') + weight: int + + +class StageDataStageDropInfo(BaseModel): + firstPassRewards: list[ItemBundle] | None = None + firstCompleteRewards: list[ItemBundle] | None = None + passRewards: list[list[WeightItemBundle]] | None = None + completeRewards: list[list[WeightItemBundle]] | None = None + displayRewards: list[StageDataDisplayRewards] + displayDetailRewards: list[StageDataDisplayDetailRewards] + + +class StageData(BaseModel): + stageType: str + difficulty: str + performanceStageFlag: str + diffGroup: str + unlockCondition: list[StageDataConditionDesc] + stageId: str + levelId: str | None + zoneId: str + code: str + name: str + description: str + hardStagedId: str | None + dangerLevel: str | None + dangerPoint: float + loadingPicId: str + canPractice: bool + canBattleReplay: bool + apCost: int + apFailReturn: int + etItemId: str + etCost: int + etFailReturn: int + etButtonStyle: None + apProtectTimes: int + diamondOnceDrop: int + practiceTicketCost: int + dailyStageDifficulty: int + expGain: int + goldGain: int + loseExpGain: int + loseGoldGain: int + passFavor: int + completeFavor: int + slProgress: int + displayMainItem: None + hilightMark: bool + bossMark: bool + isPredefined: bool + isHardPredefined: bool + isSkillSelectablePredefined: bool + isStoryOnly: bool + appearanceStyle: int + stageDropInfo: StageDataStageDropInfo + startButtonOverrideId: None + isStagePatch: bool + mainStageId: str + + +class RetroTrailRewardItem(BaseModel): + trailRewardId: str + starCount: int + rewardItem: ItemBundle + + +class RetroTrailData(BaseModel): + retroId: str + trailStartTime: int + trailRewardList: list[RetroTrailRewardItem] + stageList: list[str] + relatedChar: str + relatedFullPotentialItemId: None + themeColor: str + fullPotentialItemId: str + + +class RetroActData(BaseModel): + retroId: str + type_: int = Field(alias='type') + linkedActId: list[str] + startTime: int + trailStartTime: int + index: int + name: str + detail: str + haveTrail: bool + customActId: str | None + customActType: str + + +class StageValidInfo(BaseModel): + startTs: int + endTs: int + + +class RetroStageOverrideInfo(BaseModel): + apCost: int + apFailReturn: int + completeFavor: int + dropInfo: StageDataStageDropInfo + expGain: int + goldGain: int + passFavor: int + zoneId: str + + +class RetroTable(BaseModel): + __version__ = '23-07-27-18-50-06-aeb568' + + customData: ActivityCustomData + initRetroCoin: int + retroActList: dict[str, RetroActData] + retroCoinMax: int + retroCoinPerWeek: int + retroDetail: str + retroPreShowTime: int + retroTrailList: dict[str, RetroTrailData] + retroUnlockCost: int + ruleData: RetroTrailRuleData + stageList: dict[str, StageData] + stages: dict[str, RetroStageOverrideInfo] | None = None + stageValidInfo: dict[str, StageValidInfo] + zoneToRetro: dict[str, str] + + class Config: + extra = 'allow' diff --git a/ArknightsUID/utils/models/gamedata/RoguelikeTable.py b/ArknightsUID/utils/models/gamedata/RoguelikeTable.py new file mode 100644 index 0000000..9e95015 --- /dev/null +++ b/ArknightsUID/utils/models/gamedata/RoguelikeTable.py @@ -0,0 +1,205 @@ +from pydantic import BaseModel, Field + + +class Blackboard(BaseModel): + key: str + value: float | None = None + valueStr: str | None = None + + +class RoguelikeBuff(BaseModel): + key: str + blackboard: list[Blackboard] + + +class RoguelikeOuterBuff(BaseModel): + buffId: str | None = None + level: int + name: str + iconId: str + description: str + usage: str + key: str + blackboard: list[Blackboard] + + +class RoguelikeOutBuffData(BaseModel): + id_: str = Field(alias='id') + buffs: dict[str, RoguelikeOuterBuff] + + +class RoguelikeEndingData(BaseModel): + id_: str = Field(alias='id') + backgroundId: str + name: str + description: str + priority: int + unlockItemId: str | None + changeEndingDesc: None + + +class RoguelikeModeData(BaseModel): + id_: str = Field(alias='id') + name: str + canUnlockItem: int + scoreFactor: float + itemPools: list[str] + difficultyDesc: str + ruleDesc: str + sortId: int + unlockMode: str + color: str + + +class RoguelikeChoiceSceneData(BaseModel): + id_: str = Field(alias='id') + title: str + description: str + background: str + + +class RoguelikeChoiceData(BaseModel): + id_: str = Field(alias='id') + title: str + description: str | None + type_: str = Field(alias='type') + nextSceneId: str | None + icon: str | None + param: dict[str, object] + + +class RoguelikeZoneData(BaseModel): + id_: str = Field(alias='id') + name: str + description: str + endingDescription: str + backgroundId: str + subIconId: str + + +class RoguelikeStageData(BaseModel): + id_: str = Field(alias='id') + linkedStageId: str + levelId: str + code: str + name: str + loadingPicId: str + description: str + eliteDesc: str | None + isBoss: int + isElite: int + difficulty: str + + +class RoguelikeRelicFeature(BaseModel): + id_: str = Field(alias='id') + buffs: list[RoguelikeBuff] + + +class RoguelikeUpgradeTicketFeature(BaseModel): + id_: str = Field(alias='id') + profession: int + rarity: int + professionList: list[str] + rarityList: list[int] + + +class RoguelikeRecruitTicketFeature(BaseModel): + id_: str = Field(alias='id') + profession: int + rarity: int + professionList: list[str] + rarityList: list[int] + extraEliteNum: int + extraFreeRarity: list[int | None] + extraCharIds: list[str] + + +class RelicStableUnlockParam(BaseModel): + unlockCondDetail: str + unlockCnt: int + + +class RoguelikeItemData(BaseModel): + id_: str = Field(alias='id') + name: str + description: str | None + usage: str + obtainApproach: str + iconId: str + type_: str = Field(alias='type') + rarity: str + value: int + sortId: int + unlockCond: str | None + unlockCondDesc: str | None + unlockCondParams: list[str | None] + stableUnlockCond: RelicStableUnlockParam | None + + +class RoguelikeItemTable(BaseModel): + items: dict[str, RoguelikeItemData] + recruitTickets: dict[str, RoguelikeRecruitTicketFeature] + upgradeTickets: dict[str, RoguelikeUpgradeTicketFeature] + relics: dict[str, RoguelikeRelicFeature] + + +class RoguelikeConstTableEventTypeData(BaseModel): + name: str + description: str + + +class RoguelikeConstTableCharUpgradeData(BaseModel): + evolvePhase: int + skillLevel: int + skillSpecializeLevel: int + + +class RoguelikeConstTableRecruitData(BaseModel): + recruitPopulation: int + upgradePopulation: int + + +class RoguelikeConstTablePlayerLevelData(BaseModel): + exp: int + populationUp: int + squadCapacityUp: int + battleCharLimitUp: int + + +class RoguelikeConstTable(BaseModel): + playerLevelTable: dict[str, RoguelikeConstTablePlayerLevelData] + recruitPopulationTable: dict[str, RoguelikeConstTableRecruitData] + charUpgradeTable: dict[str, RoguelikeConstTableCharUpgradeData] + eventTypeTable: dict[str, RoguelikeConstTableEventTypeData] + shopDialogs: list[str] + shopRelicDialogs: list[str] + shopTicketDialogs: list[str] + mimicEnemyIds: list[str] + clearZoneScores: list[int] + moveToNodeScore: int + clearNormalBattleScore: int + clearEliteBattleScore: int + clearBossBattleScore: int + gainRelicScore: int + gainCharacterScore: int + unlockRelicSpecialScore: int + squadCapacityMax: int + bossIds: list[str] + + +class RoguelikeTable(BaseModel): + __version__ = '23-07-27-18-50-06-aeb568' + + constTable: RoguelikeConstTable + itemTable: RoguelikeItemTable + stages: dict[str, RoguelikeStageData] + zones: dict[str, RoguelikeZoneData] + choices: dict[str, RoguelikeChoiceData] + choiceScenes: dict[str, RoguelikeChoiceSceneData] + modes: dict[str, RoguelikeModeData] + endings: dict[str, RoguelikeEndingData] + outBuffs: dict[str, RoguelikeOutBuffData] + + class Config: + extra = 'allow' diff --git a/ArknightsUID/utils/models/gamedata/RoguelikeTopicTable.py b/ArknightsUID/utils/models/gamedata/RoguelikeTopicTable.py new file mode 100644 index 0000000..486e3d7 --- /dev/null +++ b/ArknightsUID/utils/models/gamedata/RoguelikeTopicTable.py @@ -0,0 +1,1197 @@ +from pydantic import BaseModel, Field + + +class RoguelikeTopicBasicDataHomeEntryDisplayData(BaseModel): + topicId: str + displayId: str + startTs: int + endTs: int + + +class RoguelikeTopicConfig(BaseModel): + loadCharCardPlugin: bool | None = None + webBusType: str + monthChatTrigType: int + loadRewardHpDecoPlugin: bool + loadRewardExtraInfoPlugin: bool + + +class RoguelikeTopicBasicData(BaseModel): + id_: str = Field(alias='id') + name: str + startTime: int + disappearTimeOnMainScreen: int + sort: int + showMedalId: str + medalGroupId: str + fullStoredTime: int + lineText: str + homeEntryDisplayData: list[RoguelikeTopicBasicDataHomeEntryDisplayData] + moduleTypes: list[str] + config: RoguelikeTopicConfig + + +class RoguelikeTopicConstPredefinedChar(BaseModel): + charId: str + canBeFree: bool + uniEquipId: str | None + recruitType: str + + +class RoguelikeTopicConst(BaseModel): + milestoneTokenRatio: int + outerBuffTokenRatio: int | float + relicTokenRatio: int + rogueSystemUnlockStage: str + ordiModeReOpenCoolDown: int + monthModeReOpenCoolDown: int + monthlyTaskUncompletedTime: int + monthlyTaskManualRefreshLimit: int + monthlyTeamUncompletedTime: int + bpPurchaseSystemUnlockTime: int + predefinedChars: dict[str, RoguelikeTopicConstPredefinedChar] + + +class RoguelikeTopicUpdate(BaseModel): + updateId: str + topicUpdateTime: int + topicEndTime: int + + +class RoguelikeTopicEnroll(BaseModel): + enrollId: str + enrollTime: int + + +class RoguelikeTopicBP(BaseModel): + id_: str = Field(alias='id') + level: int + tokenNum: int + nextTokenNum: int + itemID: str + itemType: str + itemCount: int + isGoodPrize: bool + isGrandPrize: bool + + +class RoguelikeTopicMilestoneUpdateData(BaseModel): + updateTime: int + endTime: int + maxBpLevel: int + maxBpCount: int + maxDisplayBpCount: int + + +class RoguelikeTopicBPGrandPrize(BaseModel): + grandPrizeDisplayId: str + sortId: int + displayUnlockYear: int + displayUnlockMonth: int + acquireTitle: str + purchaseTitle: str + displayName: str + displayDiscription: str + bpLevelId: str + accordingCharId: str | None = None + accordingSkinId: str | None = None + detailAnnounceTime: str | None = None + picIdAftrerUnlock: str | None = None + + +class RoguelikeTopicMonthMission(BaseModel): + id_: str = Field(alias='id') + taskName: str + taskClass: str + innerClassWeight: int + template: str + paramList: list[str] + desc: str + tokenRewardNum: int + + +class ItemBundle(BaseModel): + id_: str = Field(alias='id') + count: int + type_: str = Field(alias='type') + + +class RoguelikeTopicMonthSquad(BaseModel): + id_: str = Field(alias='id') + teamName: str + teamSubName: str | None + teamFlavorDesc: str | None + teamDes: str + teamColor: str + teamMonth: str + teamYear: str + teamIndex: str | None + teamChars: list[str] + zoneId: str | None + chatId: str + tokenRewardNum: int + items: list[ItemBundle] + startTime: int + endTime: int + taskDes: str | None + + +class RoguelikeTopicChallenge(BaseModel): + challengeId: str + sortId: int + challengeName: str + challengeGroup: int + challengeGroupSortId: int + challengeGroupName: str | None + challengeUnlockDesc: str | None + challengeUnlockToastDesc: str | None + challengeDes: str + challengeConditionDes: list[str] + taskDes: str + completionClass: str + completionParams: list[str] + rewards: list[ItemBundle] + + +class RoguelikeTopicDifficulty(BaseModel): + modeDifficulty: str + grade: int + name: str + subName: str | None + enrollId: str | None + haveInitialRelicIcon: bool + scoreFactor: int | float + canUnlockItem: bool + doMonthTask: bool + ruleDesc: str + failTitle: str + failImageId: str + failForceDesc: str + sortId: int + equivalentGrade: int + color: str | None + bpValue: int + bossValue: int + addDesc: str | None + isHard: bool + unlockText: str | None + displayIconId: str | None + + +class RoguelikeTopicBankReward(BaseModel): + rewardId: str + unlockGoldCnt: int + rewardType: str + desc: str + + +class ActArchiveRelicItemData(BaseModel): + relicId: str + relicSortId: int + relicGroupId: int + orderId: str + isSpRelic: bool + enrollId: str | None + + +class ActArchiveRelicData(BaseModel): + relic: dict[str, ActArchiveRelicItemData] + + +class ActArchiveCapsuleItemData(BaseModel): + capsuleId: str + capsuleSortId: int + englishName: str + enrollId: str | None + + +class ActArchiveCapsuleData(BaseModel): + capsule: dict[str, ActArchiveCapsuleItemData] + + +class ActArchiveTrapItemData(BaseModel): + trapId: str + trapSortId: int + orderId: str + enrollId: str | None + + +class ActArchiveTrapData(BaseModel): + trap: dict[str, ActArchiveTrapItemData] + + +class ActArchiveChatItemData(BaseModel): + chatFloor: int + chatDesc: str | None + chatStoryId: str + + +class ActArchiveChatGroupData(BaseModel): + sortId: int + numChat: int + clientChatItemData: list[ActArchiveChatItemData] + + +class ActArchiveChatData(BaseModel): + chat: dict[str, ActArchiveChatGroupData] + + +class ActArchiveEndbookItemData(BaseModel): + endBookId: str + sortId: int + enrollId: str | None = None + isLast: bool | None = None + endbookName: str + unlockDesc: str + textId: str + + +class ActArchiveEndbookGroupData(BaseModel): + endId: str + endingId: str + sortId: int + title: str + cgId: str + backBlurId: str + cardId: str + hasAvg: bool + avgId: str + clientEndbookItemDatas: list[ActArchiveEndbookItemData] + + +class ActArchiveEndbookData(BaseModel): + endbook: dict[str, ActArchiveEndbookGroupData] + + +class ActArchiveBuffItemData(BaseModel): + buffId: str + buffGroupIndex: int + innerSortId: int + name: str + iconId: str + usage: str + desc: str + color: str + + +class ActArchiveBuffData(BaseModel): + buff: dict[str, ActArchiveBuffItemData] + + +class ActArchiveTotemItemData(BaseModel): + id_: str = Field(alias='id') + type_: int = Field(alias='type') + enrollConditionId: str | None + sortId: int + + +class ActArchiveTotemData(BaseModel): + totem: dict[str, ActArchiveTotemItemData] + + +class ActArchiveChaosItemData(BaseModel): + id_: str = Field(alias='id') + isHidden: bool + enrollId: str | None + sortId: int + + +class ActArchiveChaosData(BaseModel): + chaos: dict[str, ActArchiveChaosItemData] + + +class RoguelikeArchiveComponentData(BaseModel): + relic: ActArchiveRelicData + capsule: ActArchiveCapsuleData | None + trap: ActArchiveTrapData + chat: ActArchiveChatData + endbook: ActArchiveEndbookData + buff: ActArchiveBuffData + totem: ActArchiveTotemData | None + chaos: ActArchiveChaosData | None + + +class RoguelikeArchiveUnlockCondDesc(BaseModel): + archiveType: str + description: str + + +class RoguelikeArchiveEnroll(BaseModel): + archiveType: str + enrollId: str | None + + +class RoguelikeArchiveUnlockCondData(BaseModel): + unlockCondDesc: dict[str, RoguelikeArchiveUnlockCondDesc] + enroll: dict[str, RoguelikeArchiveEnroll] + + +class RoguelikeTopicDetailConstPlayerLevelData(BaseModel): + exp: int + populationUp: int + squadCapacityUp: int + battleCharLimitUp: int + maxHpUp: int + + +class RoguelikeTopicDetailConstCharUpgradeData(BaseModel): + evolvePhase: int + skillLevel: int + skillSpecializeLevel: int + + +class RoguelikeTopicDetailConst(BaseModel): + playerLevelTable: dict[str, RoguelikeTopicDetailConstPlayerLevelData] + charUpgradeTable: dict[str, RoguelikeTopicDetailConstCharUpgradeData] + difficultyUpgradeRelicDescTable: dict[str, str] + tokenBpId: str + tokenOuterBuffId: str + previewedRewardsAccordingUpdateId: str + tipButtonName: str + collectButtonName: str + bpSystemName: str + autoSetKV: str + bpPurchaseActiveEnroll: str + defaultSacrificeDesc: str | None + defaultExpeditionSelectDesc: str | None + gotCharBuffToast: str | None + gotSquadBuffToast: str | None + loseCharBuffToast: str | None + monthTeamSystemName: str + battlePassUpdateName: str + monthCharCardTagName: str + monthTeamDescTagName: str + outerBuffCompleteText: str + outerProgressTextColor: str + challengeTaskTargetName: str + challengeTaskConditionName: str + challengeTaskRewardName: str + challengeTaskModeName: str + challengeTaskName: str + outerBuffTokenSum: int + needAllFrontNode: bool + showBlurBack: bool + + +class RoguelikeGameInitData(BaseModel): + modeId: str + modeGrade: int + predefinedId: str | None + initialBandRelic: list[str] + initialRecruitGroup: list[str] | None + initialHp: int + initialPopulation: int + initialGold: int + initialSquadCapacity: int + initialShield: int + initialMaxHp: int + initialKey: int + + +class RoguelikeGameStageData(BaseModel): + id_: str = Field(alias='id') + linkedStageId: str + levelId: str + code: str + name: str + loadingPicId: str + description: str + eliteDesc: str | None + isBoss: int + isElite: int + difficulty: str + capsulePool: str | None + capsuleProb: int | float + vutresProb: list[float] + boxProb: list[float] + specialNodeId: str | None = None + + +class RoguelikeGameZoneData(BaseModel): + id_: str = Field(alias='id') + name: str + clockPerformance: str | None + displayTime: str | None + description: str + endingDescription: str + backgroundId: str + zoneIconId: str + isHiddenZone: bool + + +class RoguelikeZoneVariationData(BaseModel): + pass + + +class RoguelikeGameTrapData(BaseModel): + itemId: str + trapId: str + trapDesc: str + + +class RoguelikeGameRecruitTicketData(BaseModel): + id_: str = Field(alias='id') + profession: int + rarity: int + professionList: list[str] + rarityList: list[int] + extraEliteNum: int + extraFreeRarity: list[int] + extraCharIds: list[str] + + +class RoguelikeGameUpgradeTicketData(BaseModel): + id_: str = Field(alias='id') + profession: int + rarity: int + professionList: list[str] + rarityList: list[int] + + +class RoguelikeGameCustomTicketData(BaseModel): + id_: str = Field(alias='id') + subType: str + discardText: str + + +class Blackboard(BaseModel): + key: str + value: int | float | None = None + valueStr: str | None = None + + +class RoguelikeBuff(BaseModel): + key: str + blackboard: list[Blackboard] + + +class RoguelikeGameRelicData(BaseModel): + id_: str = Field(alias='id') + buffs: list[RoguelikeBuff] + + +class RoguelikeGameRelicCheckParam(BaseModel): + valueProfessionMask: int + valueStrs: list[str] | None + valueInt: int + + +class RoguelikeGameRelicParamData(BaseModel): + id_: str = Field(alias='id') + checkCharBoxTypes: list[str] + checkCharBoxParams: list[RoguelikeGameRelicCheckParam] + + +class RoguelikeGameRecruitGrpData(BaseModel): + id_: str = Field(alias='id') + iconId: str + name: str + desc: str + unlockDesc: str | None + + +class RoguelikeChoiceDisplayData(BaseModel): + type_: str = Field(alias='type') + costHintType: int | None = None + effectHintType: int | None = None + funcIconId: str | None + itemId: str | None + difficultyUpgradeRelicGroupId: str | None = None + taskId: str | None + + +class RoguelikeGameChoiceData(BaseModel): + id_: str = Field(alias='id') + title: str + description: str | None + lockedCoverDesc: str | None + type_: str = Field(alias='type') + leftDecoType: str + nextSceneId: str | None + icon: str | None + displayData: RoguelikeChoiceDisplayData + forceShowWhenOnlyLeave: bool + + +class RoguelikeGameChoiceSceneData(BaseModel): + id_: str = Field(alias='id') + title: str + description: str + background: str | None + titleIcon: str | None + subTypeId: int + useHiddenMusic: bool + + +class RoguelikeGameNodeTypeData(BaseModel): + name: str + description: str + + +class RoguelikeGameNodeSubTypeData(BaseModel): + eventType: str + subTypeId: int + iconId: str + name: str | None + description: str + + +class RoguelikeGameVariationData(BaseModel): + id_: str = Field(alias='id') + type_: str = Field(alias='type') + outerName: str + innerName: str + functionDesc: str + desc: str + iconId: str | None + sound: str | None + + +class RoguelikeGameCharBuffData(BaseModel): + id_: str = Field(alias='id') + iconId: str + outerName: str + innerName: str + functionDesc: str + desc: str + buffs: list[RoguelikeBuff] + + +class RoguelikeGameSquadBuffData(BaseModel): + id_: str = Field(alias='id') + iconId: str + outerName: str + innerName: str + functionDesc: str + desc: str + buffs: list[RoguelikeBuff] + + +class RoguelikeTaskData(BaseModel): + taskId: str + taskName: str + taskDesc: str + rewardSceneId: str + taskRarity: str + + +class RoguelikeGameConst(BaseModel): + initSceneName: str + failSceneName: str + hpItemId: str + goldItemId: str + populationItemId: str + squadCapacityItemId: str + expItemId: str + bankMaxGold: int + bankCostId: str | None + bankDrawCount: int + bankDrawLimit: int + mimicEnemyIds: list[str] + bossIds: list[str] + goldChestTrapId: str + normBoxTrapId: str | None + rareBoxTrapId: str | None + badBoxTrapId: str | None + maxHpItemId: str | None + shieldItemId: str | None + keyItemId: str | None + chestKeyCnt: int + chestKeyItemId: str | None + keyColorId: str | None + onceNodeTypeList: list[str] + gpScoreRatio: int + overflowUsageSquadBuff: str | None + specialTrapId: str | None + trapRewardRelicId: str | None + unlockRouteItemId: str | None + hideBattleNodeName: str | None + hideBattleNodeDescription: str | None + hideNonBattleNodeName: str | None + hideNonBattleNodeDescription: str | None + charSelectExpeditionConflictToast: str | None + itemDropTagDict: dict[str, str] + expeditionReturnDescCureUpgrade: str | None + expeditionReturnDescUpgrade: str | None + expeditionReturnDescCure: str | None + expeditionReturnDesc: str | None + expeditionReturnDescItem: str | None + expeditionReturnRewardBlackList: list[str] + gainBuffDiffGrade: int + dsPredictTips: str | None + dsBuffActiveTips: str | None + totemDesc: str | None + relicDesc: str | None + buffDesc: str | None + portalZones: list[str] + + +class RoguelikeTopicCapsule(BaseModel): + itemId: str + maskType: str + innerColor: str + + +class RoguelikeGameEndingDataLevelIcon(BaseModel): + level: int + iconId: str + + +class RoguelikeGameEndingData(BaseModel): + id_: str = Field(alias='id') + familyId: int + name: str + desc: str + bgId: str + icons: list[RoguelikeGameEndingDataLevelIcon] + priority: int + changeEndingDesc: str | None + bossIconId: str | None + + +class RoguelikeBattleSummeryDescriptionData(BaseModel): + randomDescriptionList: list[str] + + +class TipData(BaseModel): + tip: str + weight: int | float + category: str + + +class RoguelikeGameItemData(BaseModel): + id_: str = Field(alias='id') + name: str + description: str | None + usage: str + obtainApproach: str + iconId: str + type_: str = Field(alias='type') + subType: str + rarity: str + value: int + sortId: int + canSacrifice: bool + unlockCondDesc: str | None + + +class RoguelikeBandRefData(BaseModel): + itemId: str + iconId: str + description: str + bandLevel: int + normalBandId: str + + +class RoguelikeEndingDetailText(BaseModel): + textId: str + text: str + eventType: str + showType: int + choiceSceneId: str | None + paramList: list[str] + otherPara1: str | None + + +class RoguelikeGameTreasureData(BaseModel): + treasureId: str + groupId: str + subIndex: int + name: str + usage: str + + +class RoguelikeDifficultyUpgradeRelicData(BaseModel): + relicId: str + equivalentGrade: int + + +class RoguelikeDifficultyUpgradeRelicGroupData(BaseModel): + relicData: list[RoguelikeDifficultyUpgradeRelicData] + + +class RoguelikeTopicDetail(BaseModel): + updates: list[RoguelikeTopicUpdate] + enrolls: dict[str, RoguelikeTopicEnroll] + milestones: list[RoguelikeTopicBP] + milestoneUpdates: list[RoguelikeTopicMilestoneUpdateData] + grandPrizes: list[RoguelikeTopicBPGrandPrize] + monthMission: list[RoguelikeTopicMonthMission] + monthSquad: dict[str, RoguelikeTopicMonthSquad] + challenges: dict[str, RoguelikeTopicChallenge] + difficulties: list[RoguelikeTopicDifficulty] + bankRewards: list[RoguelikeTopicBankReward] + archiveComp: RoguelikeArchiveComponentData + archiveUnlockCond: RoguelikeArchiveUnlockCondData + detailConst: RoguelikeTopicDetailConst + init: list[RoguelikeGameInitData] + stages: dict[str, RoguelikeGameStageData] + zones: dict[str, RoguelikeGameZoneData] + variation: dict[str, RoguelikeZoneVariationData] + traps: dict[str, RoguelikeGameTrapData] + recruitTickets: dict[str, RoguelikeGameRecruitTicketData] + upgradeTickets: dict[str, RoguelikeGameUpgradeTicketData] + customTickets: dict[str, RoguelikeGameCustomTicketData] + relics: dict[str, RoguelikeGameRelicData] + relicParams: dict[str, RoguelikeGameRelicParamData] + recruitGrps: dict[str, RoguelikeGameRecruitGrpData] + choices: dict[str, RoguelikeGameChoiceData] + choiceScenes: dict[str, RoguelikeGameChoiceSceneData] + nodeTypeData: dict[str, RoguelikeGameNodeTypeData] + subTypeData: list[RoguelikeGameNodeSubTypeData] + variationData: dict[str, RoguelikeGameVariationData] + charBuffData: dict[str, RoguelikeGameCharBuffData] + squadBuffData: dict[str, RoguelikeGameSquadBuffData] + taskData: dict[str, RoguelikeTaskData] + gameConst: RoguelikeGameConst + shopDialogs: dict[str, list[str]] + capsuleDict: dict[str, RoguelikeTopicCapsule] | None + endings: dict[str, RoguelikeGameEndingData] + battleSummeryDescriptions: dict[str, RoguelikeBattleSummeryDescriptionData] + battleLoadingTips: list[TipData] + items: dict[str, RoguelikeGameItemData] + bandRef: dict[str, RoguelikeBandRefData] + endingDetailList: list[RoguelikeEndingDetailText] + treasures: dict[str, list[RoguelikeGameTreasureData]] + difficultyUpgradeRelicGroups: dict[str, RoguelikeDifficultyUpgradeRelicGroupData] + + +class RoguelikeModuleBaseData(BaseModel): + moduleType: str + + +class RoguelikeSanRangeData(BaseModel): + sanMax: int + diceGroupId: str + description: str + sanDungeonEffect: str + sanEffectRank: str + sanEndingDesc: str | None + + +class RoguelikeSanCheckConsts(BaseModel): + sanDecreaseToast: str + + +class RoguelikeSanCheckModuleData(RoguelikeModuleBaseData): + sanRanges: list[RoguelikeSanRangeData] + moduleConsts: RoguelikeSanCheckConsts + + +class RoguelikeDiceData(BaseModel): + diceId: str + description: str + isUpgradeDice: int + upgradeDiceId: str | None + diceFaceCount: int + battleDiceId: str + + +class RoguelikeDiceRuleData(BaseModel): + dicePointMax: int + diceResultClass: str + diceGroupId: str + diceEventId: str + resultDesc: str + showType: str + canReroll: bool + diceEndingScene: str + diceEndingDesc: str + sound: str + + +class RoguelikeDiceRuleGroupData(BaseModel): + ruleGroupId: str + minGoodNum: int + + +class RoguelikeDicePredefineData(BaseModel): + modeId: str + modeGrade: int + predefinedId: str | None + initialDiceCount: int + + +class RoguelikeDiceModuleData(RoguelikeModuleBaseData): + dice: dict[str, RoguelikeDiceData] + diceEvents: dict[str, RoguelikeDiceRuleData] + diceChoices: dict[str, str] + diceRuleGroups: dict[str, RoguelikeDiceRuleGroupData] + dicePredefines: list[RoguelikeDicePredefineData] + + +class RoguelikeChaosData(BaseModel): + chaosId: str + level: int + nextChaosId: str | None + prevChaosId: str | None + iconId: str + name: str + functionDesc: str + desc: str + sound: str + sortId: int + + +class RoguelikeChaosRangeData(BaseModel): + chaosMax: int + chaosDungeonEffect: str + + +class RoguelikeChaosPredefineLevelInfo(BaseModel): + chaosLevelBeginNum: int + chaosLevelEndNum: int + + +class RoguelikeChaosModuleConsts(BaseModel): + maxChaosLevel: int + maxChaosSlot: int + chaosNotMaxDescription: str + chaosMaxDescription: str + chaosPredictDescription: str + + +class RoguelikeChaosModuleData(RoguelikeModuleBaseData): + chaosDatas: dict[str, RoguelikeChaosData] + chaosRanges: list[RoguelikeChaosRangeData] + levelInfoDict: dict[str, dict[str, RoguelikeChaosPredefineLevelInfo]] + moduleConsts: RoguelikeChaosModuleConsts + + +class RoguelikeTotemLinkedNodeTypeData(BaseModel): + effectiveNodeTypes: list[str] + blurNodeTypes: list[str] + + +class RoguelikeTotemBuffData(BaseModel): + totemId: str + color: str + pos: str + rhythm: str + normalDesc: str + synergyDesc: str + archiveDesc: str + combineGroupName: str + bgIconId: str + isManual: bool + linkedNodeTypeData: RoguelikeTotemLinkedNodeTypeData + distanceMin: int + distanceMax: int + vertPassable: bool + expandLength: int + onlyForVert: bool + portalLinkedNodeTypeData: RoguelikeTotemLinkedNodeTypeData + + +class RoguelikeTotemSubBuffData(BaseModel): + subBuffId: str + name: str + desc: str + combinedDesc: str + info: str + + +class RoguelikeTotemModuleConsts(BaseModel): + totemPredictDescription: str + colorCombineDesc: dict[str, str] + bossCombineDesc: str + battleNoPredictDescription: str + shopNoGoodsDescription: str + + +class RoguelikeTotemBuffModuleData(RoguelikeModuleBaseData): + totemBuffDatas: dict[str, RoguelikeTotemBuffData] + subBuffs: dict[str, RoguelikeTotemSubBuffData] + moduleConsts: RoguelikeTotemModuleConsts + + +class RoguelikeVisionData(BaseModel): + sightNum: int + level: int + canForesee: bool + dividedDis: int + status: str + clr: str + desc1: str + desc2: str + icon: str + + +class RoguelikeVisionModuleDataVisionChoiceConfig(BaseModel): + value: int + type_: int = Field(alias='type') + + +class RoguelikeVisionModuleConsts(BaseModel): + maxVision: int + totemBottomDescription: str + chestBottomDescription: str + goodsBottomDescription: str + + +class RoguelikeVisionModuleData(RoguelikeModuleBaseData): + visionDatas: dict[str, RoguelikeVisionData] + visionChoices: dict[str, RoguelikeVisionModuleDataVisionChoiceConfig] + moduleConsts: RoguelikeVisionModuleConsts + + +class RoguelikeModule(BaseModel): + moduleTypes: list[str] + sanCheck: RoguelikeSanCheckModuleData | None + dice: RoguelikeDiceModuleData | None + chaos: RoguelikeChaosModuleData | None + totemBuff: RoguelikeTotemBuffModuleData | None + vision: RoguelikeVisionModuleData | None + + +class RoguelikeTopicDisplayItem(BaseModel): + displayType: str + displayNum: int + displayForm: str + tokenDesc: str + sortId: int + + +class RoguelikeTopicDev(BaseModel): + buffId: str + sortId: int + nodeType: str + nextNodeId: list[str] + frontNodeId: list[str] + tokenCost: int + buffName: str + buffIconId: str + buffTypeName: str + buffDisplayInfo: list[RoguelikeTopicDisplayItem] + + +class RoguelikeTopicDevToken(BaseModel): + sortId: int + displayForm: str + tokenDesc: str + + +class RL01EndingText(BaseModel): + summaryVariation: str + summaryDefeatBoss: str + summaryAccidentMeet: str + summaryCapsule: str + summaryActiveTool: str + summaryActor: str + summaryTop: str + summaryZone: str + summaryEnding: str + summaryMode: str + summaryGroup: str + summarySupport: str + summaryNormalRecruit: str + summaryDirectRecruit: str + summaryFriendRecruit: str + summaryFreeRecruit: str + summaryMonthRecruit: str + summaryUpgrade: str + summaryCompleteEnding: str + summaryEachZone: str + summaryPerfectBattle: str + summaryMeetBattle: str + summaryMeetEvent: str + summaryMeetShop: str + summaryMeetTreasure: str + summaryBuy: str + summaryInvest: str + summaryGet: str + summaryRelic: str + summarySafeHouse: str + summaryFailEnd: str + + +class RL01CustomizeData(BaseModel): + developments: dict[str, RoguelikeTopicDev] + developmentTokens: dict[str, RoguelikeTopicDevToken] + endingText: RL01EndingText + + +class RL02Development(BaseModel): + buffId: str + nodeType: str + frontNodeId: list[str] + nextNodeId: list[str] + positionP: int + positionR: int + tokenCost: int + buffName: str + buffIconId: str + effectType: str + rawDesc: str + buffDisplayInfo: list[RoguelikeTopicDisplayItem] + enrollId: str | None + + +class RL02DevRawTextBuffGroup(BaseModel): + nodeIdList: list[str] + useLevelMark: bool + groupIconId: str + useUpBreak: bool + sortId: int + + +class RL02DevelopmentLine(BaseModel): + fromNode: str + toNode: str + fromNodeP: int + fromNodeR: int + toNodeP: int + toNodeR: int + enrollId: str | None + + +class RL02EndingText(BaseModel): + summaryMutation: str + summaryDice: str + summaryDiceResultGood: str + summaryDiceResultNormal: str + summaryDiceResultBad: str + summaryDiceResultDesc: str + summaryCommuDesc: str + summaryHiddenDesc: str + summaryKnightDesc: str + summaryGoldDesc: str + summaryPracticeDesc: str + summaryCommuEmptyDesc: str + summaryCommuNotEmptyDesc: str + summaryHiddenPassedDesc: str + summaryHiddenNotPassedDesc: str + summaryKnightPassedDesc: str + summaryKnightNotPassedDesc: str + summaryGoldThreshold: int + summaryGoldHighDesc: str + summaryGoldLowDesc: str + summaryPracticeThreshold: int + summaryPracticeHighDesc: str + summaryPracticeLowDesc: str + + +class RL02CustomizeData(BaseModel): + developments: dict[str, RL02Development] + developmentTokens: dict[str, RoguelikeTopicDevToken] + developmentRawTextGroup: list[RL02DevRawTextBuffGroup] + developmentLines: list[RL02DevelopmentLine] + endingText: RL02EndingText + + +class RL03Development(BaseModel): + buffId: str + nodeType: str + frontNodeId: list[str] + nextNodeId: list[str] + positionRow: int + positionOrder: int + tokenCost: int + buffName: str + buffIconId: str + effectType: str + rawDesc: list[str] + buffDisplayInfo: list[RoguelikeTopicDisplayItem] + groupId: str + enrollId: str | None + + +class RL03DevRawTextBuffGroup(BaseModel): + nodeIdList: list[str] + useLevelMark: bool + groupIconId: str + sortId: int + + +class RL03DevDifficultyNodePairInfo(BaseModel): + frontNode: str + nextNode: str + + +class RL03DevDifficultyNodeInfo(BaseModel): + buffId: str + nodeMap: list[RL03DevDifficultyNodePairInfo] + enableGrade: int + + +class RL03EndingText(BaseModel): + summaryGetTotem: str + summaryDemoPointUp: str + summaryDemoPointDown: str + summaryDemoGradeUp: str + summaryDemoGradeDown: str + summaryVisionPointUp: str + summaryVisionPointDown: str + summaryVisionGradeUp: str + summaryVisionGradeDown: str + summaryMeetTrade: str + summaryFightWin: str + summaryFightFail: str + summaryExchangeTotem: str + summaryExchangeRelic: str + summaryMeetSecretpath: str + summaryUseTotem: str + summaryVisionGrade: str + summaryActor: str + summaryTop: str + summaryZone: str + summaryEnding: str + summaryMode: str + summaryGroup: str + summarySupport: str + summaryNormalRecruit: str + summaryDirectRecruit: str + summaryFriendRecruit: str + summaryFreeRecruit: str + summaryMonthRecruit: str + summaryUpgrade: str + summaryCompleteEnding: str + summaryEachZone: str + summaryPerfectBattle: str + summaryMeetBattle: str + summaryMeetEvent: str + summaryMeetShop: str + summaryMeetTreasure: str + summaryBuy: str + summaryInvest: str + summaryGet: str + summaryRelic: str + summarySafeHouse: str + summaryFailEnd: str + + +class RL03DifficultyExt(BaseModel): + modeDifficulty: str + grade: int + totemProb: int | float + relicDevLevel: str + buffs: list[str] | None + buffDesc: list[str] + + +class RL03CustomizeData(BaseModel): + developments: dict[str, RL03Development] + developmentsTokens: dict[str, RoguelikeTopicDevToken] + developmentRawTextGroup: list[RL03DevRawTextBuffGroup] + developmentsDifficultyNodeInfos: dict[str, RL03DevDifficultyNodeInfo] + endingText: RL03EndingText + difficulties: list[RL03DifficultyExt] + + +class RoguelikeTopicCustomizeData(BaseModel): + rogue_1: RL01CustomizeData + rogue_2: RL02CustomizeData + rogue_3: RL03CustomizeData | None = None + + +class RoguelikeTopicTable(BaseModel): + __version__ = '23-04-23-15-07-53-24a81c' + + topics: dict[str, RoguelikeTopicBasicData] + constant: RoguelikeTopicConst + details: dict[str, RoguelikeTopicDetail] + modules: dict[str, RoguelikeModule] + customizeData: RoguelikeTopicCustomizeData + + class Config: + extra = 'allow' diff --git a/ArknightsUID/utils/models/gamedata/SandboxTable.py b/ArknightsUID/utils/models/gamedata/SandboxTable.py new file mode 100644 index 0000000..7a4b223 --- /dev/null +++ b/ArknightsUID/utils/models/gamedata/SandboxTable.py @@ -0,0 +1,399 @@ +from pydantic import BaseModel, Field + + +class SandboxMapConstTable(BaseModel): + directionNames: list[str] + homeNodeStageId: str + homeRushStageCode: str + homeRushStageName: str + homeRushDesc: str + crazyRevengeRushGroup: str + homeBuildModeBGM: str + + +class SandboxBaseConstTable(BaseModel): + cookRegularCostItemId: str + cookRegularCostItemIdCnt: int + squadTabNameList: list[str] + charRarityColorList: list[str] + sumFoodLimitedCount: int + sumBuildingLimitedCount: int + sumTacticalLimitedCount: int + sumFoodMatLimitedCount: int + sumBuildingMatLimitedCount: int + sumStaminaPotLimitedCount: int + sumGoldLimitedCount: int + itemLimitedCount: int + blackBoxSlotCnt: int + scoutNodeUpgradeId: str + battleNodeUpgradeId: str + staminaPotCostOnce: int + staminaPotItemId: str + staminapotRedMinCnt: int + staminapotYellowMinCnt: int + staminapotGreenMinCnt: int + staminapotMaxPercentCnt: int + staminaPotActionPoint: int + goldItemId: str + toolboxSlotCapacity: int + toolboxSlotCnt: int + teamPopulationLimit: int + researchInformationDesc: str + settleFailDesc: str + settleAbortDesc: str + settleSucDesc: str + + +class TipData(BaseModel): + tip: str + weight: int | float + category: str + + +class SandboxFoodProduceData(BaseModel): + itemId: str + mainMaterialItems: list[str] + buffId: str + unlockDesc: str + + +class SandboxFoodmatBuffData(BaseModel): + itemId: str + buffId: str | None + buffDesc: str | None + matType: str + sortId: int + + +class SandboxFoodStaminaData(BaseModel): + itemId: str + potCnt: int + foodStaminaCnt: int + + +class SandboxBuildProduceData(BaseModel): + itemProduceId: str + itemId: str + itemTypeText: str + materialItems: dict[str, int] + + +class SandboxBuildGoldRatioData(BaseModel): + itemId: str + ratio: int + effectDesc: str + + +class SandboxBuildingItemData(BaseModel): + itemId: str + itemSubType: str + itemRarity: int + + +class SandboxBuildProduceUnlockData(BaseModel): + itemId: str + buildingEffectDesc: str + buildingItemDesc: str + buildingUnlockDesc: str + + +class SandboxCraftItemData(BaseModel): + itemId: str + sortId: int + getFrom: str + npcId: str | None + notObtainedDesc: str + itemType: str + + +class SandboxItemTrapData(BaseModel): + itemId: str + trapId: str + trapPhase: int + trapLevel: int + skillIndex: int + skillLevel: int + + +class SandboxDevelopmentData(BaseModel): + buffId: str + positionX: int + positionY: int + frontNodeId: str | None + nextNodeIds: list[str] | None + buffLimitedId: str + tokenCost: int + canBuffResearch: bool + buffResearchDesc: str | None + buffName: str + buffIconId: str + nodeTitle: str + buffEffectDesc: str + + +class SandboxDevelopmentLimitData(BaseModel): + buffLimitedId: str + positionX: int + buffCostLimitedCount: int + + +class SandboxItemToastData(BaseModel): + itemType: str + toastDesc: str + color: str + + +class SandboxDevelopmentLineSegmentData(BaseModel): + fromNodeId: str + passingNodeIds: list[str] + fromAxisPosX: int + fromAxisPosY: int + toAxisPosX: int + toAxisPosY: int + + +class SandboxRewardItemConfigData(BaseModel): + rewardItem: str + rewardType: str + + +class SandboxRewardData(BaseModel): + rewardList: list[SandboxRewardItemConfigData] + + +class SandboxRewardCommonConfig(BaseModel): + dropType: int | None = None + rewardItemId: str + rewardItemType: str + count: int + + +class SandboxTrapRewardConfigData(SandboxRewardCommonConfig): + dropType: int + + +class SandboxRewardConfigGroupData(BaseModel): + stagePreviewRewardDict: dict[str, SandboxRewardData] + stageDefaultPreviewRewardDict: dict[str, SandboxRewardData] + rushPreviewRewardDict: dict[str, SandboxRewardData] + stageRewardDict: dict[str, SandboxRewardData] + rushRewardDict: dict[str, SandboxRewardData] + trapRewardDict: dict[str, SandboxRewardCommonConfig] + enemyRewardDict: dict[str, SandboxRewardCommonConfig] + keyWordData: dict[str, str] + + +class SandboxStaminaData(BaseModel): + levelUpperLimit: int + staminaUpperLimit: int + + +class SandboxNodeTypeData(BaseModel): + nodeType: str + name: str + subName: str + iconId: str + + +class SandboxNodeUpgradeData(BaseModel): + nodeUpdradeId: str + name: str + description: str + upgradeDesc: str + itemType: str + itemSubType: str + itemCnt: int + itemRarity: int + + +class SandboxWeatherData(BaseModel): + weatherId: str + weatherType: str + weatherLevel: int + name: str + description: str + weatherTypeName: str + weatherTypeIconId: str + functionDesc: str + buffId: str + + +class SandboxStageData(BaseModel): + stageId: str + levelId: str + code: str + name: str + loadingPicId: str + description: str + actionCost: int + powerCost: int + + +class SandboxEventData(BaseModel): + eventSceneId: str + hasThumbtack: bool + + +class SandboxEventSceneData(BaseModel): + choiceSceneId: str + type_: str = Field(alias='type') + title: str + description: str + choices: list[str] + + +class SandboxEventChoiceData(BaseModel): + choiceId: str + type_: str = Field(alias='type') + costAction: int + finishScene: bool + title: str + description: str + + +class SandboxEventTypeData(BaseModel): + eventType: str + iconId: str + + +class SandboxMissionData(BaseModel): + missionId: str + desc: str + effectDesc: str | None + costAction: int + charCnt: int + professionIds: list[str] + profession: int + costStamina: int + + +class SandboxUnitData(BaseModel): + id_: str = Field(alias='id') + name: str + + +class SandboxDailyDescTemplateData(BaseModel): + type_: str = Field(alias='type') + templateDesc: list[str] + + +class RushEnemyConfig(BaseModel): + enemyKey: str + branchId: str + count: int + interval: int | float + + +class RushEnemyGroupConfig(BaseModel): + enemyGroupKey: str + weight: int + enemy: list[RushEnemyConfig] + dynamicEnemy: list[str] + + +class RushEnemyGroupRushEnemyDBRef(BaseModel): + id_: str = Field(alias='id') + level: int + + +class RushEnemyGroup(BaseModel): + rushEnemyGroupConfigs: dict[str, list[RushEnemyGroupConfig]] + rushEnemyDbRef: list[RushEnemyGroupRushEnemyDBRef] + + +class RuneDataSelector(BaseModel): + professionMask: int + buildableMask: int + charIdFilter: list[str] | None + enemyIdFilter: list[str] | None + enemyIdExcludeFilter: list[str] | None + skillIdFilter: list[str] | None + tileKeyFilter: list[str] | None + groupTagFilter: list[str] | None + filterTagFilter: list[str] | None + + +class Blackboard(BaseModel): + key: str + value: int | float | None = None + valueStr: str | None = None + + +class RuneData(BaseModel): + key: str + selector: RuneDataSelector + blackboard: list[Blackboard] + + +class RuneTablePackedRuneData(BaseModel): + id_: str = Field(alias='id') + points: int | float + mutexGroupKey: str | None + description: str + runes: list[RuneData] + + +class LegacyInLevelRuneData(BaseModel): + difficultyMask: int + key: str + professionMask: int + buildableMask: int + blackboard: list[Blackboard] + + +class SandboxActTable(BaseModel): + mapConstTable: SandboxMapConstTable + baseConstTable: SandboxBaseConstTable + battleLoadingTips: list[TipData] + foodProduceDatas: dict[str, SandboxFoodProduceData] + foodmatDatas: dict[str, SandboxFoodmatBuffData] + foodmatBuffDatas: dict[str, SandboxFoodmatBuffData] + foodStaminaDatas: dict[str, SandboxFoodStaminaData] + buildProduceDatas: dict[str, SandboxBuildProduceData] + buildGoldRatioDatas: list[SandboxBuildGoldRatioData] + buildingItemDatas: dict[str, SandboxBuildingItemData] + buildProduceUnlockDatas: dict[str, SandboxBuildProduceUnlockData] + craftItemDatas: dict[str, SandboxCraftItemData] + itemTrapDatas: dict[str, SandboxItemTrapData] + trapDeployLimitDatas: dict[str, int] + developmentDatas: dict[str, SandboxDevelopmentData] + developmentLimitDatas: dict[str, SandboxDevelopmentLimitData] + itemToastDatas: dict[str, SandboxItemToastData] + developmentLineSegmentDatas: list[SandboxDevelopmentLineSegmentData] + rewardConfigDatas: SandboxRewardConfigGroupData + charStaminaMapping: dict[str, dict[str, list[SandboxStaminaData]]] + nodeTypeDatas: dict[str, SandboxNodeTypeData] + nodeUpgradeDatas: dict[str, SandboxNodeUpgradeData] + weatherDatas: dict[str, SandboxWeatherData] + stageDatas: dict[str, SandboxStageData] + eventDatas: dict[str, SandboxEventData] + eventSceneDatas: dict[str, SandboxEventSceneData] + eventChoiceDatas: dict[str, SandboxEventChoiceData] + eventTypeDatas: dict[str, SandboxEventTypeData] + missionDatas: dict[str, SandboxMissionData] + unitData: dict[str, SandboxUnitData] + dailyDescTemplateDatas: dict[str, SandboxDailyDescTemplateData] + rushAvgDict: dict[str, str] + rushEnemyGroup: RushEnemyGroup + runeDatas: dict[str, RuneTablePackedRuneData] + itemRuneList: dict[str, list[LegacyInLevelRuneData]] + + +class SandboxItemData(BaseModel): + itemId: str + itemType: str + itemName: str + itemUsage: str + itemDesc: str + itemRarity: int + sortId: int + recommendTypeList: list[str] | None + recommendPriority: int + obtainApproach: str + + +class SandboxTable(BaseModel): + __version__ = '23-07-27-18-50-06-aeb568' + + sandboxActTables: dict[str, SandboxActTable] + itemDatas: dict[str, SandboxItemData] diff --git a/ArknightsUID/utils/models/gamedata/ShopClientTable.py b/ArknightsUID/utils/models/gamedata/ShopClientTable.py new file mode 100644 index 0000000..68f94b9 --- /dev/null +++ b/ArknightsUID/utils/models/gamedata/ShopClientTable.py @@ -0,0 +1,108 @@ +from pydantic import BaseModel, Field + + +class ShopRecommendData(BaseModel): + imgId: str + slotIndex: int + cmd: str + param1: str | None + param2: str | None + skinId: str | None + + +class ShopRecommendGroup(BaseModel): + recommendGroup: list[int] + dataList: list[ShopRecommendData] + + +class ShopKeeperWord(BaseModel): + id_: str = Field(alias='id') + text: str + + +class ShopRecommendItem(BaseModel): + tagId: str + displayType: str + tagName: str + itemTag: str + orderNum: int + startDatetime: int + endDatetime: int + groupList: list[ShopRecommendGroup] + tagWord: ShopKeeperWord + + +class ShopCreditUnlockItem(BaseModel): + sortId: int + unlockNum: int + charId: str + + +class ShopCreditUnlockGroup(BaseModel): + id_: str = Field(alias='id') + index: str + startDateTime: int + charDict: list[ShopCreditUnlockItem] + + +class ShopClientDataShopKeeperData(BaseModel): + welcomeWords: list[ShopKeeperWord] + clickWords: list[ShopKeeperWord] + + +class ShopCarouselDataItem(BaseModel): + spriteId: str + startTime: int + endTime: int + cmd: str + param1: str | None + skinId: str + furniId: str + + +class ShopCarouselData(BaseModel): + items: list[ShopCarouselDataItem] + + +class ChooseShopRelation(BaseModel): + goodId: str + optionList: list[str] + + +class ShopClientGPData(BaseModel): + goodId: str + displayName: str + condTrigPackageType: str + + +class LMTGSShopSchedule(BaseModel): + gachaPoolId: str + LMTGSId: str + iconColor: str + iconBackColor: str + storeTextColor: str | None = None + startTime: int + endTime: int + + +class LMTGSShopOverlaySchedule(BaseModel): + gachaPoolId1: str + gachaPoolId2: str + picId: str + + +class ShopClientTable(BaseModel): + __version__ = '23-07-27-18-50-06-aeb568' + + recommendList: list[ShopRecommendItem] + creditUnlockGroup: dict[str, ShopCreditUnlockGroup] + shopKeeperData: ShopClientDataShopKeeperData + carousels: list[ShopCarouselData] + chooseShopRelations: list[ChooseShopRelation] + shopUnlockDict: dict[str, str] + extraQCShopRule: list[str] + repQCShopRule: list[str] + shopGPDataDict: dict[str, ShopClientGPData] + shopMonthlySubGoodId: str + ls: list[LMTGSShopSchedule] + os: list[LMTGSShopOverlaySchedule] diff --git a/ArknightsUID/utils/models/gamedata/SkillTable.py b/ArknightsUID/utils/models/gamedata/SkillTable.py new file mode 100644 index 0000000..2d80562 --- /dev/null +++ b/ArknightsUID/utils/models/gamedata/SkillTable.py @@ -0,0 +1,51 @@ + +from pydantic import BaseModel, Field + + +class ItemBundle(BaseModel): + id_: str = Field(alias='id') + count: int + type_: str = Field(alias='type') + + +class SpData(BaseModel): + spType: int + levelUpCost: list[ItemBundle] | None + maxChargeTime: int + spCost: int + initSp: int + increment: int | float + + +class Blackboard(BaseModel): + key: str + value: int | float | None = None + valueStr: str | None = None + + +class SkillDataBundleLevelData(BaseModel): + name: str + rangeId: str | None + description: str | None + skillType: int + durationType: int + spData: SpData + prefabId: str | None + duration: int | float + blackboard: list[Blackboard] + + +class SkillDataBundle(BaseModel): + skillId: str + iconId: str | None + hidden: bool + levels: list[SkillDataBundleLevelData] + + +class SkillTable(BaseModel): + __version__ = '23-07-27-18-50-06-aeb568' + + skills: dict[str, SkillDataBundle] + + def __init__(self, data: dict) -> None: + super().__init__(skills=data) diff --git a/ArknightsUID/utils/models/gamedata/SkinTable.py b/ArknightsUID/utils/models/gamedata/SkinTable.py new file mode 100644 index 0000000..92f3976 --- /dev/null +++ b/ArknightsUID/utils/models/gamedata/SkinTable.py @@ -0,0 +1,89 @@ + +from pydantic import BaseModel + + +class CharSkinDataTokenSkinInfo(BaseModel): + tokenId: str + tokenSkinId: str + + +class CharSkinDataBattleSkin(BaseModel): + overwritePrefab: bool + skinOrPrefabId: str | None + + +class CharSkinDataDisplaySkin(BaseModel): + skinName: str | None + colorList: list[str] | None + titleList: list[str] | None + modelName: str | None + drawerList: list[str] | None + designerList: list[str] | None + skinGroupId: str | None + skinGroupName: str | None + skinGroupSortIndex: int + content: str | None + dialog: str | None + usage: str | None + description: str | None + obtainApproach: str | None + sortId: int + displayTagId: str | None + getTime: int + onYear: int + onPeriod: int + + +class CharSkinData(BaseModel): + skinId: str + charId: str + tokenSkinMap: list[CharSkinDataTokenSkinInfo] | None + illustId: str | None + dynIllustId: str | None + avatarId: str + portraitId: str | None + dynPortraitId: str | None + dynEntranceId: str | None + buildingId: str | None + battleSkin: CharSkinDataBattleSkin + isBuySkin: bool + tmplId: str | None + voiceId: str | None + voiceType: str + displaySkin: CharSkinDataDisplaySkin + + +class CharSkinGroupInfo(BaseModel): + skinGroupId: str + publishTime: int + + +class CharSkinKvImgInfo(BaseModel): + kvImgId: str + linkedSkinGroupId: str + + +class CharSkinBrandInfo(BaseModel): + brandId: str + groupList: list[CharSkinGroupInfo] + kvImgIdList: list[CharSkinKvImgInfo] + brandName: str + brandCapitalName: str + description: str + sortId: int + + +class SpecialSkinInfo(BaseModel): + skinId: str + startTime: int + endTime: int + + +class SkinTable(BaseModel): + __version__ = '23-07-27-18-50-06-aeb568' + + charSkins: dict[str, CharSkinData] + buildinEvolveMap: dict[str, dict[str, str]] + buildinPatchMap: dict[str, dict[str, str]] + brandList: dict[str, CharSkinBrandInfo] + specialSkinInfoList: list[SpecialSkinInfo] diff --git a/ArknightsUID/utils/models/gamedata/StageTable.py b/ArknightsUID/utils/models/gamedata/StageTable.py new file mode 100644 index 0000000..ee090b6 --- /dev/null +++ b/ArknightsUID/utils/models/gamedata/StageTable.py @@ -0,0 +1,257 @@ +from pydantic import BaseModel, Field + + +class StageDataConditionDesc(BaseModel): + stageId: str + completeState: int + + +class StageDataDisplayRewards(BaseModel): + type_: str = Field(alias='type') + id_: str = Field(alias='id') + dropType: int + + +class StageDataDisplayDetailRewards(BaseModel): + occPercent: int + type_: str = Field(alias='type') + id_: str = Field(alias='id') + dropType: int + + +class StageDataStageDropInfo(BaseModel): + firstPassRewards: None + firstCompleteRewards: None + passRewards: None + completeRewards: None + displayRewards: list[StageDataDisplayRewards] + displayDetailRewards: list[StageDataDisplayDetailRewards] + + +class ExtraCondition(BaseModel): + index: int + template: str + unlockParam: list[str] + + +class ProgressInfo(BaseModel): + progressType: str + descList: dict[str, str] | None + + +class ItemBundle(BaseModel): + id_: str = Field(alias='id') + count: int + type_: str = Field(alias='type') + + +class ExtraInfo(BaseModel): + stageId: str + rewards: list[ItemBundle] + progressInfo: ProgressInfo + + +class StageData(BaseModel): + stageType: str + difficulty: str + performanceStageFlag: str + diffGroup: str + unlockCondition: list[StageDataConditionDesc] + stageId: str + levelId: str | None + zoneId: str + code: str + name: str | None + description: str | None + hardStagedId: str | None + dangerLevel: str | None + dangerPoint: int | float + loadingPicId: str + canPractice: bool + canBattleReplay: bool + apCost: int + apFailReturn: int + etItemId: str | None + etCost: int + etFailReturn: int + etButtonStyle: str | None + apProtectTimes: int + diamondOnceDrop: int + practiceTicketCost: int + dailyStageDifficulty: int + expGain: int + goldGain: int + loseExpGain: int + loseGoldGain: int + passFavor: int + completeFavor: int + slProgress: int + displayMainItem: str | None + hilightMark: bool + bossMark: bool + isPredefined: bool + isHardPredefined: bool + isSkillSelectablePredefined: bool + isStoryOnly: bool + appearanceStyle: int + stageDropInfo: StageDataStageDropInfo + canUseCharm: bool | None = None + canUseTech: bool | None = None + canUseTrapTool: bool | None = None + canUseBattlePerformance: bool | None = None + startButtonOverrideId: str | None + isStagePatch: bool + mainStageId: str | None + extraCondition: list[ExtraCondition] | None = None + extraInfo: list[ExtraInfo] | None = None + + +class RuneStageGroupDataRuneStageInst(BaseModel): + stageId: str + activePackedRuneIds: list[str] + + +class RuneStageGroupData(BaseModel): + groupId: str + activeRuneStages: list[RuneStageGroupDataRuneStageInst] + startTs: int + endTs: int + + +class MapThemeData(BaseModel): + themeId: str + unitColor: str + buildableColor: str | None + themeType: str | None + trapTintColor: str | None + + +class TileAppendInfo(BaseModel): + tileKey: str + name: str + description: str + isFunctional: bool + + +class WeeklyForceOpenTable(BaseModel): + id_: str = Field(alias='id') + startTime: int + endTime: int + forceOpenList: list[str] + + +class TimelyDropTimeInfo(BaseModel): + startTs: int + endTs: int + stagePic: str | None + dropPicId: str | None + stageUnlock: str + entranceDownPicId: str | None + entranceUpPicId: str | None + timelyGroupId: str + weeklyPicId: str | None + apSupplyOutOfDateDict: dict[str, int] + + +class OverrideDropInfo(BaseModel): + itemId: str + startTs: int + endTs: int + zoneRange: str + times: int + name: str + egName: str + desc1: str + desc2: str + desc3: str + dropTag: str + dropTypeDesc: str + dropInfo: dict[str, StageDataStageDropInfo] + + +class TimelyDropInfo(BaseModel): + dropInfo: dict[str, StageDataStageDropInfo] + + +class StageValidInfo(BaseModel): + startTs: int + endTs: int + + +class StageFogInfo(BaseModel): + lockId: str + fogType: str + stageId: str + lockName: str + lockDesc: str + unlockItemId: str + unlockItemType: str + unlockItemNum: int + preposedStageId: str + preposedLockId: str | None + + +class StageStartCondRequireChar(BaseModel): + charId: str + evolvePhase: int + + +class StageStartCond(BaseModel): + requireChars: list[StageStartCondRequireChar] + excludeAssists: list[str] + isNotPass: bool + + +class StageDiffGroupTable(BaseModel): + normalId: str + toughId: str | None + easyId: str + + +class StoryStageShowGroup(BaseModel): + displayRecordId: str + stageId: str + accordingStageId: str | None + diffGroup: int + + +class SpecialBattleFinishStageData(BaseModel): + stageId: str + skipAccomplishPerform: bool + + +class RecordRewardServerData(BaseModel): + stageId: str + rewards: list[ItemBundle] + + +class ApProtectZoneInfoTimeRange(BaseModel): + startTs: int + endTs: int + + +class ApProtectZoneInfo(BaseModel): + zoneId: str + timeRanges: list[ApProtectZoneInfoTimeRange] + + +class StageTable(BaseModel): + __version__ = '23-07-27-18-50-06-aeb568' + + stages: dict[str, StageData] + runeStageGroups: dict[str, RuneStageGroupData] + mapThemes: dict[str, MapThemeData] + tileInfo: dict[str, TileAppendInfo] + forceOpenTable: dict[str, WeeklyForceOpenTable] + timelyStageDropInfo: dict[str, TimelyDropTimeInfo] + overrideDropInfo: dict[str, OverrideDropInfo] + timelyTable: dict[str, TimelyDropInfo] + stageValidInfo: dict[str, StageValidInfo] + stageFogInfo: dict[str, StageFogInfo] + stageStartConds: dict[str, StageStartCond] + diffGroupTable: dict[str, StageDiffGroupTable] + storyStageShowGroup: dict[str, dict[str, StoryStageShowGroup]] + specialBattleFinishStageData: dict[str, SpecialBattleFinishStageData] + recordRewardData: dict[str, RecordRewardServerData] | None + apProtectZoneInfo: dict[str, ApProtectZoneInfo] + spNormalStageIdFor4StarList: list[str] diff --git a/ArknightsUID/utils/models/gamedata/StoryReviewMetaTable.py b/ArknightsUID/utils/models/gamedata/StoryReviewMetaTable.py new file mode 100644 index 0000000..02f52a7 --- /dev/null +++ b/ArknightsUID/utils/models/gamedata/StoryReviewMetaTable.py @@ -0,0 +1,214 @@ +from pydantic import BaseModel, Field + + +class MiniActTrialDataRuleData(BaseModel): + ruleType: str + ruleText: str + + +class ItemBundle(BaseModel): + id_: str = Field(alias='id') + count: int + type_: str = Field(alias='type') + + +class MiniActTrialDataMiniActTrialRewardData(BaseModel): + trialRewardId: str + orderId: int + actId: str + targetStoryCount: int + item: ItemBundle + + +class MiniActTrialDataMiniActTrialSingleData(BaseModel): + actId: str + rewardStartTime: int + themeColor: str + rewardList: list[MiniActTrialDataMiniActTrialRewardData] + + +class MiniActTrialData(BaseModel): + preShowDays: int + ruleDataList: list[MiniActTrialDataRuleData] + miniActTrialDataMap: dict[str, MiniActTrialDataMiniActTrialSingleData] + + +class ActArchiveResDataPicArchiveResItemData(BaseModel): + id_: str = Field(alias='id') + desc: str + assetPath: str + type_: str = Field(alias='type') + subType: str | None + picDescription: str + kvId: str | None + + +class ActArchiveResDataAudioArchiveResItemData(BaseModel): + id_: str = Field(alias='id') + desc: str + name: str + + +class ActArchiveResDataAvgArchiveResItemData(BaseModel): + id_: str = Field(alias='id') + desc: str + breifPath: str | None + contentPath: str + imagePath: str + rawBrief: str | None + titleIconPath: str | None + + +class ActArchiveResDataStoryArchiveResItemData(BaseModel): + id_: str = Field(alias='id') + desc: str + date: str | None + pic: str + text: str + titlePic: str | None + + +class ActArchiveResDataNewsFormatData(BaseModel): + typeId: str + typeName: str + typeLogo: str + typeMainLogo: str + typeMainSealing: str + + +class ActArchiveResDataActivityNewsLine(BaseModel): + lineType: int + content: str + + +class ActArchiveResDataNewsArchiveResItemData(BaseModel): + id_: str = Field(alias='id') + desc: str + newsType: str + newsFormat: ActArchiveResDataNewsFormatData + newsText: str + newsAuthor: str + paramP0: int + paramK: int + paramR: float + newsLines: list[ActArchiveResDataActivityNewsLine] + + +class ActArchiveResDataLandmarkArchiveResItemData(BaseModel): + landmarkId: str + landmarkName: str + landmarkPic: str + landmarkDesc: str + landmarkEngName: str + + +class ActArchiveResDataLogArchiveResItemData(BaseModel): + logId: str + logDesc: str + + +class ActArchiveResData(BaseModel): + pics: dict[str, ActArchiveResDataPicArchiveResItemData] + audios: dict[str, ActArchiveResDataAudioArchiveResItemData] + avgs: dict[str, ActArchiveResDataAvgArchiveResItemData] + stories: dict[str, ActArchiveResDataStoryArchiveResItemData] + news: dict[str, ActArchiveResDataNewsArchiveResItemData] + landmarks: dict[str, ActArchiveResDataLandmarkArchiveResItemData] + logs: dict[str, ActArchiveResDataLogArchiveResItemData] + + +class ActArchiveTimelineItemData(BaseModel): + timelineId: str + timelineSortId: int + timelineTitle: str + timelineDes: str + picIdList: list[str] | None = None + audioIdList: list[str] | None = None + avgIdList: list[str] | None = None + storyIdList: list[str] | None = None + newsIdList: list[str] | None = None + + +class ActArchiveTimelineData(BaseModel): + timelineList: list[ActArchiveTimelineItemData] + + +class ActArchiveMusicItemData(BaseModel): + musicId: str + musicSortId: int + + +class ActArchiveMusicData(BaseModel): + musics: dict[str, ActArchiveMusicItemData] + + +class ActArchivePicItemData(BaseModel): + picId: str + picSortId: int + + +class ActArchivePicData(BaseModel): + pics: dict[str, ActArchivePicItemData] + + +class ActArchiveStoryItemData(BaseModel): + storyId: str + storySortId: int + + +class ActArchiveStoryData(BaseModel): + stories: dict[str, ActArchiveStoryItemData] + + +class ActArchiveAvgItemData(BaseModel): + avgId: str + avgSortId: int + + +class ActArchiveAvgData(BaseModel): + avgs: dict[str, ActArchiveAvgItemData] + + +class ActArchiveNewsItemData(BaseModel): + newsId: str + newsSortId: int + + +class ActArchiveNewsData(BaseModel): + news: dict[str, ActArchiveNewsItemData] + + +class ActArchiveLandmarkItemData(BaseModel): + landmarkId: str + landmarkSortId: int + + +class ActArchiveChapterLogData(BaseModel): + chapterName: str + displayId: str + unlockDes: str + logs: list[str] + chapterIcon: str + + +class ActArchiveComponentData(BaseModel): + timeline: ActArchiveTimelineData | None = None + music: ActArchiveMusicData | None = None + pic: ActArchivePicData + story: ActArchiveStoryData | None = None + avg: ActArchiveAvgData | None = None + news: ActArchiveNewsData | None = None + landmark: dict[str, ActArchiveLandmarkItemData] | None = None + log: dict[str, ActArchiveChapterLogData] | None = None + + +class ActArchiveComponentTable(BaseModel): + components: dict[str, ActArchiveComponentData] + + +class StoryReviewMetaTable(BaseModel): + __version__ = '23-07-27-18-50-06-aeb568' + + miniActTrialData: MiniActTrialData + actArchiveResData: ActArchiveResData + actArchiveData: ActArchiveComponentTable diff --git a/ArknightsUID/utils/models/gamedata/StoryReviewTable.py b/ArknightsUID/utils/models/gamedata/StoryReviewTable.py new file mode 100644 index 0000000..5fb1759 --- /dev/null +++ b/ArknightsUID/utils/models/gamedata/StoryReviewTable.py @@ -0,0 +1,64 @@ +from pydantic import BaseModel, Field + + +class ItemBundle(BaseModel): + id_: str = Field(alias='id') + count: int + type_: str = Field(alias='type') + + +class StoryDataConditionStageCondition(BaseModel): + stageId: str + minState: int + maxState: int + + +class StoryReviewInfoClientData(BaseModel): + storyReviewType: int + storyId: str + storyGroup: str + storySort: int + storyDependence: str | None + storyCanShow: int + storyCode: str | None + storyName: str + storyPic: str | None + storyInfo: str + storyCanEnter: int + storyTxt: str + avgTag: str + unLockType: str + costItemType: str + costItemId: str | None + costItemCount: int + stageCount: int + requiredStages: list[StoryDataConditionStageCondition] | None + + +class StoryReviewGroupClientData(BaseModel): + id_: str = Field(alias='id') + name: str + entryType: str + actType: str + startTime: int + endTime: int + startShowTime: int + endShowTime: int + remakeStartTime: int + remakeEndTime: int + storyEntryPicId: str | None + storyPicId: str | None + storyMainColor: str | None + customType: int + storyCompleteMedalId: str | None + rewards: list[ItemBundle] | None + infoUnlockDatas: list[StoryReviewInfoClientData] + + +class StoryReviewTable(BaseModel): + __version__ = '23-07-27-18-50-06-aeb568' + + storyreviewtable: dict[str, StoryReviewGroupClientData] + + def __init__(self, data: dict) -> None: + super().__init__(storyreviewtable=data) diff --git a/ArknightsUID/utils/models/gamedata/StoryTable.py b/ArknightsUID/utils/models/gamedata/StoryTable.py new file mode 100644 index 0000000..f0b56f8 --- /dev/null +++ b/ArknightsUID/utils/models/gamedata/StoryTable.py @@ -0,0 +1,50 @@ +from pydantic import BaseModel, Field + + +class StoryDataTrigger(BaseModel): + type_: str = Field(alias='type') + key: str | None + useRegex: bool + + +class StoryDataConditionStageCondition(BaseModel): + stageId: str + minState: int + maxState: int + + +class StoryDataCondition(BaseModel): + minProgress: int + maxProgress: int + minPlayerLevel: int + requiredFlags: list[str] + excludedFlags: list[str] + requiredStages: list[StoryDataConditionStageCondition] + + +class ItemBundle(BaseModel): + id_: str = Field(alias='id') + count: int + type_: str = Field(alias='type') + + +class StoryData(BaseModel): + id_: str = Field(alias='id') + needCommit: bool + repeatable: bool + disabled: bool + videoResource: bool + trigger: StoryDataTrigger + condition: StoryDataCondition | None + setProgress: int + setFlags: list[str] | None + completedRewards: list[ItemBundle] | None + + +class StoryTable(BaseModel): + __version__ = '23-07-27-18-50-06-aeb568' + + stories: dict[str, StoryData] + + def __init__(self, data: dict) -> None: + super().__init__(stories=data) diff --git a/ArknightsUID/utils/models/gamedata/TechBuffTable.py b/ArknightsUID/utils/models/gamedata/TechBuffTable.py new file mode 100644 index 0000000..a952a43 --- /dev/null +++ b/ArknightsUID/utils/models/gamedata/TechBuffTable.py @@ -0,0 +1,36 @@ +from pydantic import BaseModel, Field + + +class RuneDataSelector(BaseModel): + professionMask: int + buildableMask: int + charIdFilter: list[str] | None + enemyIdFilter: list[str] | None + skillIdFilter: list[str] | None + tileKeyFilter: list[str] | None + + +class Blackboard(BaseModel): + key: str + value: float | None = None + valueStr: str | None = None + + +class RuneData(BaseModel): + key: str + selector: RuneDataSelector + blackboard: list[Blackboard] + + +class PackedRuneData(BaseModel): + id_: str = Field(alias='id') + points: float + mutexGroupKey: str | None + description: str + runes: list[RuneData] + + +class TechBuffTable(BaseModel): + __version__ = '23-07-27-18-50-06-aeb568' + + runes: list[PackedRuneData] diff --git a/ArknightsUID/utils/models/gamedata/TipTable.py b/ArknightsUID/utils/models/gamedata/TipTable.py new file mode 100644 index 0000000..6274c8a --- /dev/null +++ b/ArknightsUID/utils/models/gamedata/TipTable.py @@ -0,0 +1,21 @@ +from pydantic import BaseModel + + +class TipData(BaseModel): + tip: str + weight: float + category: str + + +class WorldViewTip(BaseModel): + title: str + description: str + backgroundPicId: str + weight: float + + +class TipTable(BaseModel): + __version__ = '23-07-27-18-50-06-aeb568' + + tips: list[TipData] + worldViewTips: list[WorldViewTip] diff --git a/ArknightsUID/utils/models/gamedata/TokenTable.py b/ArknightsUID/utils/models/gamedata/TokenTable.py new file mode 100644 index 0000000..55eb8b1 --- /dev/null +++ b/ArknightsUID/utils/models/gamedata/TokenTable.py @@ -0,0 +1,176 @@ +from pydantic import BaseModel, Field + +# 部分数据似乎不是float类型,等之后问问dice吧awa + + +class CharacterDataUnlockCondition(BaseModel): + phase: int + level: int + + +class Blackboard(BaseModel): + key: str + value: float | None = None + valueStr: str | None = None + + +class CharacterDataTraitData(BaseModel): + unlockCondition: CharacterDataUnlockCondition + requiredPotentialRank: int + blackboard: list[Blackboard] + overrideDescripton: str | None + prefabKey: str | None + rangeId: str | None + + +class CharacterDataTraitDataBundle(BaseModel): + candidates: list[CharacterDataTraitData] + + +class AttributesData(BaseModel): + maxHp: int + atk: int + def_: int = Field(..., alias='def') + magicResistance: float + cost: int + blockCnt: int + moveSpeed: float + attackSpeed: float + baseAttackTime: float + respawnTime: int + hpRecoveryPerSec: float + spRecoveryPerSec: float + maxDeployCount: int + maxDeckStackCnt: int + tauntLevel: int + massLevel: int + baseForceLevel: int + stunImmune: bool + silenceImmune: bool + sleepImmune: bool + frozenImmune: bool + levitateImmune: bool + + +class CharacterDataAttributesKeyFrame(BaseModel): + level: int + data: AttributesData + + +class ItemBundle(BaseModel): + id_: str = Field(..., alias='id') + count: int + type_: str = Field(..., alias='type') + + +class CharacterDataPhaseData(BaseModel): + characterPrefabKey: str + rangeId: str | None + maxLevel: int + attributesKeyFrames: list[CharacterDataAttributesKeyFrame] + evolveCost: list[ItemBundle] | None + + +class CharacterDataMainSkillSpecializeLevelData(BaseModel): + unlockCond: CharacterDataUnlockCondition + lvlUpTime: int + levelUpCost: list[ItemBundle] | None + + +class CharacterDataMainSkill(BaseModel): + skillId: str | None + overridePrefabKey: str | None + overrideTokenKey: str | None + levelUpCostCond: list[CharacterDataMainSkillSpecializeLevelData] + unlockCond: CharacterDataUnlockCondition + + +class TalentData(BaseModel): + unlockCondition: CharacterDataUnlockCondition + requiredPotentialRank: int + prefabKey: str + name: str | None + description: str | None + rangeId: str | None + blackboard: list[Blackboard] + + +class CharacterDataTalentDataBundle(BaseModel): + candidates: list[TalentData] | None + + +class AttributeModifierDataAttributeModifier(BaseModel): + attributeType: int + formulaItem: int + value: float + loadFromBlackboard: bool + fetchBaseValueFromSourceEntity: bool + + +class AttributeModifierData(BaseModel): + abnormalFlags: list[str] | None + abnormalImmunes: list[str] | None + abnormalAntis: list[str] | None + abnormalCombos: list[str] | None + abnormalComboImmunes: list[str] | None + attributeModifiers: list[AttributeModifierDataAttributeModifier] + + +class ExternalBuff(BaseModel): + attributes: AttributeModifierData + + +class CharacterDataPotentialRank(BaseModel): + type_: int = Field(..., alias='type') + description: str + buff: ExternalBuff | None + equivalentCost: ItemBundle | None + + +class CharacterDataSkillLevelCost(BaseModel): + unlockCond: CharacterDataUnlockCondition + lvlUpCost: list[ItemBundle] | None + + +class CharacterData(BaseModel): + name: str + description: str | None + canUseGeneralPotentialItem: bool + canUseActivityPotentialItem: bool + potentialItemId: str | None + activityPotentialItemId: str | None + nationId: str | None + groupId: str | None + teamId: str | None + displayNumber: str | None + tokenKey: str | None = None + appellation: str + position: str + tagList: list[str] | None + itemUsage: str | None + itemDesc: str | None + itemObtainApproach: str | None + isNotObtainable: bool + isSpChar: bool + maxPotentialLevel: int + rarity: int + profession: str + subProfessionId: str + trait: CharacterDataTraitDataBundle | None + phases: list[CharacterDataPhaseData] + skills: list[CharacterDataMainSkill] | None + talents: list[CharacterDataTalentDataBundle] | None + potentialRanks: list[CharacterDataPotentialRank] | None + favorKeyFrames: list[CharacterDataAttributesKeyFrame] | None + allSkillLvlup: list[CharacterDataSkillLevelCost] | None + minPowerId: str + maxPowerId: str + + +class TokenTable(BaseModel): + __version__ = '23-07-27-18-50-06-aeb568' + + tokens: dict[str, CharacterData] + + def __init__(self, data: dict) -> None: + super().__init__(tokens=data) diff --git a/ArknightsUID/utils/models/gamedata/UniequipData.py b/ArknightsUID/utils/models/gamedata/UniequipData.py new file mode 100644 index 0000000..1e1ae31 --- /dev/null +++ b/ArknightsUID/utils/models/gamedata/UniequipData.py @@ -0,0 +1,63 @@ +from pydantic import BaseModel, Field + + +class ItemBundle(BaseModel): + id_: str = Field(alias='id') + count: int + type_: str = Field(alias='type') + + +class UnlockCondition(BaseModel): + phase: int + level: int + + +class TraitDescBundle(BaseModel): + unlockCondition: UnlockCondition + requiredPotentialRank: int + overrideDescription: None + additiveDescription: str + + +class UniEquipData(BaseModel): + uniEquipId: str + uniEquipName: str + uniEquipIcon: str + uniEquipDesc: str + typeIcon: str + typeName: str + showEvolvePhase: int + unlockEvolvePhase: int + charId: str + tmplId: None + showLevel: int + unlockLevel: int + unlockFavorPercent: int + missionList: list[str] + itemCost: list[ItemBundle] | None + type_: str = Field(..., alias='type') + traitDescBundle: list[TraitDescBundle] + + +class UniEquipMissionData(BaseModel): + template: str | None + desc: str | None + paramList: list[str] + uniEquipMissionId: str + uniEquipMissionSort: int + uniEquipId: str + + +class SubProfessionData(BaseModel): + subProfessionId: str + subProfessionName: str + subProfessionCatagory: int + + +class UniequipData(BaseModel): + __version__ = '23-07-27-18-50-06-aeb568' + + equipDict: dict[str, UniEquipData] + missionList: dict[str, UniEquipMissionData] + subProfDict: dict[str, SubProfessionData] + charEquip: dict[str, list[str]] diff --git a/ArknightsUID/utils/models/gamedata/UniequipTable.py b/ArknightsUID/utils/models/gamedata/UniequipTable.py new file mode 100644 index 0000000..9eedd0e --- /dev/null +++ b/ArknightsUID/utils/models/gamedata/UniequipTable.py @@ -0,0 +1,66 @@ +from pydantic import BaseModel, Field + + +class ItemBundle(BaseModel): + id_: str = Field(alias='id') + count: int + type_: str = Field(alias='type') + + +class UniEquipData(BaseModel): + uniEquipId: str + uniEquipName: str + uniEquipIcon: str + uniEquipDesc: str + typeIcon: str + typeName1: str + typeName2: str | None + equipShiningColor: str + showEvolvePhase: int + unlockEvolvePhase: int + charId: str + tmplId: str | None + showLevel: int + unlockLevel: int + unlockFavorPoint: int + missionList: list[str] + itemCost: dict[str, list[ItemBundle]] | None + type_: str = Field(..., alias='type') + uniEquipGetTime: int + charEquipOrder: int + + +class UniEquipMissionData(BaseModel): + template: str + desc: str + paramList: list[str] + uniEquipMissionId: str + uniEquipMissionSort: int + uniEquipId: str + jumpStageId: str | None + + +class SubProfessionData(BaseModel): + subProfessionId: str + subProfessionName: str + subProfessionCatagory: int + + +class UniEquipTrack(BaseModel): + charId: str + equipId: str + + +class UniEquipTimeInfo(BaseModel): + timeStamp: int + trackList: list[UniEquipTrack] + + +class UniEquipTable(BaseModel): + __version__ = '23-07-27-18-50-06-aeb568' + + equipDict: dict[str, UniEquipData] + missionList: dict[str, UniEquipMissionData] + subProfDict: dict[str, SubProfessionData] + charEquip: dict[str, list[str]] + equipTrackDict: list[UniEquipTimeInfo] diff --git a/ArknightsUID/utils/models/gamedata/ZoneTable.py b/ArknightsUID/utils/models/gamedata/ZoneTable.py new file mode 100644 index 0000000..4cc1d38 --- /dev/null +++ b/ArknightsUID/utils/models/gamedata/ZoneTable.py @@ -0,0 +1,108 @@ +from pydantic import BaseModel, Field + + +class ZoneData(BaseModel): + zoneID: str + zoneIndex: int + type: str + zoneNameFirst: str | None + zoneNameSecond: str | None + zoneNameTitleCurrent: str | None + zoneNameTitleUnCurrent: str | None + zoneNameTitleEx: str | None + zoneNameThird: str | None + lockedText: str | None + canPreview: bool + + +class WeeklyZoneData(BaseModel): + daysOfWeek: list[int] + type_: str = Field(..., alias='type') + + +class ZoneValidInfo(BaseModel): + startTs: int + endTs: int + + +class MainlineZoneData(BaseModel): + zoneId: str + chapterId: str + preposedZoneId: str | None + zoneIndex: int + startStageId: str + endStageId: str + mainlneBgName: str + recapId: str + recapPreStageId: str + buttonName: str + buttonStyle: str + spoilAlert: bool + zoneOpenTime: int + diffGroup: list[int] + + +class ItemBundle(BaseModel): + id_: str = Field(alias='id') + count: int + type_: str = Field(alias='type') + + +class RecordRewardInfo(BaseModel): + bindStageId: str + stageDiff1: int + stageDiff: int + picRes: str | None + textPath: str | None + textDesc: str | None + recordReward: list[ItemBundle] | None + + +class ZoneRecordData(BaseModel): + recordId: str + zoneId: str + recordTitleName: str + preRecordId: str | None + nodeTitle1: str | None + nodeTitle2: str | None + rewards: list[RecordRewardInfo] + + +class ZoneRecordUnlockData(BaseModel): + noteId: str + zoneId: str + initialName: str + finalName: str | None + accordingExposeId: str | None + initialDes: str + finalDes: str | None + remindDes: str | None + + +class ZoneRecordGroupData(BaseModel): + zoneId: str + records: list[ZoneRecordData] + unlockData: ZoneRecordUnlockData + + +class ZoneRecordMissionData(BaseModel): + missionId: str + recordStageId: str + templateDesc: str + desc: str + + +class ZoneMetaData(BaseModel): + ZoneRecordMissionData: dict[str, ZoneRecordMissionData] + + +class ZoneTable(BaseModel): + __version__ = '23-07-27-18-50-06-aeb568' + + zones: dict[str, ZoneData] + weeklyAdditionInfo: dict[str, WeeklyZoneData] + zoneValidInfo: dict[str, ZoneValidInfo] + mainlineAdditionInfo: dict[str, MainlineZoneData] + zoneRecordGroupedData: dict[str, ZoneRecordGroupData] + zoneRecordRewardData: dict[str, list[str]] + zoneMetaData: ZoneMetaData diff --git a/ArknightsUID/arkuid_utils/skd/models.py b/ArknightsUID/utils/models/skland/models.py similarity index 79% rename from ArknightsUID/arkuid_utils/skd/models.py rename to ArknightsUID/utils/models/skland/models.py index 8e0d898..682ee28 100644 --- a/ArknightsUID/arkuid_utils/skd/models.py +++ b/ArknightsUID/utils/models/skland/models.py @@ -1,7 +1,3 @@ -import datetime -from typing import Dict, List, Optional - -import msgspec from msgspec import Struct, field @@ -18,7 +14,7 @@ class PlayerManufactureFormulaInfo(Struct): itemId: str count: int weight: int - costs: List[str] + costs: list[str] costPoint: int @@ -117,14 +113,14 @@ class ActivityZone(Struct): zoneReplicaId: str clearedStage: int totalStage: int - stageStatus: List[ActivityZoneStageStatus] + stageStatus: list[ActivityZoneStageStatus] class PlayerActivity(Struct): actId: str actReplicaId: str type_: str = field(name='type') - zones: List[ActivityZone] + zones: list[ActivityZone] class RewoardItem(Struct): @@ -151,7 +147,7 @@ class RogueRecord(Struct): class PlayerRogue(Struct): - records: List[RogueRecord] + records: list[RogueRecord] class TowerReward(Struct): @@ -170,7 +166,7 @@ class TowerRecord(Struct): class PlayerTower(Struct): - records: List[TowerRecord] + records: list[TowerRecord] reward: TowerReward @@ -185,7 +181,7 @@ class CampaignRecord(Struct): class PlayerCampaign(Struct): - records: List[CampaignRecord] + records: list[CampaignRecord] reward: CampaignReward @@ -198,7 +194,7 @@ class PlayerRecruit(Struct): startTs: int finishTs: int duration: int - selectTags: List[Optional[RecruitTag]] + selectTags: list[RecruitTag | None] state: int @@ -220,7 +216,7 @@ class BuildingClue(Struct): received: int dailyReward: bool needReceive: int - board: List[str] + board: list[str] sharing: bool shareCompleteTime: int @@ -248,7 +244,7 @@ class BuildingControl(Struct): slotId: str slotState: int level: int - chars: List[BuildingChar] + chars: list[BuildingChar] class BuildingCorridor(Struct): @@ -289,7 +285,7 @@ class BuildingTraining(Struct): class BuildingHire(Struct): slotId: str level: int - chars: List[BuildingChar] + chars: list[BuildingChar] state: int refreshCount: int completeWorkTime: int @@ -299,7 +295,7 @@ class BuildingHire(Struct): class BuildingMeeting(Struct): slotId: str level: int - chars: List[BuildingChar] + chars: list[BuildingChar] clue: BuildingClue lastUpdateTime: int completeWorkTime: int @@ -308,25 +304,25 @@ class BuildingMeeting(Struct): class BuildingDormitories(Struct): slotId: str level: int - chars: List[BuildingChar] + chars: list[BuildingChar] comfort: int class BuildingTradings(Struct): slotId: str level: int - chars: List[BuildingChar] + chars: list[BuildingChar] completeWorkTime: int lastUpdateTime: int strategy: str - stock: List[int] + stock: list[int] stockLimit: int class BuildingManufactures(Struct): slotId: str level: int - chars: List[BuildingChar] + chars: list[BuildingChar] completeWorkTime: int lastUpdateTime: int formulaId: str @@ -340,22 +336,22 @@ class BuildingManufactures(Struct): class BuildingPower(Struct): slotId: str level: int - chars: List[BuildingChar] + chars: list[BuildingChar] class PlayerBuilding(Struct): - tiredChars: List[str] - powers: List[BuildingPower] - manufactures: List[BuildingManufactures] - tradings: List[BuildingTradings] - dormitories: List[BuildingDormitories] + tiredChars: list[str] + powers: list[BuildingPower] + manufactures: list[BuildingManufactures] + tradings: list[BuildingTradings] + dormitories: list[BuildingDormitories] meeting: BuildingMeeting hire: BuildingHire training: BuildingTraining labor: BuildingLabor furniture: BuildingFurniture - elevators: List[BuildingElevator] - corridors: List[BuildingCorridor] + elevators: list[BuildingElevator] + corridors: list[BuildingCorridor] control: BuildingControl @@ -381,8 +377,8 @@ class PlayerInfoChar(Struct): evolvePhase: int potentialRank: int mainSkillLvl: int - skills: Optional[List[PlayerInfoCharSkill]] - equip: Optional[List[PlayerInfoCharEquip]] + skills: list[PlayerInfoCharSkill] | None + equip: list[PlayerInfoCharEquip] | None favorPercent: int defaultSkillId: str gainTime: int @@ -403,14 +399,14 @@ class PlayerAssistChar(Struct): skillId: str mainSkillLvl: int specializeLevel: int - equip: Optional[PlayerAssistCharEquip] + equip: PlayerAssistCharEquip | None class PlayerMedal(Struct): type_: str = field(name='type') template: str - templateMedalList: List[str] - customMedalLayout: List[str] + templateMedallist: list[str] + customMedalLayout: list[str] total: int @@ -460,27 +456,27 @@ class ArknightsPlayerInfoModel(Struct, omit_defaults=True, gc=False): showConfig: DisplayShowConfig status: PlayerStatus medal: PlayerMedal - assistChars: List[PlayerAssistChar] - chars: List[PlayerInfoChar] - skins: List[PlayerInfoSkin] + assistChars: list[PlayerAssistChar] + chars: list[PlayerInfoChar] + skins: list[PlayerInfoSkin] building: PlayerBuilding - recruit: List[PlayerRecruit] + recruit: list[PlayerRecruit] campaign: PlayerCampaign tower: PlayerTower rogue: PlayerRogue routine: PlayerRoutine - activity: List[PlayerActivity] - charInfoMap: Dict[str, PlayerCharInfo] - skinInfoMap: Dict[str, PlayerSkinInfo] - stageInfoMap: Dict[str, PlayerStageInfo] - activityInfoMap: Dict[str, PlayerActivityInfo] - zoneInfoMap: Dict[str, PlayerZoneInfo] - towerInfoMap: Dict[str, PlayerTowerInfo] - rogueInfoMap: Dict[str, PlayerRogueInfo] - campaignInfoMap: Dict[str, PlayerCampaignInfo] - medalInfoMap: Dict[str, PlayerMedalInfo] - campaignZoneInfoMap: Dict[str, PlayerCampaignZoneInfo] - equipmentInfoMap: Dict[str, PlayerEquipmentInfo] - manufactureFormulaInfoMap: Dict[str, PlayerManufactureFormulaInfo] - charAssets: List[PlayerCharAsset] - skinAssets: List[PlayerSkinAsset] + activity: list[PlayerActivity] + charInfoMap: dict[str, PlayerCharInfo] + skinInfoMap: dict[str, PlayerSkinInfo] + stageInfoMap: dict[str, PlayerStageInfo] + activityInfoMap: dict[str, PlayerActivityInfo] + zoneInfoMap: dict[str, PlayerZoneInfo] + towerInfoMap: dict[str, PlayerTowerInfo] + rogueInfoMap: dict[str, PlayerRogueInfo] + campaignInfoMap: dict[str, PlayerCampaignInfo] + medalInfoMap: dict[str, PlayerMedalInfo] + campaignZoneInfoMap: dict[str, PlayerCampaignZoneInfo] + equipmentInfoMap: dict[str, PlayerEquipmentInfo] + manufactureFormulaInfoMap: dict[str, PlayerManufactureFormulaInfo] + charAssets: list[PlayerCharAsset] + skinAssets: list[PlayerSkinAsset]