✨ 整理目录

ArknightsUID/arkuid_utils/skd/__init__.py

@@ -1 +0,0 @@
-

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'

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)

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'

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'

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)

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]

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'

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)

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]

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'

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'

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'

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'

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'

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'

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'

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]

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'

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'

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'

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

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)

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'

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'

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'

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'

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

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)

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)

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'

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'

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]

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]

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)

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]

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]

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

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)

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)

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]

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]

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)

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]]

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]

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

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]
+    tiredChars: list[str]
-    powers: List[BuildingPower]
+    powers: list[BuildingPower]
-    manufactures: List[BuildingManufactures]
+    manufactures: list[BuildingManufactures]
-    tradings: List[BuildingTradings]
+    tradings: list[BuildingTradings]
-    dormitories: List[BuildingDormitories]
+    dormitories: list[BuildingDormitories]
     meeting: BuildingMeeting
     hire: BuildingHire
     training: BuildingTraining
     labor: BuildingLabor
     furniture: BuildingFurniture
-    elevators: List[BuildingElevator]
+    elevators: list[BuildingElevator]
-    corridors: List[BuildingCorridor]
+    corridors: list[BuildingCorridor]
     control: BuildingControl
 
 
@@ -381,8 +377,8 @@ class PlayerInfoChar(Struct):
     evolvePhase: int
     potentialRank: int
     mainSkillLvl: int
-    skills: Optional[List[PlayerInfoCharSkill]]
+    skills: list[PlayerInfoCharSkill] | None
-    equip: Optional[List[PlayerInfoCharEquip]]
+    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]
+    templateMedallist: list[str]
-    customMedalLayout: 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]
+    assistChars: list[PlayerAssistChar]
-    chars: List[PlayerInfoChar]
+    chars: list[PlayerInfoChar]
-    skins: List[PlayerInfoSkin]
+    skins: list[PlayerInfoSkin]
     building: PlayerBuilding
-    recruit: List[PlayerRecruit]
+    recruit: list[PlayerRecruit]
     campaign: PlayerCampaign
     tower: PlayerTower
     rogue: PlayerRogue
     routine: PlayerRoutine
-    activity: List[PlayerActivity]
+    activity: list[PlayerActivity]
-    charInfoMap: Dict[str, PlayerCharInfo]
+    charInfoMap: dict[str, PlayerCharInfo]
-    skinInfoMap: Dict[str, PlayerSkinInfo]
+    skinInfoMap: dict[str, PlayerSkinInfo]
-    stageInfoMap: Dict[str, PlayerStageInfo]
+    stageInfoMap: dict[str, PlayerStageInfo]
-    activityInfoMap: Dict[str, PlayerActivityInfo]
+    activityInfoMap: dict[str, PlayerActivityInfo]
-    zoneInfoMap: Dict[str, PlayerZoneInfo]
+    zoneInfoMap: dict[str, PlayerZoneInfo]
-    towerInfoMap: Dict[str, PlayerTowerInfo]
+    towerInfoMap: dict[str, PlayerTowerInfo]
-    rogueInfoMap: Dict[str, PlayerRogueInfo]
+    rogueInfoMap: dict[str, PlayerRogueInfo]
-    campaignInfoMap: Dict[str, PlayerCampaignInfo]
+    campaignInfoMap: dict[str, PlayerCampaignInfo]
-    medalInfoMap: Dict[str, PlayerMedalInfo]
+    medalInfoMap: dict[str, PlayerMedalInfo]
-    campaignZoneInfoMap: Dict[str, PlayerCampaignZoneInfo]
+    campaignZoneInfoMap: dict[str, PlayerCampaignZoneInfo]
-    equipmentInfoMap: Dict[str, PlayerEquipmentInfo]
+    equipmentInfoMap: dict[str, PlayerEquipmentInfo]
-    manufactureFormulaInfoMap: Dict[str, PlayerManufactureFormulaInfo]
+    manufactureFormulaInfoMap: dict[str, PlayerManufactureFormulaInfo]
-    charAssets: List[PlayerCharAsset]
+    charAssets: list[PlayerCharAsset]
-    skinAssets: List[PlayerSkinAsset]
+    skinAssets: list[PlayerSkinAsset]